java——集合介绍【汇总】

一、集合的理解和好处

1.1、数组的不足

1、长度开始时必须指定，而且一旦指定，不能更改

2、保存的必须为同一类型的元素

3、使用数组进行增删，比较麻烦

1.2、集合

1、可以动态保存任意多个对象，使用比较方便!

2、提供了一系列方便的操作对象的方法:add、remove,set、 get等

3、使用集合添加,删除新元素的示意代码

二、集合框架体系

2.1、单列集合

Collection 接口有两个重要的子接口 List Set , 他们的实现子类都是单列集合

2.2、双列集合

Map 接口的实现子类是双列集合，存放的 K-V

三、Collection 接口和常用方法

3.1、Collection接口实现类的特点

3.1.1、public interface Collection<E> extends iterable <E>

1、collection实现子类可以存放多个元素，每个元素可以是0bject

2、有些Collection的实现类，可以存放重复的元素(List)，有些不可以(Set)

3、有些Collection的实现类，有些是有序的(List)，有些不是有序(Set)

4、Collection接口没有直接的实现子类，是通过它的子接口Set 和 List来实现的

3.1.2、Collection 接口常用方法

方法	说明
boolean add(E e)	添加单个元素
boolean remove(Object o)	删除指定元素
boolean contains(Object o)	查找元素是否存在
boolean addAll(Collection<? extends E> c)	添加多个元素
boolean containsAll(Collection<?> c)	查找多个元素是否都存在
boolean removeAll(Collection<?> c)	删除多个元素
int size()	获取元素个数
boolean isEmpty()	判断是否为空
void clear()	清空

3.2、Collection 接口遍历元素方式 1-使用 Iterator(迭代器)

3.2.1、基本介绍

Java.util

接口 Iterator<E>

所有已知子接口：

