Java，集合框架体系

原创于 2025-12-13 17:41:53 发布 · 719 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#windows #开发语言

Java 专栏收录该内容

22 篇文章

订阅专栏

Java集合框架体系概要

java.util包下

java.util.Collection：存储一个一个数据
- 子接口：List：存储有序的、可重复的数据（“动态”数组）
  - ArrayList（主要实现类）、LinkedList、Vector
- 子接口：Set：存储无序的、不可重复的数据（高中学习的集合）
  - HashSet（主要实现类）、LinkedHashSet、TreeSet
java.util.Map：存储一对一对的数据（key-value键值对，（x1，y1）、（x2，y2）—> y=f(x)，类似高中的函数）
- HashMap（主要实现类）、LinkedHashMap、TreeMap、Hashtable、Properties

Collection接口及方法

JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set和List）去实现。
Collection 接口是 List和Set接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 集合。方法如下：

添加

（1）add(E obj)：添加元素对象到当前集合中
（2）addAll(Collection other)：添加other集合中的所有元素对象到当前集合中，即this = this ∪ other

@Test
public void test1()
{
    Collection coll = new ArrayList();

    //add()
    coll.add("AA");
    coll.add(123);
    coll.add(new Object());
    coll.add(new Person("Tom",10));
    System.out.println(coll);//[AA, 123, java.lang.Object@6574b225, Person{name='Tom', age=10}]

    //addAll()
    Collection coll1 = new ArrayList();
    coll1.add(456);
    coll1.add("BB");
    coll.addAll(coll1);
    System.out.println(coll);//[AA, 123, java.lang.Object@6574b225, Person{name='Tom', age=10}, 456, BB]

}

判断

（3）int size()：获取当前集合中实际存储的元素个数
（4）boolean isEmpty()：判断当前集合是否为空集合
（5）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素
（6）boolean containsAll(Collection coll)：判断coll集合中的元素是否在当前集合中都存在。即coll集合是否是当前集合的“子集”
（7）boolean equals(Object obj)：判断当前集合与obj是否相等

//size()
System.out.println(coll.size());//4
System.out.println(coll1.size());//2

//isEmpty()
System.out.println(coll.isEmpty());//false

//contains()
System.out.println(coll.contains("aa"));//false
System.out.println(coll.contains("AA"));//true
System.out.println(coll.contains(new Person("Tom",10)));//false

//equals()
coll.equals(coll);//true
coll.equals(coll1);//false

删除

（8）void clear()：清空集合元素
（9） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。
（10）boolean removeAll(Collection coll)：从当前集合中删除所有与coll集合中相同的元素。即this = this - this ∩ coll
（11）boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与coll集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this = this ∩ coll；

//clear()
//        coll.clear();
        System.out.println(coll);//[]
        System.out.println(coll.size());//0

        //remove()
        coll.remove(new Person("Tom",10));//[AA, 123, java.lang.Object@6574b225]
        coll.remove("AA");//[123, java.lang.Object@6574b225]
        System.out.println(coll);

        //removeAll()
        coll.removeAll(coll1);
        System.out.println(coll);//[java.lang.Object@6574b225]

        //retainAll()
        coll.retainAll(coll1);

其他

（12）Object[] toArray()：返回包含当前集合中所有元素的数组
（13）hashCode()：获取集合对象的哈希值
（14）iterator()：返回迭代器对象，用于集合遍历

//toArray()
Object[] obj = coll.toArray();
System.out.println(Arrays.toString(obj));//[AA, 123, java.lang.Object@6574b225, Person{name='Tom', age=10}]

//hashCode()
System.out.println(coll.hashCode());//-1407561297

注：数组 —> 集合：asList(Object … objs)

集合 —> 数组：toArray()

Iterator(迭代器)接口

作用：本身并不提供存储对象的能力，用来遍历集合元素
获取迭代器对象：
- ```
Iterator iterator = coll.iterator();
```
实现遍历的三种方式：

