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集合（底层链表）：查询慢 增删快

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

set接口底层是哈希表是由每个元素会生成一个哈希值
会先判断哈希值知否相同如果相同进入下一个判断equals如果都相等就重复
会被替换掉
Set接口底层由哈希表排序并不是按照输入顺序排序的
       
3.我们为什么要重写HashCode( )和equals（）方法？
省资源
这两个方法是为了实现哈希值比较


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

比较equals（）耗费资源内容短的对象还好.可是内容非常长的对象是很浪费资源的.不如哈希值比较

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


被排序的集合里面存储的元素 必须实现Comparable接口重写ComparablTo

排序规则:自己(this)-参数;升序

                参数-this;降序

                        sore(集合,new 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接口下都有哪些集合，他们各自有什么特点

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接口下都有哪些集合，他们各自有什么特点
    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接口下都有哪些集合，他们各自有什么特点
Arraylist  :元素增删慢，查找快
Iinkedlist：元素增删快，查找慢
Voctor:
2.Set接口下的集合是如何保证无序不可重复的
在set接口下的集合会重写HashCode（）和equals（）方法，如果哈希值相同那么就会用equals（）来判断内容是否相同，
如果equals（）判断相同，两个元素就是相同，只会存储一个元素。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet
集合中的对象唯一。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为equals()判断比较繁琐，先从哈希值来判断，要是不同，那么元素就是单一，相同的话再用equals来判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:强行对实现它的每个类的对象进行整体排序。
                    这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。
                    只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
                    实现 此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，
                    对象可以用作有序映射中 的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
                   从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
                   或者为那些没有自然顺序的对象collection提供排序。
使用Comparator接口使用多，因为方便且不用定义一个类。

1.List接口下都有哪些集合，他们各自有什么特点
Arraylist:查询快,增删慢
Linkedlist:增删快,查询慢
vector集合:效率低,安全

2.Set接口下的集合是如何保证无序不可重复的
调用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接口下的集合是如何保证无序不可重复的
调用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接口下的集合有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接口下都有哪些集合，他们各自有什么特点
答：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接口下都有哪些集合，他们各自有什么特点
有Vector,ArrayList,LinkedList集合。
Vector:不能使用迭代器和增强for循环，如果要进行遍历，只能使用枚举方法
ArrayList:底层结构是数组。由于数组地址值是连续的，所以ArrayList的查询速度非常快，但由于数组的长度是固定的，所以ArrayList的增删操作非常麻烦，底层需要重新创建一个新数组，再将原来的数组值转移到新数组。
LinkedList:底层结构是双向链表，所以增删操作非常简单方便，有很多独有的首尾操作方法。但是查询速度慢，由于链表连接的地址值并不是连续的，所以查询某个具体值需要从首个地址开始一步步查询下去，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合：主要结构是数组+链表或红黑树。集合内元素的存储是根据每个元素的哈希值大小排列存储到数组中，导致存储到数组中的元素并非有序的。而元素的hashCode()和equals()方法重写保证了元素不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
因为要使Set集合元素不会重复，需要使用equals()方法判读元素是否相同，但由于有时元素内容非常多，导致使用equals()方法比较效率很低，因此重写HashCode()方法。这个方法是根据元素的内容生成哈希值。哈希值不同，元素必然不同，哈希值相同，元素可能相同可能不同，如果相同，再用equals()判读。
通过，重写这两个方法，可以使得存储效率提升。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()。这个方法是根据元素的内容生成哈希值。哈希值不同，元素内容必然不同，哈希值相同，元素内容可能相同可能不同，如果相同，再用equals()判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口是自己和别人参数比较，一般在定义类的时候，自己实现这个接口功能，需要重写比较的规则CompareTo方法，它强行对实现它的每个类的对象进行整体排序；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提供排序。

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接口下有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接口下都有哪些集合，他们各自有什么特点
       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接口下都有哪些集合，他们各自有什么特点
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接口下都有哪些集合，他们各自有什么特点
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接口。