Java_Collection集合与Map集合的理解与应用

集合

概述：可以存储多个数据的容器

• 集合和数组的区别：

  • 相同点：都可以存储多个数组

  • 不同点：

    • 数组中可以存多个数据，但是不能自由的实现数据的新增和删除操作

      集合中除了可以存储多个数据，还可以自由的实现数据的新增和删除操作

    • 数组中及可以存储基本类型的数据有可以存储引用类型数据

      集合中只能存储引用类型数据

    • 数组本身自带的功能较少，集合中自带的功能比较多

集合的体系

Collection集合

概述：此类是单列集合的顶层接口，任何单列集合都属于该接口的子接口或者实现类。

• 特点
  • 是一个接口不能去创建对象。只能通过实现类创建对象访问其中的方法。
  • 在java.util包，需要导包使用
  • Collection中定义的方法，子接口和实现类都可以去使用。

Collection集合中常用的方法

• **add(E e) ：**往集合中添加元素
• **addAll(Collection<? extends E> c) ：**将集合c中的内容全添加到调用者集合中
• **remove(Object o) ：**删除集合中的o元素
• **removeAll(Collection<?> c) ：**删除调用者集合中和c集合中相同的元素
• **clear() ：**清空集合
• **contains(Object o) ：**判断集合中是否包含元素o
• **containsAll(Collection<?> c) ：**判断调用者集合中是否全部包含集合c的所有元素
• **isEmpty() ：**判断集合是否为空
• **size() ：**返回集合中元素的个数

 //创建Collection的实现类list，用接口接收
        Collection c = new ArrayList();
        //添加add
        c.add("chen");
        c.add("shuang");
        System.out.println(c);
        Collection c1 = new ArrayList();
        c1.add("1999");
        c1.add("0328");
        c1.add(4);
        //add All
        c.addAll(c1);
        System.out.println(c);

        //删除集合中的元素
        c.remove("chen");
        //删除集合c中和集合c1中相同的元素
        c.removeAll(c1);
        System.out.println(c);

        //判断集合中包含某一个元素
        System.out.println("------------");
        System.out.println(c.contains(4));
        System.out.println(c.containsAll(c1));
        //将集合中元素全部删除
        c.clear();
        //判断集合是否为空
        System.out.println(c.isEmpty());
        //判断集合元素个数
        System.out.println(c.size());

Collection集合的遍历方式

Collection集合的第一种遍历方式

• **转数组遍历：**将集合中的数据转到一个数组中，再遍历数组，等于是间接的遍历集合。

• **集合转为数组的方法：**toArray()

 		Collection c =new ArrayList();
        c.add(new Person("陈一",11));
        c.add(new Person("陈二",13));
        c.add(new Person("陈三",12));
//遍历方法一：
        //先把集合转成数组，用Object超类接收
        Object[] o = c.toArray();
        //遍历Object数组
        for (int i = 0; i < c.size(); i++) {
            //强制转型为Person类型
            Person p = (Person)o[i];
            System.out.println(p.getName());
        }
//陈一
//陈二
//陈三

Collection集合的第二种遍历方式

• 使用迭代器遍历集合

  迭代：更新换代，一个到下一个

  迭代器：用来获取集合中每一个元素的对象

• **获取迭代器的方式：**通过集合定义的方法来获取：iterator()

• 迭代器对象可以使用的方法：

  • next();

  • hasNext();

• 注意事项：

  • 虽然每次使用的方法都是next，但是获取的值是不同的
  • next方法不仅可以获取下一个元素，而且获取之后，可以将指针指向下一个元素
  • hasnext方法只可以判断是否有下一个元素，不能移动指针
  • 如果集合中没有下一个元素了，仍然获取，会出现一个异常： NoSuchElementException

 		Collection c =new ArrayList();
        c.add(new Person("陈一",11));
        c.add(new Person("陈二",13));
        c.add(new Person("陈三",12));

//先获取一个迭代器对象
        Iterator i = c.iterator();
        //使用hasNext()方法判断是否有下一个元素，如果有返回true否则false
        while (i.hasNext()){
            //如果有下一个元素，就用next()来获取该元素
            System.out.println(i.next());
        }
//Person{name='陈一', age=11}
//Person{name='陈二', age=13}
//Person{name='陈三', age=12}

        //强转--
        Iterator i1 = c.iterator();
        while (i1.hasNext()){
            //注意：(Person)i1.next()
            Person pp = (Person)i1.next();
            System.out.println(pp.getName()+"是："+pp.getAge());
        }
