集合框架和泛型

FST_XUAN FST_XUAN 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 879平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2026-04-06 12:32:23 发布 879 阅读 AI 写同款· GEO 优化 ›
Java集合框架及泛型 集合框架及泛型的介绍和基础理解，方便大家了解集合框架及泛型。 立即下载

集合框架概述

  1. 集合类的作用：存储对象，长度可变。
  2. 所属的包：java.util
  3. 集合框架常用体系 
     
    
Collection 
    
    |---List（有序）：通过重写equals()保证唯一性。 
    
        |---ArrayList（变长数组）：查询效率高，更新效率低。线程不同步 
    
        |---LinkedList（链表）：更新效率高，查询效率低。 
    
        |---Vector（数组）：线程同步，效率低，被ArrayList取代。 
    
    |---Set（唯一） 
    
        |---HashSet（哈希表）：重写hashCode()和equals()保证唯一性。 
    
        |---TreeSet（二叉树）：通过让元素具备比较性或让集合具备比较性保证唯一性和排序。 
    
Map 
    
    |---HashMap（哈希表）：允许使用null键null值，线程不同步，效率高。 
    
    |---TreeMap（二叉树）：可以按键排序，不同步。 
    
    |---HashTable（二叉树）：不允许使用null键null值，线程同步，效率低。
  4. 如何选择具体的集合类？
    1. 要求时间复杂度：List
      • 查询操作多：ArrayList
      • 更新操作多：LinkedList
    2. 要求空间复杂度：Set
      • 只要求唯一性：HashSet
      • 要求唯一、有序：TreeSet

Collection接口

  1. 共性方法（关于集合）

    1. 增：add(Object)
    2. 删：remove(Object)、clear()
    3. 查：size()、contains(Object)、isEmpty()
    4. 并：addAll(Collection)
    5. 交：retainAll(Collection)
    6. 差：removeAll(Collection)

  2. Iterator迭代器

    1. 为什么出现迭代器？

      由于Collection子接口下有的有索引有的没索引，不能像数组循环一样获取元素，因此必须有hasNext()和next()，两个方法只有一起使用时才有意义，因此将其封装成Collection的内部类，修饰为private并对外提供获取内部类对象的接口iterator()，返回类型是Iterator。比喻：Collection接口是娃娃机，Iterator是娃娃机的夹子，娃娃机夹子有抓取娃娃的操纵杆next()。

    2. 迭代器示例

      Iterator it = al.iterator();
while(it.hasNext())
{
    sop(it.next());
}

    3. 注意

      在迭代时不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常，所以只能通过迭代器的方法操作元素。

  3. List接口

    1. List特有方法（关于索引） 
       
      
增：add(index,ele)、addAll(index,Collection) 
      
删：remove(index) 
      
改：set(index,ele) 
      
查：get(index)、indexOf(ele)、subList(from,to)、listIterator()

    2. ListIterator迭代器

      ListIterator相较于Iterator迭代器的作用：由于List集合有索引，因此可在迭代的同时使用ListIterator迭代器的增删改查方法对元素进行操作。方法：add(ele)、remove()、set(ele)、hasNext()、hasPrivious()。

      ListIterator li = al.listIterator();
while(li.hasNext())
{
    Object obj = li.next(); 
    if(obj.equals("haha"))
        li.add("hehe");     //利用迭代器进行集合的添加元素
}

    3. LinkedList特有方法（关于收尾结点）

      1.增：addFirst()、addLast()、
2.删：removeFirst()、removeLast()
3.查：getFirst()、getLast()
若集合中没有元素，会出现NoSuchElementException异常