@Test
    public void test1()
    {
        Collection coll = new ArrayList();

        coll.add("AA");
        coll.add(new Person("Tom",10));
        coll.add(128);
        coll.add(new String("高数"));

        //获取迭代器对象
        Iterator iterator = coll.iterator();

        //方式一
//        System.out.println(iterator.next());//AA
//        System.out.println(iterator.next());//Person{name='Tom', age=10}
//        System.out.println(iterator.next());//128
//        System.out.println(iterator.next());//高数

        //方式二
//        for (int i = 0; i < coll.size(); i++)
//        {
//            System.out.println(iterator.next());
//        }

        //方式三:推荐用法
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
    }

迭代器的执行原理

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，接下来通过一个图例来演示Iterator对象迭代元素的过程

在这里插入图片描述

foreach循环

foreach循环（也称增强for循环）是 JDK5.0 中定义的一个高级for循环，专门用来遍历数组和集合的，内部原理其实就是迭代器。
foreach循环的语法格式：

for(元素的数据类型 局部变量 : Collection集合或数组)
{ 
  	//操作局部变量的输出操作
}
//这里局部变量就是一个临时变量，自己命名就可以

@Test
public void test1()
{
    Collection coll = new ArrayList();

    coll.add("AA");
    coll.add(new Person("Tom",10));
    coll.add(128);
    coll.add(new String("高数"));

    //遍历集合
    for(Object obj : coll)
    {
        System.out.println(obj);
    }

    int[] a = new int[]{1,2,3,4,5};
    //遍历数组
    for (Object obj : a)
    {
        System.out.println(obj);
    }
}

注：foreach通常只用来进行遍历操作，一般不进行增删操作，在foreach中进行增删操作会破坏迭代器的状态

List接口

特点：
- 鉴于Java中数组用来存储数据的局限性，我们通常使用java.util.List替代数组List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
- List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
常用方法：
- 插入元素
  - void add(int index, Object ele):在index位置插入ele元素
  - boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
- 获取元素
  - Object get(int index):获取指定index位置的元素
  - List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
- 获取元素索引
  - int indexOf(Object obj):返回obj在集合中首次出现的位置
  - int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
- 删除和替换元素
  - Object remove(int index):移除指定index位置的元素，并返回此元素
  - Object set(int index, Object ele):设置指定index位置的元素为ele

@Test
    public void test1()
    {
        List list = new ArrayList();

        list.add("AA");
        list.add("BB");
        list.add(123);
        list.add(new Person("Tom",10));

        System.out.println(list);//[AA, BB, 123, Person{name='Tom', age=10}]

        //add(int index,Object element)
        list.add(2,"CC");
        System.out.println(list);//[AA, BB, CC, 123, Person{name='Tom', age=10}]

        //addAll(int index,Collection else)
        List list1 = Arrays.asList(1,2,3);
//        list.add(2,list1);//将list1整体作为一个元素插入集合中
        System.out.println(list);//[AA, BB, [1, 2, 3], CC, 123, Person{name='Tom', age=10}]
        list.addAll(2,list1);//将集合中的所有元素插入到指定位置中
        System.out.println(list);//[AA, BB, 1, 2, 3, CC, 123, Person{name='Tom', age=10}]

        //remove(int index)
        //删除索引2
        list.remove(2);//[AA, BB, 2, 3, CC, 123, Person{name='Tom', age=10}]
        System.out.println(list);
        //删除数据“2”
        list.remove(Integer.valueOf(2));
        System.out.println(list);//[AA, BB, 3, CC, 123, Person{name='Tom', age=10}]
    }

List实现类之间的区别

ArrayList：
- List的主要实现类
- 线程不安全的、效率高
- 底层使用Object[]数组存储
Vector：
- List的古老实现类
- 线程安全的、效率低
- 底层使用Object[]数组存储
LinkedList：
- 底层使用双向链表的方式进行存储
- 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。这是由底层采用链表（双向链表）结构存储数据决定的。
- 特有方法：
  - void addFirst(Object obj)
  - void addLast(Object obj)
  - Object getFirst()
  - Object getLast()
  - Object removeFirst()
  - Object removeLast()

Set接口

