详解集合框架

一、集合框架的概述
1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储。
2.（1）数组在存储多个数据方面的特点：
1⃣️一旦初始化以后，其长度就确定了。
2⃣️数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
比如：String arr[]
（2）数组在存储多个数据方面的缺点：
1⃣️一旦初始化以后，其长度就不可修改了。
2⃣️数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
3⃣️获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
4⃣️数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
3.Java集合可分为Collection和Map两种体系
（1）Collection接口：单列数据，定义了存取一组对象的方法的集合
1⃣️List接口：元素有序、可重复的集合。—>动态数组

ArrayList、LinkedList、Vector

2⃣️Set接口：元素无序、不可重复的集合。—>数学中的“集合”

HashSet、LinkedHashSet、TreeSet

（2）Map接口：双列数据，保存具有映射关系“key-value对”的集合。一个key只能对应一个value；但是一个value可以对应多个key—>数学中的函数：y=f(x)

HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

二、Collection接口
1、Collection接口中的常用方法
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class CollectionTest {
    public static void main(String[] args){
        Collection coll=new ArrayList();

        //add(Object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());

        //size()：获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中
        Collection coll1=new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll.size());
        System.out.println(coll1.size());

        //clear()：清空集合元素
        coll.clear();

        //isEmpty()：判断当前集合是否为空
        System.out.println(coll.isEmpty());

        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(456);
        coll.add(new Date());
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("小明",15));
        Person p=new Person("小刚",14);
        coll.add(p);

        //contains(Object obj)：判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        System.out.println(coll.contains(123));//true
        System.out.println(coll.contains(new String("Tom")));//true
        System.out.println(coll.contains(p));//true
        boolean contains= coll.contains("aa");
        System.out.println(contains);//false
        System.out.println(coll.contains(new Person("小明", 15)));//如果没有重写equals()，则为false；如果重写了equals()，则为true

        //containsAll(Collection coll1)：判断形参coll中的所有元素是否都存在于当前集合中
        System.out.println(coll.containsAll(coll1));

        //remove(Object obj)：
        System.out.println(coll.size());
        System.out.println(coll.remove(123));
        System.out.println(coll.remove(new Person("小明", 15)));
        System.out.println(coll.size());

        //removeAll(Collection coll1)：差集：从当前集合中移除coll1中所有的元素，即移除两个集合所共有的元素
        System.out.println(coll);
        System.out.println(coll.removeAll(coll1));
        System.out.println(coll.size());
        System.out.println(coll);

        coll.add("abc");
        coll1.add("abc");
        //retainAll(Collection coll1)：交集：获取当前集合和coll1集合的交集，并返回给当前集合
        System.out.println(coll);
        coll.retainAll(coll1);
        System.out.println(coll);

//#################################################################################
        coll.clear();

        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(456);
        coll.add(new Date());
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("小明",15));

        coll1.clear();

        coll1.add("AA");
        coll1.add("BB");
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Date());
        coll1.add(new String("Tom"));
        coll1.add(false);
        coll1.add(new Person("小明",15));

        //equals(Object obj)：要想返回true，需要当前集合和形参集合的元素都相同
        System.out.println(coll.equals(coll1));

        //hashCode()：返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //集合--->数组：toArray()
        Object[] arr=coll.toArray();
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        //数组--->集合：调用Arrays类的静态方法asList()
        List list=Arrays.asList("AA","BB");
        System.out.println(list);

        List arr1=Arrays.asList(1,2,3);
        System.out.println(arr1);

        List arr2=Arrays.asList(new Integer[]{1,2});
        System.out.println(arr2);

        
        
    }
}

class Person{
    private String name;
    private int age;