//陈一是：11
//陈二是：13
//陈三是：12

Collection集合的第三种遍历方式

• 使用增强for循环遍历

• 增强for循环：

  ​ 它是JDK5之后出现的，其内部原理Iterator迭代器相同

格式：

 for(元素的数据类型 元素名称：集合或者数组名称){
     元素名称的使用
 }

 //for(超类 公共名称：集合名称)
        for (Object o1:c){
            System.out.println(o1);
        }

代码：

 		Collection c =new ArrayList();
        c.add(new Person("陈一",11));
        c.add(new Person("陈二",13));
        c.add(new Person("陈三",12));

        //for(超类 公共名称：集合名称)
        for (Object o1:c){
            System.out.println(o1);
        }
//Person{name='陈一', age=11}
//Person{name='陈二', age=13}
//Person{name='陈三', age=12}

        //强转--遍历单个元素值
        for (Object o2 : c) {
            Person p1 = (Person)o2;
            System.out.println((p1.getName())+"是"+(p1.getAge()));
        }
//陈一是11
//陈二是13
//陈三是12

List集合

List集合是Collection接口下的子接口

• 特点：
  • 属于一个单列集合
  • 不能直接创建对象，可以通过实现类创建对象
  • 该集合中的元素特点：
    • 有序：元素存入的和取出的顺序可以保证一致
    • 有索引：每个元素都有自己的一个位置，通过有序的序号来表示这个位置，索引
    • 可重复：集合中可以存储相同的元素值

List集合中特殊的方法

• **add(int index, E element) ：**往集合中的指定位置添加元素
• **get(int index) ：**获取集合中指定元素的值
• **remove(int index) ：**删除指定位置的元素
• **set(int index, E element) ：**修改集合中指定位置的元素值为element

代码：

并发修改异常解决

ConcurrentModificationException

出现该异常的原因：

• 一边使用迭代器对象遍历集合，一边使用集合对象增加或者删除元素

ConcurrentModificationException异常
            Iterator i =list.iterator();   
            while (i.hasNext()){          //使用迭代器遍历集合 
                Object o = i.next();
                if (o.equals("chen")){
                    list.add("AAA");      //集合对象增加元素
                }
            }
        System.out.println(list);

解决方案：【统一】

• 一边使用集合对象遍历，一边使用集合对象增加或者删除
• 一边使用迭代器遍历，一边使用迭代器增加或删除

第一种方式：

• 使用集合遍历：list.size方法和List.get方法

• 使用集合增加：list.add

 //解决办法一：使用集合遍历
        for (int i = 0; i < list.size()-1; i++) {
            Object o = list.get(i);
            System.out.print(o+" ");
        }

第二种方式：

• **迭代器遍历：**hasnext next
• 迭代器增加：
  • 使用父类中获取迭代器对象的方式，没有增加元素的方法，所以要使用List集合特有的获取方式：listIterator（）
  • 通过这个特有的方式获取的迭代器对象，不仅可以遍历集合，而且有add方法来增加元素。

ListIterator lis =list.listIterator();
        while (lis.hasNext()){
            Object o = lis.next();
            if (o.equals("chen")){
                lis.add("AAA");
            }
        }

List的实现类

概述：List集合也是一个接口，根据底层存储数据方式的不同有不同的实现类

分类：

• ArrayList
• LinkedList

ArrayList

List集合的实现类，本类没有特殊的方法，只能使用接口中定义的方法

特点：

• 底层数组实现，可以表示元素有序
• 查询元素的效率高，增删元素的效率低
• 特点：元素有序，元素有索引，元素可以重复

总结：

• 使用空参构造创建一个ArrayList集合对象，其实底层维护了一个空Object数组
• 当第一次向集合中添加元素，底层先将数组扩容，从0扩容10
• 当10个元素存储之后，继续存储其他元素，底层继续对数组进行扩容，扩容原来的1.5倍，依次类推。

LinkedList

属于List接口的实现类，可以使用接口中继承方法

• 底层通过双向链表实现，可以保证元素有序

• 查询元素效率低，增删元素效率高