JDK1.6出现的替代方法
1.增：offerFirst()、offerFirst()
2.删：peakFirst()、peakLast()
3.查：pollFirst()、pollLast()
若集合中没有元素，会返回null。

  4. Set接口

    1. HashSet保证唯一性依据：hashCode和equals()。先比较两个对象的hashCode是否相同，若不同，直接存储进集合；若相同，再用equals()比较是否是同一个对象，若不是就存储进集合，否则不存储。代码示例。

      import java.util.*;
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    //重写hashCode()
    public int hashCode()
    {
        return name.hashCode()+age;
    }

    //重写equals()
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;

        return name.equals(p.name) && age == p.age;
    }

    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class  HashSetDemo
{
    public static void main(String[] args) 
    {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a2",12));    //重复元素
        hs.add(new Person("a3",13));


        for(Iterator it  = hs.iterator();it.hasNext();)
        {
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}

    2. TreeSet可实现元素排序，排序的两种方式

      • 让元素自身具备比较性：实现Comparable，重写compareTo()，使元素实现自然排序。
      • 让集合具备比较性：自定义比较器类，实现Comparator接口，重写compare()，传自定义比较器类的对象给集合的构造函数，让集合排序。应用场景：当使用别人的类，但比较性不是自己需要的时候。
      //第一种排序方式：让元素自身具备比较性，实现自然排序
import java.util.*;
class Person implements Comparable      
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    //重写compareTo方法
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Person))
            throw new RuntimeException("不是人对象");
        Person p = (Person)obj;

        if(this.age > p.age)
            return 1;
        if(this.age == p.age)   //若主要依据相同，要比较次要依据
            return this.name.compareTo(p.name);
        return -1;
    }

    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class TreeSetDemo 
{
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();

        ts.add(new Person("lisi01",22));
        ts.add(new Person("lisi02",25));
        ts.add(new Person("lisi03",22));
        ts.add(new Person("lisi03",22));    //重复元素
        ts.add(new Person("lisi04",23));

        for(Iterator it = ts.iterator();it.hasNext();)
        {
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}
      //第二种排序方式：让集合具备比较性
import java.util.*;
class MyComparator implements Comparator
{
    //重写compare方法
    public int compare(Object o1,Object o2)
    {
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;

        int num = p1.getName().compareTo(p2.getName());
        if(num == 0)        //若主要依据相同，要比较次要依据
            return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        return num;
    }
}
class TreeSetDemo1
{
    public static void main(String[] args) 
    {
        //传入比较器对象使集合具备比较性
        TreeSet ts = new TreeSet(new MyComparator());

        ts.add(new Person("lisi01",22));
        ts.add(new Person("lisi02",25));
        ts.add(new Person("lisi03",22));
        ts.add(new Person("lisi03",22));    //重复元素
        ts.add(new Person("lisi04",23));

        for(Iterator it = ts.iterator();it.hasNext();)
        {
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}

泛型

  1. 作用

    1. 将运行时期出现的问题ClassCastException转移到了编译时期，方便于程序员解决问题。
    2. 避免了强制转换麻烦。
    3. 一般在集合类中使用。
    import java.util.*;
class  GenericDemo
{
    public static void main(String[] args) 
    {
        //定义时就明确了要操作的类型
        ArrayList<String> al = new ArrayList<String>();

        //只能操作String类型
        al.add("abc01");
        al.add("abc02");
        al.add("abc03");

        for(Iterator<String> it = al.iterator();it.hasNext();)
        {
            String s = it.next();
            System.out.println(s);
        }
    }
}

  2. 泛型类

    使用场景：当类的对象要操作的类型一确定，成员方法操作的类型就明确，就可定义泛型类。

    /*
//泛型前做法
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
*/

//泛型类
class Utils<T>
{
    private T t;
    public void setObject(T t)
    {
        this.t = t;
    }
    public T getObject()
    {
        return t;
    }
}

class GenericDemo2
{
    public static void main(String[] args) 
    {
        //泛型前做法
//      Tool t = new Tool();
//      t.setObject(new String("abc"));
//      String s = (String)t.getObject();   //需要转型
//      System.out.println(s);

        //泛型做法
        Utils<String> u = new Utils<String>();
        u.setObject(new String("abc"));
        String s = u.getObject();           //无需转型
        System.out.println(s);
    }
}

  3. 泛型方法

    使用场景：为了让类中的不同方法可以操作不同类型，就可以将泛型定义在法上，类似于重载。

    class Demo<T>
{
    public void show(T t)       //跟随类的泛s型
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)  //方法上的泛型
    {
        System.out.println("print:"+q);
    }
}

class  GenericDemo3
{
    public static void main(String[] args) 
    {
        Demo<Integer> d = new Demo<Integer>();  //指定操作的类型是Integer

        d.show(new Integer(3));
        //d.show("abc");                        //编译出错，show()参数类型只能是Integer

        d.print(3);                             //print()参数类型任意
        d.print("abc");
    }
}

    静态方法的泛型只能定义在方法上，因为静态比对象先加载。

  4. 泛型限定

    1. 泛型的限定：? 通配符，代表任意类型
2. 泛型限定上限：<? extends E> 接收E或者E的子类型
3. 泛型限定下限：<? super E>> 接收E或者E的父类型
    //泛型限定上限
import java.util.*;
class GenericDemo4 
{
    public static void main(String[] args) 
    {
        TreeSet<Person> ts = new TreeSet<Person>(new Comp());
        ts.add(new Person("lisi1"));
        ts.add(new Person("lisi2"));
        ts.add(new Person("lisi3"));

        TreeSet<Student> ts1 = new TreeSet<Student>(new Comp());
        ts1.add(new Student("zhang1"));
        ts1.add(new Student("zhang2"));
        ts1.add(new Student("zhang3"));

        print(ts);
        print(ts1);
    }

    //泛型限定，只可以接收Person及其子类对象
    public static void print(TreeSet<? extends Person> al)  
    {
        for(Iterator<? extends Person> it = al.iterator();it.hasNext();)
        {
            //只能调用父类中的方法
            System.out.println(it.next().getName());
            //it.next().showName();     //编译出错，无法使用子类特有方法
        }
    }
}

class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
    public void showName()
    {
        System.out.println(getName());
    }
}

//比较器泛型使用，可以比较Person和Person子类
class Comp implements Comparator<Person>    
{
    public int compare(Person p1,Person p2)
    {
        //只能用父类方法
        return p1.getName().compareTo(p2.getName());    
    }
}
    //泛型限定下限
import java.util.*;  
import stu.love.v.Demo11;  

//父类的比较器   <Person>  
class CompareByAge implements Comparator<Person>  
{  
    public int compare(Person s1,Person s2)  
    {  
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        if(num==0)  
            return s1.getName().compareTo(s2.getName());  
        return num;  
    }  

}  

/*// 子类 特殊的 比较器  Student  
class ComByAge implements Comparator<Student>  
{  
    public int compare(Student s1,Student s2)  
    {  
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        if(num==0)  
            return s1.getName().compareTo(s2.getName());  
        return num;  
    }  
}  

// 子类 特殊的 比较器 Teacher  
class ComByAge2 implements Comparator<Teacher>  
{  
    public int compare(Teacher s1,Teacher s2)  
    {  
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        if(num==0)  
            return s1.getName().compareTo(s2.getName());  
        return num;  
    }  
}*/  

class Demo13   
{  
    //TreeSet<E>(Comparator<? super E> comparator) 定义比较器时，可以是E类型，还可以是E的父类型,E在创建集合对象时确定  
    public static void main(String[] args)   
    {  
        TreeSet<Student> t1 = new TreeSet<Student>(new CompareByAge());  
        t1.add(new Student("zhaosi",23));  
        t1.add(new Student("lisi",25));  
        t1.add(new Student("wangwu",20));  


        TreeSet<Teacher> t2 = new TreeSet<Teacher>(new CompareByAge());  
        t2.add(new Teacher("wang",38));  
        t2.add(new Teacher("lilaoshi",48));  
        t2.add(new Teacher("zhanglaoshi",58));  
    }  
}

Map接口

  1. 描述

    存储键值对，一个键对应一个值，当后添加的键与之前的键相同时，后添加的元素会覆盖之前的元素。

  2. 方法 
     
    
增：put(key,value)、putAll(Map) 
    
删：remove(key)、clear() 
    
获取：size()、get(key)、values()、entrySet()、keySet() 
    
判断：isEmpty()、containsKey(key)、containsValue(value)

  3. 获取元素的两种方式：keySet和entrySet()

    1. keySet()：获取Map集合的键集合
    2. entrySet()：获取Map集合的映射关系集合
    //keySet()和entrySet()用法案例
import java.util.*;
class MapDemo2 
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();

        map.put("02","lisi2");
        map.put("01","lisi1");
        map.put("03","lisi3");
        map.put("04","lisi4");

        //1,通过keySet获取键的集合
        Set<String> keySet = map.keySet();
        for(Iterator<String> it = keySet.iterator();it.hasNext();)
        {
            //取出一个键
            String key = it.next(); 
            //通过键获取值            
            System.out.println(key+":"+map.get(key));   
        }

        //2，通过entrySet获取映射关系集合
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for(Iterator<Map.Entry<String,String>> it1 = entrySet.iterator();it1.hasNext();)
        {
            //取出一个映射关系
            Map.Entry<String,String> me = it1.next();
            //通过映射关系获取键
            String key = me.getKey();
            //通过映射关系获取值
            String value = me.getValue();
            System.out.println(key+":"+value);
        }
    }
} 
    /*
    Map集合一键一值用例

    "yure"  Student("01","zhangsan")
    "yure"  Stduent("02","lisi")

    "jiuye"  Student("01" "wangwu")
    "jiuye"  Student("02" "zhaoliu")
    即一对多关系，由于Map是一对一关系，后会覆盖前，
    因此要将一对多化解为一对一：将值存储在集合中。
*/

