Java集合（一）：泛型与Collection集合

Java集合容器类在声明阶段无法确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前，将集合元素默认设计为Object对象类型；但是在JDK1.5之后使用泛型来替代对象类型，因为此时除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理、如何过滤、如何转化为String字符串等都是确定的，即：将集合元素的类型设计成为一个参数，这个类型参数就称其为泛型。

泛型的优点

像ArrayList、Vector底层都是维护了一个Object对象数组，如果不加以规范，那么，加入本意是想向集合中存入一个Student学生对象，但是在实际存储时候，放入了一个Integer整型元素，那么，程序也是可执行的。但是，在后续进行处理时，由于Integer整型元素不存在Student学生的属性，那么，就可能导致程序抛出异常。

而使用了泛型之后，那么，在定义集合时，就可以指定要存储的元素类型，这样，在实际调用add()方法存储元素时，编译器就会自动进行检查，并提示一些错误元素（例如：Integer整型元素）的的添加操作。

同时，我们称用来指定泛型的尖括号（<>）为“钻石运算符”，会根据变量声明包含的泛型类型，自动进行类型推断。

自定义泛型类型

要注意一点，泛型类型对应的一定是引用数据类型。

自定义泛型类/接口

如下为自定义泛型类和使用的示例代码，

import java.util.Arrays;

public class GenericTest_Class<E> {
    //properties
    private String name;
    private Integer age;
    private E gender;

    //methods

    public void a(E gender){
        System.out.println(gender);
    }
    public void b(E[] m){
        System.out.println(Arrays.toString(m));
    }
}

//子类继承父类时，可以指定泛型类型为Integer-那么在实例化时，默认就是Integer类型
class SubGenericTest_Class extends GenericTest_Class<Integer>{

}

class Test{
    public static void main(String[] args) {
        //实例化子类
        SubGenericTest_Class subGenericTest_class = new SubGenericTest_Class();
        subGenericTest_class.a(65);

        //不指定泛型
        GenericTest_Class genericTest_class = new GenericTest_Class();
        genericTest_class.a(15);
        genericTest_class.b(new String[]{"a","b","c"});
        //指定泛型
        GenericTest_Class<Integer> genericTest_class1 = new GenericTest_Class<>();
        genericTest_class1.a(15);
        genericTest_class1.b(new Integer[]{1,2,3});
    }
}

泛型使用细节

【1】一个泛型类，可以指定多个泛型参数，

【2】泛型类的构造器不能添加泛型参数。

【3】不同的泛型的引用类型不可以相互赋值，

【4】泛型擦除：如果不指定泛型类型，那么默认就是Object类型。

【5】泛型类的静态方法参数中，无法使用泛型参数。

【6】不允许直接使用泛型类型创建数组，但是可以通过Object对象数组类型强转实现。

自定义泛型方法

泛型方法：并不是带泛型参数的方法就是泛型方法，要求如下：

该方法的泛型的参数类型要和当前的类的泛型无关，直观地将：泛型方法的泛型参数应当和所在类的泛型参数类型不一样。

示例如下，

public class GenericTest_Class<E> {
    //properties
    private String name;
    private Integer age;
    private E gender;

    //methods
    //不是泛型方法
    public void a(E gender){
        E[] es = (E[]) new Object[5];
        System.out.println(gender);
    }
    //不是泛型方法
    public void b(E[] m){
        System.out.println(Arrays.toString(m));
    }
    
    //是泛型方法-{T和当前类的泛型参数E不同}
    public <T> void genericTest(T t){
        System.out.println(t);
    }
    
}

泛型方法的泛型参数类型是在方法被调用时，才确定下来的。

对于静态方法，其定义形式只需要在泛型参数之前，添加static关键字即可。

泛型与继承关系

不存在继承关系的情况

默认情况下，List<A>与List<B>之间是不存在继承关系的，两者实质上是并列的（因为在底层，ArrayList维护的是一个Object类型的数组）。例如：

通配符与存在继承关系的情况

虽然List<A>与List<B>之间不存在继承关系，但是通过使用通配符（？），我们可以让List<?>变为List<A>与List<B>的父类。

如下，

