Java笔记：集合

最新推荐文章于 2024-07-21 15:23:30 发布

Alice_LMY

最新推荐文章于 2024-07-21 15:23:30 发布

阅读量100

点赞数

分类专栏： Java笔记

本文链接：https://blog.csdn.net/Alice_Lee_Lee/article/details/114303741

版权

Java笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1. Java 集合框架概述

集合与数组都是对多个数据进行存储操作的结构，简称 Java 容器（此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储）
数组在存储多个数据方面的特点：

一旦初始化以后，其长度就确定了
数组一旦定义好，其元素的类型也就确定了，那么就只能操作指定类型的数据
数组在存储多个数据方面的缺点：

一旦初始化以后，其长度就不可修改
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足
集合框架：
Collection 接口：单列数据，定义了存取一组对象的方法的集合
1. List：元素有序、可重复的集合（ArrayList，LinkedList，Vector）
2. Set：元素无序、不可重复的集合（HashSet，LinkedHashSet，TreeSet）
Map 接口：双列数据，保存具有映射关系“key-value对”的集合（HashMap，LinkedHashMap，TreeMap，Hashtable，Properties）

2. Collection 接口中的方法

boolean add(Object e) 将元素e添加到集合collection中
int size() 获取添加的元素的个数
boolean addAll(Collection c) 将集合c中的元素添加到当前的集合中
void clear() 清空集合元素

boolean isEmpty() 判断当前集合是否为空

public void test() throws Exception {
	Collection collection = new ArrayList();
	// boolean add(Object e) 将元素e添加到集合collection中
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);// 自动装箱
	collection.add(new Date());

	// int size() 获取添加的元素的个数
	System.out.println(collection.size());// 4

	// boolean addAll(Collection c) 将集合c中的元素添加到当前的集合中
	Collection collection1 = new ArrayList();
	collection1.add("诸葛亮");
	collection1.add(425);
	collection.addAll(collection1);
	System.out.println(collection);// [李白, 韩信, 1208, Wed Mar 03 14:16:28 CST 2021, 诸葛亮, 425]

	// void clear() 清空集合元素
	collection.clear();

	// boolean isEmpty() 判断当前集合是否为空
	System.out.println(collection.isEmpty());
}

boolean contains(Object o) 判断集合中是否包含给定的元素

boolean containsAll(Collection c) 判断当前集合中是否包含给定集合中的所有元素

public void test() throws Exception {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);
	collection.add(new Date());
	
	// boolean contains(Object o) 判断集合中是否包含给定的元素
	System.out.println(collection.contains(1208));// true
	
	Collection collection1 = new ArrayList();
	collection1.add("李白");
	collection1.add("韩信");
	// boolean containsAll(Collection c) 判断当前集合中是否包含给定集合中的所有元素
	System.out.println(collection.containsAll(collection1));
}

注意：contains 与 containsAll 判断的标准是使用对象的 equals 方法，如果给定元素与集合中的元素使用 equals 判断返回 true，那么 contains 方法就返回 true

boolean remove(Object o) 从当前集合中移除指定元素

boolean removeAll(Collection c) 从当前集合中移除给定集合中的所有元素

public void test() {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);
	collection.add(new Date());
	
	// boolean remove(Object o) 从当前集合中移除指定元素
	collection.remove("李白");
	System.out.println(collection);// [韩信, 1208, Thu Mar 04 21:39:19 CST 2021]
	
	Collection collection1 = new ArrayList();
	collection1.add("李白");
	collection1.add("韩信");
	// boolean removeAll(Collection c) 从当前集合中移除给定集合中的所有元素
	collection.removeAll(collection1);
	System.out.println(collection);// [1208, Thu Mar 04 21:41:06 CST 2021]
}

boolean retainAll(Collection c) 获取当前集合与给定集合的交集

boolean equals(Object o) 比较当前集合与给定集合的元素是否全部相同

public void test() {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);
	collection.add(new Date());
	
	Collection collection1 = new ArrayList();
	collection1.add("李白");
	collection1.add("韩信");
	collection1.add("诸葛亮");
	
	// boolean retainAll(Collection c) 获取当前集合与给定集合的交集
	collection.retainAll(collection1);
	System.out.println(collection);// [李白, 韩信]
	
	// boolean equals(Object o) 比较当前集合与给定集合的元素是否全部相同（有序的集合还要考虑顺序是否相同，无序的集合只需要考虑元素是否相同）
	System.out.println(collection.equals(collection1));// false
}

