集合基础知识

集合

集合概述

• 集合主要分成Collection和Map两大部分。

• Collection部分继承结构图：

  

• Map部分继承结构图

  

Collection和Iterator

Collection接口概述

1. Collection接口是Java单列集合体系的根接口，Java中所有的单列集合都实现了这个接口中的所有抽象方法。
2. Collection接口中定义了所有单列集合都具备的功能。所有实现类以及子接口都可以使用Collection中定义的方法。

Collection定义的常用方法

常用方法	说明
public boolean add(E e)	添加元素到集合末尾,返回是否添加成功
public boolean addAll(Collection<? extends E> c)	将指定Collection中的所有元素都添加都此集合中
public boolean remove(Object obj)	删除集合中的指定参数元素,返回是否删除成功。
boolean removeAll(Collection c)	移除此 collection 中那些也包含在指定 collection
public boolean contains(Object obj)	判断集合中是否包含指定元素,返回是否包含结果。
public boolean containsAll(Collection<?> c)	如果此 Collection 包含指定 Collection 中的所有 元素，则返回 true。
public int size()	返回当前中的元素个数
public void clear()	清空集合中的所有元素
public boolean isEmpty()	判断当前集合是否为空集合 true:没元素 false:有元素
public T[] toArray(T[] t)	按照参数数组的类型将当前集合中的元素转换为对应类型的数组
Iterator iterator()	返回在此 collection 的元素上进行迭代的迭代器。

Iterator迭代器概述

• 迭代器Iterator是一种用于循环从集合中依次获取元素的技术。
• 本质上是一个接口，里面规定如何依次获取元素的方法。
• 迭代器就是一种遍历单列集合的解决方案,所有的单列集合都可以通过迭代器遍历。

注意：

• 一次hasNext要搭配一次next方法获取元素(不要在while循环中不获取元素也不建议获取多次元素)。

• 经过查看源码发现每调用依次next()方法cursor都会加一，但是并没有判断是否有值如果没有值会出现异常。

• 在循环中过程中不能删除集合中的数据，迭代器有自我保护机制。

  • 对集合长度进行修改的时候modCount的值就会++，int expectedModCount = modCount; 预期修改次数进行赋值在创建迭代器的时候会进行一个赋值。每次执行next()方法的时候都会进行预期值与实际修改值的比较 如下：

      if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        }
    

    代码示例：

    public class IteratorDemo1 {
        public static void main(String[] args) {
            ArrayList<String> strList = new ArrayList<>();
            strList.add("张二狗");
            strList.add("李狗蛋");
            strList.add("刘铁柱");
    
            Iterator<String> it = strList.iterator();
            while (it.hasNext()){
                String element = it.next();
                System.out.println(element);
            }
        }
    }
    

List接口

List接口概述

List接口是Collection接口的子接口。二者是继承的关系。接口继承另外一个的接口的目的很简单：增强！在原有父接口的基础上定义新的规范方法。List也可以用Collection中方法，List接口下面主要有两个实现ArrayList和LinkedList还有一个Vector，但是Vector已经不建议使用Vector 中的方法都是同步的，效率慢。

List接口的特点：

• 带有索引，可以通过索引操作集合中的元素。
• 有序，存储到List集合中的元素会按照存入的顺序排列。
• 可重复，List集合中的元素可以保存重复元素。

List接口中特有的方法

1. 添加元素到指定索引

   • //添加元素到指定索引，原索引元素统一向后移动一位
     public void add(int index， E e)//
     

2. 删除指定索引的元素

   • // 删除指定索引的元素，并返回被删除的元素
     public E remove(int index)
     

3. 替换指定索引的元素

   • //将指定索引的元素替换为参数e，返回被替换的元素
     public E set(int index，E e) 
     

