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

1.List接口下都有哪些集合，他们各自有什么特点         ArrayList    增删速度慢，但是查找速度快，应为 ArrayList 底层是用数组来实现的，增删时，每次都要创建新的数组所以增删速度慢，但是应为是使用的数组，而数组都是带索引的，并且空间是连续的所以查询的速度快。         LinkedList   增删速度快，但是查找速度慢，LinkedList底层是用链表实现的，链表有三个属性，一个是本元素的地址，一个是元素，还有一个是下一个元素的地址。当需要增删只需要改变相应的地址就行了，但是查找时，每次都是重头开始找，所以查找元素的速度较慢。 2.Set接口下的集合是如何保证无序不可重复的         Set接口下的集合底层是用的是哈希表来实现的，当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较，如果链表中没有相同的哈希值，那么就可以确定集合中是没有重复的元素的，会先把哈希值存储在数组中，并且把对应的元素使用链表的方法保存在对应的哈希值下，如果两个元素有相同的哈希值，那么则会调用equals（）方法进行比较是否相等，如果元素不相等，则会添加到对应的哈希值的链表下，当链表的个数超过8个时，会转换成红黑树,以增加查找的速度。 3.我们为什么要重写HashCode( )和equals（）方法？        应为Object类中的HashCode( )方法获取的对象的地址值，equals（）方法比较的是地址的值，如果我们不进行重写HashCode( )和equals（）方法，那么并不能保证元素的唯一性； 4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？         先判断HashCode()， Set接口下的集合底层是用的是哈希表来实现的，当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较，如果链表中没有相同的哈希值，那么就可以确定集合中是没有重复的元素的，会先把哈希值存储在数组中，并且把对应的元素使用链表的方法保存在对应的哈希值下，如果两个元素有对应的哈希值，那么则会调用equals（）方法进行比较是否相等，如果元素不相等，则会添加到对应的哈希值的链表下 5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？       Comparable的是对使用同一类的所有对象进行排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。      Comparator接口使用的较多， Comparable的是对使用同一类的所有对象进行排序，而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接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是数组，因此元素增删慢，查找快；
LinkedList：底层的结构是链表结构，因此元素查找慢，增删快。

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

3.我们为什么要重写HashCode( )和equals（）方法？
Object类中的HashCode()方法返回的是元素的逻辑地址值，而我们希望用HashCode()对元素内容进行计算，以此来决定存储位置并进行初步判断元素的重复性；当待添加的元素和集合中的某个元素的hash值一样时，再调用方法equals()进行元素内容的比较，因此要重写equals()方法，否则比较的是地址值。

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

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator接口使用更多。因为Comparable接口的实现类中只能实现compareTo()一次，不能经常修改类的代码实现自己想要的排序；而Comparator接口可以以匿名内部类的方式使用，从而允许在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序，在灵活性上优于Comparable接口。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层是数组，查询快，增删慢
LinkedList:底层是链表，查询慢，增删快；首尾查询快，有许多与首尾相关的方法
Vector: 安全性高；时间比较久，逐渐被ArrayList取代

2.Set接口下的集合是如何保证无序不可重复的
无序：存储时通过不同的哈希值进行对应的保存，在取出时是按照特定的规则取出
不重复：
（1）首先，equals（）方法可以对对象内容进行比较，但是效率低下；
（2）可以通过HashCode方法和哈希值对equals（）方法进行优化；
（3）在调用equals（）方法前，先判断哈希值，通过重写HashCode方法获得根据对象内容生成的一串哈希值；
（4）如果哈希值不相等，那么这两个对象的内容肯定不同，直接添加到集合中；
        如果哈希值相等，那么这两个对象的内容有可能不同，调用equals()方法对这两个对象的内容进行比较，如比较结果不同，将此内容添加到同一个哈希值下的槽中

3.我们为什么要重写HashCode( )和equals（）方法？
因为要确保set集合存储不重复的元素的前提，就是要重写HashCode( )和equals（）方法，Object中的HashCode( )方法默认获取的是模拟的地址值，我们需要重写HashCode( )方法，让其根据对象的内容生产一串哈希值，再比较哈希值，快速判断两个对象的内容是否相同，如哈希值相同，就需要调用equals（）方法，而equals（）方法默认比较的是地址值，需要重写才能让其比较属性内容，最终达到存储元素不重复的效果。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode( )，因为如果使用equals（）方法，效率低下，对此引入了HashCode( )、哈希值进行优化，通过先判断两个元素的哈希值可以提高运行效率

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：排序的规则在类中已经规定完成，不能及时根据自身需求更改排序规则；调用是比较简单，可以通过Collections.sort进行排序
Comparator：可以在调用时根据自身需求更改排序规则；调用时格式相对复杂，需要指定比较器
Comparator接口用得多，因为Comparato在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