在Collection接口方法中，也使用到了通配符。

使用了通配符之后，在调用get(index)方法获取元素时，建议使用Object类型的变量进行接收，避免出错。

泛型受限

通过使用泛型，可以指定集合参数的兼容性上限和兼容性下限。这种用法在集合的API方法中经常使用，如下图所示，

示例代码如下，


class Person{

}

class Teacher extends Person{

}

public class FanXing_Limit  {
    //properties

    //methods
    public static void main(String[] args) {
        List<Object> objects = new ArrayList<>();
        List<Person> people = new ArrayList<>();
        List<Teacher> teachers = new ArrayList<>();
        //指定泛型的上限-表示：元素只能是Person及其子类的对象
        List<? extends Person> list_upper = null;
        list_upper = people;
        list_upper = teachers;
        
        //指定泛型的下限-表示：元素元素可以存放Person及其父类的对象
        List<? super Person> list_lower = null;
        list_lower = people;
        list_lower = objects;
    }
}

集合概述

集合的作用与存储内容

集合是一个容器，可以用来容纳多个对象。在实际开发中，最经典的应用场景就是：数据库相关的操作。

例如：连接数据库之后，从数据库中查询n条记录，将其封装为n个Java对象；然后，用一个集合对象来存放这n个Java对象（的引用）；最终将这个集合返回给前端，由前端进行数据解析、页面渲染。

值得一提的是：Java集合只能用于存储引用数据类型，更准确的说——集合中存储的是对N个Java对象内存地址的引用。

集合与数据结构

不同的集合，底层是对不同的数据结构的具体实现。

例如：ArrayList底层是对动态数组的实现，LinkedList底层是对链表的实现，TreeSet底层是对二叉树的实现。

但是这并非要求我们一开始就去精通数据结构，只需要我们掌握：在什么样的情况下，选择合适的集合类型去使用即可。

集合：Collection接口的继承结构

Collection接口的继承结构如下图所示，

集合：Map接口继承结构

Map接口的继承结构如下图所示，

Collection接口

Collection接口及其子类都可以获取一个Iterator迭代器对象，用以完成集合元素的遍历操作。

Collection接口的常用方法

Collection接口提供了与增加、删除、查询相关的方法。

增加方法

用于实现增加单个元素、通过集合增加一批元素，返回值都是boolean类型，

【1】boolean add(E e);

【2】boolean addAll(Collection col);

删除方法

用于删除单个元素、部分元素、所有元素、满足指定条件的元素，返回值为void或者boolean类型，

【1】删除所有：void clear();

【2】删除单个元素：boolean remove(E e);

【3】删除coll参数包含的部分元素：boolean removeAll(Collection coll)；

【4】删除满足条件的元素：boolean removeIf（Predicate<? super E> filter）;

其中：removeAll（）方法，可以实现集合的求差运算；removeIf（）方法，可以实现集合元素的筛选操作（详见：《JDK8-Predicate接口使用举例》）。

查询方法

用于判断某个/某几个元素是否存在、集合是否为空、集合元素个数的方法，

【1】判断某个元素是否存在：boolean contains(Object o)；

【2】判断某几个元素是否存在：boolean containsAll(Collection<?> coll)；

【3】集合是否为空：boolean isEmpty();

【4】集合中元素个数：int size();

迭代器

用于获取一个迭代器对象，进行集合元素的遍历操作。

Iterator<?> iterator()；

使用增强for循环、迭代器对象遍历Collection集合对象的示例代码如下，

   public static void main(String[] args) {
        Collection collection = new ArrayList();
        //调用方法
        collection.add(3);
        collection.add(4);
        collection.add(7);
        collection.add(1);
        collection.add(10);
        //普通for循环-失败-[Collection接口本身没有提供通过下标获取元素的方法]
        //方式1：增强for循环
        for(Object integer:collection){
            System.out.println(integer);
        }
        //方式2：迭代器遍历
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }

迭代器执行原理：代码在执行时，通过迭代器Iterator接口对象的hasNext()方法，判断当前指针的下一个位置是否存在元素；如果存在，那么就进入while()循环，并通过next()移动指针，获取下一个位置的元素；如果不存在，那么就结束while()循环，表示Collection集合中的元素已经遍历结束。

