1.List接口下都有哪些集合，他们各自有什么特点
在API中可以看到List接口下有很多集合我们目前学习的有：
（1）Arraylist集合：特点是底层的结构是数组结构，所以增删速度慢，查找速度快
（2）LinkedList集合：特点是底层的结构是链表结构，所以增删速度快，查找速度慢
（3）Vector集合：JDK早期使用的结构，只不过现在被ArrayList淘汰；
特点是底层也是数组结构而且是单线程数组安全型更高，效率低

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合底层是一个哈希表结构（数组+链表/红黑树），会先调用HashCode计算哈希值；
如果哈希值没冲突则会添加存储元素；
如果哈希值冲突则会重写equals方法比较元素内容；
内容元素相同则不添加存储，不相同则就添加存储；

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

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据在存入Set集合的时候会先判断HashCode；
因其底层结构是哈希表结构系统会随机生成一个十进制整数的虚拟地址；
判断完哈希值相同才会判断equals；

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：对同一类下的所有对象进行排序；
Comparator：是对单一对象进行排序；
Comparator使用的比较多。使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。

王佳盛

1.        List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是一个数组结构；查询快，增删慢。
LinkedList：底层是链表结构；查询慢，增删快。
Vector：底层也是数组结构，是单线程的。效率较低。

2.        Set接口下的集合是如何保证无序不可重复的
Set接口下的集合在添加元素是会先调用HashCode（）方法，判断集合中是否存在哈希冲突，如果不存在哈希冲突，就将元素存入集合。如果存在，就调用equals（）方法，判断元素内容是否相同，不相同就存入集合。否则不存入集合。

3.        我们为什么要重写HashCode( )和equals（）方法？
在我们需要创建一个存储没有重复元素的集合（Set）时，我们自定义的类需要重写HashCode（）和equals（）方法，保证向集合添加自定义类的元素是唯一的。如果没有重写，则可能存储的元素内容相同。

4.        数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）方法，因为哈希值不同，对象内容肯定不同；哈希值相同，对象内容可能相同（例如“重地”和“通话”，哈希值相同，内容不同），可能不同；

5.        Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
使用Comparator接口多，因为使用Comparable接口需要继承接口，重写compareTo（）方法，耦合度太高；而使用Comparator接口可以使用匿名内部类，比较灵活。

王佳盛

1.        List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是一个数组结构；查询快，增删慢。
LinkedList：底层是链表结构；查询慢，增删快。
Vector：底层也是数组结构，是单线程的。效率较低。

2.        Set接口下的集合是如何保证无序不可重复的
Set接口下的集合在添加元素是会先调用HashCode（）方法，判断集合中是否存在哈希冲突，如果不存在哈希冲突，就将元素存入集合。如果存在，就调用equals（）方法，判断元素内容是否相同，不相同就存入集合。否则不存入集合。

3.        我们为什么要重写HashCode( )和equals（）方法？
在我们需要创建一个存储没有重复元素的集合（Set）时，我们自定义的类需要重写HashCode（）和equals（）方法，保证向集合添加自定义类的元素是唯一的。如果没有重写，则可能存储的元素内容相同。

4.        数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）方法，因为哈希值不同，对象内容肯定不同；哈希值相同，对象内容可能相同（例如“重地”和“通话”，哈希值相同，内容不同），可能不同；

5.        Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
使用Comparator接口多，因为使用Comparable接口需要继承接口，重写compareTo（）方法，耦合度太高；而使用Comparator接口可以使用匿名内部类，比较灵活。

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

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

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

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

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

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

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

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

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

Comparable：是对同一类下的所有对象进行排序；   Comparator：是对单一对象进行排序。
Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。

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

(1)ArrayList集合:数据存储的结构是数组结构,元素增删慢,查找快
(2)LinkedList集合:数据存储的结构是链表结构,元素增删快,查找慢

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

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

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

在给HashSet中存放自定义类型元素时，需要重新对象中的hashCode和eauals方法，
建立自己的比较方式，才能保证HashSet集合中的对象唯一

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

先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。

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

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

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接口下都有哪些集合，他们各自有什么特点
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集合：
1.有序的集合,存储元素和取出元素的顺序是一致的
2.有索引,包含了一些带索引的方法
3.允许存储重复的元素

