1.List接口下都有哪些集合，他们各自有什么特点
2.Set接口下的集合是如何保证无序不可重复的
3.我们为什么要重写HashCode( )和equals（）方法？
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

1.List接口下都有哪些集合，他们各自有什么特点 有序，有索引，元素可重复

• LinkedList：双向链表结构
• ArrayList：多线程，底层是数组结构
• Vector：单线程，同步，底层是数组，迭代器和前两个不一样
  

2.Set接口下的集合是如何保证无序不可重复的
通过HashCode方法判断，哈希值不一样直接存储，当发生哈希碰撞时，会调用equals方法判断内容是否一致，一致不添加，不一致存储；
3.我们为什么要重写HashCode( )和equals（）方法？
equals 对于系统比较的是地址值，需要改写比较对象的属性和内容
HashCode方法地址是本地系统的，内容一样的时候可能地址不一样，这时需要改写HashCode方法让内容一样的对象返回一样的地址值；
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，效率高速度快
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：对所有类的对象进行排序，一般不随便修改，不能按自己随意的方式排序；
Comparator：对对象进行排序，可以更改已有的默认排序和对没有排序的LIst对象定义排序，可以定义自己想要的排序方式，进行多级的排序规则
Comparator用的多，简便，一般排序用的频繁的情况下使用Comparable接口

陈建秋
1.List接口下都有哪些集合，他们各自有什么特点  ArrayList，底层为数组，查询快，增删慢，线程不安全。
LinkedList，底层为链表，增删快，查询慢，线程不安全。
Vector，线程同步安全，但是效率低。
2.Set接口下的集合是如何保证无序不可重复的
   无序：Set集合底层是哈希表，元素的存放根据哈希值指定存放的位置，所以数据是无序的。
  不可重复：
  1.先对哈希值进行比较，哈希值不同才能添加进集合，如果哈希值碰撞了。
  2.使用equals方法对指定的内容进行比较，只有内容也不相等的才能加入集合。
3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写equals方法比较的是地址值，每个new出来的对象的地址都是不同比较没有意义，如果不重写Hashcode方法，返回的Hash值也是不同地址值的10进制表示，如果默认对象某些内容相同为同一对象，但是由于哈希值不同，就会判定两个对象不同，会产生歧义。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCod因为哈希值比较的是数值判断效率高，而且好的哈希算法的哈希碰撞是很少的，可以大量的减少equals的比较次数，确保了数据
的效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
  Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
Compator接口使用较多应为它使用灵活，可以根据不同的需求进行排序，只需要通过重写接口方法就可以实现，而Comparable则需要修改原来的类。

邹毅涛
1.List接口下都有哪些集合，他们各自有什么特点
List接口下都有ArrayList 、LinkedList、Vector。在1.2版本之后ArrayList取代了Vector，特点是查找快增删慢，LinkedList特点是增删快查找慢。
2.Set接口下的集合是如何保证无序不可重复的
Set通过哈希值保证无序，通过HashCode()和equals方法避免重复。
3.我们为什么要重写HashCode( )和equals（）方法？
Object类中的equals只比较了对象的地址值，重写使其比较内容是否相等，HashCode防止哈希碰撞。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，如果哈希值相同，在判断equals。HashCode是将对象的内部地址转换成十进制整数返回。提高查找效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator需要自己定义。比较灵活。

1.List接口下都有哪些集合，他们各自有什么特点
  ArrayList，LinkList等，ArrayList由于底层是有数组组成的，所以具有查询快，增删慢的特点，Linklist底层有链表的组成，所以有具有查询慢增删快的特点。他们都有序，有索引，可重复的特点。
2.Set接口下的集合是如何保证无序不可重复的
通过特定算法生成HashSet值，如果出现碰撞还可以通过equals来判断是否相等，所以确保了元素的唯一性。
3.我们为什么要重写HashCode( )和equals（）方法？
  当出现哈希值一样的的时候并不代表元素是一样的，所以需要重写HashCode( )，equeals默认比较的是对象的地址值，要比较内容才能判断是否一样，所以也要重写。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
  先判断 HashCode()，因为生成HashCode()的运行资源较少而且较快，当HashCode()一样的时候再去判断equals（）并不会增加很大负担。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的比较多，因为Comparator比较灵活，不需要在对象类中重写方法也不需要实现接口。而且如果要修改也会方便的多。