List接口的常用方法

List集合相比Collection父接口，多出来的成员方法都是和index索引/下标操作元素相关的。

public interface List<E> extends Collection<E>

如上所示，List接口继承了Collection父接口，那么，Collection借口中包含的成员方法，在List接口中也存在。

以下，我们主要关注List接口中拓展出来的特有方法。

添加元素的方法

通过索引添加集合元素的方法。

【1】添加元素到指定的索引位置：void add（int index,E e）；

【2】替换指定索引位置的元素：E set（int index，E element）；

获取元素的方法

通过索引获取集合元素的方法。

Object get（int index）；

删除元素的方法

通过索引删除集合元素。

boolean remove（int index）；

关于List集合的示例代码如下，

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(3);
        list.add(1);
        list.add(5);
        list.add(2);

        //添加元素
        list.add(4,10);
        //替换元素
        list.set(0,100);
        //删除集合元素
        list.remove(2);//删除下标为2的元素

        //遍历集合元素
        //普通for循环
        System.out.println("普通for循环");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //增强for循环
        System.out.println("增强for循环");
        for (Object o : list) {
            System.out.println(o);
        }

        //迭代器遍历
        System.out.println("迭代器遍历");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

    }

ArrayList类

ArrayList类是List接口的实现子类，常用方法和List父接口基本一致。

ArrayList底层是通过动态数组实现的，但是在jdk1.7和jdk1.8的底层实现有所不同。

jdk1.7源码分析

【1】在设计结构上， ArrayList继承了AbstractList抽象父类，AbstractList抽象父类实现了List接口。

【2】在构造器初始化上，ArrayList在初始化时，为内部维护的elementData对象数组分配了长度为10的内存空间。

初始化时的内存结构如下图所示，

【3】在添加元素、调用add()方法时，会向内部维护的elementData对象数组中添加元素，添加成功时，返回true。

【4】在初始数组已满、需要进行数组扩容操作时，会自动进行1.5倍的扩容操作。

jdk1.8源码分析

【1】JDK1.8在底层设计上，ArrayList底层依旧维护了两个重要成员属性：对象数组elementData和size元素个数。

【2】在构造器初始化时，直接给elementData对象进行赋值（引用一个空的数组，长度为0，所占内存空间为0）。

【3】在添加元素、调用add()方法时，才会执行自动分配长度为10的数组内存空间操作。

【4】在初始数组已满、需要进行数组扩容操作时，仍旧会执行1.5倍的扩容操作。

Vector类

Vector是List接口的实现子类，它是线程安全的。

【1】在底层设计上，内部维护了一个Object对象数组elementData用于存储元素、一个elementCount用于存储元素的实际个数。

【2】在构造器初始化时，会直接提供10个长度的内存空间。

【3】在添加元素上，被调用的add()方法被synchronized关键字修饰，是线程安全的方法。

【4】在elementData数组已满，进行扩容时，执行2倍的容量扩充操作。

LinkedList类

LinkedList类底层是对链表数据结构的实现。

LinkedList类的常用方法

LinkedList提供了大量操作头尾元素的方法。

【1】增加操作

void addFirst(E e)：在列表开头添加元素；

void addLast（E e）：在列表的结尾添加元素。

boolean offer（E e）：将指定元素添加为列表的的尾部（最后一个元素）

boolean offerFirst(E e)：在此列表的前面插入指定的元素

boolean offerLast(E e)：在该列表的末尾插入指定的元素

void push（E e）：将元素推入堆栈中

【2】获取/查询操作

E element（）：获取第一个元素（但不删除）；

E getFirst()：获取头元素

E getLast（）：获取尾元素

int indexOf(Object obj)：返回此元素的第一个索引值；找不到则返回-1

E peek（）：查询但不删除此列表的头

E peekFirst（）：查询但不删除此列表的第一个元素，如果此列表为空，则返回 null

E peekLast（）：查询但不删除此列表的尾部元素，如果此列表为空，则返回 null

【3】删除操作

E poll（）：查询并删除此列表的头

E pollFirst（）：查询并删除此列表的第一个元素，如果此列表为空，则返回 null