int hashCode() 返回当前对象的哈希值
Object[] toArray() 将集合转换为数组
Arrays.asList() 将数组转换为集合

Iterator iterator() 返回Iterator接口的实例，用于遍历集合元素

public void test() {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);
	collection.add(new Date());

	// int hashCode() 返回当前对象的哈希值
	System.out.println(collection.hashCode());// 695790786

	// Object[] toArray() 将集合转换为数组
	Object[] array = collection.toArray();
	System.out.println(Arrays.toString(array));// [李白, 韩信, 1208, Thu Mar 04 22:13:40 CST 2021]

	// Arrays.asList() 将数组转换为集合
	List<String> list = Arrays.asList(new String[] { "李白", "韩信", "诸葛亮", "赵云", });
	System.out.println(list);// [李白, 韩信, 诸葛亮, 赵云]
	// 此时的int数组相当于一个元素
	List<int[]> list1 = Arrays.asList(new int[] {123,456});
	System.out.println(list1);// [[I@6b1274d2]
	// 此时可以正常的看成两个元素
	List<Integer> list2 = Arrays.asList(new Integer[] {123,456});
	System.out.println(list2);// [123, 456]
	
	// Iterator iterator() 返回Iterator接口的实例，用于遍历集合元素
	Iterator iterator = collection.iterator();
}

3. Iterator 迭代器接口

迭代器模式：提供一种方法访问一个容器对象中的各个元素，而又不需暴露该对象的内部细节。

Object next() 获取集合中的元素（指针下移，将下移以后集合位置上的元素返回），如果找不到元素，会抛出 NoSuchElementException 异常

boolean hasNext() 判断对应的集合中是否还有元素

public void test() {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);
	collection.add(new Date());

	Iterator iterator = collection.iterator();
	// Object next()：获取集合中的元素（指针下移，将下移以后集合位置上的元素返回），如果找不到元素，会抛出 NoSuchElementException 异常
	System.out.println(iterator.next());

	// boolean hasNext() 判断对应的集合中是否还有元素
	while (iterator.hasNext()){
		System.out.println(iterator.next());
	}
}

集合对象每次调用都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前

void remove() 删除集合中的元素

public void test() {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);

	Iterator iterator = collection.iterator();
	while (iterator.hasNext()){
		Object o = iterator.next();
		if ("韩信".equals(o)) {
			// void remove() 删除集合中的元素
			iterator.remove();
		}
	}
	System.out.println(collection);// [李白, 1208]
}

如果还未调用 next() 或在上一次调用 next() 之后已经调用了 remove() ，再调用 remove() 都会报 IllegalStateException 异常

增强的 for 循环

JDK5.0 新增了 foreach 循环，用于遍历集合、数组

public void test() {
	Collection collection = new ArrayList();
	collection.add("李白");
	collection.add("韩信");
	collection.add(1208);

	// 内部仍然调用了迭代器
	for (Object o : collection) {
		System.out.println(o);
    }
}

4. Collection 子接口一：List

三个类都实现了 List 接口，存储数据的特点相同（有序，可重复）
ArrayList：List 接口的主要实现类，线程不安全，效率高，底层使用 Object[] elementData 存储
Vector：List 接口的古老实现类，线程安全，效率低，不常用，底层使用 Object[] elementData 存储
LinkedList：底层使用双向链表存储；因此对于频繁的插入、删除操作，使用此类的效率会更高

4.1 源码分析

4.1.1 ArrayList的源码分析

JDK7 的情况：

List list = new ArrayList();

底层创建了长度是10的 Object[] elementData

list.add("赵云");

elementData[0] = “赵云”；如果此次的添加导致 elementData 容量不够，则需要扩容，默认情况下扩容为原来容量的1.5倍，同时需要将原有的数据复制到新的数组中

建议开发中使用带参数的构造器来指定容量 List list = new ArrayList(int i);

JDK8中的变化：

List list = new ArrayList();

底层 Object[] elementData 初始化为 {}，并没有创建数组

list.add("赵云");

此时创建长度为10的数组，elementData[0] = “赵云”；后续的添加扩容操作与 JDK7 一致

总结：JDK7 中的 ArrayList 的创建类似于单例的饿汉式，JDK8 中的 ArrayList 的创建类似于单例的懒汉式，延迟了数组的创建时间，节省了内存

4.1.2 LinkedList的源码分析