4. 获取指定索引的元素

   • //获取指定索引的元素并返回
     public E get(int index)
     

   代码示例：

   public class ListDemo1 {
       public static void main(String[] args) {
           ArrayList<String> nameList = new ArrayList<>();
           nameList.add("张三");
           nameList.add("李四");
           nameList.add("王五");
           nameList.add("赵六");  //没有给索引(默认排列的)
           //通过索引操作元素(肯定会有索引越界的风险)
    
           //1.添加元素到指定索引 (张三和李四中间加一个王小花)
           nameList.add(1, "王小花");
           System.out.println("[nameList]:" + nameList);
    
           //2.删除指定索引的元素 (删除王五)
           String removeElement = nameList.remove(3);
           System.out.println("[remove element]:" + removeElement);
           System.out.println("[nameList]:" + nameList);
    
           //3.替换指定索引的元素 (将张三替换为张小三)
           String replaceElement = nameList.set(0, "张小三");
           System.out.println("[replace element]:" + replaceElement);
           System.out.println("[nameList]:" + nameList);
    
           //4.获取指定索引的元素 (List体系特有的遍历方式,基于get方法+for循环)
           for (int i = 0; i < nameList.size(); i++) {
               System.out.println(nameList.get(i));
           }
       }
   }
   

ArrayList实现类

• ArrayList类是List接口的实现类，底层的数据结构是基于数组的，所以ArrayList一般更适用于频繁查询的数据进行存储的情况。
• ArrayList类在实现了List接口与Collection接口的基础上，没有什么特有的方法。

ArrayList的构造方法

1. ArrayList类的无参构造方法

   • public ArrayList()
     

   • 注意：ArrayList的无参构造，创建出来的集合默认保存10个元素，扩容阈值:0.75(当实际元素个数/数组长度>0.75扩容) 扩容1.5倍。

2. ArrayList类的有参构造方法（初始化容量）

   • public ArrayList(int initCapacity)
     

   • ArrayList类的有参构造，创建出来的集合底层的数组的大小根据参数明确。实际开发中这个构造方法很常用。

3. ArrayList类的有参构造方法（集合转换）

   • public ArrayList(Collection coll)
     

   • ArrayList类的有参构造，可以将参数集合的元素作为本次创建出来的集合中的默认元素。

   代码示例：

   public class ListDemo2 {
       public static void main(String[] args) {
           //ArrayList的无参构造:默认可以保存10个元素 扩容阈值:0.75 扩容后是之前的1.5倍
           ArrayList<String> strList = new ArrayList<>();
    
           //ArrayList的有参构造:通过实际传递的参数明确底层数组的默认大小 预计:要保存50个元素
           ArrayList<Integer> numberList = new ArrayList<>(50);
    
           //ArrayList类的有参构造:通过传递一个单列集合完成创建出来的集合内容的初始化
           numberList.add(11);
           numberList.add(22);
           numberList.add(33);
    
           ArrayList<Integer> numberListTwo = new ArrayList<>(numberList);
           System.out.println("[numberListTwo]:" + numberListTwo);
       }
   }
   

LinkedList实现类

• LinkedList是Java中List接口的另外一个实现类，底层基于双向链表。LinkedList实现了List接口和Collection接口的所有方法，也有特有方法。
• 双向链表其实就是在节点中加入了保存上一个节点的指针域，特点就是不仅可以从头结点开始找，也可以从尾结点开始向前找。
• 好处：在获取元素的时候，可以判断元素离头近还是离尾近，选择对应的头尾节点开始获取，弊端：占用的空间更大。

LinkedList特有方法

1. LinkedList操作头结点的方法

   • public E getFirst() : 获取头结点元素并返回
   • public E addFirst(E e) : 添加元素到链表中并作为头结点
   • public E removeFirst() : 删除头结点并返回被删除的元素

