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

1.List接口下都有哪些集合，他们各自有什么特点
    ArrayList集合：底层数据结构为数组，查询快：数组的是连续的，根据索引值就能查找元素；增删慢，因为数组的长度是固定的，要增加或者删除元素，无法在原数组上直接增加或者删除元素，都需要新建一个符合要求长度新数组，把原数组元素和要增加或者删除了元素的原数组按照索引放入新数组中，这样数组的增删速度慢。
    LinkedList集合：1.底层数据结构是链表，查询慢：链表中地址不是连续的，每次查询元素，都必须从头开始查询；增删快：链表结构，增加/删除一个元素，对链表的整体结构没有影响，因此增删快；2.里边包含了大量操作首尾元素的方法；3.使用LinkedList集合特有的方法时，不能使用多态。
    Vector集合：JAVA1.0的方法，数据存储效率较低，但是安全性高。

2.Set接口下的集合是如何保证无序不可重复的
    Set集合底层是数组+链表/红黑树的结构，存入元素时会先判断哈希值，对应数组内哈希值的位置，然后判断内容，内容不一致就以链表形式连接在一起，一致则不存入，因此它是无序且不可重复的。
   
3.我们为什么要重写HashCode( )和equals（）方法？
    不重写HashCode( )的话，只要new了一个新的自定义对象，不管内容是不是相同都会生成新的哈希值，这样存入到Set集合里就会产生重复内容，与要求不符，因此需要重写HashCode( )，使内容完全相同的对象哈希值也相同。
    不重写equals（）方法的话，比较自定义对象时比较的就是地址值而不是自定义对象的内容，与需求不符。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
    先判断HashCode()再判断equals（），因为当一个对象的内容过多时，equals（）需要频繁的进行字段的比较，这样就很耗费性能，而哈希值较为简单，且哈希值不同的对象内容肯定不同，因此一般先判断HashCode()，比较节省性能。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator和Comparable的区别：
    Comparable:引用对象（自己）和别人(参数)比较,自己需要实现Comparable接口,因此需要在对象类中重写比较的规则compareTo方法
    Comparator:找一个第三方对象来对两个人进行比较，写在类中方法内
Comparator使用的多，因为Comparable需要在类中重写，这样耦合性比较高，排序方式不同时，需要反复

1.List接口下都有哪些集合，他们各自有什么特点
Vector集合:单线程，效率慢，但是安全
ArrayList集合:查询快，增删慢，底层是一个数组
LinkedList集合：查询慢，增删快，底层是一个链表

2.Set接口下的集合是如何保证无序不可重复的
（1）重写Object类中继承过来的hashCode方法，自定义，根据对象的内容生成的哈希值
（2）我们进行集合元素存储的时候，比如向HashSet集合添加元素的时候，会先调用hashCode方法，生成哈希值，不同对象的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象内容可能相同，可能不同
（4）比较哈希值如果不同，直接存，如果相同再调用equals方法进行比较

3.我们为什么要重写HashCode( )和equals（）方法？
为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；
equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，其一是因为要根据hash值找到对应的存储位置，其二是因为hash冲突的概率很低，用hash值判断已经能区分大部分的元素，当hash值一样时再调用equals()方法，这样能提高程序运行效率。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要在类中实现，耦合性强。
Comparator可以直接在测试类中用局部匿名实现类使用，所有Comparator用的比较多

1.List接口下都有哪些集合，他们各自有什么特点
答：
ArrayList集合：查询快，增删慢。底层是数组，数组有索引值，所以查询的速度快，但数组要增删需要重新创建一个新数组对象，将其他的元素添加到新数组中
LinkedList集合：查询慢，增删快。底层是链表。链表一个节点包含了一个数据源（存储数组），两个指针域（存储地址），链表中地址不是连续的，每次查询都要从头开始。而增删对链表的整体结构没有影响。
Vector集合：查询快，增删慢

2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合重写了Object类中的hashCode()和equals()方法，使元素先查询哈希值是否相同，哈希值不同，对象的内容不同，直接存进去。哈希值相同，内容可能相同，也可能不同。内容相同就不存，内容不同就存进去。