实现原理是双向链表

LinkedList list = new LinkedList();

内部声明了 Node 类型的 first 和 last 属性，默认值为null

list.add(123);

将123封装到 Node 中，创建 Node 对象

4.1.3 Vector的源码分析

JDK7 和 JDK8 中通过 Vector() 构造器创建对象时，底层都创建了长度为10的数组
在扩容方面，默认扩容为原来的数组长度的2倍

4.2 常用方法

void add(int index, Object element) 在指定位置添加元素，其他元素后移
boolean addAll(int index, Collection c) 在指定位置添加给定集合中的所有元素，其他元素后移
Object get(int index) 获取给定索引位置的元素
int indexOf(Object o) 获取给定元素在当前集合中第一次出现的索引，找不到则返回-1
int lastIndexOf(Object o) 获取给定元素在当前集合中最后一次出现的索引，找不到则返回-1
Object remove(int index) 删除指定索引的元素，并返回该元素
Object set(int index, Object element) 使用给定元素替换指定索引位置的元素
List subList(int fromIndex, int toIndex) 取子集合（左闭右开）

public void test() {
	List list = new ArrayList();
	list.add("李白");
	list.add("韩信");
	list.add("百里守约");
	list.add("赵云");
	list.add("诸葛亮");
	System.out.println(list);// [李白, 韩信, 百里守约, 赵云, 诸葛亮]

	// void add(int index, Object element) 在指定位置添加元素，其他元素后移
	list.add(2, "铠");
	System.out.println(list);// [李白, 韩信, 铠, 百里守约, 赵云, 诸葛亮]

	List list1 = new ArrayList();
	list1.add("百里玄策");
	list1.add("李信");

	// boolean addAll(int index, Collection c) 在指定位置添加给定集合中的所有元素，其他元素后移
	list.addAll(2, list1);
	System.out.println(list);// [李白, 韩信, 百里玄策, 李信, 铠, 百里守约, 赵云, 诸葛亮]

	// Object get(int index) 获取给定索引位置的元素
	System.out.println(list.get(3));// 李信

	// int indexOf(Object o) 获取给定元素在当前集合中第一次出现的索引，找不到则返回-1
	System.out.println(list.indexOf("李白"));// 0

	// int lastIndexOf(Object o) 获取给定元素在当前集合中最后一次出现的索引，找不到则返回-1
	System.out.println(list.lastIndexOf("韩信"));// 1

	// Object remove(int index) 删除指定索引的元素，并返回该元素
	Object object = list.remove(2);
	System.out.println(object);// 百里玄策
	System.out.println(list);// [李白, 韩信, 李信, 铠, 百里守约, 赵云, 诸葛亮]

	// Object set(int index, Object element) 使用给定元素替换指定索引位置的元素
	list.set(2, "至尊宝");
	System.out.println(list);// [李白, 韩信, 至尊宝, 铠, 百里守约, 赵云, 诸葛亮]
	
	// List subList(int fromIndex, int toIndex) 取子集合（左闭右开）
	List list2 = list.subList(3, 7);
	System.out.println(list2);// [铠, 百里守约, 赵云, 诸葛亮]
}

4.3 遍历方式总结

三种方式：iterator 迭代器，增强的 for 循环，普通的 for 循环

public void test() throws Exception {
	List list = new ArrayList();
    list.add("韩信");
    list.add("李白");
    list.add(1208);
    list.add(425);

    // 方式一：使用迭代器
    Iterator iterator = list.iterator();
    while (iterator.hasNext()) {
    	System.out.println(iterator.next());
    }
    System.out.println("**********************************");

	// 方式二：增强for循环
	for (Object o : list) {
        System.out.println(o);
    }
	System.out.println("**********************************");
	
	// 方式三：普通的for循环
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
}

5. Collection 子接口二：Set

HashSet：作为 Set 接口的主要实现类；线程不安全的；可以存储 null 值
LinkedHashSet：作为 HashSet 的子类；遍历其内部数据时可以按照添加顺序去遍历
TreeSet：可以按照添加元素的指定属性进行排序
Set 接口中没有额外定义新的方法，使用的都是 Collection 中声明过的方法

5.1 Set 的无序性和不可重复性的理解

以 HashSet 为例说明

无序性：不等同于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
不可重复性：保证添加的元素按照 equal() 方法判断时不能返回 true，即相同的元素只能添加一个；

5.2 添加元素的过程

