• boolean add(Object o); //向集合中加入一个对象的引用
• void clear(); //删除集合中所有的对象，即不再持有这些对象的引用
• boolean isEmpty(); //判断集合是否为空
• boolean contains(Object o); //判断集合中是否持有特定对象的引用
• boolean remove(Object o); //从集合中删除一个对象的引用
• int size(); //返回集合中元素的数目
• Iterartor iterator(); //返回一个Iterator对象，可以用来遍历集合中的元素
• Object[] toArray(); //返回一个数组，该数组中包括集合中的所有元素
• Stream stream(); //返回一个以集合为源的流，jdk1.8新加的

• 有序性：List 接口维护了元素的插入顺序，可以按照元素在列表中的位置来访问和操作元素，插入的顺序即输出的顺序。
• 允许存储重复元素：与 Set 不同，List 允许在列表中存储相同的元素。
• 允许元素为空：可以插入多个null元素。
• 可通过索引访问元素：List 接口提供了根据索引访问元素的方法，例如 get(int index) 和 set(int index, E element)。

• void add(int index, E element) ：在指定索引位置插入元素。
• E get(int index) ：获取指定索引位置的元素。
• E set(int index, E element) ：将指定索引位置的元素替换为新的元素。
• int indexOf(Object o) ：返回指定元素在列表中第一次出现的索引。
• int lastIndexOf(Object o) ：返回指定元素在列表中最后一次出现的索引。
• E remove(int index) ：移除指定索引位置的元素。

• ArrayList：基于数组实现的 List，适合随机访问元素
  • 优点： 底层数据结构是数组，查询快，增删慢。
  • 缺点： 线程不安全（一般不考虑到线程的安全因素，用Arraylist效率比较高）

• LinkedList：基于链表实现的 List，适合频繁插入、删除操作。
  • 优点： 底层数据结构是链表，增删快，查询慢。
  • 缺点： 线程不安全。

• Vector：线程安全的 List，较少在现代代码中使用。
  • 优点： 底层数据结构是数组，查询快，增删慢。线程安全。
  • 缺点： 效率低（相比 ArrayList 线程不安全的，性能会稍慢一些）。

• 动态数组：ArrayList 内部使用数组来存储元素，可以根据需要动态增加其大小，而不需要手动处理数组扩容的问题。
• 按索引访问：由于基于数组实现，ArrayList 可以通过索引快速访问元素，具有良好的随机访问性能。
• 允许存储重复元素：与 Set 不同，ArrayList 允许在列表中存储相同的元素。
• 允许元素为空：可以插入多个null元素。
• 易于使用：ArrayList 提供了丰富的操作方法，如添加元素、删除元素、获取元素等，使用方便。

1. ArrayList() ：创建一个空的 ArrayList，当第一次add时才会初始化初始容量为 10。
2. ArrayList(int initialCapacity) ：创建一个具有指定初始容量的 ArrayList。
3. ArrayList(Collectionc) ：使用指定 collection 中的元素来构造一个 ArrayList。

• 双向链表：LinkedList 内部使用双向链表来存储元素，每个节点包含对前一个和后一个元素的引用，便于在列表中进行插入和删除操作。
• 插入和删除效率高：由于基于链表实现，插入和删除操作的效率比较高，不需要像数组那样涉及数据的搬移。
• 支持高效的迭代：LinkedList 实现了 List 接口和 Queue 接口，可以作为队列或栈来使用，并且支持高效的迭代操作。
• 占用更多内存：相比于 ArrayList，LinkedList 的每个节点都需要额外的空间存储指向前后节点的引用，可能占用更多的内存

1. LinkedList() ：创建一个空的 LinkedList。
2. LinkedList(Collectionc) ：创建一个包含指定集合中的元素的 LinkedList，这样就可以通过将现有集合传递给构造函数来初始化 LinkedList。