1.List接口下都有哪些集合，他们各自有什么特点   ArrayList  ：底层是数组结构   查询快 增删慢 LinkedList： 底层是链表结构   查询慢 增删快   Vector  Stack 等等。。。 2.Set接口下的集合是如何保证无序不可重复的     通过 hash 值进行比较  不一样的话直接储存   如果一样  再进行equals  比较  不一样 储存  一样不储存 保证元素唯一 3.我们为什么要重写HashCode( )和equals（）方法？   equals（）方法默认比较的是两个对象的地址值，没有实际意义，所以需要重新写   HashCode( )方法，防止哈希碰撞情况发生 4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？   先判断HashCode( ) 如果hash值一样   在用equals 比较内容 5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？   Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，无需指定比较器。 Comparator：强行对某个对象进行整体排序。创建第三方实现Comparator接口重写 compare方法 的对象  将 对象 传递给sort方法（如Collections.sort或 Arrays.sort），  比较常用

1.List接口下都有哪些集合，他们各自有什么特点ArrayList集合，底层是数组查找快，增删慢
LinkedList集合，底层是链表结构，查找慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
利用重写的hashCode和equals方法，如hashCode判断已经存在此哈希吗，则equals判断内容是否一致，如一致则是同一元素，如不一致则发生哈希碰撞
3.我们为什么要重写HashCode( )和equals（）方法？
当集合中的元素的对象是需要重写hashCode,生产哈希值，重写equals判断内容是否一致
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode,可以提高效率
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要类中重写comparaTo方法，不能需改比较的方式
Comparator可以方便修改比较方式，Comparator用的多

郭林源
1.List接口下都有哪些集合，他们各自有什么特点--->所学的有LinkedList（提供了大量操作首尾元素的方法）,ArrayList（大小可变的数组）Vector（单线程的，速度慢），List接口特点：集合有索引值，有序排列，元素可重复

2.Set接口下的集合是如何保证无序不可重复的--->利用HashSet哈希算法生成哈希值，确保每个集合元素的唯一性

3.我们为什么要重写HashCode( )和equals（）方法？--->如果不重写它们，哈希值默认比较的是地址值，如果出现哈希碰撞，再调用equals方法时，比较的也是地址值，无法确保集合元素的唯一性

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？-->先判断哈希值，哈希表由数组+链表+红黑树组成，先判断其哈希值是否一致，如果出现哈希碰撞，可能该数组位置上有两个哈希值相同的元素，再用equals判断是否是同样内容的元素

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？-->Comparator使用的最多，Comparable只能在类中实现compareTo()一次 ，不能经常修改类的代码实现自己想要的排序，而Comparator直接创建匿名内部类后，可直接进行排序规则修改

1.List接口下都有哪些集合，他们各自有什么特点？
         list接口下有ArrayList集合，LinkedList集合
              ArrayList的集合特点：集合数据存储的结构是数组结构。元素增删慢，查找快
              LinkedList集合的特点：底层是一个链表结构，查询慢，增删快，双向链表，有序集合
2.Set接口下的集合是如何保证无序不可重复的？
        Set接口下的集合没有索引值，元素无序，会以某种规则保证存入的元素不出现重复不允许存储重复元素。
3.我们为什么要重写HashCode( )和equals（）方法？
         方法中两个对象默认比较的是地址值，无法比较对象的内容，无意义。HashCode( )和equals（）能比较对象的内容

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
          向set集合中存入元素的时候 1.先比较哈希值 2.如果发生了哈希碰撞的话就会调用equals方法进行内容比较

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。  Comparable接口使用得比较多，能进行自动排序，无序指定比较器
                          
田浪

1.List接口中有ArrayList集合，LinkedList集合，Vector集合等
ArrayList集合增删慢，查询快是最常用的集合，LinkedList集合增删快查找慢，Vector集合实现是同步的。
2Set在增加数据是会调用hashCode方法和equals方法，来判断数据是否重复
3可以用自己的方式重写hashCode方法和equals方法减少哈希碰撞保证数据在集合中的唯一性
4先调用hashCode方法如果哈希值相同再使用equals方法判断数据是否相同，先使用hashCode方法因为方法给定的值一般情况下是唯一的如果出现哈希碰撞再调用equals方法来判断两个数据是否相同
5Comparable和Comparator：区别在于Comparator进行排序需要自己定义比较方式来进行比较，
Comparable则是拿参数与自身进行比较，所以一般情况下Comparable用的多
-------------------------------------------------------------------------------------------   周楠