Set接口是Collection的子接口，Set接口相较于Collection接口没有提供额外的方法
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
Set集合支持的遍历方式和Collection集合一样：foreach和Iterator。
Set的常用实现类有：HashSet、TreeSet、LinkedHashSet。
较List，Map来说，Set使用的较少，用来过滤重复数据
HashSet、LinkedHashSet特性：
- 无序性：
  - 不等于随机性
  - set的值存入数组是根据其数据的哈希值确定位置，所以导致其位置分布没有顺序
- 不可重复性：
  - 传入Set集合的类必须要重写equlas和hashCode方法
  - 存入set集合的值，会先判断其哈希值是否相同，如果相同则无法存入集合

主要实现类HashSet

底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储

实现类LinkedHashSet

为HashSet的子类；在现有的数组+单向链表+红黑树结构中增加一对双向链表
可以按照元素顺序实现遍历，便于频繁的查询操作

实现类TreeSet

底层使用红黑树存储
可以按照添加元素的指定属性的大小顺序进行遍历（默认自然排序）
添加到TreeSet中的元素必须是同一个类型的对象，否则会报ClassCastException
判断元素是否相同，不考虑hashCode和equals方法，意味着TreeSet中的元素不必要重写hashCode和equals方法
比较元素大小或比较元素是否相等的标准是compareTo()或compare()的返回值，返回值为0说明相等

Map接口

存储一对一对的数据（key-value键值对，（x1，y1）、（x2，y2）—> y=f(x)，类似高中的函数）
Map中的key彼此之间是不可重复的、无序的，所有的key就构成了一个Set集合，所以key所在的类要重写HashCode和equals方法
Map中的value彼此之间是可重复的、无序的，所有的value构成一个Collection集合，所以value所在的类要重写equals方法
key-value构成一个entry，所有的entry彼此之间是不可重复的、无序的，所有的entry构成一个Set集合

常用方法

添加、修改操作：
- Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
- void putAll(Map m):将m中的所有key-value对存放到当前map中
删除操作：
- Object remove(Object key)：移除指定key的key-value对，并返回value
- void clear()：清空当前map中的所有数据
元素查询的操作：
- Object get(Object key)：获取指定key对应的value
- boolean containsKey(Object key)：是否包含指定的key
- boolean containsValue(Object value)：是否包含指定的value
- int size()：返回map中key-value对的个数
- boolean isEmpty()：判断当前map是否为空
- boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图操作的方法：
- Set keySet()：返回所有key构成的Set集合
- Collection values()：返回所有value构成的Collection集合
- Set entrySet()：返回所有key-value对构成的Set集合

主要实现类HashMap

主要实现类；线程不安全的，效率高
可以添加null的key值或value值
底层使用数组+单向链表+红黑树结构存储
子类LinkedHashMap
- 在HashMap数据结构的基础上，增加了一对双向链表，用于记录添加元素的先后顺序，遍历时按照遍历的顺序显示
- 开发中，频繁的遍历操作，建议使用此类

实现类Hashtable

古老实现类；线程安全的，效率低
不可以添加null的key或value值
底层使用数组+单向链表结构存储
子类Properties
- key和value都是String类型，常用来处理属性文件

实现类TreeMap

底层使用红黑树存储
可以按照添加的key-value中的key元素的指定的属性大小顺序进行排序，需要考虑自然排序、定制排序
**（参考TreeSet）**TreeMap中key必须是同一类的对象，判断元素是否相同，不考虑hashCode和equals方法，意味着TreeSet中的元素不必要重写hashCode和equals方法，比较元素大小或比较元素是否相等的标准是compareTo()或compare()的返回值，返回值为0说明相等

Collections工具类

参考操作数组的工具类：Arrays，Collections 是一个操作 Set、List 和 Map 等集合的工具类。

常用方法

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法（均为static方法）：

排序操作：

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
Object min(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最小元素
int binarySearch(List list,T key)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且必须是可比较大小的，即支持自然排序的。而且集合也事先必须是有序的，否则结果不确定。
int binarySearch(List list,T key,Comparator c)在List集合中查找某个元素的下标，但是List的元素必须是T或T的子类对象，而且集合也事先必须是按照c比较器规则进行排序过的，否则结果不确定。
int frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数

复制、替换