• 不包含重复元素：Set 中不允许包含重复的元素，每个元素在 Set 中都是唯一的。
• 允许空元素：允许一个空元素。
• 无序性：Set 不保证元素的顺序，即元素存储的顺序和插入的顺序不一定相同，但可以使用特定的实现类如 TreeSet 来维护元素的排序状态。
• 常用实现类：Java 中常见的 Set 接口的实现类包括 HashSet、TreeSet 和 LinkedHashSet。
• 用途广泛：由于其元素不重复的特性，Set 通常用于需要确保元素唯一性的场景，例如去重操作、查找某个元素是否存在等。

• boolean add(E e) ：向 Set 中添加一个元素，如果该元素已经存在，则不会添加并返回 false。
• boolean contains(Object o) ：判断 Set 中是否包含指定的元素。
• boolean remove(Object o) ：从 Set 中移除指定的元素。
• int size() ：返回 Set 中的元素个数。
• boolean isEmpty() ：判断 Set 是否为空。

• 不包含重复元素：与 Set 接口一致，HashSet 保证集合中不包含重复的元素，每个元素在 HashSet 中是唯一的。
• 基于哈希表：HashSet 内部使用哈希表来存储元素，这使得查找、插入和删除操作具有很高的性能。
• 无序性：HashSet 不保证元素的顺序，即元素存储的顺序和插入的顺序不一定相同。
• 允许 null 元素：HashSet 允许包含一个 null 元素。