1.List接口下都有哪些集合，他们各自有什么特点
答：LinkedList集合与ArrayList集合。LinkedList查找慢，增删快，是以链表结构存储数据的。
ArrayList查找快，增删慢，是以数组结构存储数据的。
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合在保存时有覆盖重写equals（）方法和hashCode（）方法，双重把关，
保证集合元素无序不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：保证Set接口下的集合元素无序不可重复。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()的返回值，若返回值为0，则判断equals（）的返回值是true还是false。
因为HashCode()的返回值是整型，运行快，所以先判断HashCode()。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable是强行对实现它的每个类的对象进行整体排序，无需指定比较器，适用于高频率排序的类。
Comparator是强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。
（黄嘉欣）

1.ArrayList合集数据存储的结构是数组结构。特点:元素增删慢，查找快。
LinkedList合集数据的结构是链表结构。特点：方便元素添加,删除的合集。
2.HashSet是Set接口的一个现实类,它所存储的元素是不可重复的（是由hashCode和equals方法决定的），并且元素都是无序的
3.因为Object的equal方法默认是两个对象的引用的比较，意思就是指向同一内存,地址则相等，否则不相等；如果你现在需要利用对象里面的值来判断是否相等，则重载equal方法。 当equal相等时，hashCode必 须相等，而且如果是object对象，必须重载hashCode和equal方法
4.先判断HashCode()因为不同的对象可能会生成相同的hashcode值,如果要判断两个对象是否真正相等，必须通过equals方法。
5.

3.我们为什么要重写HashCode( )和equals（）方法？
答：如果我们往集合中存放自定义的对象，那么保证其唯一， 就必须复写hashCode和equals方法建立属于当前对象的比较方式。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode（），只有HashCode返回值冲突的时候才会调用equals方法进行判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
答：Comparator：相当于找一个第三方的裁判，比较两个

1.List接口下都有哪些集合，他们各自有什么特点      ArrayList:有序,有索引,元素可重复,数据结构是数组,查询快,增删慢      LinkedList:有序,有索引,元素可重复,数据是链表结构,查询慢,增删快      Vector:有序,有索引,元素可重复, 2.Set接口下的集合是如何保证无序不可重复的      使用hashcode方法和equals方法 3.我们为什么要重写HashCode( )和equals（）方法？   保证set接口下的集合中的元素不会重复 4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？      先判断hashcode();哈希值是十进制的,判断起来比较节约系统资源, 5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？      Comparator:相当于找一个第三方的裁判比较两个;Comparable:自己(this)和别人(参数)比较,自己需要实现                 Comparable接口,重写比较的规则compareto方法, comparator用的比较多,因为他制定规则比较灵活

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:数组集合，查询快，增删慢。   LinkedList：链表集合，查询慢，增删快。
2.Set接口下的集合是如何保证无序不可重复的
通过hash值和equals方法进行判定重复性
3.我们为什么要重写HashCode( )和equals（）方法？
为了制定我们想要的规则
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode，因为该值是基本数据类型，判断更迅捷。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么
Comparator用的多，因为改变规则时不需要在实现类中修订/重写方法。

1.List接口下都有哪些集合，他们各自有什么特点
list接口下有：
ArrayList :
底层是数组结构，查询快，增删慢

LinkedList:
特点：1.底层是双向链表结构，查询慢，增删快
2.包含大量操作首尾元素的方法
3.不能使用多态

2.Set接口下的集合是如何保证无序不可重复的


保证元素唯一性的方式依赖于： hashCode 与 equals 方法。
先判断hashcode()，如果不相同直接存储，相同再比较equals（），不相同继续存储，如果还相同就不存储。

3.我们为什么要重写HashCode( )和equals（）方法？
HashCode( )和equals（）是系统默认给出的随机哈希值，容易发生哈希碰撞，所以需要重写。


4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？

先判断hashcode()，如果不相同直接存储，相同再比较equals（），不相同继续存储，如果还相同就不存储。
不同就直接存储，提高存储效率。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

Comparator使用的多，因为Comparator不需要实现接口，更加灵活。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合查找快，增删慢，
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
先比较hash值，相同再equal比较true则元素相同不存储
3.我们为什么要重写HashCode( )和equals（）方法？
重写HashCode( )方法给元素唯一的哈希值，equals（）不重写比较的是地址值无意义。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，Hash值是唯一值，只有发生哈希碰撞时才需要对元素进行内容判断，更省内存
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。Comparator：强行对某个对象进行整体排序。
Comparator用的多，方法的重写只对当前对象产生影响，更加灵活。

1.List接口下都有哪些集合，他们各自有什么特点

ArrayList:底层的数据结构使用的是数组结构；特点：查找快，但增加删除慢。
LinkedList：底层使用的是链表数据结构；特点：增删速度快，但是查找修改慢。
Vector：底层是数组结构，和ArraysList功能一样，但是Vector是同步的，ArraysList是不同步。被ArrayList替代。

2.Set接口下的集合是如何保证无序不可重复的

Set是一个接口，常用的Set实现类那就是HashSet了。
-------------------------------------------------
public HashSet() {
map = new HashMap<E,Object>();
    }
-------------------------------------------------

这是HashSet的构造方法。 可以看到HashSet内部其实就是一个HashMap 。

因为HashMap在put一个Key时会判断，将要放进去的Key的hash值与目前HashMap中定位到的那个Key的hash值比较。

如果hash值相当，继续比较 这两个对象的地址或者内容是否相当。

如果相当：判断出来要添加的Key与HashMap中的Key重复，把Value的值给替换成最新的。

HashSet中的Value是一个固定值PRESENT。 所以修改不修改无所谓。

3.我们为什么要重写HashCode( )和equals（）方法？

    首先equals与hashcode间的关系是这样的：

    1、如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；

    2、如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)   

    由于为了提高程序的效率才实现了hashcode方法，先进行hashcode的比较，如果不同，那没就不必在进行equals的比较了，这样就大大减少了equals比较的次数，这对比需要比较的数量很大的效率提高是很明显的，一个很好的例子就是在集合中的使用；

    我们都知道java中的List集合是有序的，因此是可以重复的，而set集合是无序的，因此是不能重复的，那么怎么能保证不能被放入重复的元素呢，但靠equals方法一样比较的话，如果原来集合中以后又10000个元素了，那么放入10001个元素，难道要将前面的所有元素都进行比较，看看是否有重复，这个效率可想而知，因此hashcode就应遇而生了，java就采用了hash表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据只要看对应的hashcode地址上是否有值，那么就用equals比较，如果没有则直接插入，只要就大大减少了equals的使用次数，执行效率就大大提高了。

    继续上面的话题，为什么必须要重写hashcode方法，其实简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？

    就跟之前题目提到的为什么重写hashCode和equals里面说到的，

hashCode的重写保证了元素的唯一性，而hashCode的值是int类型，数值比较的运算速度远远快于内容的比较速度，越是优秀的算法，哈希碰撞的概率越小，这样就大大减少了equals的使用次数，执行效率

就大大提高了。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

    Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

    Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

    Compatator使用的多，因为可以实现自己想要的排序的排序方法，而Comparable，只有自一种然比较方法，不能满足我们不同的排序需求。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层居于数组的栈类型结构，查询速度快，增删效率低。
LinkedList:底层居于链表格式类型的结构，查询速度慢，增删快。
Vector:同ArrayList，但是操作是单线程的，效率低。

2.Set接口下的集合是如何保证无序不可重复的

Set通过hashCode和equals方法实现元素不重复。
由于是通过哈希值来确定元素的存储位置，所以是无序的。

3.我们为什么要重写HashCode( )和equals（）方法？

默认的HashCode（） 方法比较的是默认的对象地址值，为了确保对象的唯一性，需要重写HashCode（）和equals（）方法。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？

先判断HashCode，在HashCode不同的时候才调用equals（）方法。hashcode是调用根据哈希算法的本地方法产生哈希值，比较能确保唯一性，效率高。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

comparable 强行对实现它的每个类的对象进行整体排序，不能修改类的代码实现自己想要的排序，
用Collections.sort或者Arrays.sort进行自动排序，无需指定比较器
Comparator 可以将 Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。

lijionghua

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合查找快，增删慢，
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
没有索引，所有是一个无序集合
3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法默认比较的是两个对象的地址值，无意义，所有需要重新写
HashCode( )方法，防止哈希碰撞情况发生
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值，因为哈希值判断完之后还会判断内容是否相等
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别在于一个已经定义好的，一个需要自己定义的，
如果没有特殊必要Comparable使用较多，
如非必要，基本不使用Comparator。