LinkedList集合：
1.底层是一个链表结构:查询慢,增删快
2.里边包含了大量操作首尾元素的方法

2.Set接口下的集合是如何保证无序不可重复的
因为通过调用重写了HashCode和equals方法。

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

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,因为
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是对使用同一类的所有对象进行排序，
Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。
Comparator使用的比较多，Comparable的是对使用同一类的所有对象进行排序，
而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。
可以对使用同一类的对象按不同的规则进行排序。

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接口下都有哪些集合，他们各自有什么特点
ArrayList：集合数据存储的结构是数组结构，元素增删慢，查找快
LinkedList：集合数据存储的结构是链表结构，元素增删快，查找慢

2.Set接口下的集合是如何保证无序不可重复的
HashSet 底层的实现其实是一个HashMap 支持，使得它存储的元素不可重复并且无序。
LinkedHashSet是HsahSet一个子类，所以同样元素不可重复并且无序。
3.我们为什么要重写HashCode( )和equals（）方法？
如果我们往集合中存放自定义的对象，那么对象的内容可以不同，难以保证存入的对象其唯一，
就必须复写hashCode和equals方法建立属于当前对象的比较方式，确定对象内容，进行具体比较。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashcode()
因为要先进行方法计算插入数组的索引值确定一个大的范围，再进行判断该范内元素是否存在即equals方法。这样执行的顺序查找效率高。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable已经把排序的规则写死了，不能像Comparator一样灵活的更改排序规则。
Comparator使用的多，因为可以根据实际情况进行规定排序规则。

1.List接口下都有哪些集合，他们各自有什么特点
答：ArrayList :底层结构是数组实现，查找速度款，增删速度慢
      linkedList：底层是链表实现的，增删速度快，查找速度慢
      vector：jdk早期使用的结构，安全性 更高，效率低

2.Set接口下的集合是如何保证无序不可重复的
答：通过使用哈希表结构（数组+链表+红黑树）来实现的
      1.首先要添加的元素的哈希值找到对应的数组位置，若哈希值对于的位置上没有元素直接添加
      2.若已经有元素类，在通过equals判断元素是否重复，不重复蔡添加

3.我们为什么要重写HashCode( )和equals（）方法？
答：因为要保证元素的唯一性，因为Object类中的HashCode()方法获取的是对象的地址值，
equals（）方法比较的也是地址值，如果我们不进行重写的话就回出现相同的的元素

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

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable :是对同一类下的所有对象进行排序
      Comparator:是对单一的对象进行排序
      Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况

1.List接口下都有哪些集合，他们各自有什么特点
Vector:可以实现可增长的对象数组,相较于安全
ArrayList: 底层是一个数组结构，查找快，增删慢
LinkedList:底层是一个链表结构，查找慢，增删快

2.Set接口下的集合是如何保证无序不可重复的
当向set接口下的集合添加元素时，编译器会计算该元素的hashcode，按照hash值找到元素存储的内存区域，这样元素的存储就是无序的；同时，如果该元素的hash和集合内的某个元素一样，则调用equals方法对这两个元素进行比较，如果一致则不把该元素加入到集合中，这样就保证了元素不重复。

3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写HashCode( )和equals（）方法的话，对象比较的是哈希值，所以需要重写HashCode( )和equals（）方法，使哈希值一样，其内容也一致

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

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
Comparator接口使用的多，因为Comparable接口的实现类中只能实现compareTo()一次，不能经常修改类的代码实现自己想要的排序；而Comparator接口可以以匿名内部类的方式进行排序在灵活性上优于Comparable接口。

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接口下都有哪些集合，他们各自有什么特点
       ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快
       LinkedListt 集合数据存储的结构是链表结构,查询快，增删

2.Set接口下的集合是如何保证无序不可重复的
     1.  不包含重复元素基于哈希表实现的
3.我们为什么要重写HashCode( )和equals（）方法？
    如果两个对象需要判断是否内容相同，调用equals方法