2. LinkedList操作尾节点的方法

   • public E getLast() : 获取尾结点元素并返回
   • public E addLast(E e) : 添加元素到链表中并作为尾结点
   • public E removeLast() : 删除尾结点并返回被删除的元素

   代码示例：

   public class ListDemo3 {
       public static void main(String[] args) {
           LinkedList<String> nameList = new LinkedList<>();
           nameList.add("张三");
           nameList.add("李四");
           nameList.add("王五");
           nameList.add("赵六");
    
           //1.添加元素作为头结点/尾结点
           nameList.addFirst("王小花"); //可以被等价替换为:add(0,"王小花");
           nameList.addLast("小六子"); //可以被等价替换为:add("小六子");
           System.out.println("[add]:" + nameList);
    
           //2.获取头结点元素/尾结点元素
           String firstElement = nameList.getFirst(); //可以被等价替换为:get(0);
           String lastElement = nameList.getLast(); //可以被等价替换为:get(nameList.size()-1);
           System.out.println("[get]:" + firstElement + " " + lastElement);
    
           //3.删除头结点元素/尾结点元素
           nameList.removeFirst(); //可以被等价替换为:remove(0);
           nameList.removeLast(); //可以被等价替换为:remove(nameList.size()-1);
           System.out.println("[remove]:" + nameList);
       }
   }
   

补：（面试题：）LinkedList与ArrayList的比较

1. 从底层结构上而言，ArrayList底层基于数组，LinkedList底层基于双向链表。
2. ArrayList适合存储和访问数据，LinkedList则更适合数据的处理，在使用时可以合理的选择List结构。

Set接口

Set集合的概述和特点

• Set接口是Collection接口的子接口。二者是继承的关系。
• Set接口的存在的意义是为了和List进行区分，Set接口的特点就是保证元素唯一。
• 无论是Set接口的哪个实现类，都保证元素唯一，但是保证元素唯一的方式不一致。

哈希表

1. 默认的哈希值生成逻辑

   • 当一个类没有重写hashCode的前提下，创建了对象，对象调用hashCode方法返回哈希值，那么哈希值的生成逻辑默认调用Object类的hashCode方法。
   • Object类的hashCode会根据调用对象的内存地址生成哈希值，和对象的内容无关联！即便两个对象内容一致，地址值不一致的话哈希值也不一样。

2. 重写的哈希值生成逻辑

   • 当一个类重写了hashCode的前提下，创建了对象，对象调用hashCode方法返回哈希值，那么哈希值的生成逻辑默认调用自己本类的hashCode方法。
   • 重写的hashCode会根据调用对象的内容生成哈希值，和对象的地址值无关联！即便两个对象地址值不一致，内容一致的话哈希值一定一样。

   代码示例：

   //实体类
   public class Dog {
       private String name;
       private Integer age;
   
       @Override
       public boolean equals(Object o) {
           if (this == o) return true;
           if (o == null || getClass() != o.getClass()) return false;
   
           Dog dog = (Dog) o;
   
           if (name != null ? !name.equals(dog.name) : dog.name != null) return false;
           return age != null ? age.equals(dog.age) : dog.age == null;
       }
   
       //重写了hashCode(基于IDEA提供的方式)
       @Override
       public int hashCode() {
           int result = name != null ? name.hashCode() : 0;
           result = 31 * result + (age != null ? age.hashCode() : 0);
           return result;
       }
   
       @Override
       public String toString() {
           return "Dog{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
       }
   
       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;
       }
   
       public Dog() {
       }
   
       public Dog(String name, Integer age) {
           this.name = name;
           this.age = age;
       }
   }
   

   public class HashSetDemo3 {
       public static void main(String[] args) {
           //创建两个Dog对象
           Dog dogOne = new Dog("笨笨", 3);
           Dog dogTwo = new Dog("笨笨", 3);
   
           //通过调用hashCode方法生成dogOne和dogTwo的哈希值
           //由于Dog类重写了hashCode方法,那么调用的hashCode就是Dog类本身的hashCode方法逻辑
           int one = dogOne.hashCode();
           int two = dogTwo.hashCode();
   
           //因为两个内容一样，所以哈希一样
           System.out.println("[dogOne hashCode]:" + one);
           System.out.println("[dogTwo hashCode]:" + two);
           dogOne.setName("花花");
           dogOne.setAge(5);
           int one2 = dogOne.hashCode();
           //内容不同哈希不同
           System.out.println("[dogOne hashCode1]:" + one);
           System.out.println("[dogOne hashCode2]:" + one2);
       }
   }
   