3.我们为什么要重写HashCode( )和equals（）方法？
答：因为如果两个对象需要判断是否相同内容，用equals方法比较，比较耗费性能。所以我们对Object类继承过来的hashCode()方法进行覆盖重写，不让他生成地址值，而是根据对象的内容生成hash值，进行比较，比较hash值比equals方法容易的多。
（1）重写Object类中继承过来的hashCode()方法，自定义，根据对象的内容生成的哈希值
（2）我们在进行集合元素存储的时候，比如先HashSet集合添加元素的时候，会先调用hashCode()的方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象的内容有可能相同，有可能不同。
（4）比较哈希值如果不同，直接存。如果相同，再调用equals方法进行内容比较

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，因为Set集合底层是用哈希表，哈希表=数组+链表/红黑树，会先计算元素的哈希值，然后通过哈希值比较，如果链表中没有相同的哈希值，直接存进去。如果有相同的哈希值，在判断equals()方法。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则ComparTo方法
Comparator：相当于一个比较器来比较两个元素
Comparator接口的使用多，因为Comparable只能在类中实现一次ComparaTo()，并不能经常修改类代码实现自己想要的排序。

1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下的集合有AbstractList, AbstractSequentialList, ArrayList,AttributeList,CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector。常用的两种是ArrayList和LinkedList，特点如下：
ArrayList：数据存储的结构是数组结构,元素增删慢,查找快，默认初始长度是10
LinkedList：数据存储的结构是一个双向链表，查询慢，增删快，包含了大量操作首尾元素的方法。

2.Set接口下的集合是如何保证无序不可重复的
答：无序性：仅使用哈希表存储数据，不添加额外的链表来记录元素顺序。
不可重复性：依赖于hashCode与equals 方法。Set类的集合在进行集合元素存储的时候，先重写Object类中继承过来的HashCode()方法，根据对象的内容生成的哈希值。比较哈希值，如果不同，直接存；如果相同，再调用equals方法进行内容比较，保证元素不重复。

3.我们为什么要重写HashCode( )和equals（）方法？
答：如果两个对象需要判断是否内容相同，可以调用equals方法进行比较，但如果一个对象的字段过多，那就会偏频繁的进行字段的比较，非常的耗费性能。我们可以对Object类继承过来的hashCode方法进行覆盖重写，不让他生成地址值，而是根据我们对象的内容，生成hash值进行比较。因为比较hash值比equals方法容易得多。如果hash值相同，再调用equals方法进行内容比较。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()。因为比较hash值比equals方法容易得多。如果一个对象的字段过多，那么对应的equals()方法就会偏频繁的进行字段的比较，非常的耗费性能。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator接口使用的多。因为要使用Comparable接口，需在源代码类中需要实现Comparable接口，重写compareTo方法，耦合性高，且比较标准变动时，不易修改，比较死板。而Comparator使用时，只需在Collections.sort方法中实现Comparator接口的匿名内部类，根据实际需求可以方便地改动，比较灵活，所以使用的多。

1.List接口下都有哪些集合，他们各自有什么特点
答：
        Arraylist集合：底层数组结构，增删慢，查询快；
        LinkedList集合：底层是链表结构，增删快，查询慢；包含大量操作首尾方法；
        Vector集合：数据存储效率低，但安全；
2.Set接口下的集合是如何保证无序不可重复的
答：
        先创建一个数组，然后用hashCode方法计算对象的哈希值，与数组内部元素的哈希值比较，如果没有相同就添加进数组中；如果哈希值相同，就用equals方法比较两个元素的内容，如果不相同，就单向链表或红黑树连接在一起，如果内容相同就舍弃不存入数组；因此保证了集合无序不可重复；