• 使用构造方法创建一个LinkedList对象，底层什么也没有维护（数据是保存在Node对象中，如果没有数据，就不需要创建Node对象）

  如果使用该集合对象增加一个元素，那么底层就会新建一个Node对象（节点）来保存该元素的值，以及上一个元素和下一个元素的地址值，如果继续新增元素，那么该新增的元素就是最后一个元素，将上一个元素的last地址改为新元素的地址，也会将新元素的上一个元素地址进行保存

特有方法：【因为linkedList可以记录头部和尾部元素的地址，所以有一些操作头部和尾部元素的方法：】

• addFirst(); 在头部位置添加元素
• addLast(); 在尾部添加元素
• removeFirst(); 删除头部位置的元素
• removeLast(); 删除尾部的元素
• getFirst(); 获取头部元素
• getLast(); 获取尾部元素

总结

• 数组和集合的区别

• Colllection特点

  方法

• Collection遍历方式：

  转数组：toArray

  迭代器：iterator

  增强for循环

• List集合特点

• 元素有序 有索引 可以存储重复值

• add(index ,e) get(index) remove(index) set(index,e)

  特有的遍历方式： size() get(index)

• 异常：并发修改异常

  使用同一个对象遍历集合，增删元素

• ArrayList：

  底层数组实现，查询快，增删慢

• LinkedList：

  底层双向链表实现，查询慢，增删快

  有特殊的方法

• 数组和集合的区别

• Colllection特点

  方法

• Collection遍历方式：

  转数组：toArray

  迭代器：iterator

  增强for循环

• List集合特点

• 元素有序 有索引 可以存储重复值

• add(index ,e) get(index) remove(index) set(index,e)

  特有的遍历方式： size() get(index)

• 异常：并发修改异常

  使用同一个对象遍历集合，增删元素

• ArrayList：

  底层数组实现，查询快，增删慢

• LinkedList：

  底层双向链表实现，查询慢，增删快

  有特殊的方法

  Set集合

概述：该集合是一个单列集合，是Collection集合的子接口。

特点：

• 在java.util包中

• 该类元素特点：

  ​ 不可重复：集合中不可以存储相同的元素（去重）

   **没有索引：集合中没有一些操作元素索引的方法**
  

  ​ 无序：元素存储的顺序和取出的顺序不能保持一致

TreeSet集合

概述：TreeSet集合为Set集合的实现类。

特点：

• 不可重复：集合不可以存放重复的元素（去重）

• 无序：元素存入和取出的顺序不一致

• 无索引：元素没有索引来对应

• 该集合底层使用二叉树来存储

  虽然该集合是无序存入和取出，但是该集合可以对元素进行排序

存储元素排序方式：

• 如果集合中存储的是整数、小数则按照数据的大小，从小到达排序

• 如果集合中存储的是字符、则按照字符转码后的整数从小到达排序

• 如果是非中文字符串类型，则按照字符串中字符转码后的整数从小到达排序

• 如果是中文字符串则按照中文字符解码后的数字大小，从小到大排列

• 如果是自定义的类型对象，不能直接使用TreeSet集合存储

  ​ 解决方案：实现Comparable接口，并重写接口中的compareTo方法

compareTo方法排序原理：

• Comparable接口: 是一个比较接口

• 需要重写该接口的方法： public int compareTo(Object o)

• 方法的比较规则：

  Comparable接口: 是一个比较接口

（2）需要重写该接口的方法： public int compareTo(Object o)

（3）方法的比较规则：

返回值为0 默认添加的元素重复，就实现去重

返回值为正 默认添加的元素大，将元素存储在右子树（后取）

返回值为负 默认添加的元素小，将元素存储在左子树（先取）

//person类实现比较接口并重写compareTo方法
public class Person implements Comparable<Person> {
     @Override
    public int compareTo(Person o) {
//        当前的减去上一次的返回值大，放右边，后取出，所以是从大到小排序
//        return this.age-o.age;
        //年龄比
        int a= this.age-o.age;
        //姓名比
        int b = this.name.compareTo(o.name);
        return a!=0 ? a:b;
    }
}

//以上类重写后的方法可以决定测试类中TreeSet集合输出的排序顺序
public class Person_complication {
    public static void main(String[] args) {
        TreeSet<Person> p = new TreeSet<>();
        p.add(new Person("张三",18));
        p.add(new Person("李四",15));
        p.add(new Person("王五",20));
        p.add(new Person("赵六",14));
        p.add(new Person("陈八",16));
        p.add(new Person("王五",16));
        p.add(new Person("周七",22));

        System.out.println(p);
         }
}