import java.util.*;
class  MapDemo5
{
    public static void main(String[] args) 
    {
        //预热班
        List<Student> yure = new ArrayList<Student>();
        yure.add(new Student("01","zhangsan"));
        yure.add(new Student("02","lisi"));

        //就业班
        List<Student> jiuye = new ArrayList<Student>();
        jiuye.add(new Student("01","wangwu"));
        jiuye.add(new Student("02","zhaoliu"));

        //学校
        HashMap<String,List<Student>>  czbk = new HashMap<String,List<Student>>();
        czbk.put("yure",yure);      //学校有预热班和就业班
        czbk.put("jiuye",jiuye);

        //遍历czbk集合，获取所有教室
        for(Iterator<String> it  = czbk.keySet().iterator();it.hasNext();)
        {
            String roomName = it.next();                //获取一个键（教室名称）
            List<Student> room = czbk.get(roomName);    //通过教室名称获取学生集合
            System.out.println(roomName);   
            getInfos(room);         //输出每个学生的信息
        }
    }
    //遍历list集合中每个学生的信息
    public static void getInfos(List<Student> list)
    {
        for(Iterator<Student> it = list.iterator();it.hasNext();)
        {
            System.out.println(it.next());
        }
    }
}
class Student
{
    private String id;
    private String name;
    Student(String id,String name)
    {
        this.id = id;
        this.name = name;
    }
    public String toString()
    {
        return id+name;
    }
}