HashSet实现类

• HashSet 按照哈希算法存取数据的，具有非常好性能， 它的工作原理是这样的，当向 HashSet 中插入数据的时候，他会调用对象的 hashCode 得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置。
• 由于哈希表是通过元素的哈希值进行散列保存的，所以存入和取出的顺序可能不一致。但是并不能说HashSet是无序的(存入和取出是没有顺序的)，因为本质上HashSet是按照哈希值的计算去保存数据的。
• Set接口在继承Collection接口的基础上，没有新增特有方法。所以对于HashSet的使用就是Collection接口中的方法。

例：

public class HashSetDemo1 {
    public static void main(String[] args) {

        HashSet<String> nameSet = new HashSet<>();

        //添加元素（HashSet对于重复的元素处理方案就是不存储）
        nameSet.add("张二狗");
        nameSet.add("刘铁柱");
        nameSet.add("李狗蛋");
        nameSet.add("张二狗");
        System.out.println(nameSet);

        //删除元素
        nameSet.remove("刘铁柱");
        System.out.println(nameSet);

        //判断是否包含元素
        System.out.println("李狗蛋是否存在："+nameSet.contains("李狗蛋"));
        System.out.println("刘铁柱是否存在："+nameSet.contains("刘铁柱"));
    }
}

注意：所以最终要记住的一个前提就是，如果HashSet保存自定义的元素并且想要保证按照元素的内容保证唯一，那么自定义元素所在的类必须重写hashCode和equals方法。

LinkedHashSet实现类

• 有特殊的需求既要求保证元素唯一也要求保证存入和取出的顺序一致的情况下，就可以使用LinkedHashSet解决此问题。LinkedHashSet是一种既可以保证元素唯一也可以保证存取有序的单列集合。

• LinkedHashSet底层依然基于哈希表来保证元素唯一，但是在哈希表结构外还单独维护了一个链表，用于记录保存元素的顺序。LinkedHashSet在获取元素的时候会从链表进行元素的获取来体现存入顺序。

  代码示例：

  public class LinkedHashSetDemo1 {
      public static void main(String[] args) {
         
          LinkedHashSet<String> strings = new LinkedHashSet<>();
          strings.add("王小花"); //0
          strings.add("张二狗"); //1
          strings.add("张二狗");
          strings.add("刘铁柱"); //2
          strings.add("李狗蛋"); //3
          strings.add("李狗蛋");
          strings.add("刘铁柱");
  
          //张二狗 / 刘铁柱 / 李狗蛋
          //LinkedHashSet在获取元素的时候会从链表进行元素的获取来体现存入顺序。
          for (String name : strings) {
              System.out.println(name);
          }
  
          System.out.println("======");
  
          //对比:HashSet
          HashSet<String> stringHashSet = new HashSet<>();
          stringHashSet.add("王小花");
          stringHashSet.add("张二狗");
          stringHashSet.add("刘铁柱");
          stringHashSet.add("李狗蛋");
  
          for (String name : stringHashSet) {
              System.out.println(name);
          }
      }
  }
  

TreeSet实现类

• TreeSet实现类也是Set接口的比较常用的实现类。

• TreeSet底层基于红黑树结构，可以按照指定的排序规则对集合元素进行排序。

• TreeSet集合同时也保证元素唯一，保证唯一的方式是基于排序规则保证，如果两个元素进行排序之后返回结果为0，则默认重复。

• TreeSet实现类的构造方法

  • public TreeSet(Comparator<? super E> comparator)
  • TreeSet在构造的时候需要传递一个自定义排序接口的实现类对象用于指定集合中的元素排序规则。
  • 当add方法执行的时候会自动根据排序规则明确元素的顺序并且排除掉重复元素。