Listlterator(E>, XILEventReoder
所有已知实现类：
BeoContextSupport，BCStterotor，EventReaderDelezate，Scanner

1、terator对象称为迭代器，主要用于遍历 Collection 集合中的元素。

2、所有实现了Collection接口的集合类都有一个iterator(), 用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。

3、Iterator的结构

4、Iterator 仅用于遍历集合，Iterator 本身并不存放对象。

3.2.2、迭代器的执行原理

terator iterator = coll.iterator0://得到一个集合的迭代器
while(iterator.hasNext()){
    //hasNext():判断是否还有下一个元素
    System.out.println(iterator.next();
    //next()作用:1.下移 2.将下移以后集合位置上的元素返回
}

3.2.3、Iterator接口方法

hasNext()

next()

remove()

注意：在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NosuchElementException异常。

3.2.4、应用

Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
// System.out.println("col=" + col);

// 遍历col集合
// 1. 先得到 col 对应的迭代器
Iterator iterator = col.iterator();
// 2. 使用 while 循环遍历
while (iterator.hasNext()) {//判断是否还有数据
    //返回下一个元素，类型是 Object
    Object obj = iterator.next();
    System.out.println("obj=" + obj);
}
// idea快捷键，快速生成 while => itit
// 显示所有的快捷键的的快捷键 ctrl + j
// 3. 当退出 while 循环后 , 这时 iterator 迭代器，指向最后的元素
// iterator.next();//NoSuchElementException
// 4. 如果希望再次遍历，需要重置我们的迭代器
iterator = col.iterator();

3.3、Collection 接口遍历对象方式 2-for 循环增强

3.3.1、基本介绍

1、增强for循环可以替代iterator迭代器

2、特点：增强for就是简化版的iterator，本质一样。只能用于遍历集合和数组

3.3.2、基本语法

for(元素类型 元素名 : 集合名或数组名){
    访问元素
}

3.3.3、应用

Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
// System.out.println("col=" + col);

//1. 使用增强for, 在Collection集合
//2. 增强for， 底层仍然是迭代器
//3. 增强for可以理解成就是简化版本的 迭代器遍历
//4. ***快捷键方式 I
for (Object book : col) {
    System.out.println("book=" + book);
}

//增强for，也可以直接在数组使用
int[] nums = {1, 8, 10, 90};
for (int i : nums) {
    System.out.println("i=" + i);
}

四、List 接口

4.1、List 接口基本介绍

java.util
接口 List<E>
所有超级接口：
Collection<E>, Iterable<E>
所有已知实现类：
AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector

1、List接口是Collection接口的子接口
2、List 集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
3、List 集合中的每个元素都有其对应的顺序索引，即支持索引，索引是从 0 开始的
4、List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中对应的元素。

4.2、List 接口的常用方法

方法	说明
void add(int index, Object ele)	在 index 位置插入
boolean addAll(int index, Collection eles)	从 index 位置开始将 eles 中的所有元素添加进来
Object get(int index)	获取指定 index 位置的元素
int indexOf(Object obj)	返回 obj 在集合中首次出现的位置
int lastIndexOf(Object obj)	返回 obj 在当前集合中末次出现的位置
Object remove(int index)	移除指定 index 位置的元素，并返回此元素
Object set(int index, Object ele)	设置指定 index 位置的元素为 ele , 相当于替换
List subList(int fromIndex, int toIndex)	返回从 fromIndex 到 toIndex 位置的子集合

4.3、 List 的三种遍历方式 [ArrayList, LinkedList,Vector]

//List 接口的实现子类 ArrayList  Vector LinkedList
List list = new ArrayList();
//List list = new Vector();
//List list = new LinkedList()

//add...

//1. 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
//2. 增强 for
for (Object o : list) {
System.out.println("o=" + o);
}
//3. 使用普通 for
for (int i = 0; i < list.size(); i++){
System.out.println("对象=" + list.get(i));

4.4、List 接口的实现子类—ArrayList

4.4.1、ArrayList 基本介绍

1、ArrayList 可以加入null,并且多个

2、ArrayList是由数组来实现数据存储的[后面老师解读源码]

3、ArrayList 基本等同于Vector，除了 ArrayList是线程不安全(执行效率高)看源码。在多线程情况下，不建议使用ArrayList

4.4.2、ArrayList底层结构

1、ArrayList中维护了一个Object类型的数组
transient Object[ ] elementData; //transient 短暂的表示该属性不会被序列化
2、当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0 ，第一次添加则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5 倍；
3、如果使用的是指定大小的构造器，则初始扩容elementData容量为指定大小，如果需要再次扩容，则直接扩容为1.5倍；

4.5、List 接口的实现子类—Vector

4.5.1、Vector基本介绍

1、 Vector类的定义说明

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

2、 Vectorl底层也是一个对象数组，protected Object[] elementData;

4.5.2、Vector底层结构

1、Vector 底层也是一个对象数组，protected Object[ ] elementData；

2、Vector 是线程同步的，即线程安全，Vector类的操作方法带有synchronized
在开发中，需要线程同步安全时，考虑使用Vector

4.6、List 接口的实现子类—LinkedList

4.6.1、LinkedList基本介绍

1、LinkedList底层实现了双向链表和双端队列特点

2、可以添加任意元素(元素可以重复)，包括null

3、线程不安全，没有实现同步

4.6.2、LinkedList底层结构

1、 LinkedList底层维护了一个双向链表

2、LinkedList中维护了两个属性first和last分别指向首节点和尾节点

3、每个节点(Node对象)，里面又维护了prev、next, item三个属性。其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表

4、所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

4.7、ArrayList，LinkedList，Vector的比较

	底层结构	版本	线程安全(同步)效率	扩容倍数
ArrayList	可变数组	jdk1.2	不安全效率高	如果有参构造1.5倍如果是无参 1.第一次10 2.从第二次开始按1.5扩容
Vector	可变数组 Object[]	jdk1.0	安全增删效率较低改查效率较高	如果是无参，默认10，满后，就按2倍扩容如果指定大小，则每次直接按2倍扩容
LinkedList	双向链表		不安全，增删效率较高，改查效率较低

五、Set接口

5.1、Set接口基本介绍

java.util
接口 Set<E>
类型参数：
E - 此 set 所维护元素的类型
所有超级接口：
Collection<E>, Iterable<E>
所有已知子接口：
NavigableSet<E>, SortedSet<E>
所有已知实现类：
AbstractSet, ConcurrentSkipListSet, CopyOnWriteArraySet, EnumSet, HashSet, JobStateReasons, LinkedHashSet, TreeSet

1、无序(添加和取出的顺序不一致)，没有索引。但是每次取出的顺序一致

2、不允许重复元素，所以最多包含一个null

5.2、Set 接口的常用方法

和 List 接口一样, Set 接口也是 Collection 的子接口，因此，常用方法和 Collection 接口一样.

5.3、Set 接口的遍历方法

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口。

1、可以使用迭代器

2、增强for

3、不能使用索引的方式来获取。

//1. 以 Set 接口的实现类 HashSet 来讲解 Set 接口的方法
//2. set 接口的实现类的对象(Set 接口对象), 不能存放重复的元素, 可以添加一个 null
//3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
//4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是他是固定
Set set = new HashSet();
set.add("john");
//方式 1： 使用迭代器
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
    Object obj = iterator.next();
    System.out.println("obj=" + obj);
}
//方式 2: 增强 for
for (Object o : set) {
    System.out.println("o=" + o);
}
//set 接口对象，不能通过索引来获取

5.4、Set 接口的实现子类—HashSet

5.4.1、HashSet基本介绍

1) HashSet实现了Set接口

2) HashSet实际上是HashMap

