JavaSE之第十章集合框架

zounan07

已于 2022-08-07 10:00:34 修改

阅读量171

点赞数

文章标签：算法 java 数据结构

于 2022-08-05 21:17:10 首次发布

本文链接：https://blog.csdn.net/weixin_45603326/article/details/126185744

版权

第十章集合框架

数组就是一种集合
有一个非常明显的缺点：大小固定

10.1 基本结构

Collection接口
可以存放多个元素的容器，这就是集合
有的集合是有序的，有的集合是无序的
有的集合允许重复元素，有的集合不允许重复元素

List接口
列表：有序的
实现类：
ArrayList类
LinkedList类
Vector类
Set接口
集合：不一定有序
实现类：
HashSet类
TreeSet类
Map接口
映射：A->B
Map接口中的元素必须是一对键-值（Key-Value）
可以从集合中，根据Key找到它对应的Value
实现类：
HashMap类
HashTable类

队列：Queue先进先出 FIFO Firt In First Out
使用LinkedList
客服电话、12306排队买票、滴滴打车

10.2 Collection接口

Collection层次结构中的根接口。Collection表示一组对象，这些对象也成为collection的元素。一切collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些是无序的。
Collection接口概述
既然Collection接口是集合中的顶层接口，那么它中定义的所有功能子类都可以使用，是共性的功能，是集合中所有实现类必须拥有的方法。
所有我们学习的时候首先从父类Collection开始，然后再学习子类中特有的内容。
Collection接口的基本方法

Collection接口与Collections类有何区别？
Collection是一个接口，它规定集合的基本操作
Collections是一个类，主要是用来操作集合的

Collecton接口常用的子接口有：List接口、Set接口
List接口常用的子类有：ArrayList类、LinkedList类
Set接口常用的子类有：HashSet类、LinkedHashSet类
List允许有重复的元素，有序。
Set不予许有重复元素，无序。

创建集合的格式：
方式1：Collection<元素类型> 变量名 = new ArrayList<元素类型>();
方式2：Collection 变量名 = new ArrayList();
方式1创建的集合，只能存储<>中指定的元素类型，该方式为常用方式
方式2创建的集合，集合的元素类型默认为Object类型，即任何类型的元素都可以存储。

演示Collection接口中的方法：

public void test1() {
	Collection<String> collection = new ArrayList<>();
	collection.add("张三");
	collection.add("李四");
	collection.add("王五");
	collection.add("张三");
	System.out.println(collection);
	collection.remove("张三");
	System.out.println(collection);
	Object[] array = collection.toArray();
	for (int i = 0; i < array.length; i++) {
		System.out.print(array[i] + "  ");
	}
}