• 如果使用无参数构造创建TreeSet对象，那么就是使用自然排序规则存储的对象就要必须实现comparable接口

• 注意：有些时候只通过某些字段对比，但是其他字段内容不同，也会被认为重复。所以对于TreeSet的排序规则最好给出次要排序条件！)

代码示例：

//实体类
public class Person {
    private String name;
    private String address;
    private Integer age;

    public Person() {
    }

    public Person(String name, String address, Integer age) {
        this.name = name;
        this.address = address;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) && Objects.equals(address, person.address) && Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, address, age);
    }
}

public class TreeSetDemo1 {
    public static void main(String[] args) {

        TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int result=o1.getAge()-o2.getAge();

                //次要条件
                if (result==0){
                    result=o1.equals(o2)?0:1;//如果主要条件对比之后结果是0(为了保证内容不同的元素也可以被添加进去)
                }
                return result;
            }
        });

        //如果使用无参数构造创建TreeSet对象，那么就是使用自然排序规则存储的对象就要必须实现comparable接口
        //TreeSet<Person> persons = new TreeSet<>();

        //向TreeSet中添加元素(自动在添加元素的时候给元素进行排序)
        persons.add(new Person("张三", "北京市", 25));
        persons.add(new Person("刘麻子", "北京市", 26));
        persons.add(new Person("李四", "北京市", 22));
        persons.add(new Person("赵六", "北京市", 24));
        persons.add(new Person("王麻子", "北京市", 23));
        persons.add(new Person("王五", "北京市", 24)); //TreeSet会认为该元素重复

        //遍历TreeSet打印每一个元素(是否按照指定的规则进行排序)
        for (Person person : persons) {
            System.out.println(person);
        }
    }
}

双列集合Map接口

Map集合的概述和特点

Map 中可以放置键值对，也就是每一个元素都包含键对象和值对象，Map 实现较常用的为 HashMap，HashMap 对键对象的存取和 HashSet 一样，仍然采用的是哈希算法，所以如果使用自定类作为 Map 的键对象，必须复写 equals 和 hashCode 方法。

双列集合的特点：

• 双列集合一次需要存储一对数据，分别是一个键和一个值。
• 键可以重复，值不可以重复。
• 键和值是一一对应的关系，每一个键只能找到自己对应的值，值不可以找键。
• 键和值的整体称之“键值对对象”，或者是Entry对象。

HashMap实现类

• HashMap底层基于哈希表，可以保证键的唯一性，注意:自定义的类作为键要重写equals和hashCode方法，HashMap不保证元素的存取顺序。

• HashMap的无参构造方法是HashMap最常用的public HashMap()。