以 HashSet 为例说明

向 HashSet 中添加元素 a，首先调用元素 a 所在类的 hashCode()，计算元素 a 的哈希值，此哈希值接着通过某种算法计算出在 HashSet 底层数组中的存放位置（索引位置）
如果该索引位置上没有其他元素，则元素 a 就存储在该位置上，添加成功；如果该位置上有其他元素 b（或以链表形式存在的多个元素，则比较元素a与元素b的哈希值
如果哈希值不相同则元素 a 添加成功，如果哈希值相同，进而需要调用元素 a 所在类的 equals() 方法，如果返回true，则元素 a 添加失败，如果返回 false，则元素 a 添加成功，此时都将元素 a 与该位置的其他元素以链表的方式存储（JDK7 中最后一次添加的元素作为链表的头存在数组中，而JDK8 中第一次添加的元素作为链表头存在数组中）

总结：

向 Set 中添加的数据，其所在的类一定要重写 hashCode() 和 equals()
重写的 hashCode() 和 equals() 尽可能保持一致性，即相等的对象必须具有相等的散列码
重写 hashCode() 的基本原则

在程序运行时，同一个对象多次调用 hashCode() 应该返回相同的值
当两个对象的 equals() 比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应该相等
对象中用作 equals() 比较的属性，都应该用来计算 hashCode 值

5.3 LinkedHashSet

LinkedHashSet 作为 HashSet 的子类，在添加数据的同时，每个数据还维护了两个引用，用来维护链表
优点：对于频繁的遍历操作，LinkedHashSet 的效率高于 HashSet

5.4 TreeSet

TreeSet 底层使用红黑树存储数据，数据是排好序的，查找速度比 List 快
向 TreeSet 中添加的数据，要求是相同类的对象，且可以比较大小
两种排序方式：自然排序（实现 Comparable 接口）和定制排序（Comparator）
自然排序中，比较两个对象是否相同的标准为：compareTo() 返回0，不再是equals()

定制排序中，比较两个对象是否相同的标准为：compare() 返回0，不再是equals()

Set set = new TreeSet(new Comparator() {
	@Override
    public int compare(Object o1, Object o2) {
    	return 0;
    }
});

6. Map 接口

存储双列数据，即 key-value 对的数据
key 是无序且不可重复的，使用 Set 来存储；因此 key 所在的类要重写 equals() 和 hashCode() （以 HashMap 为例说明）
value 是无序且可重复的，使用 Collection 来存储；因此 value 所在的类要重写 equals()
一个键值对构成一个 Entry 对象，entry 是无序且不可重复的，使用 Set 来存储

6.1 Map的实现类的结构

HashMap 主要实现类，线程不安全的，效率高；可以存储 null 的 key 和 value
Hashtable 古老实现类，线程安全，效率低；不可以存储 null 的 key 和 value
LinkedHashMap 保证在遍历 Map 的元素时，可以按照添加的顺序实现遍历，原因：在原有的 HashMap 底层结构基础上，添加了一对引用，指向前一个和后一个元素；对于频繁的遍历操作，此类执行效率高于 HashMap
TreeMap：保证按照添加的 key-value 对进行排序，实现排序遍历（此时按照 key 来排序），底层使用红黑树
HashMap 底层：数组+链表（JDK7即之前）；数组+链表+红黑树（JDK8）
Properties：常用来处理配置文件，key 和 value 都是 String 类型

6.2 HashMap 的底层实现原理

以 JDK7 为例说明

HashMap map = new HashMap();

在实例化以后，底层创建了长度是16的一维数组 Entry[] table

map.put(key1, value1); // ...可能已经执行过多次 put...

首先，调用 key1 所在类的 hashCode()，计算 key1 的哈希值，此哈希值经过某种算法计算以后，得到在 Entry 数组中的存放位置
如果此位置上的数据为空，此时 key1-value1 添加成功；如果此位置上的数据不为空（此位置上存在一个或链表形式的多个数据），比较当前 key1 和已经存在数据的 key 的哈希值进行比较
如果 key1 的哈希值与已经存在的数据的哈希值都不相同，此时 key1-value1 添加成功；如果 key1 的哈希值与已经存在的某一个数据的哈希值相同，继续比较：调用 key1 所在类的 equals()
如果 equals() 返回 false，此时 key1-value1 添加成功；如果 equals() 返回 true，使用 value1 替换相同 key 的 value 值，此时 key1-value1 和原来的数据以链表的方式存储
在不断的添加过程中，会涉及到扩容问题（即当该次添加的位置不为空，且此时数组的元素个数超过了临界值）默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来