Collections 工具类

作用：由于List集合不能排序，Collections工具类提供了对List集合进行排序的方法和其他对集合进行操作的方法。

收录于
Java

当前文章被收录于：

Java
15 篇文章 0 人学习
订阅专栏 查看详情
标签
#泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Java基础笔记之集合框架和泛型 详细的介绍了集合框架的用法，及其语法规则，剖析了使用的使用注意事项，帮助更牢靠的掌握集合框架的知识及泛型内容。谢谢 立即下载

相关推荐

集合框架和泛型机制的解释

非常详细的解释，望各位快来下载啊，不错的选择啊

集合框架和泛型（详解）

集合框架和泛型（详解）

没有简介 843

数据分析：美团大赛的具体案例制作

在数据集中，存在三个变量的经纬度数据，分别是商家的经纬度数据（'sender_lng', 'sender_lat'），顾客的经纬度数据（'recipient_lng', 'recipient_lat'）和骑手的经纬度数据（'grab_lng', 'grab_lat'）。根据结果可知，平台订单创建时间的中位数为2022-10-21 02:59:01，平台订单创建时间的众数为2022-10-19 03:29:41、2022-10-23 03:29:47，与直方图相符。接下来，我们对是否为预定订单变量进行分析。

m0_68269346的博客 2496

java高级开发 第十三章——泛型与集合框架

