一、Java 集合框架体系

Java 集合可分为 Collection 和 Map 两大体系：

• Collection 接口：用于存储一个一个的数据，也称单列数据集合。
  • List 子接口：用来存储有序的、可以重复的数据（主要用来替换数组，"动态"数组）
    实现类:ArrayList(主要实现类)、LinkedList、Vector
  • Set 子接口：用来存储无序的、不可重复的数据（类似于高中讲的"集合"）
    实现类:HashSet(主要实现类)、LinkedHashSet、TreeSet
• Map 接口：用于存储具有映射关系“key-value 对”的集合，即一对一对的数据，也称双列数据集合。(类似于高中的函数、映射。(x1,y1) —> y = f(x) )
  • 实现类:HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties

---

Collection接口的继承树:

---

Map接口的继承树:

---

二、Collection接口和方法

JDK 不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set 和 List）去实现。

Collection 接口是 List 和 Set 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 集合。

• Collection接口方法:
  • 添加:
    • add(E obj)：添加元素对象到当前集合中
    • addAll(Collection other)：添加other集合的所有元素到当前集合中，即 this = this ∪ other
  • 
  • 判断:
    • int size()：获取当前集合中实际存储的元素个数
    • boolean isEmpty()：判断当前集合是否为空集合
    • boolean contains(Object obj)：判断当前集合中是否存在与 obj 对象equals返回true的元素
    • boolean containsAll(Collection coll)：判断 coll 集合中的元素是否在当前集合中都存在。即 coll 集合是否是当前集合的“子集”
    • boolean equals(Object obj)：判断当前集合与 obj 是否相等
  • 删除:
    • void clear()：清空集合元素
    • boolean remove(Object obj) ：从当前集合中删除第一个找到的与 obj 对象 equals 返回 true 的元素。
    • boolean removeAll(Collection coll)：从当前集合中删除所有与 coll 集合中相同的元素。即 this = this - this ∩ coll
    • boolean retainAll(Collection coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与 coll 集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即 this = this ∩ coll
  • 其他:
    • Object[] toArray()：返回包含当前集合中所有元素的数组
    • hashCode()：获取集合对象的哈希值
    • iterator()：返回迭代器对象，用于集合遍历

1. List接口

List 集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

List集合可以理解为一个可扩展的数组。

List 集合存储数据，就像银行门口客服，给每一个来办理业务的客户分配序号：第一个来的是“张三”，客服给他分配的是 0；第二个来的是“李四”，客服给他分配的 1；以此类推，最后一个序号应该是“总人数-1”。

• JDK API 中 List 接口的实现类常用的有：ArrayList、LinkedList 和 Vector。

以下是一些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

package com.example.list;
import java.util.ArrayList;
import java.util.List;
public class TestListMethod {public static void main(String[] args) {// 创建 List 集合对象List<String> list = new ArrayList<String>();// 往 尾部添加 指定元素list.add("图图");list.add("小美");list.add("不高兴");System.out.println(list); // ["图图","小美","不高兴"]// add(int index,String s) 往指定位置添加list.add(1,"没头脑"); // ["图图","没头脑","小美","不高兴"]System.out.println(list);// String remove(int index) 删除指定位置元素 返回被删除元素System.out.println("删除索引位置为 2 的元素");System.out.println(list.remove(2));System.out.println(list); // ["图图","没头脑","不高兴"]// String set(int index,String s)// 在指定位置 进行 元素替代（改）list.set(0, "三毛");System.out.println(list);// String get(int index) 获取指定位置元素// 跟 size() 方法一起用 来 遍历的for(int i = 0;i<list.size();i++){System.out.println(list.get(i));}//还可以使用增强 forfor (String string : list) {System.out.println(string);}}
}

List 接口主要实现类：ArrayList

• ArrayList 是 List 接口的主要实现类
• 本质上，ArrayList 是对象引用的一个”变长”数组
• Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是 Vector 实例。Arrays.asList(…) 返回值是一个固定长度的 List 集合
  

List 的实现类之二：LinkedList

• 对于频繁的插入或删除元素的操作，建议使用 LinkedList 类，效率较高。这是由底层采用链表（双向链表）结构存储数据决定的。
• 特有方法:
  • void addFirst(Object obj) 在链表表头添加元素
  • void addLast(Object obj) 在链表末尾添加元素
  • Object getFirst() 获取链表第一个元素
  • Object getLast() 获取链表最后一个元素
  • Object removeFirst() 删除链表第一个元素
  • Object removeLast() 删除链表最后一个元素

---

ArraryList和LinkedList的优缺点:

ArrayList 的优缺点：
优点：

1. 随机访问快速： ArrayList基于数组实现，可以通过索引进行快速随机访问元素。
2. 适合读取操作： 适合对列表进行频繁的读取操作，因为它可以快速访问任何位置的元素。
3. 节约空间： 相对于LinkedList，ArrayList在存储元素时通常占用更少的空间。

缺点:

1. 插入和删除操作慢：对于大型列表，插入和删除操作的性能较低，因为需要移动元素来维护连续性。
2. 扩容： 当ArrayList达到其容量限制时，需要进行扩容操作，这可能导致性能损失。
3. 不适合频繁的插入和删除操作： 如果需要频繁执行插入和删除操作，ArrayList的性能可能会受到影响。

LinkedList 的优缺点：
优点:

1. 插入和删除操作快速： LinkedList基于链表实现，在插入和删除操作时效率较高，因为只需要改变指针而不需要移动元素。
2. 适合频繁的插入和删除操作： 如果需要频繁执行插入和删除操作，LinkedList可能比ArrayList更适合。
3. 迭代器性能： 在迭代器遍历过程中，LinkedList的性能优于ArrayList。

缺点

1. 随机访问慢： LinkedList不支持随机访问，访问特定位置的元素可能需要遍历列表，因此随机访问效率较低。
2. 占用更多空间： 相对于ArrayList，LinkedList在存储元素时可能占用更多的空间，因为需要额外的指针来连接节点。

List 的实现类之三：Vector

• Vector 是一个古老的集合，JDK1.0 就有了。大多数操作与 ArrayList 相同，区别之处在于 Vector 是线程安全的。

• 在各种 List 中，最好把 ArrayList 作为默认选择。当插入、删除频繁时，使用LinkedList；Vector 总是比 ArrayList 慢，所以尽量避免使用。

• 特有方法：

  • void addElement(Object obj)
  • void insertElementAt(Object obj,int index)
  • void setElementAt(Object obj,int index)
  • void removeElement(Object obj)
  • void removeAllElements()

2. Set接口

• Set 接口是 Collection 的子接口，Set 接口相较于 Collection 接口没有提供额外的方法。
• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
• Set 集合支持的遍历方式和 Collection 集合一样：foreach 和 Iterator。
• Set 的常用实现类有：HashSet、TreeSet、LinkedHashSet。

Set 主要实现类：HashSet

• HashSet 是 Set 接口的主要实现类，大多数时候使用 Set 集合时都使用这个实现类。
• HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存储、查找、删除性能。
• HashSet 具有以下特点:
  • 不能保证元素的排列顺序(使用元素的Hashcode值作为index存储)
  • HashSet 不是线程安全的
  • 集合元素可以是 null
• HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法得到的哈希值相等，并且两个对象的 equals()方法返回值为 true。
• 对于存放在 Set 容器中的对象，对应的类一定要重写 hashCode()和 equals(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。
• HashSet 集合中元素的无序性，不等同于随机性。这里的无序性与元素的添加位置有关。具体来说：我们在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的 hash 值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性。

---

HashSet添加元素的过程:

第 1 步：当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的hashCode() 方法得到该对象的 hashCode 值，然后根据 hashCode 值，通过某个散列函数决定该对象在 HashSet 底层数组中的存储位置。

第 2 步：如果要在数组中存储的位置上没有元素，则直接添加成功。元素会保存在底层数组中。

第 3 步：如果要在数组中存储的位置上有元素，则继续比较：

• 如果两个元素的 hashCode 值不相等，则添加成功；
• 如果两个元素的 hashCode()值相等，则会继续调用 equals()方法：
  • 如果 equals()方法结果为 false，则添加成功。由于该底层数组的位置已经有元素
    了，则会通过链表的方式继续链接，存储。
  • 如果 equals()方法结果为 true，则添加失败

重写 hashCode() 方法的基本原则:

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

重写 equals()方法的基本原则:

1. 重写 equals 方法的时候一般都需要同时复写 hashCode 方法。通常参与计算hashCode 的对象的属性也应该参与到 equals()中进行计算。
2. 推荐：开发中直接调用 Eclipse/IDEA 里的快捷键自动重写 equals()和 hashCode()方法即可。

为什么用 Eclipse/IDEA 复写 hashCode 方法，有 31 这个数字？
首先，选择系数的时候要选择尽量大的系数。因为如果计算出来的 hash 地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）

其次，31 只占用 5bits,相乘造成数据溢出的概率较小。

再次，31 可以 由 i*31== (i<<5)-1 来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）

最后，31 是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有 1 来整除！(减少冲突)

Set 实现类之二：LinkedHashSet

LinkedHashSet 是 HashSet 的子类，不允许集合元素重复。

LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以添加顺序保存的。

LinkedHashSet 插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。

Set 实现类之三：TreeSet

• TreeSet 是 SortedSet 接口的实现类，TreeSet 可以按照添加的元素的指定的属性的大小顺序进行遍历。

• TreeSet 底层使用红黑树结构存储数据

• TreeSet 特点：不允许重复、实现排序（自然排序或定制排序）

• TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

  • 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。
    • 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现Comparable 接口。
    • 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
  • 定制排序：如果元素所属的类没有实现 Comparable 接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过 Comparator接口来实现。需要重写compare(T o1,T o2)方法。
    • 利用 int compare(T o1,T o2)方法，比较 o1 和 o2 的大小：如果方法返回正整数，则表示 o1 大于 o2；如果返回 0，表示相等；返回负整数，表示 o1 小于 o2。
    • 要实现定制排序，需要将实现 Comparator 接口的实例作为形参传递给 TreeSet 的构造器。

• 因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。

• 对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj) 或 compare(Object o1,Object o2)方法比较返回值。返回值为 0，则认为两个对象相等。

三、Map的接口和方法

• Map 与 Collection 并列存在。用于保存具有映射关系的数据：key-value
  • Collection 集合称为单列集合，元素是孤立存在的（理解为单身）。
  • Map 集合称为双列集合，元素是成对存在的(理解为夫妻)。
• Map 中的 key 和 value 都可以是任何引用类型的数据。但常用 String 类作为 Map的“键”。
• Map 接口的常用实现类：HashMap、LinkedHashMap、TreeMap 和Properties。其中，HashMap 是 Map 接口使用频率最高的实现类。
  

1. Map中Key和Value的特点

这里主要以 HashMap 为例说明。HashMap 中存储的 key、value 的特点如下:

Map 中的 key 用 Set 来存放，不允许重复，即同一个 Map 对象所对应的类，须重写 hashCode()和 equals()方法

• key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value，不同 key 对应的 value 可以重复。value 所在的类要重写 equals()方法。
• key 和 value 构成一个 entry。所有的 entry 彼此之间是无序的、不可重复的。

2. Map接口的常用方法

• 添加、修改操作：
  • 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 集合

3. Map 的主要实现类：HashMap

• HashMap 是 Map 接口使用频率最高的实现类。
• HashMap 是线程不安全的。允许添加 null 键和 null 值。
• 存储数据采用的哈希表结构，底层使用一维数组+单向链表+红黑树进行 key-value数据的存储。与 HashSet 一样，元素的存取顺序不能保证一致。
• HashMap 判断两个 key 相等的标准是：两个 key 的 hashCode 值相等，通过equals() 方法返回 true。
• HashMap 判断两个 value 相等的标准是：两个 value 通过 equals() 方法返回true。

举栗说明:

public static void main(String[] args) {HashMap map = new HashMap();map.put("许仙", "白娘子");map.put("董永", "七仙女");map.put("牛郎", "织女");map.put("许仙", "小青");System.out.println("所有的 key:");Set keySet = map.keySet();for (Object key : keySet) {System.out.println(key);}System.out.println("所有的 value:");Collection values = map.values();for (Object value : values) {System.out.println(value);}System.out.println("所有的映射关系:");Set entrySet = map.entrySet();for (Object mapping : entrySet) {//System.out.println(entry);Map.Entry entry = (Map.Entry) mapping;System.out.println(entry.getKey() + "->" + entry.getValue());}
}

4. Map 实现类之二：LinkedHashMap

• LinkedHashMap 是 HashMap 的子类
• 存储数据采用的哈希表结构+链表结构，在 HashMap 存储结构的基础上，使用了一对双向链表来记录添加元素的先后顺序，可以保证遍历元素时，与添加的顺序一致。

• 通过哈希表结构可以保证键的唯一、不重复，需要键所在类重写 hashCode()方法、equals()方法。

5. Map 实现类之三：TreeMap

• TreeMap 存储 key-value 对时，需要根据 key-value 对进行排序。TreeMap 可以保
  证所有的 key-value 对处于有序状态。
• TreeSet 底层使用红黑树结构存储数据
• TreeMap 的 Key 的排序：
  • 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
  • 定制排序：创建 TreeMap 时，构造器传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
  • TreeMap 判断两个 key 相等的标准：两个 key 通过 compareTo()方法或者 compare()方法返回 0。

举个栗子:

public class TestTreeMap {/** 自然排序举例* */@Testpublic void test1(){TreeMap map = new TreeMap();map.put("CC",45);map.put("MM",78);map.put("DD",56);map.put("GG",89);map.put("JJ",99);Set entrySet = map.entrySet();for(Object entry : entrySet){System.out.println(entry);}}/** 定制排序** */@Testpublic void test2(){//按照 User 的姓名的从小到大的顺序排列TreeMap map = new TreeMap(new Comparator() {@Overridepublic int compare(Object o1, Object o2) {if(o1 instanceof User && o2 instanceof User){User u1 = (User)o1;User u2 = (User)o2;return u1.name.compareTo(u2.name);}throw new RuntimeException("输入的类型不匹配");}});map.put(new User("Tom",12),67);map.put(new User("Rose",23),"87");map.put(new User("Jerry",2),88);map.put(new User("Eric",18),45);map.put(new User("Tommy",44),77);map.put(new User("Jim",23),88);map.put(new User("Maria",18),34);Set entrySet = map.entrySet();for(Object entry : entrySet){System.out.println(entry);}}
}
class User implements Comparable{String name;int age;public User(String name, int age) {this.name = name;this.age = age;}public User() {}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}/*举例：按照 age 从小到大的顺序排列，如果 age 相同，则按照 name 从大到小的
顺序排列* */@Overridepublic int compareTo(Object o) {if(this == o){return 0;}if(o instanceof User){User user = (User)o;int value = this.age - user.age;if(value != 0){return value;}return -this.name.compareTo(user.name);}throw new RuntimeException("输入的类型不匹配");}
}

6. Map 实现类之四：Hashtable

• Hashtable 是 Map 接口的古老实现类，JDK1.0 就提供了。不同于 HashMap，Hashtable 是线程安全的。
• Hashtable 实现原理和 HashMap 相同，功能相同。底层都使用哈希表结构（数组+单向链表），查询速度快。
• 与 HashMap 一样，Hashtable 也不能保证其中 Key-Value 对的顺序。
• Hashtable 判断两个 key 相等、两个 value 相等的标准，与 HashMap 一致。
• 与 HashMap 不同，Hashtable 不允许使用 null 作为 key 或 value。

Hashtable 和 HashMap 的区别

HashMap:底层是一个哈希表（jdk7:数组+链表;jdk8:数组+链表+红黑树）,是一个线程不安全的集合,执行效率高
Hashtable:底层也是一个哈希表（数组+链表）,是一个线程安全的集合,执行效率低

HashMap 集合:可以存储 null 的键、null 的值
Hashtable 集合,不能存储 null 的键、null 的值
Hashtable 和 Vector 集合一样,在 jdk1.2 版本之后被更先进的集合(HashMap,Arra
yList)取代了。所以 HashMap 是 Map 的主要实现类，Hashtable 是 Map 的古老实现类。

Hashtable 的子类 Properties（配置文件）依然活跃在历史舞台
Properties 集合是一个唯一和 IO 流相结合的集合

7. Map 实现类之五：Properties

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件
• 由于属性文件里的 key、value 都是字符串类型，所以 Properties 中要求 key 和value 都是字符串类型
• 存取数据时，建议使用 setProperty(String key,String value)方法和 getProperty(String key)方法

举个栗子:

@Test
public void test01() {Properties properties = System.getProperties();String fileEncoding = properties.getProperty("file.encoding");//
当前源文件字符编码System.out.println("fileEncoding = " + fileEncoding);
}
@Test
public void test02() {Properties properties = new Properties();properties.setProperty("user","songhk");properties.setProperty("password","123456");System.out.println(properties);
}
@Test
public void test03() throws IOException {Properties pros = new Properties();pros.load(new FileInputStream("jdbc.properties"));String user = pros.getProperty("user");System.out.println(user);
}

四、Collections工具类

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 frequency(Collection c，Object o)：返回指定集合中指定元素的出现次数

• 复制、替换

  • void copy(List dest,List src)：将 src 中的内容复制到 dest 中
  • boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
  • 提供了多个 unmodifiableXxx()方法，该方法返回指定 Xxx 的不可修改的视图。

• 添加

  • boolean addAll(Collection c,T… elements)将所有指定元素添加到指定 collection 中。

• 同步

  • Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题：
    

举个大栗子:

package com.atguigu.collections;
import org.junit.Test;
import java.text.Collator;
import java.util.*;
public class TestCollections {@Testpublic void test01(){/*public static <T> boolean addAll(Collection<? super T> c,T... 
elements)将所有指定元素添加到指定 collection 中。Collection 的集合的元素类
型必须>=T 类型*/Collection<Object> coll = new ArrayList<>();Collections.addAll(coll, "hello","java");Collections.addAll(coll, 1,2,3,4);Collection<String> coll2 = new ArrayList<>();Collections.addAll(coll2, "hello","java");//Collections.addAll(coll2, 1,2,3,4);//String 和 Integer 之间没
有父子类关系}
@Testpublic void test02(){
/*
* public static <T extends Object & Comparable<? super T>> T max(Col
lection<? extends T> coll)
* 在 coll 集合中找出最大的元素，集合中的对象必须是 T 或 T 的子类对象，而且支
持自然排序
* 
* public static <T> T max(Collection<? extends T> coll,Comparator<? 
super T> comp)
* 在 coll 集合中找出最大的元素，集合中的对象必须是 T 或 T 的子类对象，按照比
较器 comp 找出最大者
*
*/List<Man> list = new ArrayList<>();list.add(new Man("张三",23));list.add(new Man("李四",24));list.add(new Man("王五",25));/** Man max = Collections.max(list);//要求 Man 实现 Comparable 接
口，或者父类实现* System.out.println(max);*/Man max = Collections.max(list, new Comparator<Man>() {@Overridepublic int compare(Man o1, Man o2) {return o2.getAge()-o2.getAge();}});System.out.println(max);}
@Testpublic void test03(){/** public static void reverse(List<?> list)* 反转指定列表 List 中元素的顺序。*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world");System.out.println(list);Collections.reverse(list);System.out.println(list);}
@Testpublic void test04(){/* public static void shuffle(List<?> list) * List 集合元素进行随机排序，类似洗牌，打乱顺序*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world");Collections.shuffle(list);System.out.println(list);}
@Testpublic void test05() {/* public static <T extends Comparable<? super T>> void sort(L
ist<T> list)* 根据元素的自然顺序对指定 List 集合元素按升序排序* public static <T> void sort(List<T> list,Comparator<? super
T> c)* 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序*/List<Man> list = new ArrayList<>();list.add(new Man("张三",23));list.add(new Man("李四",24));list.add(new Man("王五",25));Collections.sort(list);System.out.println(list);Collections.sort(list, new Comparator<Man>() {@Overridepublic int compare(Man o1, Man o2) {return Collator.getInstance(Locale.CHINA).compare(o1.g
etName(),o2.getName());}});System.out.println(list);}
@Testpublic void test06(){/* public static void swap(List<?> list,int i,int j)* 将指定 list 集合中的 i 处元素和 j 处元素进行交换*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world");Collections.swap(list,0,2);System.out.println(list);}
@Testpublic void test07(){/* public static int frequency(Collection<?> c,Object o)* 返回指定集合中指定元素的出现次数*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world","hello","hello
");int count = Collections.frequency(list, "hello");System.out.println("count = " + count);}
@Testpublic void test08(){/* public static <T> void copy(List<? super T> dest,List<? ext
ends T> src)* 将 src 中的内容复制到 dest 中*/List<Integer> list = new ArrayList<>();for(int i=1; i<=5; i++){//1-5list.add(i);}List<Integer> list2 = new ArrayList<>();for(int i=11; i<=13; i++){//11-13list2.add(i);}Collections.copy(list, list2);System.out.println(list);List<Integer> list3 = new ArrayList<>();for(int i=11; i<=20; i++){//11-20list3.add(i);}
//java.lang.IndexOutOfBoundsException: Source does not fit in 
dest//Collections.copy(list, list3);//System.out.println(list);}
@Testpublic void test09(){/*public static <T> boolean replaceAll(List<T> list，T oldVa
l，T newVal)* 使用新值替换 List 对象的所有旧值*/List<String> list = new ArrayList<>();Collections.addAll(list,"hello","java","world","hello","hello
");Collections.replaceAll(list, "hello","song");System.out.println(list);}
}