1.List接口下都有哪些集合，他们各自有什么特点
    ArrayList:     集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。    许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
        
    LinkedList:集合数据存储的结构是链表结构。方便元素添加、删除的集合。
   
    Vector:Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。Vector 是同步的，可用于多线程。

2.Set接口下的集合是如何保证无序不可重复的
    底层的实现其实是一个 java.util.HashMap 支持
   
3.我们为什么要重写HashCode( )和equals（）方法？
    给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
    先判断HashCode(),如果hash code相同,就没有必要使用equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
    Comparator
    以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:是一个长度可变的数组,它用于遍历数据,查询快,增删慢;
LinkedList:是以链表结构的形式存放数据的,所以增删快,查询慢;
Vector:是数组的祖宗,无上限,较为安全,随着元素的增加Vector长度也会自动增加,后逐渐被ArrayList取代了。
2.Set接口下的集合是如何保证无序不可重复的
是因为Set接口下的add方法每次增加前都重写了元素的HashCode()方法和equals()方法;
3.我们为什么要重写HashCode( )和equals（）方法？
这样才能保证了元素的不可重复性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
HashCode的效率相对比equals方法要高,所以每次重写equals方法前先用HashCode方法给元素一个逻辑地址(虚拟地址),再拿这个逻辑地址去跟集合里面的元素进行比较,如果没有相同的哈希值元素就添加,如果发生哈希碰撞这个时候就需要使用equals方法进行内容比较,这样才保证了元素的不可重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的比较多,因为Comparator方法较为简单,还可以在方法内实现一些较为复杂的可以通用的逻辑,从而达到节省重复的步骤.
Comparator和Comparable的区别:
Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
Comparator：相当于找一个第三方的裁判，比较两个

1.List接口下都有哪些集合，他们各自有什么特点
1.LinkedList   底层是一个链表数据结构 查询慢,增删快
2.ArrayList    底层是一个数组数据结构   查询快,增删慢
3.Vector      老数据结构,安全性高
2.Set接口下的集合是如何保证无序不可重复的
前提: 存储的元素必须重写hashCode方法和equals方法
1,先用 HashCode 方法进行比较,如果哈希值相同在使用 equals()方法 可以对对象的内容进行判断
如果不同 表示不重复, 如果相同表示重复
3.我们为什么要重写HashCode( )和equals（）方法？
保证元素唯一性的方式依赖于：hashCode与equals方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值,如果哈希值不同,没有必要去判断equals方法, 如果哈希值相同,在使用equals方法判断内容是否相同,所以 HashCode先判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器.

1.List接口下都有哪些集合，他们各自有什么特点List接口下有ArrayList,LinkedList
ArrayList的特点是底层是数组结构,查询速度快,增删速度慢;
LinkedList的特点是底层是链表结构,查询速度慢,增删速度快;

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合的无序说的是存取顺序不同,这是因为Set接口下的集合是通过哈希值来存放存储的元素,把每个元素存放在对应的哈希值位置处.
取出时安装特定的规则取出,去存储的顺序无关,这就实现了集合的无序性.
Set接口下的集合通过重写HashCode方法和equals方法来实现他的不可重复性;

3.我们为什么要重写HashCode( )和equals（）方法？
因为默认的HashCode()方法和equals()方法是比较地址值,无法根据元素的内容进行深一步的比较,无法保证存储元素的不可重复性,所以需要重写;

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
首先判断HashCode()方法,因为哈希值不同2个元素肯定不同,所以先获取哈希值进行判断,提高效率;
而当哈希值相同的情况下,两个元素的内容有可能不同,所以这时候还需要进行equals()判断.

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

Comparable是强行对实现它的每个类的对象进行整体排序,。这种排序被称为类的自然排序，类的compareTo方法
被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或
Arrays.sort），从而允许在排序顺序上实现精确控制