public HashSet() {map = new HashMap<>();
}public HashSet(Collection<? extends E> c) {map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));addAll(c);
}public HashSet(int initialCapacity, float loadFactor) {map = new HashMap<>(initialCapacity, loadFactor);
}public HashSet(int initialCapacity) {map = new HashMap<>(initialCapacity);
}//在LinkedHashSet的构造方法中调用
HashSet(int initialCapacity, float loadFactor, boolean dummy) {map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

• 不包含重复元素：与 Set 接口一致，TreeSet 保证集合中不包含重复的元素，每个元素在 TreeSet 中是唯一的。
• 有序性：TreeSet 通过红黑树实现，可以保证集合中的元素是有序的，通常是按照元素的自然顺序或者通过 Comparator 接口定义的比较规则进行排序。
• 基于红黑树：红黑树是一种自平衡的二叉搜索树，能够保持高效的插入、删除和查找操作。
• 不允许 null 元素：TreeSet 不允许包含 null 元素，否则会抛出 NullPointerException 异常。

public TreeSet() {this(new TreeMap<E,Object>());
}TreeSet(NavigableMap<E,Object> m) {this.m = m;
}public TreeSet(Comparator<? super E> comparator) {this(new TreeMap<>(comparator));
}public TreeSet(Collection<? extends E> c) {this();addAll(c);
}public TreeSet(SortedSet<E> s) {this(s.comparator());addAll(s);
}

import java.util.TreeSet;public class TreeSetExample {public static void main(String[] args) {// 创建一个TreeSet，元素自然排序（升序）TreeSet<Integer> numbers = new TreeSet<>();// 添加一些元素numbers.add(5);numbers.add(3);numbers.add(8);numbers.add(1);// 打印整个TreeSetSystem.out.println("TreeSet: " + numbers);// 查找是否存在某个元素System.out.println("Contains 6: " + numbers.contains(6));// 删除一个元素numbers.remove(3);System.out.println("TreeSet after removing 3: " + numbers);// 遍历TreeSetSystem.out.println("Traversing TreeSet:");for (int number : numbers) {System.out.println(number);}// 排序和检索操作System.out.println("First element: " + numbers.first());System.out.println("Last element: " + numbers.last());System.out.println("Element greater than 4: " + numbers.higher(4));System.out.println("Element lower than 4: " + numbers.lower(4));}
}

四、Queue

Queue 接口是 Java 集合框架中定义的一个接口，它代表了一种队列数据结构，遵循先进先出（FIFO）的原则。Queue 接口继承自 Collection 接口，提供了用于操作队列的方法。

主要方法：

• 添加元素：
  • boolean add(E e) ：将指定元素插入队列，如果队列已满则抛出异常。
  • boolean offer(E e) ：将指定元素插入队列，如果队列已满则返回 false。
• 获取并移除元素：
  • E remove() ：获取并移除队列的头部元素，如果队列为空则抛出异常。
  • E poll() ：获取并移除队列的头部元素，如果队列为空则返回 null。
• 获取但不移除元素：
  • E element() ：获取但不移除队列的头部元素，如果队列为空则抛出异常。
  • E peek() ：获取但不移除队列的头部元素，如果队列为空则返回 null。
• 其他方法：
  • int size() ：返回队列中的元素个数。
  • boolean isEmpty() ：判断队列是否为空。

常见实现类

• LinkedList：实现了 Queue 接口，可以作为队列使用。
• ArrayDeque：同样也实现了 Queue 接口，是一个基于数组实现的双端队列，可以作为队列使用。
• PriorityQueue：优先级队列

应用场景

Queue 接口在 Java 中有许多实际的应用场景，特别是在需要进行异步处理、任务调度、消息传递等方面。以下是一些常见的 Queue 接口的应用场景：

• 任务调度：在多线程编程中，可以使用队列来实现任务调度，将需要执行的任务按照一定的顺序或优先级放入队列中，然后由工作线程按照队列的顺序依次取出并执行这些任务。
• 消息传递：在消息队列（Message Queue）系统中，消息被发送者放入队列，接收者从队列中获取消息并处理。这种方式可以实现解耦和异步通信，常见的消息队列如 RabbitMQ、Kafka 等都是基于队列的实现。
• 生产者消费者模式：队列常常用于实现生产者消费者模式，生产者向队列中放入数据，消费者从队列中取出数据并进行处理，实现了生产和消费的解耦。
• 线程池任务管理：线程池通常使用队列来存储待执行的任务，任务提交到线程池后会被放入队列中等待执行，线程池中的线程会从队列中取出任务并执行。
• 网络爬虫：在网络爬虫程序中，可以使用队列来存储待访问的 URL，爬虫程序从队列中取出 URL 进行访问和解析，将新发现的 URL 放回队列中继续爬取。
• 事件驱动编程：使用事件队列可以实现事件驱动编程模型，将事件按顺序放入队列中，然后由事件处理器逐个处理这些事件。

4.1 ArrayDeque

ArrayDeque 是一个基于数组实现的双端队列，为了满足可以同时在数组两端插入或删除元素的需求，数组必须是循环的，也就是说数组的任何一点都可以被看作是起点或者终点。

这是一个包含了 4 个元素的双端队列，和一个包含了 5 个元素的双端队列：

• 键值对映射：Map 中的数据以键值对的形式存储，每个键都与一个值相关联。
• 键的唯一性：Map 中的键是唯一的，同一个键只能对应一个值。
• 值的重复性：Map 中的值可以重复，不同的键可以映射到相同的值。
• 键和值均可为 null：Map 中的键和值都可以为 null。
• 实现类可以根据需求选择：Java 提供了多个实现 Map 接口的类，如 HashMap、TreeMap、LinkedHashMap、ConcurrentHashMap 等，每种实现类都有自己的特点和适用场景。

• void clear() ：清空 Map 中的所有键值对。
• boolean containsKey(Object key) ：判断 Map 中是否包含指定的键。
• boolean containsValue(Object value) ：判断 Map 中是否包含指定的值。
• V get(Object key) ：获取指定键对应的值。
• boolean isEmpty() ：判断 Map 是否为空。
• SetkeySet() ：返回包含所有键的 Set 集合。
• V put(K key, V value) ：向 Map 中添加键值对。
• V remove(Object key) ：移除指定键对应的键值对。
• int size() ：返回 Map 中键值对的数量。
• Collectionvalues() ：返回包含所有值的 Collection 集合。

• 基于哈希表：HashMap 内部通过哈希表来存储键值对，通过哈希算法可以快速定位到存储位置，实现了常数时间复杂度的插入、删除和查找操作。
• 允许键和值为 null：HashMap 允许键和值都为 null，且可以有一个 null 键和多个 null 值。
• 非线程安全：HashMap 是非线程安全的，如果需要在多线程环境下使用，可以考虑使用 ConcurrentHashMap。
• 无序性：HashMap 不保证键值对的顺序，即插入顺序不会影响元素的遍历顺序。
• 初始容量和加载因子：HashMap 可以指定初始容量和负载因子，加载因子表示哈希表在 rehashing（扩容）之前可以达到多满的程度，默认负载因子为 0.75。
• 迭代器：HashMap 提供了迭代器（Iterator）来遍历键值对。

• HashMap() ：默认构造方法创建一个初始容量为 16，加载因子为 0.75 的空 HashMap。
• HashMap(int initialCapacity) ：创建一个指定初始容量，加载因子为 0.75 的空 HashMap。
• HashMap(int initialCapacity, float loadFactor) ：创建一个指定初始容量和加载因子的空 HashMap。
• HashMap(Mapm) ：使用指定 Map 中的键值对创建一个新的 HashMap。新 HashMap 的容量为原 Map 的两倍。

• put(K key, V value) ：将指定的键值对存储到 HashMap 中。
• get(Object key) ：获取指定键对应的值。
• remove(Object key) ：移除指定键对应的键值对。
• containsKey(Object key) ：判断是否包含指定的键。
• size() ：返回 HashMap 中键值对的数量。
• keySet() ：返回包含所有键的 Set 集合。
• values() ：返回包含所有值的 Collection 集合。​​

• HashMap 底层通过数组、链表、红黑树组合实现。数组被称为“桶”（buckets），每个桶存储一个链表或者一个红黑树，桶位置的节点为链表或红黑树的头结点。
• HashMap 根据 key 的 hashCode 值来确定其存储位置，通过 hashCode 来快速定位到对应的桶。
  • hash ：h = key.hashCode()) ^ (h >>> 16) hashcode与hashcode右移16位做异或运算，为了使hashcode的高位也参加运算，使key充分散列
  • i = (n - 1) & hash 通过hash值计算出桶的位置
• hashCode 和 equals 方法：
  • 在 HashMap 中，key 的 hashCode 用于确定其在数组中的索引位置。
  • 如果两个 key 的 hashCode 相同，HashMap 会使用 equals 方法来进一步判断它们是否相等。
• 解决哈希冲突：
  • 当不同的 key 计算出相同的 hashCode 值时，就会发生哈希冲突。
  • HashMap 使用链表或红黑树来存储具有相同 hashCode 的 key-value 对，以解决哈希冲突。
  • 当链表长度过长（默认超过8个节点），链表会转换为红黑树，以提高检索效率。
• 扩容与负载因子：
  • 当 HashMap 中的元素个数超过负载因子（默认为 0.75 * 容量）时，HashMap 会进行扩容操作。
  • 扩容会创建一个新的更大的数组（2倍扩容：newCap = oldCap << 1），并将原数组中的元素重新分配到新数组中，以减少哈希碰撞。
• 迭代顺序：
  • HashMap 的遍历顺序并不是按照插入顺序或者自然顺序，而是根据 key 的 hashCode 来确定顺序。
  • 因此，HashMap 中的元素遍历顺序是不确定的，不同的运行环境可能会有不同的遍历顺序。
• 线程安全性：
  • HashMap 在多线程环境下不是线程安全的，如果需要在多线程环境中使用，可以考虑使用 ConcurrentHashMap。

5.2 ConcurrentHashMap（重点）

ConcurrentHashMap是J.U.C(java.util.concurrent包)的重要成员，它是HashMap的一个线程安全的、支持高并发的版本。

Map 接口的另一个实现类 Hashtable 虽然是线程安全的，但是执行效率很低。

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable {//......public ConcurrentHashMap() {}public ConcurrentHashMap(int initialCapacity) {if (initialCapacity < 0)throw new IllegalArgumentException();int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?MAXIMUM_CAPACITY :tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));this.sizeCtl = cap;}public ConcurrentHashMap(int initialCapacity, float loadFactor) {this(initialCapacity, loadFactor, 1);}public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) {if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)throw new IllegalArgumentException();if (initialCapacity < concurrencyLevel)   // Use at least as many binsinitialCapacity = concurrencyLevel;   // as estimated threadslong size = (long)(1.0 + (long)initialCapacity / loadFactor);int cap = (size >= (long)MAXIMUM_CAPACITY) ?MAXIMUM_CAPACITY : tableSizeFor((int)size);this.sizeCtl = cap;}public ConcurrentHashMap(Map<? extends K, ? extends V> m) {this.sizeCtl = DEFAULT_CAPACITY;putAll(m);}
}

• 保持插入顺序：LinkedHashMap​会记住元素的插入顺序，并且迭代时会按照插入顺序返回元素。
• 内部采用双向链表维护顺序：在LinkedHashMap​内部，元素以双向链表连接起来，这样可以保证元素的有序性。

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {//......//创建一个空的LinkedHashMap​，默认初始容量为16，负载因子为0.75public LinkedHashMap() {super();accessOrder = false;}//创建一个指定初始容量的LinkedHashMappublic LinkedHashMap(int initialCapacity) {super(initialCapacity);accessOrder = false;}//创建一个指定初始容量和负载因子的LinkedHashMappublic LinkedHashMap(int initialCapacity, float loadFactor) {super(initialCapacity, loadFactor);accessOrder = false;}public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {super(initialCapacity, loadFactor);this.accessOrder = accessOrder;}//创建一个包含指定映射中的所有映射关系的LinkedHashMappublic LinkedHashMap(Map<? extends K, ? extends V> m) {super();accessOrder = false;putMapEntries(m, false);}//......
}

// 创建一个LinkedHashMap实例
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();// 向LinkedHashMap中添加元素
linkedHashMap.put("A", 1);
linkedHashMap.put("B", 2);
linkedHashMap.put("C", 3);// 遍历LinkedHashMap并打印键值对（按插入顺序）
for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());
}// 输出结果将会按照插入顺序：
// A: 1
// B: 2
// C: 3

