黄志斌：
1.List接口下都有哪些集合，他们各自有什么特点
List接口下有ArrayList和LinkedList两种集合，ArrayList的特点是它的结构是数组结构，元素增减慢、查找快，而LinkedList的特点是它的结构是链表结构，元素增减快，查找慢

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

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

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

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

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 底层是数组
       LinkedListt 集合数据存储的结构是链表结构。
         1底层是一个链表结构：查询快，增删慢

     
          2里边包含了大量操作首尾元素的方法
方便元素添加、删除的集合。

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特点：底层是一个链表结构，查询慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取

和查找性能。保证元素唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
比较元素是否相等
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么

？
先判断HashCode再判断equals 因为哈希值不同，对象的内容肯定不同；哈希值相同

，对象的内容相同，有可能不同
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的多，因为这个接口是在实现类里面，而不是抽象类里面。

1.List接口下都有哪些集合，他们各自有什么特点？
（1）list接口常见实现类有ArrayList、LinkedList、Vector；
（2）各自的特点
        1）ArrayList：底层采用数组结构，查询快，增删慢
        2）Linked:底层采用链表结构，查询慢，增删快，对内存的空间利用率高
        3）Vector:和Arraylist类似，区别在于它是线程安全型的，所以效率较低，栈内存设计使用到Vector,其它地方
             很少使用
2.Set接口下的集合是如何保证无序不可重复的
（1）以TreeSet和HashSet为例
        1）TreeSet的元素需要内部实现比较器或则创建TreeSet对象的时候传入比较器，通过比较器来判断两个元素的
             大小，如果要存入的元素和原集合中的某个元素相同就不进行存储，从而保证唯一性
        2）HashSet集合在存储元素时，会先调用元素的hashCode（）方法，判断当前要存储的元素hash值是否已经
              在集合中存在，如果已经存在（可能是不同元素但是发生hash冲突），就调用equal方法，如果euqal判断
              也是相等，则不进行存储
3.我们为什么要重写HashCode( )和equals（）方法？
（1）要存入HashSet集合的元素，必须重写这两个方法，因为HashSet会根据这两个方法判断要存入元素是否已经
        在集合中存在，从而保证存储的唯一性，如果不重写，默认对地址比较，不对内容比较，这样地址不一样，但内
         容一样的元素也会存储进来
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）先判断HashCode（），因为hashCode通过算法获取和内容相关的hash值，速度较快，equals判断速度较慢
         而且hashCode不同肯定是不同的元素，相同可能是相同的元素，也可能是不同元素但是发生hash冲突，这个
         时候再调用equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparator使用比较多，因为Comparator是外部比较器，在使用比较方法的时候当成参数传进去接口，比较
         灵活，修改也比较方便，Comparable是内部比较器，在被比较的元素类定义时实现该接口，修改不方便。

1.List接口下都有哪些集合，他们各自有什么特点
1,ArrayList
ava.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。


2,LinkedList


java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

3,Vector
现在已经被ArrayList集合取代

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

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

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

先判断HashCode(),如果一个对象的字段过多,那就会频繁的进行字段的比较,非常耗费性能,所以先判断HashCode(),只有在哈希值相同的时候,在判断equals()
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

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



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



1.List接口下都有哪些集合，他们各自有什么特点
1,ArrayList
ava.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。


2,LinkedList


java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

3,Vector
现在已经被ArrayList集合取代

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

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

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

先判断HashCode(),如果一个对象的字段过多,那就会频繁的进行字段的比较,非常耗费性能,所以先判断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是根据存储对象的哈希值来确定元素在集合中的存储位置，在调用add方法时会先调用添加元素的hashCode方法和equals方法，进行判断因此具有良好的存取和查找性能，而保证元素唯一性的方式依赖于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接口下的集合是如何保证无序不可重复的
     是通过HashCode( )和equals（）方法。
         add方法在调用元素的hascode方法计算字符哈希值，会在集合中找有没有这个哈希值，
     发现没有就会把元素存储到集合中，如果有会调用equals方法和哈希值相同的元素进行
     比较返回布尔值，如果是true就不会把相同的元素存储到集合中，如果是false会把元素
      加入相同哈希值的元素“下”

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

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
      先判断HashCode()，Set集合的底层数据结构是数组和链表，数组储存的是哈希值，而链表链接的是在这个哈希值下的元素
       存数据时先判断哈希值是否存在集合中，没有则会把元素存入集合，如果有则会调用equals（）方法来判断内容是否一致
        如果内容相同则判断为同一个元素，则不会把相同元素放入集合，如果没有则会把元素放在这个哈希值“下”

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
     Comparable：自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
                   而要实现这个接口需要在自定义类中并必须重写compaerTo方法，这样不方便我们以后对这个方法的更改操作
     Comparator：相当于找一个第三方的裁判,比较两个
                   可以使用匿名内部类来把方法抽离出来，更改起来影响不大            