E是其中的泛型，代表一种数据类型，可以是类或接口，不能是基本数据类型。泛型可以作为类的成员变量的类型，方法的类型，局部变量的类型。带有泛型的类称为泛型类。(1)用具体的类型代替E(2)使用通配符？Cone<?//Geometry类或Geometry的子类或实现了Geometry接口的类Cone<?//B类或者B的任何父类Cone<?通过类实现这个接口时可以指定泛型的具体类型，也可以不指定。

NLxxxxX的博客 1161

从零开始：手把手教你设计DP接口电路（含原理图实战）

本文是一份详尽的DisplayPort接口电路设计实战指南。文章从DP接口的核心架构与HDMI的差异讲起，手把手解析了高速差分对、AUX辅助通道、热插拔检测等关键模块的原理图设计要点，并提供了一个完整的DP Source端原理图实例，最后总结了PCB布局与信号完整性的核心考量，旨在帮助硬件工程师高效、稳定地完成DP接口电路设计。

transformer2023的博客 734

TMC5130/TMC5160步进电机驱动芯片深度解析与工程实践

步进电机驱动芯片是精密运动控制系统的物理执行核心，其性能直接决定定位精度、运行噪声与系统鲁棒性。基于电流闭环控制与电压前馈调制的混合驱动原理，现代智能驱动芯片如TMC51X0系列实现了微步插补、堵转检测和片上运动规划等关键技术突破。这类芯片通过SPI寄存器级配置实现StealthChop静音驱动与SpreadCycle高动态响应模式的无缝切换，在3D打印、CNC、机器人关节等场景中显著提升能效比与控制带宽。本文围绕TMC5130与TMC5160的硬件架构差异、寄存器操作时序、驱动模式物理机制及FreeRTO

weixin_35797963的博客 409

Java的集合框架和泛型

Java 集合框架，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes。其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储store、检索retrieve、管理manipulate，即平时我们俗称的增删查改CRUD。数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。

2302_77179144的博客 1179

ACT代码梳理：新手学具身智能，不需要学会一堆理论，先跑起来再说

我是一个刚接触具身智能的小白。第一次看 ACT 项目，什么 Transformer、VAE、Mujoco、rollout，全是天书。但我没打算先把理论补完。太难，也太慢。我的策略是：直接上手，边做边学，卡在哪就学到哪。这篇文章是我的第一站——带你一起看懂 ACT 项目的整体架构，了解它的核心模块和流程。开始前，我列了 本文出现的18 个关键词，是我一开始完全搞不懂的。你可以先扫一眼，如果不认识的超过 10 个，那我们就是同路人，可以放心往下看了。

qq_17405041的博客 1207

第一章 集合框架和泛型

Collection接口常用通用方法还有：clear()、isEmpty()、iterator()、toArray()将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性、本质是参数化类型。Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作，最常用的实现类是HashMap。Map.Entry() 返回的是当前Map的item，但是这个方法只在遍历的时候有用。map.entrySet()方法，返回的是当前Map的 item Set集合。

weixin_62008675的博客 1462

影楼精修-AI追色算法解析

本文解析了像素蛋糕软件中AI追色功能的技术原理与实现方案，为理解AI追色技术提供了实用参考。

Trent1985的专栏 2万+

基于Python的全卷积网络（FCN）实现路径损耗预测

本文提出一种基于全卷积网络（FCN）的无线信道路径损耗预测方法。通过合成数据生成模块构建包含房间布局和发射点坐标的训练数据集，采用双分支FCN架构融合空间特征与坐标信息，引入空间注意力机制增强关键区域提取。实验表明，该方法相比传统模型能更准确地预测复杂环境下的路径损耗，平均绝对误差降低约35%。系统支持端到端训练，可扩展融合多模态数据，为5G网络规划等应用提供高效预测工具。

huanghm88的专栏 577

集合框架和泛型0129

集合框架是Java编程语言中的一个重要部分，它提供了一组接口和类，用于存储、检索和操作对象组。这个框架定义了各种类型的集合，包括列表、队列、集合和映射。这些接口和类提供了丰富的功能，使得Java程序员可以方便地处理对象组。它们还提供了线程安全和并发控制机制，使得在多线程环境中也可以安全地使用。

SXY_211的博客 1146

最新Python爬虫实战（入门爬虫篇）——案例8：图书网畅销榜数据采集（详细爬虫思路截图+抓包动图演示＋完整爬虫代码＋详细注释）

本次案例通过 Python 爬虫技术，成功实现了对图书网畅销榜多页数据的批量爬取与 Excel 保存。代码采用模块化设计，包含分页参数构造、API 接口请求、JSON 数据解析、Excel 数据持久化等完整流程；通过配置模拟浏览器的请求头，有效规避基础反爬策略，保证请求的稳定性。整个爬虫逻辑遵循 “分页遍历 → 接口请求 → JSON 解析 → 提取图书信息 → 保存到 Excel” 的标准流程，与电商类接口爬取范式高度一致。

努力让自己发光，对的人才能迎着光而来 29万+

Java集合框架和泛型机制

1、 2、泛型 应用背景：存入容器的对象在取出时需要强制转换类型，因为对象加入容器时都被转化为Object类型，而取出时又要转成实际类型。 在Java中向下类型转换时容易出现ClassCastException的异常，这时应当尽量避免。有什么办法可以让装入容器中的数据保存自己的类型而不被转化为Object对象呢，这就需要用到JDK5.0支持的新功能——Java的泛型。 定义：泛型只

liumei90 4867

【毕设全程指导】基于YOLOv8的包装商品检测与可视化系统（SKU110K实战）

本文介绍了一个基于YOLOv8的包装商品检测与可视化系统毕业设计方案。项目采用SKU110K数据集，通过CSV转TXT格式转换适配YOLO模型训练，包含详细的环境搭建、模型配置和训练流程。系统实现了包装商品的自动化检测，并开发了Tkinter可视化界面进行交互式检测展示。该方案结合产业应用需求与技术深度，既具备实用价值，又能充分展示学生的技术能力，适合作为计算机视觉相关专业的毕业设计选题。整个项目从数据准备到界面开发完整覆盖，帮助学生系统掌握目标检测项目的完整实现流程。

LXY_LOVE36的博客 146

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料，已经经过了本人的筛选和整理，希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助！

【Java】集合框架和泛型（三）

（1）将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性。这就是泛型。泛型的本质就是参数化类型。（2）泛型的定义语法格式如下：类1或者接口 对象 = new 类2();注意：-->“类2”可以是“类1”本身，可以是“类1”的子类，还可以是接口的实现类。-->“类2”的类型实参必须和“类1”中的类型实参相同。（3）例如：ArrayList list = new ArrayList();

swy2560666141的博客 872

温度PID控制PLC程序

温度PID稳定控制程序，适用于欧姆龙PLC，对其他PLC也具有很大参考价值

【Java高级编程】集合框架和泛型

Java集合框架提供了比数组更灵活的存储方案，主要包括List（有序可重复）、Set（无序不可重复）和Map（键值对）三大接口。ArrayList基于动态数组实现，适合随机访问；LinkedList基于链表，适合频繁增删。HashSet实现Set接口，存储唯一元素；HashMap实现Map接口，提供高效键值查询。泛型可增强类型安全性，避免强制转换。Collections工具类提供排序、查找等功能。集合框架通过不同实现类满足各类数据存储需求，解决了数组长度固定、操作受限等问题。

2401_84149564的博客 1078

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表，创建专业级图表以简化复杂的信息。

集合框架和泛型——JAVA

@月月鸟 集合 数组与集合的区别 数组可以存储基本数据类型或者引用数据类型，集合只能存储引用数据类型，如果存储基本数据类型，会自动转换为包装类型 。 数组在定义的时候，就会确定存储的数据类型，即只能存储一种数据类型，集合中如果没有泛型限制，默认存储的都是Object类型。 数组的长度是固定不变的，不能够进行自动增长，而集合是可以根据数据的多少进行自动增长。 List接口 1. 使用Arra...

Angels_Descent的博客 513
上一篇： 多线程
下一篇： Java Web基础——Action+Service +Dao三层的功能划分
点赞 2
评论 0
书签 书签 4
FST_XUAN
FST_XUAN
博客等级 码龄10年 3粉丝 8原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值