• 增删改查方法

  • HashMap的添加键值方法

    • public V put(K key,V value) : 将一个键和一个值保存到Map集合中。如果存入的时候键已经存在了，则会产生覆盖效果。

  • HashMap的删除键值方法：

    • public V remove(Object key) : 传入键(任意对象),删除成功返回被删除的值,不存在返回null
    • public boolean remove(Object key,Object value) : 传入键值进行删除,返回被删除的结果

  • HashMap的根据键获取值的方法

    • public V get(Object key) : 传入键(任意对象)如果存在于Map中,则返回对应的值,否则返回NULL.

  代码示例：

  public class MapDemo1 {
      public static void main(String[] args) {
          //创建HashMap集合用于保存学生姓名String与学生地址String的对应关系。
          HashMap<String, String> students = new HashMap<>();
          students.put("张二狗","北京市昌平区");
          students.put("刘铁柱","北京市昌平区");
          students.put("李狗蛋","北京市海淀区");
          students.put("王小花","北京市门头沟区");
  
          System.out.println("map:"+students);
  
          //2.put:如果添加的数据的键已经存在,那么会使用新值覆盖掉老值 也有修改的含义
          String oldVlaue = students.put("刘铁柱", "北京市大兴区");
          System.out.println("被覆盖的值市："+oldVlaue);
          System.out.println("map:"+students);
  
          //3.remove:可以单独传递一个键进行删除 也可以传递键与值进行匹配删除
          //remove:传递键 如果键存在则删除键值返回被删除的值,如果键不存在,则返回NULL
          String removeValue = students.remove("张二狗");
          System.out.println("removeValue:"+removeValue);
  
          String removeValue2 = students.remove("张大狗");
          System.out.println("removeValue2:"+removeValue2);
          System.out.println("map:"+students);
  
          //remove:传递键值 如果键不存在则删除失败返回false,如果键存在并且值也对应则删除成功返回true,如果键存在但是值不对应删除失败返回false
          boolean removeResult = students.remove("张三毛", "北京市通州区");//键不存在
          System.out.println("[removeResult]:" + removeResult);
  
          boolean removeResult2 = students.remove("李狗蛋", "北京市朝阳区"); //键存在,但是值不对应
          System.out.println("[removeResult2]:" + removeResult2);
  
          boolean removeResult3 = students.remove("王小花", "北京市门头沟区"); //键存在,值对应
          System.out.println("[removeResult3]:" + removeResult3);
          System.out.println("map:"+students);
  
          //4.get:传递键获取值 如果传递的键存在则获取对应值,如果传递的键不存在则获取NULL
          String value = students.get("王小花");
          System.out.println("value:"+value);
  
          String value2 = students.get("李狗蛋");
          System.out.println("value2："+value2);
      }
  }
  
  

• 其他成员方法

  • HashMap的判断是否包含指定键、值

    • public boolean containsKey(Object key) : 判断HashMap是否包含指定键
    • public boolean containsValue(Object value) : 判断HashMap是否包含指值

  • HashMap的获取长度/是否为空/清空

    • public int size() : 返回Map中的键值对个数
    • public boolean isEmpty() : 返回Map是否为空Map
    • public void clear() : 清空Map中的所有元素

  代码示例：

  public class MapDemo2 {
      public static void main(String[] args) {
          HashMap<String, String> students = new HashMap<>();
          students.put("张二狗","北京市昌平区");
          students.put("刘铁柱","北京市昌平区");
          students.put("李狗蛋","北京市海淀区");
          students.put("王小花","北京市门头沟区");
  
          //containsKey:判断是否包含指定的键
          boolean containsResult = students.containsKey("赵爱民");
          System.out.println("containsResult:"+containsResult);
  
          boolean containsResult2 = students.containsKey("张二狗");
          System.out.println("containsResult2:"+containsResult2);
  
          //containsValue:判断是否包含指定的值
          boolean containsResult3 = students.containsValue("北京市朝阳区");
          System.out.println("containsResult3:"+containsResult3);
  
          boolean containsResult4 = students.containsValue("北京市昌平区");
          System.out.println("containsResult4:"+containsResult4);
  
          //size:获取长度（键值对的个数）/isEmpty：是否空集合/clear：清空
          System.out.println("size:"+students.size());
          System.out.println(students.isEmpty());
  
          students.clear();
  
          System.out.println("size:"+students.size());
          System.out.println(students.isEmpty());
      }
  }
  

LinkedHashMap实现类

• LinkedHashMap可以基于底层的哈希表完成键的唯一性保证，并且通过底层的链表结构保证元素的存取有序。
• LinkedHashMap与HashMap的方式一样。

代码示例：

public class MapDemo7 {
    public static void main(String[] args) {
        //LinkedHashMap/HashMap底层都是基于哈希表的,可以保证键的唯一性(自定义的元素作为键,必须要重写equals/hashCode方法)
        //LinkedHashMap底层还维护了一个链表(保证键值的存取顺序) 只有一些特殊的情况需要使用LinkedHashMap(排序)
        LinkedHashMap<Student, String> students = new LinkedHashMap<>();
        students.put(new Student("张三",23,100),"北京市昌平区");
        students.put(new Student("李四",21,60),"北京市朝阳区");
        students.put(new Student("王五",20,96),"北京市昌平区");
        students.put(new Student("赵六",25,80),"北京市海淀区");

        students.put(new Student("张三",23,100),"北京市通州区");
        Set<Map.Entry<Student, String>> entrySet = students.entrySet();
        for (Map.Entry<Student, String> entry : entrySet) {
            System.out.println(entry.getKey()+"  "+entry.getValue());
        }
    }
}