3.我们为什么要重写HashCode( )和equals（）方法？
答：
        HashCode( )：如果不重写，返回的是该对象的哈希值，而不是该对象内容的哈希值；而每次new出来的对象，不管内容一不一样其哈希值肯定不一样的，用这样的哈希值来比较就没有意义了；
        equals（）：如果不重写，比较的是地址值而不是内容
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：
        先判断HashCode()；
        原因：相较于HashCode方法，equals方法非常耗费性能；先用HashCode方法进行筛选，如果出现哈希值相同的在用equals去判断内容，这样能更节省性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：
        区别：
                Comparable：自己和别人比较，需要自己现Comparable接口，重写CompareTo方法
                Comparator：找第三方来比较两个对象
        使用：Comparator使用得多；
        因为：如果使用Comparable来控制，如果想换排序方法，就要经常在方法类中进行修改，耦合性很高；而Comparator则在匿名内部类中，耦合性低

1.List接口下都有哪些集合，他们各自有什么特点
LinkedList:底层是一个链表,提供了很多用于操作集合首尾数据的方法,查询慢,增删快
ArrayList:底层是一个数组,查询快,增删慢
Vector:JDK1.2以后被ArrayList取代,是不同步的,速度较慢

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合底层是哈希表(+链表),哈希表中用数组存储每个元素对应的哈希值,相同哈希值但内容不同的元素用链表或二叉树存储
调用add方法时, 会自动调用对象的hashCode和equals方法, hashCode不在集合中就直接存储, 相同则调用equals方法对比对象内容.

3.我们为什么要重写HashCode( )和equals()方法？
默认的HashCode()和equals()(也就是Object类中的)是对对象的逻辑地址值计算哈希值与比较,不能满足Set集合存储不重复对象的要求,而直接比较
两个对象的所有内容消耗资源太大,所以重写HashCode方法根据对象内容计算对象的哈希值,再重写equals方法,当对象哈希值相同时进行比较.

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals()，为什么？
先判断HashCode(),
若哈希值相同才调用equals方法可以节省equals方法比较两个对象所消耗的性能

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator接口使用更多, 因为Comparable方法需要在被比较的对象类中实现并重写compareTo方法, 这样的代码的耦合度较高, 当需求变更时
就要修改已经在使用的类,而Comparator接口没有这种困扰

1.List接口下都有哪些集合，他们各自有什么特点
Vector:单线程,速度慢,数组结构
ArrayList:底层是一个数组结构,查询快,增删慢.多线程
LinkerList:数据存储 结构是链表结构.方便添加,删除.多线程
2.Set接口下的集合是如何保证无序不可重复的
底层是一个哈希表结构,哈希值会数组某个制定位置中,哈希值相同的元素会存储在同一条链中,重写hashCode和equals方法保证不可重复,当同类中的哈希值时,再用重写的equals方法比较内容是否相同
3.我们为什么要重写HashCode( )和equals（）方法？
一方面节省资源,另一方面如果不重写HashCode( )和equals（）方法,两个相同内容的对象会被当成不同元素储存
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode方法,当哈希值相同的时候再用equals方法判断内容是否相同,节约资源
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
Comparator用的多,减小代码耦合性

1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下的集合：ArrayList,LinkedList,AbstractList, AbstractSequentialList,  AttributeList, CopyOnWriteArrayList,  RoleList, RoleUnresolvedList, Stack,Vector
特点：ArrayList元素增删慢，查找快；LinkedList集合方便元素添加、删除，提供大量首尾操作方法
2.Set接口下的集合是如何保证无序不可重复的
答：根据对象的哈希值来确定元素在集合中的存储位置，使用hashCode与queals方法来确保元素的唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
答：重写对象中的hashCode和equals方法，建立自己的比较方式，才能保
证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：首先判断HashCode()，如果不同就存入，如果相同再判断equals()，这样做可以提高存取和查找性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。

3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类

的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比

较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控

制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