1.List接口下都有哪些集合，他们各自有什么特点
答：
(1).ArrayList集合
特点：底层是一个数组结构，元素增删慢，查找快，元素都带有索引值，存储空间连续
(2).LinkedList集合
特点：底层是一个链表结构，元素增删快，查找慢，存储空间不连续，但是每个元素都带有链表，增删更快
(3).vector集合
特点;JDK早期使用的集合，已全面被ArrayList取代
2.Set接口下的集合是如何保证无序不可重复的
答：由于Set接口底下的集合重写了hashCode和equals方法，具备了哈希表，可以实现不可重复，原理如下：
hashCode方法重写后保证哈希值唯一，equals方法重写后会比较哈希值相同的两个元素内容是否相同，如果相同后一个元素不存入集合，如果不同则会添加到对应的哈希值链表下，两个方法叠加使用保证内部元素不可重复。

3.我们为什么要重写HashCode( )和equals（）方法？
答:保证集合内部的元素的唯一性，HashCode()方法可以获取对象的哈希值；equals()方法比较的是对象的内容，如果不重写这两个方法可能会出现相同的元素。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，再判断equals()，因为一个元素的哈希值是系统随机赋予的唯一值，如果哈希值不相同，那么内容一定不相同，那么就不需要使用equals()方法，如果出现了哈希冲突，则会调用equals方法将冲突的数据进行比较，当认定两个元素相同时，后一个元素就会被丢弃，不会存入集合
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？   
答：区别在于Comparable是对同一类的所有对象进行强制排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响
Comparator使用的比较多，因为使用Comparable是定义在类里面的，容易造成耦合性过高，而Comparator可以更灵活的调用部署，比如接收匿名内部类的内容，允许通过单一变量来排序，在灵活性上强于Comparab接口。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：List接口的数组实现，元素增删慢、查找快，不是同步
Vector：jdk 1.2之前较常用，而后逐渐被ArrayList取代，同步
LinkedList：List接口的链表实现，元素增删快、查找慢，不是同步
2.Set接口下的集合是如何保证无序不可重复的
a.Set接口下的集合比如HashSet，它底层的数据结构是数组+链表+红黑树实现的哈希表，根据元素的哈希值决定存储位置，
所以是无序的；
b.根据hashCode和equals方法来保证HashSet集合元素的唯一性，先判断hashCode方法再判断equals方法，
如果都相等说明是重复元素，就不存储
3.我们为什么要重写HashCode( )和equals（）方法？
为了提高程序性能
原因：Set集合要保证容器中的元素不重复，那么需要调用重写的equals方法进行比较，而如果对象的字段较多，
会频繁的进行字段比较，自然非常耗性能，而相比之下，比较hash值比equals方法容易，所以需要对hashCode方法
进行重写，让它根据对象的内容来生成hash值，先调用hashCode方法再调用equals方法
a.重写hashCode方法，根据对象的内容生成哈希值
b.集合存储元素时，比如向HashSet集合添加元素时，会先调用hashCode方法，生成哈希值，不同对象生成的哈希值可能相同
c.哈希值不同，那么对象的内容肯定不同；哈希值相同，对象的内容可能相同，也可能不同
d.如果哈希值不同，直接存；如果相同，再调用equals方法进行内容比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode方法
原因：如果对象的字段较多，先判断equals方法会频繁的比较字段，耗费性能，而相比之下，比较hash值比equals方法容易，
所以重写hashCode方法让它根据对象内容生成哈希值后，那么哈希值不同，对象的内容肯定不同，就无需再判断equals方法，
从而提升程序性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
1)Comparable：对实现它的每个类的对象进行整体排序，通过类中实现compareTo方法自定义比较规则，
不能经常修改类的代码实现自己想要的排序，无需指定比较器
Comparator：对某个对象整体排序，直接将Comparator传递给sort方法，允许在排序顺序上实现精确控制，需要指定比较器
2)Comparator使用的多，因为Comparable是通过让类来实现它，重写compareTo方法来指定比较规则，那么如果比较规则变了，就需要改动Comparable实现类的源码，
维护代价较大，使用Comparable代码耦合性较高；
而使用Comparator，降低了代码耦合度，直接在程序中通过匿名内部类指定的比较规则，不需要在类中实现接口，易于后期维护

1.List接口下都有哪些集合，他们各自有什么特点
答：有ArrayList，LinkedArrayList，Vector。他们三个都是可以重复，有序有索引；ArrayList和Vector底层是数组，查询快，增删慢，Vector是单线程，ArrayList是多线程；LinkedArrayList底层是链表，查询慢增删快。
2.Set接口下的集合是如何保证无序不可重复的
答：Set的add方法添加的元素的类有重写HashCode和equals方法，所以在添加元素的时候调用这两个方法可以保证存入数据不重复；而无序是因为元素是添加在哈希值对应的数组位置，哈希值在数组的前或者是后无法保证。
3.我们为什么要重写HashCode( )和equals（）方法？
答：为了确保Set集合存入的元素不重复。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，哈希值相同时再判断equals（）；Set集合添加元素时会调用这两个方法，判断添加的元素与集合中元素的哈希值是否相同，不同直接添加；相同的话添加的元素调用equals方法与相同哈希值的元素进行对比，返回false时添加，返回true不添加。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法；
Comparator:相当于找一个第三方的裁判,比较两个；
Comparator使用的比较多，因为Comparable要求所比较的类必须实现Comparable接口，重写compareTo方法比较规则，耦合性强，修改比较规则比较麻烦。