如果一个对象的字段过多，那就会频繁的进行字段的比较，非常消耗性能。
我们需要对Object类继承过来的hashcode方法进行覆盖重写，不让他生成地址值，
    而是根据我们对象的内容，生成hash值进行比较，比较hash值比equals方法容易多了

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）重写objec类中继承过来的hashcold方法，自定义，根据对象的内容生成哈希值
  
（2）我们在进行集合元素存储的时候，比如hashset集合添加元素的时候，  
   会调用hashcode方法，生成哈希值，不同对象生成的哈希值可能相同
  （3）哈希值不同，对象的内容肯定不同：哈希值相同，对象的内容可能相同，有可能不同
    （4）比较哈希值如果不同，直接存放，如果相同，在进行equals比较
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
     Comparator使用的多；
     Comparable：强行对实现它的每个类的对象进行整体排序。
        这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法
    Comparator强行对某个对象进行整体排序。可以将Comparator
      传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制

李伟斌

1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下有vector：不常使用，已被 ArrayList替代；
      ArrayList：查询快，增删慢。
      LinkedList：查询慢，增删快。
2.Set接口下的集合是如何保证无序不可重复的
答：用为Set接口底层是链表结构，是无序的。并且Set接口底层有哈希值，因为哈希值是唯一的，如果重复将不存入Set集合中，所以Set接口不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：因为不重写Set接口将默认调用Object的HashCode（）和equals方法，比较的是对象的地址，这样做无法
确保Set接口里对象的唯一性，所以需要重写HashCode( )和equals（）方法，
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode（），确保哈希值是否一致，如果不一致将进行equals（）方法，如果equals（）方法比较结果一致，则不存入集合，如果不一致才存入集合中。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable接口是在类里面实现的，耦合度太高，不利于后期维护。
      Comparator则通过创建匿名内部类的方式实现接口，代码耦合度低，利于后期维护。
      工作中 Comparator接口用得较多，因为耦合度低，利于后期维护。

1.List接口下都有哪些集合，他们各自有什么特点
LinkedList集合：元素增删快，查找慢；适用于增删数据
ArrayList集合：元素增删慢，查找快；适用于查询数据，遍历数据
Vector集合：与新collection实现不同，Vector是同步的

2.Set接口下的集合是如何保证无序不可重复的
重写了HashCode()方法和equals()方法
不重写HashCode()方法得到的是对象的地址值，重写后能获取对应的哈希值；
不重写equals()方法比较的是两个对象的地址值，重写后比较两个对象的内容；
往集合中添加元素时，会先调用HashCode()方法，获取哈希值；在同一哈希值中，再用equals()方法比较两个对象的内容；这样能确保集合里的元素不重复

3.我们为什么要重写HashCode()和equals（）方法？
为了不让集合里的元素出现重复

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()；因为哈希表底层采用数组+链表实现，比较hash值比equals方法容易得多，耗费的性能更少。当HashCode()方法生成的哈希值相同时，才会调equals()方法进行内容比较。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。
Comparator：强行对某个对象进行整体排序。
Comparator接口使用的多；因为Comparable只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。而Comparator允许在排序顺序上实现精确控制。还可以用来控制某些数据结构的顺序，或者为那些没有自然顺序的对象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接口下都有哪些集合，他们各自有什么特点
LinkedList集合：元素增删快，查找慢；适用于增删数据
ArrayList集合：元素增删慢，查找快；适用于查询数据，遍历数据
Vector集合：与新collection实现不同，Vector是同步的

2.Set接口下的集合是如何保证无序不可重复的
重写了HashCode()方法和equals()方法
不重写HashCode()方法得到的是对象的地址值，重写后能获取对应的哈希值；
不重写equals()方法比较的是两个对象的地址值，重写后比较两个对象的内容；
往集合中添加元素时，会先调用HashCode()方法，获取哈希值；在同一哈希值中，再用equals()方法比较两个对象的内容；这样能确保集合里的元素不重复

3.我们为什么要重写HashCode()和equals（）方法？
为了不让集合里的元素出现重复

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()；因为哈希表底层采用数组+链表实现，比较hash值比equals方法容易得多，耗费的性能更少。当HashCode()方法生成的哈希值相同时，才会调equals()方法进行内容比较。

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

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集合：
           数据存储的结构是链表结构。方便元素添加、删除的集合。
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提供排序。