public class TreeMap<K,V> extends AbstractMap<K,V>implements NavigableMap<K,V>, Cloneable, java.io.Serializable {//......//创建一个空的TreeMap​，按照键的自然顺序进行排序public TreeMap() {comparator = null;}//创建一个空的TreeMap​，按照指定比较器进行排序public TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;}//创建一个TreeMap​，其中包含指定映射中的所有映射关系public TreeMap(Map<? extends K, ? extends V> m) {comparator = null;putAll(m);}public TreeMap(SortedMap<K, ? extends V> m) {comparator = m.comparator();try {buildFromSorted(m.size(), m.entrySet().iterator(), null, null);} catch (java.io.IOException cannotHappen) {} catch (ClassNotFoundException cannotHappen) {}}//......
}

import java.util.TreeMap;public class TreeMapExample {public static void main(String[] args) {// 创建一个 TreeMap 实例TreeMap<String, Integer> treeMap = new TreeMap<>();// 向 TreeMap 中插入键值对treeMap.put("apple", 10);treeMap.put("banana", 20);treeMap.put("orange", 15);// 获取指定键对应的值System.out.println("The value of apple: " + treeMap.get("apple"));// 移除指定键及其对应的值treeMap.remove("banana");// 遍历 TreeMap 中的键值对for (String key : treeMap.keySet()) {System.out.println(key + ": " + treeMap.get(key));}// 创建一个空的TreeMap，按照指定比较器进行排序Comparator<String> customComparator = new CustomComparator(); // 假设CustomComparator是自定义的比较器TreeMap<String, Integer> treeMap2 = new TreeMap<>(customComparator);}
}

public class ArrayList<E> extends AbstractList<E> {//......public Iterator<E> iterator() {return new Itr();}/*** An optimized version of AbstractList.Itr*/private class Itr implements Iterator<E> {int cursor;       // index of next element to returnint lastRet = -1; // index of last element returned; -1 if no suchint expectedModCount = modCount;Itr() {}public boolean hasNext() {return cursor != size;}@SuppressWarnings("unchecked")public E next() {checkForComodification();int i = cursor;if (i >= size)throw new NoSuchElementException();Object[] elementData = ArrayList.this.elementData;if (i >= elementData.length)throw new ConcurrentModificationException();cursor = i + 1;return (E) elementData[lastRet = i];}public void remove() {if (lastRet < 0)throw new IllegalStateException();checkForComodification();try {ArrayList.this.remove(lastRet);cursor = lastRet;lastRet = -1;expectedModCount = modCount;} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}@Override@SuppressWarnings("unchecked")public void forEachRemaining(Consumer<? super E> consumer) {Objects.requireNonNull(consumer);final int size = ArrayList.this.size;int i = cursor;if (i >= size) {return;}final Object[] elementData = ArrayList.this.elementData;if (i >= elementData.length) {throw new ConcurrentModificationException();}while (i != size && modCount == expectedModCount) {consumer.accept((E) elementData[i++]);}// update once at end of iteration to reduce heap write trafficcursor = i;lastRet = i - 1;checkForComodification();}final void checkForComodification() {if (modCount != expectedModCount)throw new ConcurrentModificationException();}}//......
}

public class ArrayList<E> extends AbstractList<E> {//......public ListIterator<E> listIterator() {return new ListItr(0);}private class ListItr extends Itr implements ListIterator<E> {ListItr(int index) {super();cursor = index;}public boolean hasPrevious() {return cursor != 0;}public int nextIndex() {return cursor;}public int previousIndex() {return cursor - 1;}@SuppressWarnings("unchecked")public E previous() {checkForComodification();int i = cursor - 1;if (i < 0)throw new NoSuchElementException();Object[] elementData = ArrayList.this.elementData;if (i >= elementData.length)throw new ConcurrentModificationException();cursor = i;return (E) elementData[lastRet = i];}public void set(E e) {if (lastRet < 0)throw new IllegalStateException();checkForComodification();try {ArrayList.this.set(lastRet, e);} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}public void add(E e) {checkForComodification();try {int i = cursor;ArrayList.this.add(i, e);cursor = i + 1;lastRet = -1;expectedModCount = modCount;} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}}//......
}

public static void main(String[] args) {ArrayList list = new ArrayList();list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");Iterator it = list.iterator();while (it.hasNext()) {String next = (String) it.next();System.out.println(next);}
}

public static void main(String[] args) {ArrayList list = new ArrayList();// 增加：add() 将指定对象存储到容器中list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");for (Iterator it = list.iterator(); it.hasNext();) {//迭代器的next方法返回值类型是Object，所以要记得类型转换。String next = (String) it.next();System.out.println(next);}
}

public static void main(String[] args) {ArrayList list = new ArrayList();list.add("计算机网络");list.add("现代操作系统");list.add("java编程思想");list.add("java核心技术");list.add("java语言程序设计");// 获取List专属的迭代器ListIterator lit = list.listIterator();//正序遍历while (lit.hasNext()) {String next = (String) lit.next();System.out.println(next);}System.out.println("***************");//倒序遍历while (lit.hasPrevious()) {String next = (String)lit.previous();System.out.println(next);}
}

List<String> list = new ArrayList<>();
list.add("沉默王二");
list.add("沉默王三");
list.add("沉默王四");
list.add("沉默王五");
list.add("沉默王六");System.out.println("原始顺序：" + list);// 反转
Collections.reverse(list);
System.out.println("反转后：" + list);// 洗牌
Collections.shuffle(list);
System.out.println("洗牌后：" + list);// 自然升序
Collections.sort(list);
System.out.println("自然升序后：" + list);// 交换
Collections.swap(list, 2,4);
System.out.println("交换后：" + list);//结果打印
原始顺序：[沉默王二, 沉默王三, 沉默王四, 沉默王五, 沉默王六]
反转后：[沉默王六, 沉默王五, 沉默王四, 沉默王三, 沉默王二]
洗牌后：[沉默王五, 沉默王二, 沉默王六, 沉默王三, 沉默王四]
自然升序后：[沉默王三, 沉默王二, 沉默王五, 沉默王六, 沉默王四]
交换后：[沉默王三, 沉默王二, 沉默王四, 沉默王六, 沉默王五]

System.out.println("最大元素：" + Collections.max(list));
System.out.println("最小元素：" + Collections.min(list));
System.out.println("出现的次数：" + Collections.frequency(list, "沉默王二"));// 没有排序直接调用二分查找，结果是不确定的
System.out.println("排序前的二分查找结果：" + Collections.binarySearch(list, "沉默王二"));
Collections.sort(list);
// 排序后，查找结果和预期一致
System.out.println("排序后的二分查找结果：" + Collections.binarySearch(list, "沉默王二"));Collections.fill(list, "沉默王八");
System.out.println("填充后的结果：" + list);//结果打印
原始顺序：[沉默王二, 沉默王三, 沉默王四, 沉默王五, 沉默王六]
最大元素：沉默王四
最小元素：沉默王三
出现的次数：1
排序前的二分查找结果：0
排序后的二分查找结果：1
填充后的结果：[沉默王八, 沉默王八, 沉默王八, 沉默王八, 沉默王八]

public static void main(String[] args) {ArrayList list = Lists.newArrayList();list.add(new Player("香菜"));//  返回的safeList 在add时会进行类型检查List safeList = Collections.checkedList(list, Player.class);//此时会对类型进行检查，不是Player类型，抛出异常 java.lang.ClassCastException:safeList.add("xxx");
}

ArrayList<Player> list = Lists.newArrayList();
//  TODO;-----
List<Player> synList = Collections.synchronizedList(list);

static class SynchronizedList<E> extends SynchronizedCollection<E>implements List<E> {private static final long serialVersionUID = -7754090372962971524L;final List<E> list;SynchronizedList(List<E> list) {super(list);this.list = list;}SynchronizedList(List<E> list, Object mutex) {super(list, mutex);this.list = list;}public boolean equals(Object o) {if (this == o)return true;synchronized (mutex) {return list.equals(o);}}public int hashCode() {synchronized (mutex) {return list.hashCode();}}public E get(int index) {synchronized (mutex) {return list.get(index);}}public E set(int index, E element) {synchronized (mutex) {return list.set(index, element);}}public void add(int index, E element) {synchronized (mutex) {list.add(index, element);}}public E remove(int index) {synchronized (mutex) {return list.remove(index);}}//......
}

ArrayList<Player> list = Lists.newArrayList();
//  TODO;-----
List<Player> synList = Collections.unmodifiableList(list);

static class UnmodifiableList<E> extends UnmodifiableCollection<E>implements List<E> {private static final long serialVersionUID = -283967356065247728L;final List<? extends E> list;UnmodifiableList(List<? extends E> list) {super(list);this.list = list;}public E get(int index) {return list.get(index);}public E set(int index, E element) {throw new UnsupportedOperationException();}public void add(int index, E element) {throw new UnsupportedOperationException();}public E remove(int index) {throw new UnsupportedOperationException();}public int indexOf(Object o)            {return list.indexOf(o);}public int lastIndexOf(Object o)        {return list.lastIndexOf(o);}public boolean addAll(int index, Collection<? extends E> c) {throw new UnsupportedOperationException();}@Overridepublic void replaceAll(UnaryOperator<E> operator) {throw new UnsupportedOperationException();}@Overridepublic void sort(Comparator<? super E> c) {throw new UnsupportedOperationException();}//......
}