Comparator比较器使用

案例：

使用TreeSet集合存储多个学生信息，
先按照学生的总成绩升序排列
如果总成绩相同，则按照语文成绩升序排列
如果语文成绩也相同，则按照名字的自然排序升序排列

学生类：
属性：姓名 语文成绩 数学成绩

public class Student {
    private String name;
    private int chinese;
    private int math;
    private int sum=chinese+math;
    public Student() {
    }
    public Student(String name, int chinese, int math) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getChinese() {
        return chinese;
    }
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
    public int getMath() {
        return math;
    }
    public void setMath(int math) {
        this.math = math;
    }
    public int getSum() {
        return sum;
    }
    public void setSum(int sum) {
        this.sum = sum;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", chinese=" + chinese +
                ", math=" + math +
                ", sum=" + sum +
                '}';
    }
}

//测试类
public class Student_Test {
    public static void main(String[] args) {
        //使用Comparator比较器，new一个匿名内部类
        Comparator c = new Comparator<Student>(){
            @Override
            public int compare(Student o1, Student o2) {
                int sum = o1.getSum() - o2.getSum();//此值大于零时，按成绩升序
                int chinese = o1.getChinese() - o2.getChinese();
                int name = o1.getName().compareTo(o2.getName());
                return sum == 0 ? (chinese == 0 ? name : chinese) : sum;
            }
        };
        //往集合中录入数据
        TreeSet<Student> s = new TreeSet<>(c);
        s.add(new Student("张三",50,70));
        s.add(new Student("李四",60,90));
        s.add(new Student("王五",30,95));
        s.add(new Student("赵六",40,40));
        s.add(new Student("周七",80,20));
        System.out.println(s);
    }
}

HashSet集合

概念：属于set集合的实现类

特点：

• 无序，没有索引，不可重复
• 该集合没有特殊的方法，可以使用单列接口中定义的方法
• 该集合存储元素的方式，底层是根据哈希表来进行存储的

哈希值简介

是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

• 如何获取哈希值

  Object类中的public int hashCode()：返回对象的哈希码值

• 哈希值的特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值不同

• 总结

  • 两个对象的哈希值不同，肯定是不同的对象
  • 如果两个对象的哈希值一样，可能不是同一个对象

哈希表图示

哈希表：底层就是使用 数组 + 链表 结合产生的。

JDK1.7版本哈希表的图示

• 使用数组和链表组成

JDK1.8之后对哈希表的优化

优化的原因：因为如果链表的长度过长，该链表中的数据在查询时，查询的效率低，所以当链表长度>=8时，会将该链表转为红黑树（特殊的二叉树）来存储，转换之后，链表的长度就会缩短，提高查询效率。

HashSet集合保证元素唯一性原理

LinkedHashSet集合

概述：是一个单列集合，是HashSet集合的子类

特点：

• 没有特殊的方法，可以使用父类中继承的方法

• 元素特点：

  • 无索引

  • 不可重复：和父类去重的原理一样

  • 有序：可以保证元素存入的和取出的顺序

    ​ 有序的原理和链表原理相同

单列集合总结

• Collection接口：

  • 单列集合的顶层接口
  • 方法需要重写
  • 三种遍历方式

• List：Collection集合的子接口

  • 特点：有序 有索引 可重复
  • 特有方法：通过索引操作元素的方法
  • 特有的遍历方式：size get
  • 并发修改异常：解决：使用同一个对象操作集合

• ArrayList：

  • 底层使用数组实现，查询快，增删慢

• LinkedList：

  • 底层使用双向链表实现，查询慢，增删快
  • 特有方法，操作头部和尾部元素方法

• Set：Collection接口的子接口

  • 特点：无序 无索引 去重
  • 三种遍历方式

• TreeSet：

  • 底层使用二叉树实现
  • 去重原理和无序原理：
    • 通过比较器对象Compator对象的compare
    • Comparable接口的compareTo方法
  • 可以对元素进行排序

• HashSet集合：

  • 底层使用哈希表实现

  • 去重原理：通过比较元素的哈希值和equals结果来去重

    ​ 比较之后，两个结果都相同去重，有一个不同就存入

• LinkedHashSet集合：

  • HashSet集合的子类：哈希表实现
  • 特点：有序 无索引 去重

