JAVA SE学习笔记（九）Java集合

1 Java集合框架

1.1 概述

  Java提供集合类的目的是——为了保存数量不确定的数据，以及保存具有映射关系的数据，集合类也被称为是容器类，处于java.util包下。集合类和数组的区别：数组元素可以是基本类型的值，也可以是对象，而集合里只能保存对象。Java的集合类主要是有两个接口派生而出：Collection和Map。

图1-1 Collection集合体系的继承树

图1-2 Map体系的继承树

• Java集合分为：Set、List、Queue、Map
  
  • Set代表无序、不可重复的集合
  • List代表有序、重复的集合
  • Queue队列集合
  • Map代表具有映射关系的集合，键值不可以重复
• 访问方式：List按索引、Map用key访问value、Set使用元素本身访问

1.2 Collection和Iterator接口

1.2.1 Collection接口

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

• Collection接口定义的方法：
  
  • boolean add(Object o)：用于向集合里添加一个元素
  • boolean addAll(Collection c)：用于将集合c里的所有元素添加到指定集合里
  • void clear()：清除集合里的所有元素
  • boolean contains(Object o)：返回集合里是否包含指定元素
  • boolean containsAll(Collection c)：返回集合里是否包含集合c里的所有元素
  • boolean isEmpty()：返回集合是否为空
  • Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素
  • boolean remove(Object o)：删除集合中的指定元素o，当集合中包含了一个或多个元素o时，该方法只删除第一个符合条件的元素
  • boolean removeAll(Collection c)：从集合中删除集合c中的所有的元素，如果删除了一个或多个元素，则返回true
  • boolean retainAll(Collection c)：从集合中删除集合c里不包含的元素，如果操作删除了一个或一个以上的元素，则返回true
  • int size()：返回集合中元素的个数
  • Object[] toArray()：把集合转为一个数组

1.2.2 Iterator接口

  Iterator对象主要是用于遍历Collection集合中的元素，Iterator对象也被称为迭代器

• Iterator接口提供的方法：
  
  • boolean hasNext()：如果被迭代的集合元素还没有被遍历完，则返回true
  • Object next()：返回集合里的下一个元素
  • void remove()：删除集合里上一次next方法返回的元素
  • void forEachRemaining(Consumer action)：使用Lambda方法来遍历集合元素
• 注意：当使用Iterator对集合元素进行迭代时，Iterator并不是把集合元素本身传给了迭代变量，而是把集合元素的值传给了迭代变量，所以修改迭代变量的值对集合元素本身没有任何影响。Iterator迭代器使用的是快速失败（fail-fast）机制，一旦在迭代过程中检测到该集合已经被修改，程序立即引发ConcurrentModificationException异常，而不是显示修改后的结果，这样可以避免共享资源而引发的潜在问题。

1.2.3 遍历Collection

• 使用Lambda表达式遍历集合元素

public static void main(String[] args)throws Exception {
    Collection books = new HashSet();
    books.add("机器学习");
    books.add("统计学习方法");
    books.add("社区发现");
    books.add("大数据时代");
    // Methods inherited from interface java.lang.Iterable
    books.forEach(obj -> System.out.println(obj));
}

• 使用Iterator遍历集合元素

public static void main(String[] args)throws Exception {
    Collection books = new HashSet();
    books.add("机器学习");
    books.add("统计学习方法");
    books.add("社区发现");
    books.add("大数据时代");
    Iterator it = books.iterator();
    while(it.hasNext()){
          System.out.println(it.next());
    }
}

• 使用Lambda表达式遍历Iterator来遍历集合元素

public static void main(String[] args)throws Exception {
    Collection books = new HashSet();
    books.add("机器学习");
    books.add("统计学习方法");
    books.add("社区发现");
    books.add("大数据时代");
    Iterator it = books.iterator();
    it.forEachRemaining(obj -> System.out.println(obj));
}

• 使用foreach循环遍历集合元素

public static void main(String[] args)throws Exception {
    Collection books = new HashSet();
    books.add("机器学习");
    books.add("统计学习方法");
    books.add("社区发现");
    books.add("大数据时代");
    for(Object obj : books){
        System.out.println(obj);
    }
}

2 具体的集合

2.1 链表(List)

• 在Java中，所有链表实际上都是双向链接的，每个结点存放着指向前驱和后继结点的引用
• 链表是一个有序集合

2.1.1 List接口