Collections工具类

常用方法：

方法名	说明
public static void shuffle(List<?> list)	打乱集合顺序
public static void sort(List list)	将集合中元素按照默认规则排序
public static void sort(List list，Comparator<? super T> )	将集合中元素按照指定规则排序。

代码示例：

public class CollectionsDemo1 {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(15);
        numbers.add(30);
        numbers.add(43);
        numbers.add(9);
        numbers.add(75);

        //1、获取集合中的最大值和最小值
        Integer max = Collections.max(numbers);
        Integer min = Collections.min(numbers);
        System.out.println("max："+max);
        System.out.println("min："+min);

        //3、反转集合
        System.out.println("反转前："+numbers);
        Collections.reverse(numbers);
        System.out.println("反转后："+numbers);

        //2、打乱集合
        Collections.shuffle(numbers);
        System.out.println("打乱后："+numbers);

        //4、填充集合fill
        Collections.fill(numbers,44);
        System.out.println("填充后："+numbers);
    }
}

Collections工具类comparator排序接口：

1.介绍:Comparator:比较器->接口 : 用于自己指定排序规则

2.方法: 接口中的方法:int compare(T 参数1, T 参数2);->设置比较规则

案例：

//实体类

public class CollectionsDemo2 {
    //声明一个集合保存学生信息
    private static final ArrayList<Student> STUDENT_LIST=new ArrayList<>();

    static {
        Random r = new Random();
        int rang=41,low=60;
        STUDENT_LIST.add(new Student("张三",r.nextInt(rang)+low,r.nextInt(rang)+low,r.nextInt(rang)+low));
        STUDENT_LIST.add(new Student("刘铁柱",r.nextInt(rang)+low,r.nextInt(rang)+low,r.nextInt(rang)+low));
        STUDENT_LIST.add(new Student("李四",r.nextInt(rang)+low,r.nextInt(rang)+low,r.nextInt(rang)+low));
        STUDENT_LIST.add(new Student("王五",r.nextInt(rang)+low,r.nextInt(rang)+low,r.nextInt(rang)+low));
        STUDENT_LIST.add(new Student("赵六",r.nextInt(rang)+low,r.nextInt(rang)+low,r.nextInt(rang)+low));
        STUDENT_LIST.add(new Student("乌尔提.买买提",100,100,100));
        STUDENT_LIST.add(new Student("丁一",100,100,100));
    }

    public static void main(String[] args) {
        System.out.println("============================= BEFORE SORT =============================");
        for (int i = 0; i < STUDENT_LIST.size(); i++) {
            System.out.println(STUDENT_LIST.get(i));
        }

        
        //通过Collections.sort方法对集合中的学生信息进行排序,指定排序规则
        Collections.sort(STUDENT_LIST, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //主要条件:总成绩(o1和o2的总成绩 => 3个学科相加的结果)
                int result=(o2.getMathScore()+ o2.getChineseScore()+o2.getEnglishScore())-( o1.getMathScore() +o1.getChineseScore()+ o1.getEnglishScore());
                //result当前就是主要条件对比完成之后的结果 0:两个学生的总成绩相同 非0:两个学生的总成绩不同 次要条件:姓名长度
                if (result==0)
                    result = o2.getName().length() - o1.getName().length();
                return result;
            }
        });

        System.out.println("============================= AFTER SORT =============================");
        for (int i = 0; i < STUDENT_LIST.size(); i++) {
            System.out.println(STUDENT_LIST.get(i));
        }
    }
}