JDK8 相较于 JDK7 在底层实现方面的不同

HashMap map = new HashMap(); 底层没有创建一个长度为16的数组
底层的数组是 Node[]
首次调用 put() 时，底层创建长度为16的数组
JDK7 底层结构：数组+链表；JDK8 底层结构：数组+链表+红黑树（当数组的某一个索引位置上的元素以链表形式存在的数据个数大于8且当前数组长度超过64，此时此索引位置上的所有数据改为使用红黑树存储）

LinkedHashMap 的底层实现原理

为 HashMap 中使用的 Entry 增加了两个属性：before 和 after，用来记录前一个和后一个存储的数据，因此可以记录元素添加的先后顺序

6.3 Map 的常用方法

元素的增加，删除与修改

Object put(Object key, Object value) 向 map 中添加元素
void putAll(Map m) 将给定 map 中的元素都添加到原有的 map 中
Object remove(Object key) 将指定 key 的元素删除，并返回其对应的 value
void clear() 清空 map 中的所有元素

public void test() throws Exception {
	Map map = new HashMap();
	
	// Object put(Object key, Object value) 向 map 中添加元素
	// 如果新添加的元素的 key 已经存在，就用新的 value 替换原来的 value
	map.put(1, "feidu");
	map.put(2, "jiansuiying");
	System.out.println(map);// {1=feidu, 2=jiansuiying}
	map.put(2, "chuyuan");
	System.out.println(map);// {1=feidu, 2=chuyuan}
	
	// void putAll(Map m) 将给定 map 中的元素都添加到原有的 map 中，重复的 key 还是修改对应的 value
	Map map1 = new HashMap();
	map1.put(3, "jiangting");
	map1.put(1, "dudu");
	map.putAll(map1);
	System.out.println(map);// {1=dudu, 2=chuyuan, 3=jiangting}
	
	// Object remove(Object key) 将指定 key 的元素删除，并返回其对应的 value
	Object value = map.remove(3);
	System.out.println(value);// jiangting
	System.out.println(map);// {1=dudu, 2=chuyuan}
	
	// void clear() 清空 map 中的所有元素
	map.clear();
	System.out.println(map);// {}
}

元素查询操作

Object get(Object key) 获取指定的 key 对应的 value
boolean containsKey(Object key) 是否包含指定的 key
boolean containsValue(Object value) 是否包含指定的 value
int size() 返回 map 中键值对的个数
boolean isEmpty() 判断当前 map 是否为空（map 中是否有键值对）
boolean equals(Object o) 判断当前 map 与给定的对象所拥有的键值对是否相同

public void test() throws Exception {
	Map map = new HashMap();
	map.put(1, "feidu");
	map.put(2, "jiansuiying");
	map.put(3, "chuyuan");

	// Object get(Object key) 获取指定的 key 对应的 value
	System.out.println(map.get(1));// feidu
	
	// boolean containsKey(Object key) 是否包含指定的 key
	System.out.println(map.containsKey(2));// true
	
	// boolean containsValue(Object value) 是否包含指定的 value
	System.out.println(map.containsValue("feidu"));// true
	
	// int size() 返回 map 中键值对的个数
	System.out.println(map.size());// 3
	
	// boolean isEmpty() 判断当前 map 是否为空（map 中是否有键值对）
	System.out.println(map.isEmpty());// false
	
	Map map1 = new HashMap();
	map1.put(1, "feidu");
	map1.put(2, "jiansuiying");
	map1.put(3, "chuyuan");
	// boolean equals(Object o) 判断当前 map 与给定的对象所拥有的键值对是否相同
	System.out.println(map.equals(map1));// true
}

元视图操作的方法

Set entrySet() 返回所有键值对构成的 Set
Set keySet() 返回所有 key 构成的 Set
Collection values() 返回所有 value 构成的 Collection

public void test() throws Exception {
	Map map = new HashMap();
	map.put(1, "feidu");
	map.put(2, "jiansuiying");
	map.put(3, "chuyuan");
	
	// Set entrySet() 返回所有键值对构成的 Set
	Set entrySet = map.entrySet();
	for (Object o : entrySet) {
		Map.Entry entry = (Map.Entry) o;
		System.out.println(entry.getKey());// 1
		System.out.println(entry.getValue());// feidu
		System.out.println(entry);// 1=feidu
	}
	
	// Set keySet() 返回所有 key 构成的 Set
	Set keySet = map.keySet();
	keySet.forEach(System.out::println);// 1
	
	// Collection values() 返回所有 value 构成的 Collection
	Collection values = map.values();
	values.forEach(System.out::println);// feidu
}