• List接口提供的方法：
  
  • void add(int index, Object element)：将元素element插入到List集合的index处
  • boolean addAll(int index, Collection c)：将集合c所包含的所有元素都插入到List集合的index处
  • Object get(int index)：返回集合index索引处的元素
  • int indexOf(Object o)：返回对象o在List集合中第一次出现位置的索引
  • int lastIndexOf(Object o)：返回对象o在List集合中最后一次出现位置的索引
  • Object remove(int index)：删除并返回index索引处的元素
  • Object set(int index, Object element)：将index处的元素替换成element对象，返回被替换的旧元素
  • List subList(int fromIndex, int toIndex)：返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合
  • void replaceAll(UnaryOperator operator)：根据operator指定的计算规则重新设置List集合的所有元素
  • void sort(Comparator c)：根据Comparator参数对List集合的元素排序。

2.1.2 ListIterator接口

• ListIterator接口提供的方法：
  
  • boolean hasPrevious()：返回该迭代器关联的集合是否还有上一个元素
  • Object previous()：返回该迭代器的上一个元素
  • void add(Object o)：在当前位置插入一个元素

2.1.3 ArrayList和Vector实现类

• List的两个典型实现：ArrayList和Vector，基于数组实现，通常情况下无须考虑ArrayList和Vector的initialCapacity，但是在大批量数据操作时，可以使用ensureCapacity(int minCapacity)方法一次性地增加initialCapacity，减少分配次数，提高性能，默认长度为10
• 两个和长度相关的函数：
  
  • void ensureCapacity(int minCapacity)：将ArrayList或Vector集合的Object[]数组长度增加大于或等于minCapacity值
  • void trimToSize()：调整ArrayList或Vector集合的Object[]数组长度为当前元素的个数，调用该方法可减少ArrayList或Vector集合对象占用的存储空间。