Map集合

概念：现实生活中，我们常会看到这样的一种关系：IP地址与主机名，身份证号与个人，用户名与密码，等等。

这种一一对应的关系，就叫做映射。
Java提供了专门的集合类用来存放这种对象关系的数据，存储映射关系的集合就是双列集合。

Map集合中常用的方法

• put(K key, V value) ：往集合中添加元素 每个元素是由键值对组成

  如果key值是第一次出现，就是添加

  如果key值第二次出现，就是替换

//添加键值对
map.put(1, "陈爽");
map.put(2, "张三");
map.put(3, "李四");

• remove(Object key) ：根据制定的key删除对应的键值对

//根据key删除键值对
map.remove(1);

• remove(Object key, Object value) ：根据键和值删除对应键值对

map.remove(2,"张三");

• clear() ：清空集合

//清楚所有集合
map.clear();

• containsKey(Object key) ：判断集合中是否包含key

//判断集合中是否包含key
map.containsKey(1);

• containsValue(Object value) ：判断集合中是否包含value

//判断集合中是否包含Value
map.containsValue("chenshuang");

• get(Object key) :根据key值获取对应的value值

//根据key值获取value
map.get(2);

• isEmpty() ：判断集合是否为空

//判断集合是否为空
System.out.println(map.isEmpty());

• replace(K key, V value) ：替换key对应的value值

//修改键值对
map.replace(3, "19990328");

• ** size()**：获取集合中键值对的对数

//返回集合中键值对的对数
System.out.println(map.size());

Map集合的遍历

遍历一：通过key获取Value

1、概述：

先将Map集合中的key单独获取到一个单列集合中，然后遍历该单列集合获取每一个key，再通过key依次获取每一个对应的value。

• 如何获取每一个key：keySet()

• 遍历set集合：

  三种方式

• 遍历set集合获取每一个key，再使用get方法获取key对应的value

图示：

代码：

HashMap<String,Integer> map = new HashMap<>();
        map.put("aaa",23);
        map.put("sss",318);
        map.put("ccc",999);

//遍历方式一：通过获取key来遍历
Set<String> set = map.keySet();
Iterator<String> it = set.iterator();
while (it.hasNext()){
    //获取每一个key
    String key = it.next();
    //输出key和对应的value值
    System.out.print(key+ map.get(key)+"\t");
}
//aaa23	sss318	ccc999	

遍历二：通过键值对对象来获取key和value

1、思路：

先将Map集合中的每一个键值对数据封装为一个个键值对对象，然后将每一个对象保 存在set中，遍历set集合，获取每一个键值对对象，通过方法获取该对象中的key和 value

• 获取键值对对象到set中的方法：entrySet()
  • 集合set中保存的是：一个个键值对对象 ，该键值对对象所属的类型是Entry接口
  • Entry接口是,Map集合中内部接口
  • 该接口中由两个方法：
    getKey获取key
    ​getValue获取value

思路：

• 获取set集合之后，遍历set获取每一个键值对

  三种遍历方式

• 遍历set集合之后，可以得到每一个键值对，如何获取对应的key、value

  getKey获取key

  getValue获取value

图示：

代码：

	HashMap<String,Integer> map = new HashMap<>();
			map.put("aaa",23);
			map.put("sss",318);
			map.put("ccc",999);
 
//遍历方式二：通过对key和value的对象封装来遍历
        Set<Map.Entry<String,Integer>> s= map.entrySet();
        for(Map.Entry<String,Integer> o :s){
            String key = o.getKey();
            System.out.print(key+map.get(key)+"\t");
        }
        
        for (Map.Entry<String,Integer> o : map.entrySet()){
            String key =o.getKey();
            System.out.print(key+map.get(key)+"\t");
        }
//aaa23	sss318	ccc999	
//aaa23	sss318	ccc999	

Map集合实现类

概述：Map集合为双列集合的顶层接口，底层根据不同的实现方式，有不同的实现类

• 实现类：
  • TreeMap
  • HashMap

TreeMap集合

概述：是一个双列集合，是Map集合的实现类

特点：

• 集合中的key值是唯一的，元素是无序的

  TreeMap集合key值 去重和排序原理 与TreeSet都是一样的

  底层都是二叉树来实现的

• TreeSet集合和TreeMap集合的关系：

  TreeSet集合的底层就是使用TreeMap集合实现的