    public Person(){

    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 age == person.age &&
                Objects.equals(name, person.name);
    }

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

2.集合元素的遍历操作：使用迭代器Iterator接口。
（1）内部的方法：hasNext()和next()
（2）集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
public class IteratorTest {
    public static void main(String[] args){
        Collection coll=new ArrayList();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(456);
        coll.add(new Date());
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator=coll.iterator();

        //方式一：基本不用
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        //报异常：
//        System.out.println(iterator.next());

        //方式二：不推荐
//        for (int i=0;i<coll.size();i++){
//            System.out.println(iterator.next());
//        }

        //方式三：
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

3.Iterator遍历集合的两种错误写法

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

/**
 * @author 黄振天
 * @create 2020-05-01-11:46 AM
 **/
public class IteratorTest {
    public static void main(String[] args){
        Collection coll=new ArrayList();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(456);
        coll.add(new Date());
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator=coll.iterator();
        
        //错误方式一：
//        while ((iterator.next())!=null){
//            System.out.println(iterator.next());
//        }

        //错误方式二：
//        while (coll.iterator().hasNext()){
//            System.out.println(coll.iterator().next());
//        }

    }
}

4.remove()的使用：可以在遍历的时候，删除集合中 的元素。此方法不同于集合直接调用remove()
（1）如果还未调用next()或在上一次调用next()方法之后调用了remove方法，再调用remove都会报错。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

/**
 * @author 黄振天
 * @create 2020-05-01-11:46 AM
 **/
public class IteratorTest {
    public static void main(String[] args){
        Collection coll=new ArrayList();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(456);
        coll.add(new Date());
        coll.add(new String("Tom"));
        coll.add(false);

        //remove()
        Iterator iterator1=coll.iterator();
        while (iterator1.hasNext()){
            Object obj=iterator1.next();
            if ("Tom".equals(obj)){
                iterator1.remove();
            }
        }
        Iterator iterator2=coll.iterator();
        while (iterator2.hasNext()){
            System.out.println(iterator2.next());
        }
    }
}

5.使用foreach循环遍历集合或数组

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class ForTest {
    public static void main(String[] args){
        Collection coll=new ArrayList();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(456);
        coll.add(new Date());
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合中元素的类型 局部变量:集合对象/数组变量名)
        //内部仍然调用了迭代器
        for (Object obj:coll){
            System.out.println(obj);
        }

        int[] arr=new int[]{1,2,3,4,5};
        for (int obj:arr){
            System.out.println(obj);
        }


    }
}

三、List接口
1.List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
2.ArrayList、LinkedList、Vector的异同：
（1）相同点：三个类都实现了List接口，存储数据的特点相同。
（2）不同点：
1⃣️ArrayList：作为List接口的主要实现类。线程不安全，执行效率高。
底层使用Object[] elementData存储。
2⃣️LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高。
底层使用双向链表存储。
3⃣️Vector：作为List接口的古老实现类。线程安全，执行效率低。
底层使用Object[] elementData存储。
3.ArrayList：
（1）jdk7及以前：建议开发中使用带参的构造器：

ArrayList list=new ArrayList(int capacity);

4.List接口中的常用方法测试

import java.util.ArrayList;
public class ListTest {
    public static void main(String[] args){
        ArrayList list=new ArrayList();
        list.add(123);
        list.add("456");
        list.add("AA");
        list.add(new Person("Tom",12));
//        System.out.println(list);//[123, 256, AA, Person{name='Tom', age=12}]

        //void	add(int index,Object ele)：在index位置插入ele元素
//        list.add(1,"BB");
//        System.out.println(list);//[123, BB, 256, AA, Person{name='Tom', age=12}]

        //boolean addAll​(int index,Collection eles)：从index位置开始将eles中的所有元素添加进来
//        List list1= Arrays.asList(1,2,3);
//        list.addAll(list1);
//        System.out.println(list.size());//7

//        list.add(list1);
//        System.out.println(list.size());//5

        //int indexOf​(Object o)：返回o首次出现的位置。如果不存在，返回-1
//        int index=list.indexOf("AA");
//        System.out.println(index);

        //int lastIndexOf​(Object o):返回o最后一次出现的位置。如果不存在，返回-1
//        int lastIndexOf=list.lastIndexOf("AA");
//        System.out.println(lastIndexOf);

        //Object remove​(int index):移除指定index位置的元素，并返回此元素
//        Object obj=list.remove(1);
//        System.out.println(list);
//        System.out.println("###"+obj);

        // Object set​(int index, Object element):设置指定index位置的元素element
//        list.set(2,789);
//        System.out.println(list);

        //List subList​(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合，包含fromIndex，不包含toIndex
//        List subList=list.subList(1,3);
//        System.out.println(subList);

        //get​(int index)
//        System.out.println(list.get(2));

    }
}

5.总结：常用方法
增：add​(Object obj)
删：remove​(int index) / remove​(Object o)
改：Object set​(int index, Object element)
查：get​(int index)
插：add​(int index, E element)
长度：size()
遍历：1⃣️Iterator迭代器方式2⃣️增强for循环3⃣️普通的循环

import java.util.ArrayList;
import java.util.Iterator;
public class ListTest {
    public static void main(String[] args){
        ArrayList list=new ArrayList();
        list.add(123);
        list.add("456");
        list.add("AA");
        list.add(new Person("Tom",12));
        
        //方式一：Iterator迭代器方式
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("#######################");

        //方式二：增强for循环
        for (Object obj:list){
            System.out.println(obj);
        }

        System.out.println("#######################");

        //方式三：普通的for循环
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

四、Set接口：存储无序的、不可重复的数据
1.Set接口实现类的对比：
（1）HashSet：作为Set接口的主要实现类；线程不安全；可以存储null值。
（2）LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。
（3）TreeSet：可以按照添加元素的指定属性进行排序。
2.Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
3.Set的无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
4.Set的不可重复性：保证添加的元素按照equals()判断时不能返回tru，即相同的元素只能添加一个。
5.要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()。重写的这两个方法尽可能保持一致性，即相等的对象必须具有相等的散列码（哈希值）。
6.TreeSet的自然排序：
（1）向TreeSet中添加的数据，要求是相同类的对象。
（2）自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()。

import java.time.Instant;
import java.util.Iterator;
import java.util.Objects;
import java.util.TreeSet;
public class TreeSetTest {
    public static void main(String[] args){
        TreeSet set=new TreeSet();

        //不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new Person("Tom",16));

        //举例一：
//        set.add(123);
//        set.add(456);
//        set.add(789);
//        set.add(111);
//
//        Iterator iterator=set.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }

        //举例二：
        set.add(new Person1("Tom",15));
        set.add(new Person1("John",13));
        set.add(new Person1("Mike",23));
        set.add(new Person1("Tom",21));
        Iterator iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

class Person1 implements Comparable{
    private String name;
    private int age;

    public Person1(){

    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    //按照姓名从大到小排列，年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if (o instanceof Person1){
            Person1 person1=(Person1)o;
//            return -this.name.compareTo(person1.name);
            int compare=-this.name.compareTo(person1.name);
            if (compare!=0){
                return compare;
            }else {
                return Integer.compare(this.age,person1.age);
            }
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }

    }

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

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

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

7.TreeSet定制排序：
（1）定制排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()。

 import java.time.Instant;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.TreeSet;
 public class TreeSetTest {
    public static void main(String[] args){
        //定制排序
        TreeSet set=new TreeSet(new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Person1&&o2 instanceof Person1){
                    Person1 p1=(Person1)o1;
                    Person1 p2=(Person1)o2;
                    return Integer.compare(p1.getAge(),p2.getAge());
                }else{
                    throw new RuntimeException("输入的类型不匹配");
                }
            }
        });
        set.add(new Person1("Tom",15));
        set.add(new Person1("John",13));
        set.add(new Person1("Mike",23));
        set.add(new Person1("Tom",21));
        Iterator iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

class Person1{
    private String name;
    private int age;

    public Person1(){

    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

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

五、Map接口及其多个实现类的对比
1.Map：双列数据，存储key-value对的数据。—>类似于数学中的函数：y=f(x)
（1）HashMap：作为Map的主要实现类；线程不安全，效率高；存储null的key和value。
1⃣️LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。
原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
对于频繁的遍历操作，此类执行效率高于HashMap。
（2）TreeMap：保证可以按照添加的key-value进行排序，实现排序遍历。按照key来排序的。
（3）HashTable：作为古老的实现类：线程安全，效率低；不能存储null的key和value。底层使用红黑树。
1⃣️Properties：常用来处理配置文件。key和value都是String类型。
2.Map结构理解
（1）Map中的key：无序的、不可重复的，使用Set存储所有的key。–>key所在的类要重写equals()和hashCode()
（2）Map中的value：无序的、可重复的，使用Collection存储所有的value
（3）一个键值对：key-value构成了一个Entry对象
（4）Map中的entry：无序的、不可重复的，使用Set存储所有的entry
3.Map中的常用方法：
（1）添加、删除、修改操作：

import java.util.HashMap;
import java.util.Map;
public class MapTest {
    public static void main(String[] args){
        Map map=new HashMap();

        //Object put​(Object key,Object value):将指定key-value添加到（或修改）当前map对象中
        //添加
        map.put("AA",123);
        map.put("BB",456);
        map.put(45,123);
        //修改
//        map.put("AA",789);
//        System.out.println(map);

        //void putAll​(Map<? extends K,​? extends V> m)
//        Map map1=new HashMap();
//        map1.put("zz","x");
//        map1.putAll(map);
//        System.out.println(map1);

        //void clear()
//        map.clear();
//        System.out.println(map);

        //Object remove​(Object key)
//        map.remove("AA");
//        System.out.println(map);

    }
}

（2）元素查询的操作

import javax.sound.midi.Soundbank;
import java.util.HashMap;
import java.util.Map;
public class MapTest {
    public static void main(String[] args){
        Map map=new HashMap();
        map.put("AA",123);
        map.put("BB",456);
        map.put(45,123);

        //Object remove​(Object key)
//        map.remove("AA");
//        System.out.println(map);

        //Object get​(Object key)
//        System.out.println(map.get("BB"));

        //boolean containsKey​(Object key)
//        System.out.println(map.containsKey(45));

        //boolean containsValue​(Object value)
//        System.out.println(map.containsValue(123));

        //int size()
//        System.out.println(map.size());

        //boolean isEmpty()
//        System.out.println(map.isEmpty());

        //boolean equals​(Object o)
//        Map map1=new HashMap();
       // map1.put("zz","x");
//        map1.putAll(map);
//        System.out.println(map.equals(map1));
    }
}

（3）遍历

import javax.sound.midi.Soundbank;
import java.util.*;
public class MapTest {
    public static void main(String[] args){
        Map map=new HashMap();
        map.put("AA",123);
        map.put("BB",456);
        map.put(45,123);

        //元视图操作的方法：
        //Set keySet()：返回所有key构成的Set集合
//        Set set=map.keySet();
//        Iterator iterator=set.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }

        //Collection values()：返回所有的value
//        Collection coll=map.values();
//        for (Object obj:coll){
//            System.out.println(obj);
//        }

        //Set entrySet()：遍历所有的key-value
//        Set entrySet=map.entrySet();
//        Iterator iterator=entrySet.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//        while (iterator.hasNext()){
//            Object obj=iterator.next();
//            //entrySet集合中的元素都是entry
//            Map.Entry entry=(Map.Entry)obj;
//            System.out.println(entry.getKey()+"--->"+entry.getValue());
//        }


    }
}

（4）总结：
添：Object put​(Object key,Object value)
删：Object remove​(Object key)
改：put​(Object key,Object value)
查：Object get​(Object key)
长度：int size()
遍历：Set keySet()、Collection values()、Set entrySet()
4.TreeMap的两种添加方式

import java.util.*;
import java.util.Objects;

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

        //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
        //因为是按照key进行排序的：自然排序、定制排序

        //自然排序：
//        TreeMap map=new TreeMap();
//
//        Person1 p1=new Person1("Tom",15);
//        Person1 p2=new Person1("Mike",18);
//        Person1 p3=new Person1("John",16);
//        Person1 p4=new Person1("Rose",13);
//        map.put(p1,"123");
//        map.put(p2,90);
//        map.put(p3,68);
//        map.put(p4,77);
//
//        Set entrySet=map.entrySet();
//        Iterator iterator=entrySet.iterator();
//        while (iterator.hasNext()){
//            Object obj=iterator.next();
//            Map.Entry entry=(Map.Entry)obj;
//            System.out.println(entry.getKey()+"--->"+entry.getValue());
//        }


        //定制排序：
//        TreeMap map=new TreeMap(new Comparator() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                if (o1 instanceof Person1 && o2 instanceof Person1) {
//                    Person1 p1 = (Person1) o1;
//                    Person1 p2 = (Person1) o2;
//                    return Integer.compare(p1.getAge(), p2.getAge());
//                } else {
//                    throw new RuntimeException("输入的类型不匹配");
//                }
//            }
//        });
//        Person1 p1=new Person1("Tom",15);
//        Person1 p2=new Person1("Mike",18);
//        Person1 p3=new Person1("John",16);
//        Person1 p4=new Person1("Rose",13);
//        map.put(p1,"123");
//        map.put(p2,90);
//        map.put(p3,68);
//        map.put(p4,77);
//
//        Set entrySet=map.entrySet();
//        Iterator iterator=entrySet.iterator();
//        while (iterator.hasNext()){
//            Object obj=iterator.next();
//            Map.Entry entry=(Map.Entry)obj;
//            System.out.println(entry.getKey()+"--->"+entry.getValue());
//        }
    }
}

public class Person1 implements Comparable{
    private String name;
    private int age;

    public Person1(){

    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    //按照姓名从大到小排列，年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if (o instanceof Person1){
            Person1 person1=(Person1)o;
//            return -this.name.compareTo(person1.name);
            int compare=-this.name.compareTo(person1.name);
            if (compare!=0){
                return compare;
            }else {
                return Integer.compare(this.age,person1.age);
            }
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }

    }

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

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

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

六、Collections工具类
1.Collections：操作Collection、Map的工具类。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CollectionsTest {
    public static void main(String[] args){
        List list=new ArrayList();
        list.add(123);
        list.add(43);
        list.add(756);
        list.add(-97);
        list.add(0);

        System.out.println(list);

//        Collections.reverse(list);//反转List中元素的顺序
//        System.out.println(list);

//        Collections.shuffle(list);//对List集合元素进行随机排序
//        System.out.println(list);

//        Collections.sort(list);//根据元素对自然顺序对指定List集合元素按升序排序
//        System.out.println(list);

//        Collections.swap(list,1,2);//交换指定位置对元素
//        System.out.println(list);

//        System.out.println(Collections.max(list));//按照自然顺序找到最大的

//        System.out.println(Collections.frequency(list, 0));//指定元素出现对次数

        //容易报异常
//        List list1=new ArrayList();
        //正确写法：
//        List list1=Arrays.asList(new Object[list.size()]);
//        Collections.copy(list1,list);//将list中的元素复制到list1中，list的size必须大于等于list1的size
//        System.out.println(list1);
    }
}

2.Collections提供了多个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsTest {
    public static void main(String[] args){
        List list=new ArrayList();
        list.add(123);
        list.add(43);
        list.add(756);
        list.add(-97);
        list.add(0);

        System.out.println(list);
        
        List list1=Collections.synchronizedList(list);//list1是线程安全的
     }
}