public HashSet() {
map = new HashMap();
}

3)可以存放null，但只能有一个空null

4) HashSet不保证元素是有序的，取决于hash后，在确定索引的结果（即，不保证元素顺序和取出顺序一致）

5)不能有重复元素/对象:在前面Set 接口使用已经讲过

5.4.2、HashSet 底层机制说明

分析HashSet底层是HashMap, HashMap底层是(数组+链表+红黑树)

1、模拟简单的数组+链表结构

1）先获取元素的呛希值(hashCode方法)

2）对哈希值进行运算，得出一个索引值，即为要存放在哈希表中的位置号

3）如果该位面上没有其他元素，则直接存放

4）如果该位置上已经有其他元素，则需要进行equals判断，如果相等，则不再添加。如果不相等，则以链表的方式添加。

2、分析HashSet的添加元素底层是如何实现(hash()+equals()

1）HashSet底层是HashMap

2）添加一个元素时。先得到hash值-会转成->索引值

3）找到存储数据表table，看这个索引位置是否已经存放的有元素

4）如果没有，直接加入

5）如果有，调用equals比较。如果相同，就放弃添加。如果不相同。则添加到最后

6）在Java8中,如果一条链表的元素个数到达 TREEIFY_THRESHQLD(默认是8)，并且table的大小>=MIN_TREEIFY_ CAPACITY(默认64),就会进行树化(红黑树)

3、源码解读

......

4、分析HashSet的扩容和转成红黑树机制

1）HashSet层是HashMap，第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子(loadFactor)是0.75 = 12

2）如果table数组使用到了临界值12就会扩容到16*2=32,新的临界值就是32*0.75=24,依次类推

3）在Java8中,如果一条链表的元素个数到达TREEIFY THRESHOLD(默认是8),并且table的大小>=MIN TREEIFY CAPACITY(默认64)，就会进行树化(红黑树),否则仍然采用数组扩容机制

5.5、Set 接口实现类-LinkedHashSet

1)LinkedHashSet是HashSet的子类

2)LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表

3) LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的。

4) LinkedHashSet不允许添重复元素

5.6、Set 接口实现类-TreeSet

1、TreeSet的独特之处在于它的构造器可以传入比较器，所以TreeSet常用来排序，

2、TreeSet 底层是 TreeMap

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSet_ {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();//无参构造，默认排序
        //添加数据
        treeSet.add("Jack");
        treeSet.add("Tom");
        treeSet.add("Ayo");
        treeSet.add("Luck");
        System.out.println(treeSet);//默认排序：首字母ASCII由小到大
        //[Ayo, Jack, Luck, Tom]

        //如果我们想按字符串大小排序
        //使用TreeSet提供的一个构造器，传入一个比较器（匿名内部类）指定排序规则
        treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o2).compareTo((String)o1);//利用String类的compareTo方法，由大到小
                //如果是按照长度由大到小：return ((String)o1).length()-((String)o2).length();
            }//构造器把传入的比较器对象，赋给了TreeSet的底层的TreeMap的属性this.comparator
        });
        treeSet.add("Jack");
        treeSet.add("Tom");
        treeSet.add("Ayo");
        treeSet.add("Luck");
        System.out.println(treeSet);//[Tom, Luck, Jack, Ayo]
    }
}

六、Map 接口

6.1、Map 接口实现类的特点 [很实用]

注意：这里讲的是JDK8的Map接口特点

1)Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value

2) Map 中的key和 value可以是任何引用类型的数据，会封装到HashMap$Node对象中

3) Map中的key 不允许重复，原因和HashSet 一样，前面分析过源码

4) Map 中的value可以重复

5) Map 的key可以为 null, value也可以为null，注意key 为null只能有一个，value为null可以多个

6)常用String类作为Map的 key