HashMap集合

概述：是一个双列集合，属于map集合的实现类。

特点：

• 集合中的key值是唯一的，元素是无序的
• HashMap集合去重原理和无序原理和HashSet集合原理一致
• 通过比较key的哈希值和equals的结果来实现去重
• HashSet集合底层就是使用HashMap来实现的

LinkedHashMap集合

概述：是一个双列集合，是HashMap集合的子类

特点：

• 本类没有特殊的方法，只能使用父类中继承的
• 集合中元素有序
• 集合中的key值唯一

【笔试题】HashMap集合和HashTable集合的区别

相同点：

• 两个集合都是Map接口的实现类，都属于双列集合
• 两个集合底层是使用哈希表来存储数据
• 两个集合中的方法大致相同

不同点：

• 版本不同：HashMap是jdk1.2出现的，HashTable是jdk1.0出现
• 线程安全性不同：HashMap是线程不安全的，HashTable线程安全的
• 存储的值不同：HashMap可以存储null键null值，HashTable不可以存储null

Collections工具类

本类是JDK提供的操作集合的工具类，类中定义了一些操作集合元素的方法

常用方法

• binarySearch(List<? extends Comparable<? super T>> list, T key) ：

  通过二分查找法查找元素key在集合中的索引

  前提数组或者集合一定是升序排列

  ArrayList<Integer> in = new ArrayList<>();
  in.add(2);
  in.add(3);
  in.add(4);
  in.add(5);
  int indexx = Collections.binarySearch(in,2);
  System.out.println(indexx);
  //0

//创建学生对象实现Combareble接口，然后重写了其compareTo方法
public class Student implements Comparable<Student>{
    String name;
     int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Student o) {
        return 0;
    }
}

//测试类
public class Student_test {
    public static void main(String[] args) {
        ArrayList<Student> st = new ArrayList<>();
        st.add(new Student("chen",25));
        st.add(new Student("shuang",24));
        st.add(new Student("ccccc",20));

        System.out.println(indexx);
        int index = Collections.binarySearch(st,new Student("shuang",24));
        System.out.println(index);

    }
}
//1

• frequency(Collection<?> c, Object o) ：

  获取集合中o元素出现的次数

public static void main(String[] args) {
		ArrayList<Integer> in = new ArrayList<>();
		in.add(2);
		in.add(2);
        in.add(3);
        in.add(4);
        in.add(5);
        int count1 = Collections.frequency(in,2);
        System.out.println(count1);
}
//2

//创建学生对象
public class Student {
    String name;
     int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}
//测试类
public class Student_test {
    public static void main(String[] args) {
        ArrayList<Student> st = new ArrayList<>();
        st.add(new Student("chen",25));
        st.add(new Student("shuang",24));
        st.add(new Student("shuang",24));
        st.add(new Student("ccccc",20));

        int count = Collections.frequency(st,new Student("shuang",24));
        System.out.println(count);
    }
}
//2

• max(Collection c) ： 求出集合中的最大值

//求出集合中最大值              max()
System.out.println(Collections.max(in));

• min(Collection c) ： 求出集合中的最小值

//求出集合中最小值              min()
System.out.println(Collections.min(in));

• reverse(List<?> list) ： 反转集合中的元素顺序

ArrayList<Integer> in = new ArrayList<>();
        in.add(2);
        in.add(2);
        in.add(3);
        in.add(4);
        in.add(5);
//反转集合中的元素
Collections.reverse(in);
System.out.println(in);
//[5, 4, 3, 2, 2]

• shuffle(List<?> list) ： 随机排列集合元素的顺序

//随机排列集合中的元素
Collections.shuffle(in);
System.out.println(in);
//[3, 5, 2, 4, 2]

• sort(List list) ： 将集合中的元素进行升序排列

ArrayList<Integer> in = new ArrayList<>();
        in.add(6);
        in.add(4);
        in.add(1);
        in.add(4);
        in.add(8);
//将集合中的元素升序排列
Collections.sort(in);
System.out.println(in);
//[1, 4, 4, 6, 8]

• swap(List<?> list, int i, int j) ： 交换集合中两个元素的位置

ArrayList<Integer> in = new ArrayList<>();
in.add(6);
in.add(4);
//交换集合中两个元素的位置
Collections.swap(in,0,1);
System.out.println(in);
//[4, 6]