1.List接口下都有哪些集合，他们各自有什么特点？
（1）list接口常见实现类有ArrayList、LinkedList、Vector；
（2）各自的特点
        1）ArrayList：底层采用数组结构，查询快，增删慢
        2）Linked:底层采用链表结构，查询慢，增删快，对内存的空间利用率高
        3）Vector:和Arraylist类似，区别在于它是线程安全型的，所以效率较低，栈内存设计使用到Vector,其它地方
             很少使用
2.Set接口下的集合是如何保证无序不可重复的
（1）以TreeSet和HashSet为例
        1）TreeSet的元素需要内部实现比较器或则创建TreeSet对象的时候传入比较器，通过比较器来判断两个元素的
             大小，如果要存入的元素和原集合中的某个元素相同就不进行存储，从而保证唯一性
        2）HashSet集合在存储元素时，会先调用元素的hashCode（）方法，判断当前要存储的元素hash值是否已经
              在集合中存在，如果已经存在（可能是不同元素但是发生hash冲突），就调用equal方法，如果euqal判断
              也是相等，则不进行存储
3.我们为什么要重写HashCode( )和equals（）方法？
（1）要存入HashSet集合的元素，必须重写这两个方法，因为HashSet会根据这两个方法判断要存入元素是否已经
        在集合中存在，从而保证存储的唯一性，如果不重写，默认对地址比较，不对内容比较，这样地址不一样，但内
         容一样的元素也会存储进来
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）先判断HashCode（），因为hashCode通过算法获取和内容相关的hash值，速度较快，equals判断速度较慢
         而且hashCode不同肯定是不同的元素，相同可能是相同的元素，也可能是不同元素但是发生hash冲突，这个
         时候再调用equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparator使用比较多，因为Comparator是外部比较器，在使用比较方法的时候当成参数传进去接口，比较
         灵活，修改也比较方便，Comparable是内部比较器，在被比较的元素类定义时实现该接口，修改不方便。

吴元陶：


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

        LinkedLlist集合：查询慢、增删快。底层是链表。
        ArrayList集合：查询快、增删慢。底层是数组。
        Vector集合：底层为数组，是单线程。


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: <1>底层是链表，查询慢，增删快

         <2>里面有大量特有的首尾操作的方法

Vector: 早期的集合，存储数据比较安全

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

Set接口下的集合，在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，来判断元素是否重复

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

如果我们不重写HashCode()和equals()方法，我们比较的均是对象的地址值，不是对象的内容，这样的比较没有意义

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

先判断equals()方法。如果先判断equals()方法，首先equals方法比较的时候当遇到大量的字段时，会造成性能损耗，

其次，equals判断数据是否存在后再判断HashCode就没有任何意义了。


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

Comparable接口是通过自己与对象进行比较进行排序

Comparator接口是通过第三方作裁判然后进行比较

Comparable接口使用的比较多，因为Comparable接口只能在类中实现compareTo()一次，不能经常修改类的代码实现自

己想要的排序。

Comparator接口比较灵活，可以定义在方法中，也可以用自定义的规则进行排序

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接口下的集合重写了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  :元素增删慢，查找快
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特点：底层是一个链表结构，查询慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取

和查找性能。保证元素唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
比较元素是否相等
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么

？
先判断HashCode再判断equals 因为哈希值不同，对象的内容肯定不同；哈希值相同

，对象的内容相同，有可能不同
5.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()方法。如果判断equals()的结果是不相同的，就存进去。

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

1.List接口下都有哪些集合，他们各自有什么特点
     (1)ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快
     (2)LinkedList 集合数据存储的结构是链表结构。增删速度快,提供大量首尾操作的方法。
     (3)Vector 类可以实现可增长的对象数组,与数组一样，它包含可以使用整数索引进行访问的组件,Vector是同步的。
2.Set接口下的集合是如何保证无序不可重复的？
     答:Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
      首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
      如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
      不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
      答:为了确保自定义元素具有唯一性.
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
      答:先判断HashCode(),再判断equals();哈希值不同,其对象的内容肯定不同;
      比较哈希值如果不同,直接存,如果相同,再调用equals方法进行内容比较;
      这样能够提高性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
     答:(1)Comparable：强行对实现它的每个类的对象进行整体排序。
          (2)Comparator强行对某个对象进行整体排序。
          (3)Comparator接口使用的多:因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。