1.List接口下都有哪些集合，他们各自有什么特点
答： ArrayList：底层结构是数组，元素增删慢，查找快。LinkedList：底层结构是链表结构，方便元素的添加、删除。Vector：可以实现可增长的对象数组，与数组一样，它包含可以使用整数索引进行访问的组件。
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合HashSet是根据存储对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能，而保证元素唯一性的方式依赖于hashCode()与 equals()方法。
3.我们为什么要重写HashCode( )和equals（）方法？
答：当我们给HashSet集合中存放自定义的元素或者对象时，必须重写对象中的hashCode和equals方法，才能保证HashSet集合中的对象唯一。如果不重写，比较的将是地址值。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode，因为如果哈希值不同，那么内容一定不同，哈希值相同，内容也可能不同，这种情况属于哈希冲突。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable是拿对象本身（this）与别人（参数）进行比较，需要实现Comparable接口，重写compareTo方法；
      Comparator可以看做找一个第三方的裁判，传入两个参数进行比较，不需要实现Comparable接口，重写compareTo方法，降低了类的耦合性。
      Comparator用的比较多，因为不需要实现Comparable接口，也不需要重写compareTo方法，还能降低程序代码的耦合性

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。

3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类

的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比

较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控

制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:可以存放有序可重复元素,有索引下标,元素增删慢,查找快,由于日常开发中使用最多的功能为查询数据,遍历数据,
所以ArrayList是最常用的集合
LinkedList:数据存储的结构是链表结构.方便元素添加,删除的集合,提供了大量首尾操作的方法
Vector:快被一起的集合

2.Set接口下的集合是如何保证无序不可重复的
因为HashSet 底层的实现其实是一个HashMap支持

3.我们为什么要重写HashCode( )和equals（）方法？
我们往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode()和equals()方法建立属于当前对象的比较方法

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()后判断equals(),因为当HashCode()不一致时,能判断出元素是否相等,如果判断HashCode值相等时,
就不必要使用equals,从而提高性能

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:强行对实现它的每一个类的对象进行整体排序.这种排序被称为类的自然排序,类的compareTo方法被
称为它的自然比较方法.只能在类中实现compareTo()一次,不能经常修改类的代码实现自己想要的
排序.实现此接口的对象列表(和数组)可以通过Collections.sort(和Arrays.sort)进行自动排序,对象可以用
作有序映射中的键或有序集合中的元素,无需指定比较器
Comparator:强行对某个对象进行整体排序.可以将Comparator来控制某些数据结构(如有序set或
有序映射)的顺序,或者为那些没有自然顺序的对象collection提供排序
Comparator用的比较多,因为便于程序员后期维护代码

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

（1）arraylist，特点:底层结构是数组实现，查找速度快，增删速度慢。
（2）linkedlist，特点：底层是链表实现，增删速度快，查找速度慢。
（3）vector，特点：jdk早期使用的结构，安全型更高，效率低。

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

通过使用哈希表结构（数组+链表+红黑树）来实现的。
（1）首先要添加的元素的哈希值找到对应的数组位置，若哈希值对应的位置上没有元素直接添加。
（2）若已经有元素类，再通过equals判断元素是否重复，不重复才添加。

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

为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；
equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为哈希值不同的元素一定不相同。哈希值相同了才有必要继续通过equals（）比较。
这样可以减少运算量。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：
Comparable：是对同一类下的所有对象进行排序：   Comparator：是对单一对象进行排序。

Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。

1.List接口下都有哪些集合，他们各自有什么特点？
因为都是List接口下的集合所以它们都有按顺序存取，有索引号
ArrayList集合：因为是数组数据结构所以元素查找快，增删慢。
LinkedList集合：因为底层是一个链表结构:查询慢,增删快。里边包含了大量操作首尾元素的方法。
Vector集合：是最初的集合，Vector 类可以实现可增长的对象数组。

2.Set接口下的集合是如何保证无序不可重复的?
因为set接口下底层是一个哈希表+红黑树，先用链表处理同个hash值都放在同
个链表内，同个链表内数据超过8个则转换成红黑树体系。最后通过HashCode( )找到链表再通过equals（）方法决定是否存储，所以最后存储的集合无序不可重复

3.我们为什么要重写HashCode( )和equals（）方法？
因为如果我们没重写equals（），则是两个地址值比较，如果不是同个对象则都为false，没有意义。而哈希值是一个十进制的整数,由系统随机给出即是对象的地址值,是一个逻辑地址,是模拟出来得到地址。而如果重写了则可以进行内容比较。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()再判断equals（），因为先需要判断HashCode()找到底层数组中链表，然后才通过equals（）；判断是否存储到集合当中。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable比较死板，Comparator比较灵活。所以Comparator使用比较多
因为Comparable在JAVA中已经被定义了规则如果再想换个规则排序就不可能修改源代码相对来说Comparator接口相当使用第三方仲裁判断可以在方法里作为匿名内部类
耦合度低又可以灵活判断修改排序规则所以Comparator接口使用的多。

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

Vector集合:是所有单列集合的开端

ArrayList集合:1.有序的集合2.可以存储重复元素3.有索引,包含带索引的方法

LinkedList集合:1.有序的集合2.可以存储重复元素3.有索引,包含带索引的方法

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

前提是要重写HashCode方法和equals方法.

(1.)存储元素的时候,我们调用HashCode方法先得到元素的哈希值

(2.)再看哈希表的数组有没有这个哈希值,如果没有,就把对应的元素存进去.

(3.)如果数组里面已经有这个哈希值,则调用equals方法和对应的元素进行内容的比较,如果相同,则不存储;如果不相同,则存储在对应的元素链表下面.

总结:哈希值相同,equals比较内容也相同,则不再存储这个元素到数组中;

哈希值相同,equals比较的内容不相同,则把元素存储到相同内容元素的链表下面.

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

保证Set接口下的单列集合存储元素不重复.

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

先判断HashCode,因为要先知道哈希表内的数组是否存在相同的哈希值,然后再决定存不存入.而equals是知道哈希值相同后再判断两个元素的内容是否相同

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

Comparator和Comparable的区别:

Comparable:自己(this)跟别人(参数)进行比较,自己需要实现Comparable接口,并重写ComparTo方法的定义规则

Comparator:等于找一个第三方的裁判来进行比较,它里面的方法sort(List,new Compartor)来进行比较

Comparator接口 使用的多,因为不用在实现类里面定义ComparTo方法规则,耦合度比较低,定义在实现类外部,删改数据比较方便.

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList  LinkedList Vector
ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用多的功能为 查询数据、遍历数据，所以 ArrayList 是常用的集合。
LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

2.Set接口下的集合是如何保证无序不可重复的
是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能
。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。

3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）,因为如果哈希表不同的元素内容肯定不同，但是内容不同的元素哈希表不一定不同。

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

1.List接口下都有哪些集合，他们各自有什么特点
(1)ArrayList集合:数据存储的结构是数组结构,元素增删慢,查找快
(2)LinkedList集合:数据存储的结构是链表结构,元素增删快,查找慢
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了确保自定义元素具有唯一性
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()是否存在哈希冲突,没有存在哈希冲突就会将数据存入集合,存在哈希冲突就会进行equals()判断两个元素是否相同,相同则认定两个元素相同就不会存储重复元素.
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

  
1.List接口下都有哪些集合，他们各自有什么特点
答:List接口的子类集合如下:
(1)ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快
(2)LinkedList 集合数据存储的结构是链表结构。增删速度快,提供大量首尾操作的方法。
(3)Vector 类可以实现可增长的对象数组,与数组一样，它包含可以使用整数索引进行访问的组件,Vector是同步的.

2.Set接口下的集合是如何保证无序不可重复的
答:重写HashCode( )和equals（）方法来保证元素的唯一性.

3.我们为什么要重写HashCode( )和equals（）方法？
答:我们需要对Object类继承过来的hashCode方法进行覆盖重写,不让他生成地址值,而是根据我们的内容,生成hash值,进行比较,比较hash值比equals方法容易得多.

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答:先判断HashCode(),再判断equals();哈希值不同,其对象的内容肯定不同;比较哈希值如果不同,直接存,如果相同,再调用equals方法进行内容比较;这样能够提高性能.

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答:(1)Comparable：强行对实现它的每个类的对象进行整体排序。
   (2)Comparator强行对某个对象进行整体排序。
   (3)Comparator接口使用的多.原因如下:
    因为Comparable只能在类中实现compareTo方法一次,不能经常修改类的代码实现自己想要的排序.而Comparator可以将Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构的顺序，或者为那些没有自然顺序的对象collection提供排序。