7) key和 value之间存在单向一对一关系，即通过指定的key总能找到对应的value

8) Map存放数据的key-value示意图，一对k-v是存放在H阿时候Map$Node中的，又因为Node实现了Entry接口，有些书上也说一对k-v就是一个Entry

6.2、Map接口常用方法

方法	说明
default boolean remove(Object key, Object value)	根据键删除映射关系
V get(Object key)	根据键获取值
int size()	获取元素个数
boolean isEmpty()	判断个数是否为 0
void clear()	清除 k-v
boolean containsKey(Object key)	查找键是否存在

6.3、Map接口遍历方法

Map遍历的示意图(比List, 和Set复杂点但是基本原理一样)

Map接口遍历方式

1)containsKey:查找键是否存在

2)keySet:获取所有的键

3)entrySet:获取所有关系k-v

4)values:获取所有的值

import java.util.*;

public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("海绵宝宝","派大星");
        map.put("熊大","熊二");
        map.put("大头儿子","小头爸爸");
        map.put("黑猫警长",null);
        map.put(null,"奥特曼");
        //第一种：先取出所有的Key，通过Key取出对应的value
        Set keySet = map.keySet();
        //(1)增强for
        for(Object key : keySet){
            System.out.println(key+" - "+map.get(key));
        }
        //(2)迭代器
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key+" - "+map.get(key));
        }

        //第二种：把所有的value取出
        Collection values = map.values();
        //然后遍历Collection就行
        //(1)增强for
        for(Object value : values){
            System.out.println(value);
        }
        //(2)迭代器
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object value =  iterator1.next();
            System.out.println(value);
        }

        //第三种：通过EntrySet来获取
        Set entrySet = map.entrySet();
        //(1)增强for
        for(Object entry : entrySet){
            //将entry转成map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey()+" - "+m.getValue());
        }
        //(2)迭代器
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()) {
            Object next = iterator2.next();
            //向下转型 Map.Entry
            Map.Entry m  =  (Map.Entry) next;
            System.out.println(m.getKey()+" - "+m.getValue());
        }
    }
}

6.4、Map 接口实现类-HashMap

6.4.1、HashMap 小结

1)Map接口的常用实现类:HashMap、Hashtable和Properties.

2)HashMap是Map接口使用频率最高的实现类。

3)HashMap是以 key-val对的方式来存储数据(HashMap$Node类型)[案例Entry ]4) key不能重复，但是值可以重复,允许使用nul键和null值

5)如果添加相同的key,则会覆盖原来的key-val,等同于修改.(key不会替换，val会替换)

6)与HashSet-样，不保证映射的顺序，因为底层是以hash表的方式来存储的.(jdk8的hashMap底层数组+链表+红黑树)

7)HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有synchronized

6.4.2、HashMap 底层机制及源码剖析

1、基本介绍

1) (k,v)是一个Node实现了Map.Entry<K,V>，查看HashMap的源码可以看到.

2)jdk7.0的hashmap 底层实现[数组+链表],jdk8.0底层[数组+链表+红黑树]

2、扩容机制[和HashSet相同]

1)HashMap底层维护了Node类型的数组table,默认为null

2)当创建对象时，将加载因子(loadfactor)初始化为0.75.

3)当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素。如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key和准备加入的key相是否等，如果相等，则直接替换val; 如果不相等需要判断是树结构还是链表结构。做出相应处理。如果添加时发现容量不够，则需要扩容。

4)第1次添加，则需要扩容table容量为16，临界值(threshold)为12(16*0.75)

5)以后再扩容，则需要扩容table容量为原来的2倍(32)，临界值为原来的2倍,即24,依次类推6)在Java8中,如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认是8)，并且table的大小>= MIN_ TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)

6.5、Map 接口实现类-HashTable

6.5.1、HashTable的基本介绍

1、基本内容

1)存放的元素是键值对:即K-V

2) hashtable的键和值都不能为null,否则会抛出NullPointerException

3) hashTable使用方法基本上和HashMap一样

4) hashTable是线程安全的(synchronized), hashMap是线程不安全的

5)简单看下底层结构

2、HashTable的应用案例

下面的代码是否正确，如果错误，为什么?

Hashtable table = new Hashtable0://ok
table.put("john", 100);//ok
table.put(null, 100);//异常
table.put("john", null);//异常
table.put("lucy", 100);//ok
table.put("lic", 100);//ok
table.put("lic", 88):;//替换
System.out.printin(table);

6.6、Hashtable 和 HashMap 对比

	版本	线程安全(同步)	效率	允许null键null值
HashMap	1.2	不安全	高	可以
Hashtable	1.0	安全	较低	不可以

6.7、Map 接口实现类-TreeMap

TreeMap 构造器可以传入比较器，所以TreeMap常用来排序，可以自定义存放数据顺序。

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap_ {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap();//默认构造器，默认比较：自然排序
        treeMap.put("Jack","杰克");
        treeMap.put("Tom","汤姆");
        treeMap.put("Smith","史密斯");
        System.out.println(treeMap);//{Jack=杰克, Smith=史密斯, Tom=汤姆}由小到大排序

        //如果按照传入的key由大到小排序：
        treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o2).compareTo((String)o1);
                //如果是按照长度由大到小：return ((String)o1).length()-((String)o2).length(); 
            }
        });
        treeMap.put("Jack","杰克");
        treeMap.put("Tom","汤姆");
        treeMap.put("Smith","史密斯");
        System.out.println(treeMap);//{Tom=汤姆, Smith=史密斯, Jack=杰克} 由大到小排序
    }
}

6.8、Map 接口实现类-Properties

6.8.1、基本介绍

1、Properties类继承自Hashtable类井且实现了Map接口，也是使用一种键在直对的形式来保存数据。

2、他的使用特点和Hashtable类似

3、Properties 还可以用于从xxx.properties文件中，加载数据到Properties类对象并进行读取和修改

4、说明:工作后 xxx.properties文件通常作为配置文件，这个知识点在10流举例，有兴趣可先看文章

6.8.2、基本使用

//1. Properties 继承 Hashtable
//2. 可以通过 k-v 存放数据，当然 key 和
Properties properties = new Properties
//增加
//properties.put(null, "abc");//抛出 空指针异常
//properties.put("abc", null); //抛出 空指针异常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的 key ， value 被替换
System.out.println("properties=" + properties);
//通过 k 获取对应值
System.out.println(properties.get("lic"));//88
//删除
properties.remove("lic");
//修改
properties.put("john", "约翰");//k不换，v换

6.9、总结-开发中如何选择集合实现类(记住)

1、一组对象[单列]: Collection接口

a）允许重复:List

增删多:LinkedList [麻层维护了一个双向链表]

改查多:ArrayList [麻层维护Object类型的可变数组]

b）不允许重复:Set

无序:HashSet[底层是HashMap，维护了一个哈希表即(数组+链表+

c）排序:TreeSet（提供的一个构造器，可以传入一个比较器(匿名内部类)）

TreeSet treeSet = new TreeSet();
TreeSet treeSet = new TreeSet(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //下面 调用 String 的 compareTo 方法进行字符串大小比较
        //如果老韩要求加入的元素，按照长度大小排序
        //return ((String) o2).compareTo((String) o1);
        return ((String) o1).length() - ((String) o2).length();
    }
});

插入和取出顺序一致：LinkedHashSet,维护数组+双向链表

2、组键值对[双列]: Map

a）键无序: HashMap[底层是:哈希表jdk7:数组+链表，jdk8:数组+链表+红黑树

b）键排序:TreeMap（提供的一个构造器，可以传入一个比较器(匿名内部类)）

TreeMap treeMap = new TreeMap();
TreeMap treeMap = new TreeMap(new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        //按照传入的 k(String) 的大小进行排序
        //按照 K(String) 的长度大小排序
        //return ((String) o2).compareTo((String) o1);
        return ((String) o2).length() - ((String) o1).length();
    }
});

c）键插入和取出顺序一致:LinkedHashMap

d）读取文件 Properties

6.10、Collections 工具类

6.10.1、Collections 工具类介绍

1、Collections是一个操作Set、List 和 Map等集合的工具类

2、Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作

6.10.2、排序、查找、替换操作

1、排序操作（均为 static 方法)

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

2、查找、替换

方法	说明
Object max(Collection)	根据元素的自然顺序返回给定集合中的最大元素。
Object max(Collection, Comparator)	根据指定的顺序返回给定集合中的最大元素。k
Object min(Collection)
Object min(Collection, Comparator)
int frequency(Collection, Object)	返回指定集合中指定元素的出现次数。
void copy(List dest,List src)	将什么中的内容复制到什么中？
boolean replaceAll(List list, Object oldVal, Object newVal)	使用新值替换List 对象的所有旧值