• ArrayList是线程不安全的，Vector是线程安全的，但是Vector的性能较差，不推荐使用
• Vector提供一个子类：Stack，进出栈的元素都是Object，必须进行类型转换，推荐使用ArrayDeque`
  
  • Object peek()：返回栈的第一个元素
  • Object pop()：返回栈的第一个元素，并出栈

2.1.4 固定长度的List

• Arrays工具类提供了一个asList(Object... a)方法，该方法可以把一个数组或指定个数的对象转换成一个List集合，这个集合是一个Arrays内部类ArrayList的实例，Arrays.ArrayList是一个固定长度的List集合，程序只能遍历访问该集合里的元素，不可增加、删除该集合里的元素

2.1.5 各种线性表的性能分析

1. LinkedList集合不仅提供了List的功能，还提供了双端队列、栈的功能；
2. 综合性能ArrayList优于LinkedList，在查询方面ArrayList优于LinkedList，在插入、删除方面LinkedList优于ArrayList；
3. 遍历集合元素：ArrayLis和Vector推荐使用随机访问方法（get），LinkedList推荐使用迭代器遍历
4. 执行插入、删除操作：推荐使用LinkedList
5. 线程安全型：使用Collections将集合包装成线程安全的集合。

2.3 集合(Set)

2.3.1 HashSet类

• HashSet是最常用的Set集合，HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能，HashSet的特点：
  
  • 不能保证元素的排列顺序；
  • HashSet不是同步的，不是线程安全的；
  • 集合元素值可以是null。
• HashSet的存储过程：当向HashSet中存入一个元素的时候，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode()值，然后根据该HashCode()值决定该对象在HashSet中的存储位置。如果有两个元素通过equals()方法比较返回true，但他们的hashCode()方法返回值不相等，HashSet将会把他们存储在不同的位置，依然可以添加成功。也就是说HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()返回的值也相等。

2.3.2 LinkedHashSet类

• LinkedHashSet也是根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，也就是说，当遍历LinkedHashSet的时候，LinkedHashSet将会按照元素的添加顺序来访问集合里的元素。LinkedHashSet的性能低于HashSet，但在迭代访问Set里的全部元素时将有很好的性能。

2.3.3 TreeSet类

• TreeSet是SortedSet接口的实现类，可以确保集合元素处于排序状态，TreeSet特有的方法：
  
  • Comparator comparator()：如果TreeSet采用了订制排序，则该方法返回定制排序所使用的Comparator，如果TreeSet采用的是自然排序，则返回null
  • Object first()：返回集合中的第一个元素
  • Object last()：返回集合中的最后一个元素
  • Object lower(Object e)：返回集合中位于指定元素之前的元素
  • Object higer(Object e)：返回集合中位于指定元素之后的元素
  • SortedSet subset(Object fromElement, Object toElement)：返回此Set的子集，范围从fromElement（包含）到toElement（不包含）
  • SortedSet headset(Object toElement)：返回此Set的子集，由小于toElement的元素组成
  • SortedSet tailSet(Object fromElement)：返回此Set的子集，由大于或等于fromElement的元素组成
• TreeSet采用红黑树的数据结构来存储集合元素，TreeSet支持两种排序方法：自然排序和订制排序，默认选择自然排序。
  
  • 自然排序：升序
  • 定制排序：通过Comparator对象或Lambda表达式实现TreeSet的定制排序，不可以在其中添加不同类型的对象。
• Comparable接口：compareTo(Object o)方法，实现大小比较，当为0的时候，表示两个对象相等，当为正整数的时候，表示前面的大，当为负整数的时候，表示后面的大。实现了Comparable接口的类：
  
  • BigDecimal、BigInteger等数值包装类：按数值大小比较
  • Character：按Unicode值比较
  • Boolean：true大于false
  • String：按Unicode值比较
  • Date、Time：后面的时间大于前面的时间
• 向TreeSet集合中添加元素时，只有第一个元素无须实现Comparable接口，后面添加的所有元素都必须实现Comparable接口。

2.3.4 EnumSet类

• EnumSet是一个专为枚举类设计的集合类，其中的所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式或隐式地指定，且其中的集合元素也是有序的，同枚举类中的顺序。EnumSet在内部以位向量的形式存储，不允许添加null元素。
• EnumSet提供的类方法：
  
  • EnumSet allOf(Class elementType)：创建一个包含指定枚举类里所有枚举值的EnumSet集合
  • EnumSet complementOf(EnumSet s)：创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合，新EnumSet集合包含原EnumSet集合所不包含的、此枚举类剩下的枚举值
  • EnumSet copyOf(Collection c)：使用一个普通集合来创建EnumSet集合
  • EnumSet copyOf(EnumSet s)：创建一个与指定EnumSet具有相同元素类型、相同集合元素的EnumSet集合
  • EnumSet noneOf(Class elementType)：创建一个元素类型为指定枚举类型的空EnumSet
  • EnumSet of(E first, E… rest)：创建一个包含一个或多个枚举值的EnumSet集合，传入的多个枚举值必须属于同一个枚举类
  • EnumSet range(E from, E to)：创建一个包含从from枚举值到to枚举值范围内所有枚举值类型的EnumSet集合

2.3.5 各Set实现类的性能分析

1. 常用的是HashSet和TreeSet，但是HashSet的性能总是好于TreeSet，只有需要维护顺序的时候，才考虑使用TreeSet，否则都应该使用HasSet；
2. LinkedHashSet和HashSet的对比：LinkedHashSet在遍历查询方面快，HashSet在插入删除方面表现出色；
3. EnumSet是所有集合中性能最好的，但是缺点是只能包含同一个枚举类中的枚举值作为集合元素。
4. HashSet、TreeSet、EnumSet都是线程不安全的。

2.4 队列(Queue)

队列：可以让人们有效地在尾部添加一个元素，在头部删除一个元素

2.4.1 Queue集合

• Queue接口提供的方法：
  
  • void add(Object e)：将指定元素加入此队列的尾部
  • Object element()：获取队列头部的元素，但是不删除该元素
  • boolean offer(Object e)：将指定元素加入此队列的尾部，当使用容量有限的队列时，效果优于add
  • Object peek()：获取队列头部元素，单数不删除该元素，如果队列为空，则返回null
  • Object poll()：获取队列头部的元素，并删除该元素，如果队列为空，则返回null
  • Object remove()：获取队列头部的元素，并删除该元素

2.4.2 PriorityQueue实现类

• PriorityQueue中的元素可以按照任意的顺序插入，却总是按照排序的顺序进行检索
• 优先级队列使用了一个优雅且高效的数据结构——堆

2.4.3 Deque接口和ArrayDeque实现类

• Deque接口是Queue接口的子接口，代表一个双端队列，Deque接口提供的方法：
  
  • void addFirst(Object e)：将指定元素插入该双端队列的开头
  • void addLast(Object e) ：将指定元素插入该双端队列的末尾
  • Iterator descendingIterator()：返回该双端队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素
  • Object getFirst()：获取但不删除双端队列的第一个元素
  • Object getLast()：获取但不删除双端队列的最后一个元素
  • boolean offerFirst(Object e)：将指定元素插入该双端队列的开头
  • boolean offerLast(Object e) ：将指定元素插入该双端队列的末尾
  • Object peekFirst()：获取但不删除双端队列的第一个元素，如队列为空，返回null
  • Object peekLast()：获取但不删除双端队列的最后一个元素，如队列为空，返回null
  • Object poolFirst()：获取且删除双端队列的第一个元素，如队列为空，返回null
  • Object poolLast()：获取且删除双端队列的最后一个元素，如队列为空，返回null
  • Object pop()：pop出该双端队列所表示的栈的栈顶元素
  • void push(Object e)：将一个元素push进该双端队列所表示的栈的栈顶
  • Object removeFirst()：获取并删除该双端队列的第一个元素
  • boolean removeFirstOccurrence(Object o)：删除该双端队列的第一次出现的元素o
  • Object removeLast()：获取并删除该双端队列的最后一个元素

表2-1 Deque的方法与Queue的方法对照表

Queue的方法	Deque的方法
add(e)/offer(e)	addLast(e)/offerLast(e)
remove()/poll()	removeFirst()/pollFirst()
element()/peek()	getFirst()/peekFirst()

表2-2 Deque的方法与Stack的方法对照表

Stack的方法	Deque的方法
push(e)	addFirst(e)/offerFirst(e)
pop()	removeFirst()/pollFirst()
peek()	getFirst()/peekFirst()

- Deque接口提供了一个典型的实现类：ArrayDeque，可以用作“栈”“队”

3 映射

映射用来存放键值对。

3.1 基本映射操作

• Java类库为映射提供了两个通用的实现：HashMap和TreeMap，这两个类都实现了Map接口。HashMap对键进行散列，TreeMap用键的整体顺序对元素进行排序，并将其组织成搜索树，散列或比较函数只能作用于键，与键关联的值不能进行散列或比较。
• Map接口定义的方法：
  
  • void clear()：删除该Map对象中的所有key-value对
  • boolean containsKey(Object key)：查询Map中是否包含指定的key，如果包含则返回true
  • boolean containsValue(Object value)：查询Map中是否包含一个或多个value，如果包含则返回true
  • Set entrySet()：返回Map中包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry对象
  • Object get(Object key)：返回指定key所对应的value，如果此Map中不包含该key，则返回null
  • boolean isEmpty()：查询该Map是否为空，如果为空则返回true
  • Set keyset()：返回该Map中所有key组成的Set集合
  • Object put(Object key, Object value)：添加一个key-value对
  • void putAll(Map m)：将指定Map中的key-value对复制到本Map中
  • Object remove(Object key)：删除指定key所对应的key-value对，返回被删除key所关联的value，如果该key不存在，则返回null
  • boolean remove(Object key, Object value)：删除指定键值对
  • int size()：返回Map中key-value对的个数
  • Collection value()：返回该Map里所有value组成的Collection
• Map.Entry类包含的方法：
  
  • Object getKey()：返回该Entry里包含的key值
  • Object getValue()：返回该Entry里包含的value值
  • Object setValue(V value)：设置该Entry里包含的value值，并返回新设置的value值
• Java 8 为Map新增的方法：
  
  • Object compute(Object key, BiFunction remappingFunction)：该方法使用remappingFunction根据原key-value对计算一个新value。只要新value不为null，就是用新value覆盖原value；如果原value不为null，但新value为null，则删除原key-value对；如果原value、新value同时为null，则该方法不改变任何key-value对，直接返回null
  • Object computeAbsent(Object key, Function mappingFunction)：如果传给该方法的key参数在Map中对应的value为null，则使用mappingFunction根据key计算一个新的结果，如果计算结果不为null，则用计算结果覆盖原有的value。如果原Map原来不包括该key，那么该方法可能会添加一组key-value对。
  • Object computeIfPresent(Object key, BiFunction remappingFunction)：如果传给该方法的key参数在Map中对应的value不为null，则使用mappingFunction根据key、value计算一个新的结果，如果计算结果不为null，则用计算结果覆盖原有的value。如果计算结果为null，则删除原key-value对。
  • void forEach(BiConsumer action)：遍历方法
  • Object getOrDefault(Object key, V defaultValue)：获取指定key对应的value，如果该key不存在，则返回defaultVaule
  • Object merge(Object key, Object key, BiFunction remappingFunction)：该方法会先根据key参数获取该Map中对应的vaule，如果获取的value为null，则直接用传入的value覆盖原有的value；如果获取的value不为null，则使用remappingFunction函数根据原value、新value计算一个新的结果，并用得到的结果去覆盖原有的value
  • Object putIfAbsent(Object key, Object value)：该方法会自动检测指定key对应的value是否为null，如果该key对应的value为null，该方法将会用新value代替原来的null值
  • Object replace(Object key, Object value)：将Map中指定key对应的value替换成新value。与传统put()方法不同的是，该方法不可能添加新的key-value对。如果尝试替换的key在原Map中不存在，该方法不会添加key-value对，而是返回null。
  • boolean replaceAll(K key, V oldValue, V newValue)：将Map中指定key-value对的原value替换成新value。如果在Map中找到指定的key-value对，则执行替换并返回true，否则返回false。
  • replaceAll(BiFunction function)：该方法使用BiFunction对原key-value对执行计算，并将计算结果作为该key-value对的value值

3.2 Java 8 改进的HashMap和Hashtable方法

• HashMap和Hashtable的区别：
  
  • Hashtable是一个线程安全的Map实现，但HashMap是线程不安全的实现。因此HashMap的性能要优于Hashtable
  • Hashtable不允许使用null作为key和value，但是HashMap可以

3.3 LinkedHashMap实现类

• LibkedHashMap使用双向链表来维护key-value对的次序，该列表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致；
• 性能低于HashMap

3.4 使用Properties读写属性文件

• Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件中，也可以把属性文件中的“属性名=属性值”加载到Map对象中，Properties里的key、value都是字符串对象
• 方法：
  
  • String getProperty(String key)：获取Properties中指定属性名对应的属性值
  • String getProperty(String key, String defaultValue)：同上一个函数的功能，就是在key不存在的时候返回默认值
  • Object setProperty(String key, String value)：设置属性值
  • void load(InputStream inStream)：从属性文件中加载key-value对，把加载到的key-value对追加到Properties里
  • void store(OutputStream out, String comments)：将Properties中的key-value对输出到指定的属性文件中

    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        // 向Properties中增加属性
        props.setProperty("username" , "yeeku");
        props.setProperty("password" , "123456");
        // 将Properties中的key-value对保存到a.ini文件中
        props.store(new FileOutputStream("a.ini"), "comment line");   //①
        // 新建一个Properties对象
        Properties props2 = new Properties();
        // 向Properties中增加属性
        props2.setProperty("gender" , "male");
        // 将a.ini文件中的key-value对追加到props2中
        props2.load(new FileInputStream("a.ini") );   //②
        System.out.println(props2);
        props2.loadFromXML(new FileInputStream("b.xml"));
        props2.put("time","2016/9/13");
        props2.setProperty("name","liuqinyuan");
        props2.storeToXML(new FileOutputStream("c.xml"), "刘沁源","UTF-8");
    }

3.5 SortedMap接口和TreeMap实现类

• TreeMap是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点，存储节点的时候，需要根据key对节点进行排序，采用两种排序方式：自然排序和定制排序
• TreeMap提供的方法：
  
  • Map.Entry firstEntry()：返回该Map中最小key所对应的key-value对，如果该Map为空，则返回null
  • Object firstKey()：返回该Map中的最小key值，如果该Map为空，则返回null
  • Map.Entry lastEntry()：返回该Map中最大key所对应的key-value对，如果该Map为空或不存在这样的key-value对，则返回null
  • Object lastKey()：返回该Map中最大key值，如果该Map为空或不存在这样的key-value对，则返回null
  • Map.Entry higherEntry(Object key)：返回该Map中位于key后一位的key-value对，如果该Map为空，则返回null
  • Object higherKey(Object key) ：返回该Map中位于key后一位的key值，如果该Map为空或不存在这样的key-value对，则返回null
  • Map.Entry lowerEntry(Object key)：返回该Map中位于key前一位的key-value对，如果该Map为空，则返回null
  • Object lowerEntry(Object key) ：返回该Map中位于key前一位的key值，如果该Map为空或不存在这样的key-value对，则返回null
  • NavigableMap subMap(Object fromKey, boolean fromInclusive, Object toKey, boolean toInclusive)：返回该Map的子Map，其key值的范围是从fromKey到toKey
  • SortedMap subMap(Object fromKey, Object toKey) ：返回该Map的子Map，其key值的范围是从fromKey（包括）到toKey（不包括）
  • SortedMap tailMap(Object fromKey)：返回该Map的子Map，其key值的范围是大于fromKey（包括）的所有key
  • NavigableMap tailMap(Object fromKey, boolean fromInclusive)：返回该Map的子Map，其key值的范围是大于fromKey的所有key
  • SortedMap headMap(Object toKey)：返回该Map的子Map，其key值的范围是小与toKey（不包括）的所有key
  • NavigableMap headMap(Object toKey, boolean inclusive)：返回该Map的子Map，其key值的范围是小于toKey的所有key

3.6 WeakHashMap实现类

• WeakHashMap的key只保留了对实际对象的弱引用，可能会被垃圾回收机制回收

3.7 IdentityHashMap实现类

• 和HashMap的区别在于判别两个key相等时的机制，此时的key必须严格相等（key1 == key2），而HashMap实现的是equals()方法

3.8 EnumMap实现类

• EnumMap中的所有key都必须是单个枚举类的枚举值，创建EnumMap时必须显式或隐式指定它对应的枚举类
  
  • Enmu枚举类的特征：内部以数组形式存储，性能高
  • 依据key在枚举类中的顺序排序
  • 不允许使用null做key，但是可以做value

3.9 各Map实现类的性能分析

1. HashMap性能优于Hashtable；
2. TreeMap通常比HashMap、Hashtable慢；
3. TreeMap中的key-value总是处于有序状态；
4. 推荐使用HashMap；
5. LinkedHashMap比HashMap慢，可维护添加顺序，使用==而非equals判断相等
6. EnumMap的性能最好，但实际key有限制，只能是属于同一个枚举类
   g) 操作集合的工具类：Collections
    Collections可以操作Set、List、Map等集合，用于排序、查询、修改等

3.10 排序

• Collections提供了如下方法用于对List集合的排序：
  
  • void reverse(List list)：反转指定List集合元素的顺序
  • void shuffle(List list)：对List集合元素进行随机排序
  • void sort(List list)：根据元素的自然顺序对指定List集合的元素按升序进行排序
  • void sort(List list, Comparator c)：根据指定Comparator产生的顺序对List集合元素进行排序
  • void swap(List list, int i, int j)：将指定List集合中的i处元素和j处元素进行交换
  • void rotate(List list, int distance)：当distance为正数时，将list集合的后distance个元素“整体”移到前面，当distance为负数的时候，将List集合的前distance个元素“整体”移到后面。

3.11 查找、替换

• Collections提供的查找、替换集合元素的类方法：
  
  • int binarySearch(List list, Object key)：使用二分搜索法搜索指定的List集合，以或得指定对象在List集合中的索引，强调List必须处于有序状态
  • Object max(Collection coll)：根据元素的自然顺序，返回给定集合中的最大元素
  • Object max(Collection coll, Comparator comp)：根据Comparator指定的顺序，返回给定集合中的最大元素
  • Object min(Collection coll)：根据元素的自然顺序，返回给定集合中的最小元素
  • Object min(Collection coll, Comparator comp)：根据Comparator指定的顺序，返回给定集合中的最小元素
  • void fill(List list, Object obj)：使用指定元素obj替换指定List集合中的最小元素
  • int frequency(Collection c, Object o)：返回指定集合中指定元素的出现次数
  • int indexOfSubList(List source, List target)：返回子List对象在父List对象中第一次出现的位置索引，如果没有，返回-1
  • int lastIndexOfSubList(List source, List target)：返回子List对象在父List对象中最后一次出现的位置索引，如果没有，返回-1
  • boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值newVal替换List对象中所有旧值oldVal

3.12 同步控制

• Collections类提供了多个synchronizedXxx()方法，将指定集合包装成线程同步安全的集合。

    public static void main(String[] args){
        // 下面程序创建了四个线程安全的集合对象
        Collection c = Collections.synchronizedCollection(new ArrayList());
        List list = Collections.synchronizedList(new ArrayList());
        Set s = Collections.synchronizedSet(new HashSet());
        Map m = Collections.synchronizedMap(new HashMap());
    }

3.13 设置不可变集合

1. emptyXxx()：返回一个空的、不可变的集合，此处的集合既可以是List，也可以是SortedSet、Set、SortedMap、Map等
2. singletonXxx()：返回一个只包含指定对象的，不可变的集合对象，可以是List或Map
3. unmodifiableXxx()：返回指定集合对象的不可变视图，可以使List、Set、SortedSet、Map、SortedMap