E pollLast（）：查询并删除此列表的尾部元素，如果此列表为空，则返回 null

E pop()：从堆栈中删除一个元素

removeFirst（）:删除头元素

removeLast（）：删除尾元素

示例代码如下，

  public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();

        //添加元素
        linkedList.addFirst(3);
        linkedList.addFirst(2);
        linkedList.addFirst(1);

        System.out.println("*******************");
        Integer pop = linkedList.pop();
        System.out.println(pop);
        linkedList.push(123);

        linkedList.addLast(321);

        linkedList.offerFirst(456);
        linkedList.offerLast(654);

        System.out.println(linkedList);


        //删除元素
        Integer poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList.pollFirst());
        System.out.println(linkedList.pollLast());
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());

        System.out.println("*******************");
        //遍历LinkedList
        System.out.println(linkedList);

    }

其中：poll()方法是从jdk1.6开始的，删除元素时，列表为空也不会抛出异常，而是返回一个null；但是像之前的removeFirst()、removeLast()方法，列表为空时删除的操作会导致抛出异常。

因此，更建议使用从jdk1.6开始提供的poll()、pollFirst()、pollLast()方法。

LinkedList的遍历

      
        //for循环遍历
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }

        //迭代器遍历1
        Iterator<Integer> iterator1 = linkedList.iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }


        //迭代器遍历2——更建议此种迭代器方式,因为此时Iterator迭代器存在于局部作用域中;for循环结束之后,迭代器对象自动销毁;更加节省内存.
        for (Iterator<Integer> iterator = linkedList.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }

LinkedList底层原理

LinkedList底层是对线性表-双向链表数据结构的实现。图示如下，

模拟LinkedList的源码

此处模拟LinkedList的添加add()、获取长度getSize()、获取元素get()三个方法，示例代码如下，


public class MyLinkedList {
    //properties
    private Node first;//首结点
    private Node last;//尾结点
    private int count;//元素数量
    //methods
    public MyLinkedList() {
        this.first = this.last = null;//链表为空,首尾结点均为空
        this.count = 0;//总元素为0个
    }

    //添加元素
    public void add(Object data){
        if (this.first == null){
            // 添加第1个结点
            Node node = new Node();
            node.setPre(null);
            node.setData(data);
            node.setNext(null);
            //双指针指向当前结点
            this.first = node;
            this.last = node;
        }else {
            // 添加第n>=2个结点
            Node node = new Node();
            node.setPre(this.last);//上一个节点一定是最后一个结点
            node.setData(data);
            node.setNext(null);
            //前一个节点的尾指针指向当前结点
            this.last.setNext(node);
            //修改双指针指向
            this.last = node;
        }
        //长度自增
        this.count+=1;
    }


    //获取集合中元素的数量
    public int getSize() {
        return count;
    }

    //通过下标获取元素
    public Object get(int index){
        Node n = this.first;
        //获取下标为index的元素
        for (int i = 0; i < index; i++) {
            n = n.getNext();
        }
        return n.getData();
    }

}

class Test{
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        System.out.println(list.getSize());
        System.out.println(list.get(2));
    }
}

LinkedList-JDK18源码

JDK1.8的LinkedList链表源码片段摘取如下，

※面试题：Iterator()、Iterator和Iterable关系

（1）Iterable接口是Collection的父接口，提供了iterator()的抽象方法，可用于返回一个Iterator迭代器对象。

（2）Iterable接口的抽象方法iterator()方法，由具体的子类实现，例如：ArrayList子类就实现了这个方法，

此处，Itr类是ArrayList的内部类，对Iterator接口进行了实现，主要是对hasNext()、next()方法进行了具体实现，