## 10.3 List接口 List是一个有序的集合，因此可以使用下标访问元素
可以包含重复元素
get(index) 通过下标访问元素
![](https://img-blog.csdnimg.cn/img_convert/b317eb34d1ea3da1a526a8c29300f4b5.png#crop=0&crop=0&crop=1&crop=1&height=269&id=dAd0y&originHeight=430&originWidth=932&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=&width=583)
![](https://img-blog.csdnimg.cn/img_convert/479373a0c545870f12675c3540d294c8.png#crop=0&crop=0&crop=1&crop=1&height=342&id=wEfF2&originHeight=707&originWidth=1269&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=&width=614)
**List接口特点（也是所有实现类的特点）：**
1、它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2、它是一个带有**索引**的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3、集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

List接口的常用子类有：
ArrayList集合
LinkedList集合

10.3.1 ArrayList

是List接口的大小可变数组的实现
是List接口的实现类
底层是数组
大小是可变的

ArrayList: 有序(放进去顺序和拿出来顺序一致)，可重复

创建对象

ArrayList:
1、增加元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移
2、删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
3、替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
4、查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素

//迭代器遍历ArrayList
public static void main(String[] args) {
   List<String> list = new ArrayList<String>();
   list.add("abc1");
   list.add("abc2");
   list.add("abc3");
   list.add("abc4");
   
   list.add(2, "Java");//List接口定义的方法
//迭代器
   Iterator<String> iterator = list.iterator();
   while (iterator.hasNext()) {
     String str = iterator.next();
     System.out.println(str);
   }
   System.out.println("--------------");
   //由于List集合拥有索引，因此List集合迭代方式除了使用迭代器之外，还可以使用索引进行迭代。
   for (int i = 0; i < list.size(); i++) {
     String str = list.get(i);
     System.out.println(str);      
   }
   System.out.println("--------------");
   //迭代器的并发修改异常 java.util.ConcurrentModificationException
   //就是在遍历的过程中,使用了集合方法修改了集合的长度,不允许的
   //对集合使用迭代器进行获取,获取时候判断集合中是否存在 "abc3"对象
   //如果有,添加一个元素 "ABC3"
   Iterator<String> it = list.iterator();
   while(it.hasNext()){
     String s = it.next();
     //对获取出的元素s,进行判断,是不是有"abc3"
     if(s.equals("abc3")){
        list.add("ABC3");
     }
     System.out.println(s);
   }
}

public void ttt() {
	List<String>list=newArrayList<String>();
	list.add("1");
	list.add("2");
	list.add("3");
	list.add("4");
	list.add("5");
	for(String item:list) {
		if(item.equals("3")) {
			System.out.println(item);
			list.remove(item);
		}
	}
	System.out.println(list.size());
}

遍历的时候移除使用Iterator里面的remove方法。

Iterator iterator=list.iterator();
while(iterator.hasNext()) {
    String data= (String)iterator.next();
    if(data.equals("3")) {
        // 不管在foreach还是Iterator遍历过程中都不允许使用list改变长度
        // 如果是移除元素，可以使用Iterator里面的remove，但是对于添加
        // Iterator就没有提供，可以参考ListIterator
        iterator.remove();
        System.out.println(data);
    }
}
System.out.println(list.size());

10.3.2 LinkedList类

LinkedList类也是List接口的实现类
底层采用的是链表
LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法.

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

//LinkedList各种操作
public void test() {
   LinkedList<String> link = new LinkedList<String>();
   //添加元素
   link.addFirst("abc1");
   link.addFirst("abc2");
   link.addFirst("abc3");
   //获取元素
   System.out.println(link.getFirst());
   System.out.println(link.getLast());
   //删除元素
   System.out.println(link.removeFirst());
   System.out.println(link.removeLast());
   
   while(!link.isEmpty()){ //判断集合是否为空
     System.out.println(link.pop()); //弹出集合中的栈顶元素
   }
}

ArrayList类与LinkedList类的区别
1）ArrayList类底层采用数组实现，LinkedList类底层采用链表实现
2）ArrayList类元素的查找快，而元素的添加和删除慢
LinkedList类元素查找慢，而元素的添加和删除快

ArrayList: 有序(放进去顺序和拿出来顺序一致)，可重复
HashSet: 无序(放进去顺序和拿出来顺序不一定一致)，不可重复

ArrayList和LinkedList的大致区别如下:
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
ArrayList内部是使用可増长数组实现的，所以是用get和set方法是花费常数时间的，但是如果插入元素和删除元素，除非插入和删除的位置都在表末尾，否则代码开销会很大，因为里面需要数组的移动。
LinkedList是使用双链表实现的，所以get会非常消耗资源，除非位置离头部很近。但是插入和删除元素花费常数时间。

队列：Queue先进先出 FIFO Firt In First Out
使用LinkedList
客服电话、12306排队买票、滴滴打车

10.3.3 Vector类

Vector类与ArrayList类基本一样
但Vector类是线程安全的，是同步的

Vector集合数据存储的结构是数组结构，为JDK中最早提供的集合。Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器。此接口Enumeration的功能与 Iterator 接口的功能是类似的。Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。
Vector & ArrayList比较
相同点：Vector与ArrayList本质上都是一个Object[] 数组
不同点：
1）Vector是线程安全的集合类，ArrayList并不是线程安全的类。Vector类对集合的元素操作时都加了synchronized，保证线程安全。
2）Vector与ArrayList的扩容并不一样，Vector默认扩容是增长一倍的容量，Arraylist是**增长50%**的容量。ArrayList就有利于节约内存空间。
Vector无论查询还是增删都很慢，所以被ArrayList替代了。

10.4 Set集合

是一个不包含重复元素的collection
无序
实现类有
HashSet类
TreeSet类

10.4.1 HashSet类

特点：是无序的，而且允许null
HashSet:无序(放进去顺序和拿出来顺序不一定一致)，不可重复
无序：HashSet集合不能保证的迭代顺序与元素存储顺序相同。
不重复：HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于两个方法：hashCode()与equals()方法。

HashSet元素不能重复，如何实现：
哈希表 _百度百科
当向哈希表中存放元素时，需要根据元素的特有数据结合相应的算法，这个算法其实就是Object类中的hashCode方法。由于任何对象都是Object类的子类，所以任何对象有拥有这个方法。即就是在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。
总结：保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。
给HashSet中存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法，因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等。

//Set集合操作
public void test551() {
  // 创建HashSet对象
   Set<String> set = new HashSet<String>();
   // 给集合中添加自定义对象
   set.add("zhangsan");
   set.add("lisi");
   set.add("wangwu"); 
   set.add("zhangsan");
   set.add(new String("lisi"));
   for (String string : set) {
      System.out.println(string);
   }
}

结果：
lisi
zhangsan
wangwu

因为HashSet默认是根据变量的地址判断是不是已经加入HashSet了。
这样的话：
Student stu1 = new Student(1, “张三”, 20);
Student stu2 = new Student(1, “张三”, 20);
stu1和stu2都能够加入HashSet里面，因为他们的地址不一样，但是这其实是同一个Student，
只是分别通过不同的方式new出来，如果stu1和stu2都能够加入的话，那么这个学生就在HashSet里面重复了。
所有的类都继承自Object类，Object类里面有hashCode和equal这两个方法，

HashSet调用add方法时候判断这个对象有没有已经在Set里面就是根据equal方法
解决方法就是：我们自己来判断是不是已经存在，选择你要比较的属性，覆写hashCode和equal方法
自定义类型（如果要使用HashSet，必须手动实现hashCode和equals）：

public class Student {
   private Integer id;
   private String name;
   private Integer age;
   public Student() {
     super();
     // TODO Auto-generated constructor stub
   }
   public Student(Integer id, String name, Integer age) {
     this.id = id;
     this.name = name;
     this.age = age;
   }
   public Integer getId() {
     return id;
   }
   public void setId(Integer id) {
     this.id = id;
   }
   public String getName() {
     return name;
   }
   public void setName(String name) {
     this.name = name;
   }
   public Integer getAge() {
     return age;
   }
   public void setAge(Integer age) {
     this.age = age;
   }
   @Override
   public String toString() {
     return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
   }
   @Override
   public int hashCode() {
     final int prime = 31;
     int result = 1;
     result = prime * result + ((age == null) ? 0 : age.hashCode());
     result = prime * result + ((id == null) ? 0 : id.hashCode());
     result = prime * result + ((name == null) ? 0 : name.hashCode());
     return result;
   }
   @Override
   public boolean equals(Object obj) {
     if (this == obj)
        return true;
     if (obj == null)
        return false;
     if (getClass() != obj.getClass())
        return false;
     Student other = (Student) obj;
    // 根据id值和name值age值是不是相等看是否已经存在
     if (age == null) {
        if (other.age != null)
          return false;
     } else if (!age.equals(other.age))
        return false;
     if (id == null) {
        if (other.id != null)
          return false;
     } else if (!id.equals(other.id))
        return false;
     if (name == null) {
        if (other.name != null)
          return false;
     } else if (!name.equals(other.name))
        return false;
     return true;
   }
}

测试：
public void test66() {
   HashSet<Student> set = new HashSet<>();
   set.add(new Student(1, "zhangsan1", 21));
   set.add(new Student(2, "zhangsan2", 22));
   set.add(new Student(3, "zhangsan3", 23));
   set.add(new Student(4, "zhangsan4", 24));
   set.add(new Student(2, "zhangsan2", 22));
   Iterator<Student> iterator = set.iterator();
   while (iterator.hasNext()) {
     Student student = iterator.next();
     System.out.println(student);
   }
}

结果：
Student [id=3, name=zhangsan3,  age=23]
Student [id=4, name=zhangsan4,  age=24]
Student [id=1, name=zhangsan1,  age=21]
Student [id=2, name=zhangsan2,  age=22]

LinkedHashSet介绍
我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序？
在HashSet下面有一个子类LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

public void test4() {
   Set<String> set = new LinkedHashSet<String>();
   set.add("bbb");
   set.add("aaa");
   set.add("abc");
   set.add("bbc");
   Iterator it = set.iterator();
   while (it.hasNext()) {
     System.out.println(it.next());
   }
}

10.4.2 TreeSet类

可以排序

Java中的TreeSet是Set的一个子类，TreeSet集合是用来对象元素进行排序的,同样他也可以保证元素的唯一。
那TreeSet为什么能保证元素唯一，它是怎样排序的呢？

public void test5() {
   TreeSet<Student> treeSet = new TreeSet<>();
    treeSet.add(new Student(1, "张三", 23));
    treeSet.add(new Student(2, "李四", 13));
    treeSet.add(new Student(3, "周七", 13));
    treeSet.add(new Student(4, "王五", 43));
    treeSet.add(new Student(5, "赵六", 33));
   
    System.out.println(treeSet);
}

执行结果：
出错，会抛出一个异常：java.lang.ClassCastException: com.situ.mall.test.Student cannot be cast to java.lang.Comparable
显然是出现了类型转换异常。原因在于我们需要告诉TreeSet如何来进行比较元素，如果不指定，就会抛出这个异常

如何解决：
如何指定比较的规则，需要在自定义类(Student)中实现Comparable接口，并重写接口中的compareTo方法

public class Student implements Comparable<Student>{
   private Integer id;
   private String name;
   private Integer age;
   
  //两个Student怎么比较大小
  @Override
   public int compareTo(Student o) {
       return 0;  //当compareTo方法返回0，元素值每次比较，都认为是相同的元素
       return >0;  //当compareTo方法返回值正数，元素值每次比较，都认为新插入的元素比上一个元素大，读取时就是正序排列的
       return <0; //当compareTo方法返回值负数，元素值每次比较，都认为新插入的元素比上一个元素小，读取时就是倒序排列的
   }
}
按照年龄来排序，年龄相同按照名字排序
public int compareTo(Student o) {
    int num = this.age - o.age;                //年龄是比较的主要条件
    return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
}
按照姓名长度排序：
public int compareTo(Student o) {
    int length = this.name.length() - o.name.length();              //比较长度为主要条件
    int num = length == 0 ? this.name.compareTo(o.name) : length;    //比较内容为次要条件
    return num == 0 ? this.age - o.age : num;                        //比较年龄为次要条件
}

10.5 Map接口

Map是一种非常灵活的数据类型

1、Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
2、Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
3、Collection中的集合称为单列集合，Map中的集合称为双列集合。
4、需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
5、Map中常用的集合为HashMap集合、LinkedHashMap集合。

Map的子类：HashMap、LinkedHashMap
** **https://blog.csdn.net/wobuaizhi/article/details/84105647
HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
Map接口中的常用方法

public static void main(String[] args) {
   // 创建Map对象
   Map<String, String> map = new HashMap<String, String>();
   // 给map中添加元素
   map.put("星期一", "Monday");
   map.put("星期日", "Sunday");
   System.out.println(map); // {星期日=Sunday, 星期一=Monday}
   // 根据指定的key获取对应的value
   String en = map.get("星期日");
   System.out.println(en); // Sunday
   // 根据key删除元素,会返回key对应的value值
   String value = map.remove("星期日");
   System.out.println(value); // Sunday
   System.out.println(map); // {星期一=Monday}
}

Map集合遍历键找值方式：
一、键找值方式：即通过元素中的键，获取键所对应的值
1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键
3.根据键，获取键所对应的值

二、Map集合遍历键值对方式
键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤与图解：
1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
3.通过键值对(Entry)对象，获取Entry对象中的键与值。

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

10.5.1 HashMap类

不同步可以使用null值和null键

创建对象
操作对象

Map：键值对（和查字典类似）
Map<K, V> key,value

Set<Entry<String, String>> set = map.entrySet();
map.keySet();

10.5.2 HashTable类

除了非同步和允许使用null之外，HashMap类与HashTable类大致相同

同步的，不允许使用null值

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

10.6 集合的遍历

10.6.1 List集合的遍历

1）循环下标
2）foreach
3）使用迭代器遍历

运行上述代码发生了错误 java.util.ConcurrentModificationException这是什么原因呢？
在迭代过程中，使用了集合的方法对元素进行操作。导致迭代器并不知道集合中的变化，容易引发数据的不确定性。
并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。
那么想要在迭代时对元素操作咋办？通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。

public void ttt() {
   List<String> list = new ArrayList<String>();
   list.add("1");
   list.add("2");
   list.add("3");
   list.add("4");
   list.add("5");
   for (String item : list) {
     if (item.equals("3")) {
        System.out.println(item);
        list.remove(item);
     }
   }
   System.out.println(list.size());
}
遍历的时候移除使用Iterator里面的remove方法。
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
   String data = (String) iterator.next();
   if (data.equals("3")) {
     // 不管在foreach还是Iterator遍历过程中都不允许使用list改变长度
      // 如果是移除元素，可以使用Iterator里面的remove，但是对于添加
      // Iterator就没有提供，可以参考ListIterator
     iterator.remove();
     System.out.println(data);
   }
}
System.out.println(list.size());

10.6.2 Set集合的遍历

不能使用循环遍历

Foreach

2）使用迭代器遍历（与List相似）

10.6.3 Map集合的遍历

不能使用循环遍历
1）先将键/键值对，生成一个Set，然后再遍历

在使用foreach进行遍历时，如果对集合进行添加、删除元素的操作，会报错
foreach底层也是使用迭代器进行元素遍历，是一种隐式迭代
在使用Iterator进行遍历时，如果对集合进行添加、删除的操作，也会报错
显示的迭代器操作
注意：当使用迭代器进行遍历操作时，会将原集合保护起来如果需要在迭代过程中对集合进行操作，请对迭代器进行。

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤与图解：
1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
3.通过键值对(Entry)对象，获取Entry对象中的键与值。

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

10.7 Iterator迭代器

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。
Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下：

hasNext（）方法：用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代。
next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。
在Collection接口描述了一个抽象方法iterator方法，所有Collection子类都实现了这个方法，并且有自己的迭代形式。

public void test2() {
   Collection<String> collection = new ArrayList<>();
   collection.add("张三");
   collection.add("李四");
   collection.add("王五");
   collection.add("张三");
   Iterator<String> iterator = collection.iterator();
   while (iterator.hasNext()) {//判断有没有下一个,有下一个返回true
     String data = iterator.next();//用来返回迭代的下一个元素，并把指针向后移动一位
     System.out.println(data);
   }
}

10.8 Collections类

**Collections集合工具类 Arrays **
Collections类常用方法总结
Collections是集合工具类，用来对集合进行操作。部分方法如下：

public static <T> void sort(List<T> list) // 集合元素排序
//排序前元素list集合元素 [33,11,77,55]
Collections.sort( list );
//排序后元素list集合元素 [11,33,55,77]
public static void shuffle(List<?> list) //  集合元素存储位置打乱
//list集合元素 [11,33,55,77]
Collections.shuffle( list );
//使用shuffle方法后，集合中的元素为[77,33,11,55]，每次执行该方法，集合中存储的元素位置都会随机打乱

排序操作：

void reverse(List list)：反转
void shuffle(List list),随机排序
void sort(List list),按自然排序的升序排序
void sort(List list, Comparator c);定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j),交换两个索引位置的元素
void rotate(List list, int distance),旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。
查找，替换操作：
int binarySearch(List list, Object key), 对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll),根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)，根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj),用元素obj填充list中所有元素
int frequency(Collection c, Object o)，统计元素出现次数
int indexOfSubList(List list, List target), 统计targe在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素。