1.List接口下都有哪些集合，他们各自有什么特点 List接口下的集合有： ArrayList:底层由数组的数据结构组成，集合特点和数组相同，查询快，增删慢 LinkedList:底层由链表的数据结构组成，集合特点和链表相同，查询慢，增删快 Vector：老牌的集合，安全性高，但是存储速度底下，已被ArrayList取代 2.Set接口下的集合是如何保证无序不可重复的 不可重复是依靠Set接口重写了继承自Object类中的HashCode方法和equals方法，先用hashcode方法判断哈希值是否相同，如果相同再用equals方法判断内容是否相同，如果相同，则放于储存在数组中的相同哈希值槽下 Set接口下的HashSet无序是因为它是单向链表，只有一条链子，不能保证存取时元素顺序相同 3.我们为什么要重写HashCode( )和equals（）方法？ 如果不重写这两个方法，则Set接口下的集合无法做到存储的元素不相同 4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？ 先判断HashCode再判断equals,因为equals方法是可以对对象内容进行判断的，但是效率低下！！！为了对equals方法进行优化，引入了HashCode方法和哈希值 5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？ 使用Comparable接口必须先实现 Comparable接口才能使用compareTo方法 也就是说要在不同类中使用，所以不能经常修改代码实现自己想要的顺序 而Comparator接口可以直接在同一个类中使用sort方法实现，使用匿名内部类直接对代码进行修改，就可以达到自己想要的目的

1.List接口下都有哪些集合，他们各自有什么特点ArrayList：有序，有索引，数据可重复，查询速度快，增删速度慢
LinkedList：有序，有索引，数据可重复，查询速度慢，增删速度快
2.Set接口下的集合是如何保证无序不可重复的
重写hashCode方法和equals方法；当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较，如果链表中没有相同的哈希值，会先把哈希值存储在数组中，并且把对应的元素使用链表的方法保存在对应的哈希值下，如果两个元素有相同的哈希值，那么则会调用equals（）方法进行比较是否相等，如果元素不相等，则会添加到对应的哈希值的链表下
3.我们为什么要重写HashCode( )和equals（）方法？保证元素的唯一性
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）；当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？


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

1.List接口下都有哪些集合，他们各自有什么特点
①Arraylist ，查找速度快，增删慢，底层是数组实现的
②Linkedlist ，增删快，查找慢，底层链表实现
③vector
2.Set接口下的集合是如何保证无序不可重复的
通过对象的hashcode方法和equals方法来保证数据唯一，无序是根据某种规则的顺序存入的无序。
3.我们为什么要重写HashCode( )和equals（）方法？
通过重写hashcode方法和equals方法，给予数据一个十进制的模拟哈希值，当存入数据时，判断初始空间是有这个数据的模拟哈希值，没有就把哈希值存入空间，把数据挂在哈希值下面，如果有，且相同就判断数据内容是否相同，相同就不存储，不同就存储数据在这个哈希值的最下面。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为set集合存储空间是存储的数据给予的一个十进制的模拟哈希值，哈希值下面挂着数据，哈希值不同数据肯定不同，哈希值相同在判断数据内容是否相同，相同就不存储，不同就存储数据在这个哈希值的最下面。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是定义在类里，是对类的每个对象的自然排序，Comparator是定义在方法里的某个对象按照自己的规则排序，
Comparator的使用较多。
因为Comparable是定义在类里，是对类的每个对象都要进行排序，耦合性太高，浪费内存。
因此要进行Comparator的解耦，且Comparator可以一定程度上进行自定义排序，灵活性较高

1.list接口下有ArrayList集合、LinkedList集合和Vector集合，ArrayList集合数据结构是数组，具有数组查询快，增删慢的特点；LinkedList集合数据结构为链表结构，增删快，查询慢；Vector具有安全单线程的特点。
2.Set接口下的集合存储数据结构用的是哈希表，存储数据时，数据先根据哈希值找到内存中的存储位置，当哈希值相同时，会进行equals方法的判断数据内容是否一致，不一致才会以链表结构存储在哈希值对应的位置下。取元素时是根据Set接口自定义的规则，所以无序。
3.HashCode( )获取的是对象地址值，equals（）方法比较的是对象地址值，没有意义，需要通过重写，获得内容哈希值，和内容的比较的方法。
4.先判断HashCode()方法，因为equals()方法效率差，浪费计算机资源，先通过HashCode( )方法比较则可以大大提高效率。
5.Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序

1.List接口下都有哪些集合，他们各自有什么特点
List接口下有ArrayList<E>：底层是数组构造方法，具有查询速度快（有索引），增删速度慢（增删需要创建新的数组）的特点；
,LinkedList,底层是链表构造，具有增删速度快（链表有数据域跟指针域），查询慢（需要从头开始查找）的特点。
还有Vector：Vector与ArrayList一样是基于数组结构的List集合，但是该集合效率低，线程安全。  

2.Set接口下的集合是如何保证无序不可重复的
set接口的底层是数组+链表+红黑树构成的，通过调用HashCode来确定对象的哈希值，如果哈希值没有重复，直接存入集合，如果哈希值发生哈希冲突，就调用equals确定内容是否一致；确保集合存入的元素是唯一的。

3.我们为什么要重写HashCode( )和equals（）方法？
为了确保set集合数据的不重复性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode 在判断equals,equals的内存消耗比较大，先判断地址值可以提高效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的机会比较广泛，Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结果的顺序，或者为那些没有自然顺序的对象collection提供排序。
Comparable 定义在类中，不能随意更改，使用不便。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：查询慢增删快，底层是数据结构
LinkedList：底层是链表结构，查询快增删慢；包含大量收尾操作；不能使用多态
Vector：一种稳定的集合，操作复杂被淘汰

2.Set接口下的集合是如何保证无序不可重复的
在存储前必须重写hashCode与equals方法，从地址值到内容双重确保不会出现重复内容

3.我们为什么要重写HashCode( )和equals（）方法？
因为默认的两种方法只是比较地址值，不能确定内容一致性

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为存入时先计算哈希值哈希值不同元素肯定不同，相同后再使用equals进一步判断

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable用自己和别人比较需要自己实现Comparable接口，重写比较规则方法，可以自动比较
Comparator是一个专用的比较器，当对象不支持自动比较时，写一个专用的比较起来判断大小，使用的较多

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

ArrayList集合、LinkedList集合、Vector集合。

ArrayList集合：底层是一个数组的数据存储结构。由于数组的数据结构有索引值，所以对元素的查询快，但增删慢。
LinkedList集合：LinkedList底层是一个链表结构的数据结构类型，链表结构的特点是方便增删元素，可以直接通过地址值进行这一操作，但由于每次查询都要重头开始，所以查询慢。
Vector集合：安全性比较高。

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

通过重写hashCode方法和equals方法，在比较equals方法之前，先判断哈希值，通过重写的hashCode生成一串哈希值，如果哈希值不同，则直接存集合，如果哈希值相同，但内容不同，产生哈希值相同，就要进行equals比较。

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

因为默认的HashCode方法和equals方法比较的是地址值，而我们需要比较的是内容，所以需要对这兰格方法进行重写。

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

先判断HashCode（）。因为如果两个元素的哈希值不同，那这肯定是两个不同的元素，如果哈希值相同，再进行equals的判断。

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

Comparable：是强行对实现它的每个类的对象进行整体排序。是自然排序，compareTo方法是其比较方法，只能在类中实现一次且不能经常修改类的代码实现自己想要的排序。
Comparator：强行对某个对象进行整体排序，可以通过重写compare方法自定义排序方式。

1：ArrayList底层是数组结构，增删慢，查询快。
     LinkedList底层是链表结构，增删快，查询慢。
     Vector线程安全 效率低
2：无序是因为Set接口下的集合是通过哈希值来存放元素，把每个元素放在对应的哈希值位置。取出元素与存储的顺序无关，这就实现了集合的无序性。然后通过重写HashCode方法和equals方法实现不可重复
3：保证元素的唯一性
4：先判断HashCode（），因为存储数据时，先计算对应元素的哈希值，然后在通过哈希值进行比较，当哈希值相同的情况下两个元素的内容有可能不同，所以这时候还需要equals（）判断
5：Comparator接口使用的较多，Comparable是对使用同一类的所有对象进行排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。

1.List接口下都有哪些集合，他们各自有什么特点
答：List下有3种集合，分别是ArrayList类，LinkedList类，Vector类
ArrayList集合的特点为：因为底层是数组结构，所以查找快，增删慢
LinkedList集合的特点为：因为底层为链表结构，所以查找慢，增删快
Vector集合的特点：因为是单线程的集合，所以储存数据安全，但是效率低

2.Set接口下的集合是如何保证无序不可重复的
答：首先，Set接口下的集合储存的元素必须是重写equals方法和HashCode方法的。
在一开始进行储存元素之前，会对元素进行判断，先使用HashCode方法得到的哈希值去遍历集合，看是否有一样哈希值，如果没有的话，将元素直接存入集合；
如果哈希值存在一样的，则调用equals方法，把将存入的元素与集合中哈希值一样位置的元素进行对比，如果相同则不存入，如果不同则将元素存入集合；

3.我们为什么要重写HashCode( )和equals（）方法？
答：如果不重写HashCode()和equals()方法,HashCode方法给出的是系统随机给出的哈希值，equals方法判断的是两个对象的哈希值，则在判断元素是否相同时，因为创建对象给的哈希值都是唯一的，就算内容相同的元素一直都是判定为不相同的，则Set的实现类集合会存入重复的元素。因此需要重写HashCode和equals方法，让内容一样的元素判定为重复的，才能不存入Set接口的实现类集合中。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode。因为Set集合在储存元素时，会先判断元素的哈希值在集合中是否存在，因此要先执行HashCode()，当哈希值不一样时，就可以直接存入集合中，当哈希值一样时，在进行equals方法，判定元素的内容是否一样。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：comparable接口是在类中使用的，实现的效果是对实现该接口的类的每个对象进行自然排序，其中重写compareTo方法，就可以让类的每个对象按照所重写的方法规则排序。
comparator接口可以对单一对象实现按照某种规则排序。
comparator接口使用的比较多，因为comparable接口是对类所有的对象进行排序，而comparator接口只对单一对象排序，对于同一个类中的对象，可以使用不同中的排序规则。

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

LinkedList类底层是链表 增删块，查询慢

vactor类  底层是数组 是最早的单列集合，出现在jdk1.0版本里面，功能被Arraylist逐渐代替。

2.Set接口下的集合是如何保证无序不可重复的
答：通过重写了HashCode（）和equals（）方法，保证了集合的不可重复。而Set接口下的HashSet的底层是哈希表结构（数组+链表/红黑树）是无序的。
LinkedHashSet的底层是哈希表和链表的结构，多了条链表是为了记录元素顺序，所以是有序的。

3.我们为什么要重写HashCode( )和equals（）方法？
答：重写HashCode( )和equals（）方法是为了在Set集合中存入的元素唯一。在自定义的类中如果不重写这两个方法的话，会使用Object类的方法，HashCode
（）方法是操作系统随机给出的，而且equals（）方法比较的是地址值，所以不能保证set集合存入的元素是否唯一。


4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：是先判断HashCode()方法，因为如果HashCode（）相同的话一定是不同的元素，如果相同的话，才进行equals方法的比较。
如果先进行equals（）方法的比较，需要待存的元素和集合已有的元素一一比较，比较消耗内存（工作量太大）。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator这个借口用的比较多，是在对象中单独定义一个排序方法，重写compare（）方法。这样更加方便在各个对象中定义不同的排序规则。
而Comparable接口的使用需要自定义的类实现该接口，同时这个实现了Comparable接口的类，排序方式也相当于固定了，在其他地方使用时，也是这种排序方式。灵活性差，方法和类的耦合性太高，不方便使用。

1.List接口下都有哪些集合，他们各自有什么特点
ArrarList:底层是数组构造，查询快，增删慢。
LinkedList： 底层是链表结构，查询慢，增删快。
Vecter ：底层也是数组构造，线性安全。但没有比ArrayList方便。
这三种集合都也实现了List接口的特性，有序，有索引，可重复。

2.Set接口下的集合是如何保证无序不可重复的
Set接口下有一个HashSet集合，他无序，无索引，元素不可重复。
HashSet集合添加元素的时候要重写hashCode 和equals。
3.我们为什么要重写HashCode( )和equals（）方法？
HashSet（）不能有重复的元素，重写HashCose（）比较集合里对象的哈希值，如果不重写比较的是地址值，        重写equals（）是为的比        较集合里对象的内容。才能保证HashSet（）里没有重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
要先判断HashSet（），比较哈希值是否相同，如果相同而内容不同就存放在链表下面，当链表存到8个以上就会该存在红黑树。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自然排序。
Comparator是可以某个对象的内容进行排序。

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

ArrayList集合  ：增删慢；查询快；因为底层的数据结构是数组。

LinkedList集合：增删快；查询慢；因为底层的数据结构是链表。

vator集合：可以理解为老版ArrayList



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

Set接口下的集合底层是用的是哈希表来实现的 ，通过重写hashCode方法对元素对应的哈希值进行比较，如果哈希值不同，则为不同元素，如果相同，则再用重写的equals方法对元素进行判断，如果相等那么该元素为重复元素不添加，如果不相等则添加该元素。元素根据哈希值去找到元素存储的位置，因为元素的哈希值不一样，所以并没有按规律存的。

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

如果不重写HashCode( )和equals（）方法，那么比较的就是对象的地址值，每个new出来的对象地址值不一样，那么比较没啥意义。

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

先判断HashCode()因为要根据哈希值找到对应的存储位置，这样可以区分大多数元素了，因为冲突的相对比较少，然后当发生冲突时 再判断equals（），这样可以提高操作效率。

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

Comparator接口使用更多。因为Comparable接口的实现类中只能实现compareTo()一次，不能经常修改类的代码实现自己想要的排序；而Comparator接口可以以匿名内部类的方式使用，从而允许在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序，在灵活性上优于Comparable接口