1.List接口下都有哪些集合，他们各自有什么特点？
（1）ArrayList集合：
        底层是数组，增删慢，查询快。
（2）LinkedList集合：
        底层是一个链表，增删快，查询慢。多线程。不能使用多态方式创建，会导致无法使用链表特有的操作头尾的方法。
（3）Vector集合：
        速度慢，但是线程安全。不常用，已基本被ArrayList替代。


2.Set接口下的集合是如何保证无序不可重复的？
        在向Set集合中添加元素时，Set集合会先会先计算hash值然后进行比较，如果不同就不用比较了，直接存；相同的话，再调用equals方法比较对象的内容，如果都相同，则不存进去。哈希值不同，对        象的内容一定不同；哈希值相同，对象的内容有可能相同。


3.我们为什么要重写HashCode( )和equals（）方法？
        两个对象需要判断内容是否相同，如果没有重写这两个方法，那么Set集合会默认调用equals方法进行比较，会很耗费性能。
例如我们想设计一个容器（Set集合），要求这个容器中的元素不        重复。我们如果没有重写对象类中的这两个方法，每次在存储的时候都将会需要调用equals方法进行比较：如果容器中的元素都不相        同，则存进去。这种情况下，如果一个对象的字段过多，那么就会频繁地进行字段的比较，非常耗费性能。
而如果重写这两种方法，根据对象内容分配hash值，比较hash值        比比较equals方法性能要高很多。


4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
        先判断HashCode。因为判断哈希值比使用equals方法判断对象内容是否相等性能要高很多。哈希值不同，对象的内容一定不同；哈希值相同，对象的内容有可能相同。所以Set集合一般采用先比较        哈希值的方案，如果不同就不用比较了，直接存；相同的话，再调用equals方法比较对象的内容，如果都相同，则不存进去。


5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparable：
        定义在类中，不需要传入比较器，不能自定义规则来进行精准排序。
（2）Comparator：
        定义在方法的内部类中，需要传入比较器，在类中可以自定义详细的规则来进行排序。
（3）Comparator用的更多，因为Comparable定义在类中，耦合度高，修改规则时会牵涉到类，维护性差，且不能自定义规则来进行精确的排序；而Comparator因为定义在方法的内部类中，耦合度低，维护性好，且可以自定义详细的排序规则。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：查询快，增删慢。接口的大小是可变数组的实现。实现不是同步的。
LinkedList：查询慢，增删快。接口是以链接列表实现。实现不是同步的。
Vector：可以实现可增长的对象数组。是同步的。

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合是根据对象的某种规则来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。

3.我们为什么要重写HashCode( )和equals（）方法？
因为如果不重写HashCode( )和equals（）方法，默认继承的是Object的HashCode( )和equals（）方法，比较的是地址值没有意义。无法保证元素的唯一性。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为如果HashCode()中哈希值不同，则内容肯定不同，可直接添加内容，不用再判断equals（），如果哈希值相同，则会发生哈希冲突，再进行判断equals（）判断内容是否一致。且判断HashCode()运行更快。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（，从而允许在排序顺序上实现精确控制。
Comparator接口使用的多，可以降低程序的耦合性。

1.List接口下都有哪些集合，他们各自有什么特点
Vector集合:单线程，效率慢，但是安全
ArrayList集合:查询快，增删慢，底层是一个数组
LinkedList集合：查询慢，增删快，底层是一个链表

2.Set接口下的集合是如何保证无序不可重复的
（1）重写Object类中继承过来的hashCode方法，自定义，根据对象的内容生成的哈希值
（2）我们进行集合元素存储的时候，比如向HashSet集合添加元素的时候，会先调用hashCode方法，生成哈希值，不同对象的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象内容可能相同，可能不同
（4）比较哈希值如果不同，直接存，如果相同再调用equals方法进行比较

3.我们为什么要重写HashCode( )和equals（）方法？
为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；
equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为哈希值不同的元素一定不相同。哈希值相同了才有必要继续通过equals（）比较。
这样可以减少运算量。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要在类中实现，耦合性强。
Comparator可以直接在测试类中用局部匿名实现类使用，所有Comparator用的比较多