6.4 TreeMap

向 TreeMap 中添加键值对，要求 key 必须是由同一个类创建的对象，因为排序要按照 key 进行排序（自然排序、定制排序）

public void test() throws Exception {
	Map map = new TreeMap();
	map.put(2, "jiansuiying");
	map.put(3, "chuyuan");
	map.put(1, "feidu");
	System.out.println(map);// {1=feidu, 2=jiansuiying, 3=chuyuan}
}

6.5 Properties

Properties 是 Hashtable 的子类，用于处理属性文件
Properties 里的 key 和 value 都是字符串类型

public void test() throws Exception {
	Properties props = new Properties();
	FileInputStream inputStream = new FileInputStream("jdbc.properties");
	props.load(inputStream);// 加载流对应的文件
	System.out.println(props.getProperty("name"));// dudu
	System.out.println(props.getProperty("password"));// qaz123
}

7. Collections 工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

List list = new ArrayList();
list.add(22);
list.add(-11);
list.add(30);
list.add(14);
System.out.println(list);// [22, -11, 30, 14]

void reverse(List list) 反转 List 中元素的顺序

Collections.reverse(list);
System.out.println(list);// [14, 30, -11, 22]

void shuffle(List list) 对 List 元素进行随机排序

Collections.shuffle(list);
System.out.println(list);// [14, 30, -11, 22]
Collections.shuffle(list);
System.out.println(list);// [-11, 14, 30, 22]

void sort(List list) 根据元素的自然排序对指定 List 的元素按升序排序
```
Collections.sort(list);
System.out.println(list);// [-11, 14, 22, 30]
```

void sort(List list, Comparator c) 根据定制排序对 List 的元素进行排序

Collections.sort(list, new Comparator() {
	@Override
	public int compare(Object o1, Object o2) {
		if (o1 instanceof Integer && o2 instanceof Integer) {
			Integer i1 = (Integer) o1;
			Integer i2 = (Integer) o2;
			return -i1.compareTo(i2);
		}
		throw new RuntimeException("数据类型不匹配");
	}
});
System.out.println(list);// [30, 22, 14, -11]

void swap(List list, int i, int j) 交换给定的两个索引位置的 List 元素
```
Collections.swap(list, 0, 1);
System.out.println(list);// [-11, 22, 30, 14]
```
Object min(Collection coll) 根据元素的自然排序，返回给定集合中的最小元素
Object min(Collection coll, Comparator comp) 根据给定的定制排序，返回给定集合中的最小元素
Object max(Collection coll) 根据元素的自然排序，返回给定集合中的最大元素
Object max(Collection coll, Comparator comp) 根据给定的定制排序，返回给定集合中的最大元素

int frequency(Collection c, Object o) 返回元素 o 在集合 c 中出现的次数

System.out.println(Collections.frequency(list, 30));// 1
System.out.println(Collections.frequency(list, 11));// 0

void copy(List dest, List src) 将 src 中的内容复制到 dest 中

// 此时要求 dest 的 size 要大于等于 src 的 size
List dest = Arrays.asList(new Object[list.size()]);
Collections.copy(dest, list);
System.out.println(dest);// [22, -11, 30, 14]

boolean replaceAll(List list, Object oldVal, Object newVal) 使用 newVal 替换 list 中的 oldVal
synchronizedXxx() 可将指定集合包装成线程安全的集合，从而可以解决多线程并发访问集合时的线程安全问题
```
// 此时的 safeList 就是线程安全的 List
List safeList = Collections.synchronizedList(list);
```

Alice_LMY

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java笔记：集合

1. Java 集合框架概述集合与数组都是对多个数据进行存储操作的结构，简称 Java 容器（此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储）数组在存储多个数据方面的特点：一旦初始化以后，其长度就确定了数组一旦定义好，其元素的类型也就确定了，那么就只能操作指定类型的数据数组在存储多个数据方面的缺点：一旦初始化以后，其长度就不可修改数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高获取数组中实际元素的个数的需求，数组没有现成的属性或方
复制链接

扫一扫

专栏目录