/**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

（3）Iterator接口提供了hasNext()、next()方法，用于实现集合对象的遍历操作，

※ListIterator迭代器

ListIterator迭代器允许程序员沿着任一方向遍历List列表。

为什么要引入ListIterator这个迭代器呢？

原因：在使用Iterator迭代器遍历List集合时，无法同时调用List集合的方法，执行修改元素的操作。例如：添加、删除、修改等都是不允许的。但是，ListIterator迭代器，提供了add()、set()方法，可以执行添加和设置操作。

示例代码如下，

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");

        //使用迭代器遍历在cc之后添加一个元素hh
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            if ("cc".equals(listIterator.next())) {
                listIterator.add("hh");
            }
        }
        //打印操作
        System.out.println(list);

        //逆向遍历
        ListIterator<String> iterator = list.listIterator(list.size());//获取cursor==size位置处的游标
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
        }
    }

Set接口

List接口中的元素是有序的、可重复的，但是Set接口中的元素则是无序的、唯一的。

Set接口的常用方法

Set接口中的常用方法和List接口的基本相同，但是Set——集合之中，是没有和索引相关的方法的。这意味着，我们无法使用for()循环来遍历Set接口中的元素，而只能使用增强for循环或者迭代器来遍历Set集合中的元素。

HashSet类

HashSet：成员方法

HashSet类中的方法如下，

示例代码如下，HashSet继承了Set之中元素的不可重复性。我们执行了两次添加28的操作，但是遍历结果中，只出现了一个28。

    //methods
    public static void main(String[] args) {
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.add(19);
        hashSet.add(24);
        hashSet.add(28);
        hashSet.add(28);

        System.out.println("size="+hashSet.size());
        //遍历HashSet
        for (Iterator<Integer> iterator = hashSet.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }
    }

※HashSet底层原理与应用：集合元素去重

public class Student {
    //properties
    private Integer age;
    private String name;

    //methods
    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Student() {
    }

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

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

例如：我们有一个List集合，存放了若干条Student记录，Student类的定义如上，提供了toString()方法。但是其中可能存在重复的元素，此时，就可以使用HashSet集合，来执行元素去重操作。

此时，如果直接使用HashSet来存放元素，会发现，竟然可以存放两个属性相同的Student对象。

    public static void main(String[] args) {
        test_hashSet();
    }

    private static void test_hashSet(){
        HashSet<Student> hashSet = new HashSet<>();
        hashSet.add(new Student(19,"Tom"));
        hashSet.add(new Student(18,"Lily"));
        hashSet.add(new Student(20,"Linda"));
        hashSet.add(new Student(19,"Tom"));

        for ( Iterator<Student> iterator = hashSet.iterator();iterator.hasNext();){
            Student student = iterator.next();
            System.out.println(student.toString());
        }
    }

上述现象与我们之前的理解，表面上看是“相悖”的，但其实是和HashSet的底层原理有关。

HashSet底层的数据结构就是哈希表（散列结构），实质上是通过“数组+链表”的结构实现的。这里的链表就是用来存储散列函数结果值相同的一串元素。

那么，如何判断两个是否需要延伸链表呢？

其实，在向底层数组存放元素时，如果当前位置index处已经有元素了，就调用equals()方法进行比较；如果比较结果为true，就直接舍弃；如果为false，就延伸出一个链表，用来存储下标位置相同，但是元素值不同的多个元素。

此时，我们就应当明白了，之前存储Student的HashSet集合中出现两个属性相同的Student元素的原因所在——Student类没有重写equals()方法。

如下，我们为Student类添加equals()、hashCode()方法，再次运行相同的代码，就可以看到存放的Student记录都是唯一的。

public class Student {
    //properties
    private Integer age;
    private String name;

    //methods
    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Student() {
    }

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

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

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

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

LinkedHashSet类

LinkedHashSet是HashSet的子类，通过LinkedHashSet子类，可以使得集合中的元素是有序的，即：按照元素添加顺序进行元素输出。示例代码如下，

    public static void main(String[] args) {
        HashSet<Student> hashSet = new LinkedHashSet<>();
        hashSet.add(new Student(19,"Tom"));
        hashSet.add(new Student(18,"Lily"));
        hashSet.add(new Student(20,"Linda"));
        hashSet.add(new Student(19,"Tom"));

        for (Iterator<Student> iterator = hashSet.iterator(); iterator.hasNext();){
            Student student = iterator.next();
            System.out.println(student.toString());
        }
    }

LinkedHashSet底层实现依旧是哈希表，只是多了一个总的链表，通过这个链表，可以实现元素的有序存储和遍历操作。

※比较器的使用

基本数据类型的比较，可以通过对应包装类提供的compareTo(value)方法完成，该方法是通过implements接口Comparable获得的，并返回一个int类型的值，用于表示比较结果。

①如果当前对象/值等于参数param，返回0；

②如果当前对象/值大于参数param，返回正值；

③如果当前对象/值小于参数param，返回负值。

内部比较器

同样的，对于自定义数据类型，也可以通过实现Comparable接口，重写compareTo(value)方法，来进行对象之间的比较操作。

以Student学生类为例，示例代码如下，

public class Student implements Comparable<Student>{
    //properties
    private Integer age;
    private String name;

    //methods
    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Student() {
    }

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

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

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

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

    @Override
    public int compareTo(Student o) {
        //按照年龄比较
//        return this.getAge() - o.getAge();
        //按照姓名比较
        return this.getName().compareTo(o.getName());
    }
}

外部比较器

此外，通过额外编写比较类CompareStudent，实现Comparator接口，也可以实现Student自定义类型的比较操作。示例代码如下，

//外部比较器
class CompareStudent implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        //按照年龄比较
//        return o1.getAge() - o2.getAge();
        //按照姓名比较
        return o1.getName().compareTo(o2.getName());
    }
}

比较器使用建议

更建议使用外部比较器，基于多态，其扩展性更好。

TreeSet类

TreeSet底层是通过二叉树数据结构实现的，在存放集合元素时，遵循二叉排序树的规则；在遍历集合元素时，按照中序遍历（根结点->左子树结点->右子树节点）的方式进行，得到一个升序的元素序列。

存放Integer类型

特点：元素唯一，不可重复；存放的时候是无序的，不会按照输入顺序存储；但是，遍历的时候是有序的，按照升序排列。

    //methods
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(12);
        treeSet.add(3);
        treeSet.add(7);
        treeSet.add(9);
        treeSet.add(3);
        treeSet.add(16);
        System.out.println(treeSet);
    }

底层存储元素时，是按照二叉排序树的规则组织的，即：会对元素的值进行比较（内部比较器Comparable或者外部比较器Comparator），然后将其放入左子树或者右子树中，

存放String类型

由于String类型实现了内部比较器Comparable接口，因此，存入TreeSet集合中的String字符串也是有序的。

    private static void test_String(){
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("absk");
        treeSet.add("pog");
        treeSet.add("udds");
        treeSet.add("psng");
        treeSet.add("bnsl");
        System.out.println(treeSet);
    }

存放自定义数据类型

对于自定义数据类型在TreeSet中的存放，为了遵循二叉排序树的规则，强烈建议为自定义数据类型提供内部比较器Comparable接口的实现，否则会报错。

使用内部比较器

如下所示，按照Student的姓名name字段进行排序，

public class Student implements Comparable<Student>{
    //properties
    private Integer age;
    private String name;

    //methods
    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Student() {
    }

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

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

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

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

    @Override
    public int compareTo(Student o) {
        //按照姓名比较
        return this.getName().compareTo(o.getName());
    }
}

使用TreeSet存放Student元素，如下所示，

    private static void test_Student(){
        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(new Student(12,"bnsl"));
        treeSet.add(new Student(31,"absk"));
        treeSet.add(new Student(14,"pog"));
        treeSet.add(new Student(51,"udds"));
        treeSet.add(new Student(18,"psng"));
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }

使用外部比较器

如下所示，为Student类提供外部比较器，根据年龄age进行比较。

//外部比较器
class CompareStudent implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        //按照年龄比较
        return o1.getAge().compareTo(o2.getAge());
    }
}

创建TreeSet集合对象时，将外部比较器实例作为参数传入即可，如下所示，

    private static void test_Student_1(){
        Comparator<Student> comparator = new CompareStudent();
        TreeSet<Student> treeSet = new TreeSet<>(comparator);//传入比较器参数
        treeSet.add(new Student(12,"bnsl"));
        treeSet.add(new Student(31,"absk"));
        treeSet.add(new Student(14,"pog"));
        treeSet.add(new Student(51,"udds"));
        treeSet.add(new Student(18,"psng"));
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }