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

今天虽然请假了，但是还是尝试下来回答今天的总结：

1.List接口下都有哪些集合，他们各自有什么特点
List接口下有ArrayList LinkedList和Vector集合
ArrayList：List接口基于数组数据结构，最常用的集合类型之一，增删慢查找快。
LinkedList：基于双向链表数据结构，该集合增删快查找慢。并且有大量的操作首尾位置数据的方法
以上两种都是线程不安全，效率高。
Vector与ArrayList一样是基于数组结构的List集合，但是该集合效率低，线程安全。
2.Set接口下的集合是如何保证无序不可重复的
Set下的集合，以HashSet为例通过对象的哈希值，确保该位置没有元素，equals方法在添加元素到集合前先比较元素，确保集合内元素的唯一性。
3.我们为什么要重写HashCode( )和equals（）方法？
当我们要使用HashSet集合去存储自定义对象的时候，由于HashSet依靠hashCode()方法和equals来确保存储的唯一性。否则的话，默认调用的方法会以地址值作为是否重复的依据，没有办法确保Set集合的唯一性和无序性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode()确认哈希值来确保存储和查找性能，再通过equals方法来确保当出现了相同hash值的情况的时候元素仍旧拥有唯一性。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable为定义在类中的内置比较器，需要被排序的对象的类实现了该接口，并且覆盖重写了compareTo方法，排序规则在编写类的代码的时候被该方法唯一确定，不能根据需要去随时修改，比较死板，但是不需要指定比较器，适合于需要比较固定的排序规则的时候使用。
Comparator为比较器接口，可以把Comparator作为参数传递给sort方法来实现对于排序规则的控制，通过覆盖重写其中的compare方法来根据需要实现比较规则而不需要修改原有的类的代码，并且可以用于没有自然顺序（即没有实现Comparable接口的）collection集合提供排序。也因此Comparator比Comparable相对来说更加的灵活，有更多可以被利用的场景。

王宇晨
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList 存储的结构是数组结构，元素增删慢，查找快。
LinkedList存储的结构是链表结构，元素增删快，查找慢。

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

主要是通过hashCode和equals方法保证无序不可重复的，首先获取哈希值，如果集合中没有相同的哈希值，则存入，否则产生哈希冲突，
然后使用equals方法进行比较，如果返回false则存入，否则不存入。

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

因为HashCode是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能，为了保证元素唯一性
的方式，所以要重写HashCode( )和equals（）方法

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

先判断HashCode（），因为先判断元素的哈希值是否相同，如果不相同则存入，如果相同再用equals（）比较元素的内容是否相同，提高了代码的运行效率。

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

Comparable：内比较器，一个类定义的时候实现内比较器，适用于永远不改变的规则，这种定义比较固定，不灵活。

Comparator：外比较器，强行对某个对象进行整体排序。它适用于原来的类没有比较规则，而现在需要进行比较，想要进行比较。

Comparator使用比较多，因为这种定义比较灵活。

唐杰

1.List接口下都有哪些集合，他们各自有什么特点ArrayList(数据结构为数组结构,具有查找快,增删慢,效率高,安全性较低的特点)
LinkedList(数据结构为链表结构,具有查找慢,增删快,具有大量操作内容元素头尾的方法)
Vector(安全性高,效率低)

2.Set接口下的集合是如何保证无序不可重复的
主要通过hashCode和equals方法确保不可重复及无序,存储到set集合中的时候,先通过hashCode判断该位置是否有元素,如果没有才会进行存储,如果有的话,再进行equals判断内容是否一致(前提需要重写,否则对比地址值),不一样的情况下,才会进行存储.

3.我们为什么要重写HashCode( )和equals（）方法？
在对比对象的时候,如果没有重写HashCode( )和equals（）方法,默认对比的是地址值,如果我们需要对比对象的具体的成员属性,则需要重写该方法.

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
存入Set集合的时候,先判断hashCode,因为需要先确认hashCode的值是否已经存在set集合中,如果不存在则直接存储,存在的话再进行内容比较判断是否存储.

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

Comparable是在定义类中的时候,去实现comparable接口,并重写compareTo方法.特点较为固定,后期不便于去修改比较规则,适合固定比较规则的需求下使用.
Comparator是在定义类中,没有实现内部比较器的情况下,在需要比较的时候,通过匿名内部类去调用并重写compare方法,特点比较灵活,需要改变规则的时候可以不涉及到修改源码而且随时使用的特点.

郑雪平

今天学习了三块内容：1.list集合；2.set集合；3.数据结构。list和set集合都是Collection接口底下的两个子类，都属于单列集合范畴。list集合的特点是：元素有序有索引可重复，增删慢查找速度快。常用的方法有：增（Add）删(Remove)改(Set)查(Get)，list集合有两个常用子类：Arraylist和linkedList;Set集合的特点是：元素无序无索引不可重复，增删快查找慢，set集合子类有：hashset.  和 linkedhashset. set集合依靠 hashCode 与 equals 两个方法来实现元素的唯一性不可重复。
今天还介绍了数据结构，数据结构分为：：堆栈、队列、数组、链表和红黑树 ，各种数据结构对元素的存取都有自己的特点，1.堆栈：先进后出，例如，子弹压进弹 ；2.队列：先进先出，比如火车过山洞；3.数组：查找元素快增删元素慢；4.链表：查找元素慢增删元素快；5红黑树：又叫二叉树，每个结点不超过2的有序树，将节点插入后，树的键值仍然是有序的。
Comparator比较器：将集合中元素按照默认规则排序。Comparator比较器有两种：Comparator和Comparable,两者有一定的区别：Comparable：强行对实现它的每个类的对象进行整体排序。Comparator强行对某个对象进行整体排序。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList   查找快 增删慢  
LinkedList 查找慢 增删快
Vector  线程安全效率慢  已被ArrayList取代
2.Set接口下的集合是如何保证无序不可重复的
通过HashCode（）和equals（）方法；
3.我们为什么要重写HashCode( )和equals（）方法？
根据实际要求重写方法，Set集合正确保证其元素唯一性
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()是否相同，相同再判断equals()方法
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator接口使用的多，比较灵活，根据不用要求实现不同接口
Comparable一般比较固定，不会多次更改

1.List接口下都有哪些集合，他们各自有什么特点
Arraylist Linkedlist Vervtor
查找快 增删慢  2相反  3效率低 与1相似
2.Set接口下的集合是如何保证无序不可重复的
hashcode equal 判断哈希值是否相同 再用equal 判断 再替换
3.我们为什么要重写HashCode( )和equals（）方法？
public boolean equals(Object obj) {

       return (this == obj);

}
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
HashCode()   两个相同的对象具有相同的hashcode
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
后者比较多 可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

1.List接口下都有哪些集合，他们各自有什么特点List接口下有：ArrayList集合，是数组数据结构的，增删速度慢，查询速度快。LinkedList集合，是链表数据结构的，增删速度快，查询速度慢。Vector集合，与ArrayList集合类似，但是该集合是线程安全的，效率比较低。
2.Set接口下的集合是如何保证无序不可重复的
Set接口的集合底层使用哈希表来存储元素，存储元素时，会调用元素的hascode方法算出哈希值，表示该元素在哈希表中的存储位置，若该位置没有元素，则直接存入，若该位置已经有元素存储，则调用元素的eauals方法与该位置的所有元素进行比较，若有一个为true，则表示已存在重复元素，不存入，若都为false，表示没有重复元素，存入。
3.我们为什么要重写HashCode( )和equals（）方法？
因为hascode方法不重写时默认返回的是元素的地址值，equals方法默认比较的是元素的地址值。在使用set集合时，存储数据会调用元素的hashcode和equals方法，我们需要根据开发时的需要重写hashcode和equals方法，来保证存到set集合中的元素是唯一的。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashcode再判断equals，因为需要先用hashcode方法来算出元素存储的位置，若该位置没有元素则不需要判断equals，当该位置已有元素时才需要进行equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

Comparable是内部比较器，需要实现类实现CompareTo方法写出比较规则，是类的默认比较方式。
Comparator是外部比较器，只需在需要进行比较时实现从compare方法写出比较规则，为那些没有自然排序的类提供排序方式。
Comparat使用的多，因为使用方便灵活。

1.List接口下都有哪些集合，他们各自有什么特点
[1]ArrayList:底层是数组,查询较快,修改较慢
[2]LinkedList:数据结构是链表,查询较慢,修改较快
[3]Vector:底层是数组,线程安全的,效率比较低
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合是由对象的哈希值来确定位置的,其中通过调用hashCode方法来确定哈希值,
首先先判断是否哈希冲突(哈希值相同),如果不同则存入,如果相同则不存入,
则调用equals方法来判断对象是否内容相同,如果内容相同则不存入,不同则存入.
3.我们为什么要重写HashCode( )和equals（）方法？
如果没有重写hashCode和equals方法,两者判断的都是地址值,那么除了同一个对象的话其他情况
不会相等,我们一般认为对象里面的成员属性相同则他们就是同一个对象,所以重写equals可以实现
这样的判断.
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,因为哈希值相同的对象他们的内容不一定相等,只有先判断HashCode才能知道是否有
哈希冲突,有哈希冲突的时候再去判断equals,没有则直接插入
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口是类中定义的一个比较器,可以制定类的排序规则,是固定,不灵活的比较器.
Comparator接口是需要比较的对象类中没有制定比较规则时候可以自己制定特定的比较规则.
Comparator接口使用的比较多,是不固定,灵活的比较器,因为类不一定会实现Comparable接口,我们无法去修改别人做的类,
所以需要自己制定比较规则.而且通过内名内部类就可以实现,比较方便.

1.ArrayList  数组结构，查找快，增删慢，安全性低；LinkedList 链表结构，查找慢，增删快；Vector  安全性高，效率低。
2.依靠hashCode方法跟equals方法。存储元素时会先用hashCode方法给元素转化一个哈希值，然后元素放在哈希值的位置，如果出现哈希值相同，就接着用equals方法对比两元素，一样就不存进，不同就以链表形式存进去。
3.因为如果没有重写，对比的会是地址值。
4.会先判断hashCode方法，因为要先靠哈希值判断存进Set集合里的是否有相同，如果有在用equals方法判断元素是否相同，相同不存，不同以链表形式存。
5.比较方法不同；Comparable比较固定，不灵活，适用规则固定；Comparator灵活方便，需要时在临时定义一个比较规则。Comparator使用更多，灵活方便，需要时临时定义一个比较规则即可。

王博

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：是数组结构，查找快，增删慢
LinkedList：是链表结构，查找慢，增删快


2.Set接口下的集合是如何保证无序不可重复的
通过hashCode()和equals()方法


3.我们为什么要重写HashCode( )和equals（）方法？
当存储自定义类型时，为了保证元素的唯一性，需要hashCode()和equals()方法
不重写的话默认只是对地址值的比较，而我们一般认为元素的属性和内容一样就认为是相同，所以得重写


4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode()方法，因为存储原理是先通过hashCode()来判断该元素的哈希值是否存在，不存在就直接存入元素
如果存在，就会产生哈希冲突，这个时候再来通过equals()来判断元素是否相同

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用比较多，因为Comparator比较灵活，需要排序时随时调用，定义想要的排序方法
而Comparable就比较死板，必须在定义类的啥时候去实现Comparable接口并重写compareTo方法
后期如果想换别的排序方式还得到源码中去更改

吴佳更
1.ArrayList，底层是数组，查询快，增删慢。
LinkedList，底层是链表，查询慢，增删快。
vector，线程安全效率低。
2.通过给予每个元素哈希值，当哈希值一样的时候，用equals判断元素的内容是否相同，相同时则不加入数组。
3.如果不重写，判断的是地址，则无法判断内容是否一致。重写后判断的是对象的内容。
4.先判断HashCode()，后判断equals（），因为先判断HashCode()可以提高判断效率，如果先用equals（）效率较低。
5.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接口下的集合是如何保证无序不可重复的
Set接口下的集合是通过hashCode与equals方法保证无序不可重复的。
3.我们为什么要重写HashCode( )和equals（）方法？
如果对象进行比较，不重写HashCode( )和equals（）方法，对比的是地址值。如果重写的话，对比的则是哈希值。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据在存入Set集合的时候，先判断HashCode后判断equals，先通过HashCode判断哈希值是否相同，如果相同则直接存入。如果不同，则用equals判断元素是否存在。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable在定义类的时候直接实现Comparable接口，重写compareTo方法。固定，不灵活。
Comparator在编译时new匿名内部类，比较灵活。
Comparator使用比较多，因为比较灵活。

林焕
1.list接口底下有:
Arraylist:查询快,增删慢;
LinkedList:查询慢,增删快;
Vertor:线程安全,效率不高;

2.给HashSet中存放自定义类型元素时，重写对象中的hashCode和equals方法，建立自己
的比较方式，保证HashSet集合中的对象唯一;

3.如果我们往集合中存放自定义的对象，就必须复写hashCode和equals方
法建立属于当前对象的比较方式,这样才能保证HashSet集合中的对象唯一;

4.先判断的是HashCode(),后判断equals();哈希表底层采用数组+链表+红黑树实现,
当往set集合中添加元素对象时,要先对该元素获取hash值,然后进行hash值比较,
当hash冲突时,接着会用equals()方法进行元素的比较,当元素内容不一样时,该元素放入
链表底下,当链表元素超过8个时,采用红黑树数据结构;元素内容也一样时,set集合便不
再添加该元素;

5.Comparable是使用默认规则对集合进行自然排序;Comparator可以通过自定义方法对集合
进行排序;
Comparator使用的更多,因为Comparator更加灵活,可以实现更多的集合排序;

黄希
1.List接口下都有哪些集合，他们各自有什么特点
        List接口下的集合的特点：有序、有索引、允许储存重复元素。
       
        ArrayList：查询快，增删慢；线程不安全，效率高。
        LinkedList：单向链表，由多个节点通过地址值连接而成，每个节点包含数据域与指针域，每个节点存储下一个节点的地址值。查询慢，增删快；线程不安全，效率高。
        Vector：查询快，增删慢；线程安全，排队使用，效率低。已被ArrayList替代。

2.Set接口下的集合是如何保证无序不可重复的
        以Set接口主要的实现类HashSet为例，通过哈希表保证元素存储的唯一性，不保证存取的顺序。
        哈希表是通过数组+链表实现的，JDK 8以后，数组同一个位置上的元素大等于8个，转换成红黑树来实现。
        存储元素时，先通过hashCode()方法计算元素的哈希值，确定元素在数组中的位置，如果该位置上已存在其他元素，再通过equals()方法与该位置上所有的元素逐个进行是否是相同元素的判断，如果返回true，说明是相同元素，则不存储，如果返回false，则存储。

3.我们为什么要重写HashCode( )和equals（）方法？
        在存储自定义类型的对象的时候，必须要建立自定义的比较规则，才能判断两个对象是否是同一个对象，来保证Set集合中的元素的唯一性。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
        不同元素的哈希值可能相同，所以先通过hashCode()方法获取元素的哈希值，如果哈希值相同，再通过equals()方法判断要存储的元素与集合中的是否重复。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
        Comparable接口是内比较器，实现类需要重写int compareTo(T t)方法，返回值如果是当前的减去传入的，表示升序，如果是传入的减去当前的，表示降序。适用于永远不改变比较规则的情形。
        Comparator接口是外比较器，实现类需要重写int compare(T1 t1, T2 t2)方法，返回值如果是t1的减去t2的，表示升序，如果是t2的减去t1的，表示降序。适用于原先没有比较规则，或已经有比较规则，需要临时修改规则的情形。

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

List接口下常用集合有(1)ArrayList(2)LinkedList(3)Vector
特点：
(1)ArrayList的底层采用的数据结构是数组，数组的特点是具有索引且长度不可改变。因此该集合的特点是：查询快，增删慢。
(2)LinkedList的底层采用的数据结构是链表，单向链表的特点是具有一个数据域和一个指针域。该集合的特点是：查询慢，增删快。
(3)Vector的底层采用的数据结构也是数组，它和ArrayList的不同在于，Vector集合是线程安全的，所以效率低。

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

Set的实现集合类是根据hasdCode()和equals()方法来判断添加的元素是否在集合中存在。
步骤：元素传入后会先判断该哈希值是否存在，如果存在则继续用equals方法判断是否为同一个元素。都相同则认定是同一个元素，则不添加。

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

定义类时如果不重写这两个方法，那么在一些特定环境下要使用到该方法时，hashCode()返回的是对象的地址值，
equals()比较的也是地址值，然而在实际应用中，我们常常会将具有相同属性的对象视为同一个对象，所以需要重写这两个方法从而达到实际开发所期望的效果。

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

先判断hashCode(),因为不同对象的hashCode可能存在相等的情况。

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

Comparable是在定义一个类的时候实现该接口，并覆盖compareTo()方法，指定默认的比较方式。
Comparator是在需要比较的情况下，临时创建一个匿名内部类来制定比较规则，如果需要比较的对象不想根据默认对象所对应类自带的比较规则进行排序，可以使用该比较器。
通过以上的比较，可以知道Comparator接口使用的更多，因为它更加灵活。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：数组结构，查询快，增删慢，线程不安全，效率高
LinkedList集合：链表结构，查询慢，增删快，线程不安全，效率高
Vector集合：数据结构，查询快，增删慢，线程安全，效率低

2.Set接口下的集合是如何保证无序不可重复的
通过调用hashCode方法算出一个哈希值，集合根据这个哈希值寻找存储位置，如果存储位置为空，直接存储；如果存储位置已经有了对象，也就是哈希值相同，这时调用equals方法对其进行比较，如果结果为true，代表两个对象是一样的，不存储，如果为false，代表两个对象不一样，进行存储。

3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写，两个方法比较的都是地址值，而一般情况下对象的地址值是不相同的，这就没有意义了。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），以确定元素存储位置，如果存储位置的哈希值为空的话就直接存储了，不用再判断equals方法了。
如果哈希值相同再判断equals方法确保唯一性

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口是内部比较器，只能用比较对象所属类进行实现，实现方法compareTo（），灵活性较低；
Comparator接口是外部比较器，当需要用到比较时，采用匿名内部类的形式对该接口的compare方法进行重写，灵活性好，或者如果认为当前的比较规则不适用，也可以对已经实现了Comparable的类进行重写。

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

ArrayList:查找快，增删慢,线程不安全，效率高
LinkedList：查找快，增删慢，线程不安全，效率高
Vector：线程安全，效率慢

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

通过hashCode值和equals;
首先通过hashCode值判断，值不一样就存放，值一样再通过equals判断，不同就存放，
相同就舍弃。

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

用Set集合的时候可以确保添加到集合中的元素的唯一的

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

先判断HashCode（）；哈希值如果相同就舍弃，不需要再判断

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

Comparator使用多，在方法内使用匿名内部类设置判断条件比较灵活；
Comparable重写在类中如果想要改变还需修改代码

1.ArrayList集合:结构是数组数据，查询快，增删慢。LinkedList集合:结构是链表数据,查询慢，增删快。Vector集合:结构是数组数据，线程安全但效率低。

2.主要是通过调用HashCode方法和调用equals方法来实现不可重复和无序的。

3.因为没有重写HashCode方法和equals方法当调用方法的时候对比的都是地址值的比较而不是集合元素。

4.先判断HashCode()在判断equals()因为要先计算出哈希值，如果当当前哈希值与之前存储元素的哈希值冲突的时候就要用equals比较两个元素是否相同，相同不存，不同存储。

5.Comparator使用的多因为Comparable是内比较器属于默认比较器当自己定义一个类的时候需要去实现Comparable接口和重写compareto方法，比较死板。而Comparator是外比较器通过匿名对象去调用重写了compare方法来使用比较灵活。

任佳锋
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:线程不安全，效率高。底层是数组结构
LinkedList：线程不安全，效率高。底层是链表结构
vector：近似于ArraiList 线程安全，但是效率低。


2.Set接口下的集合是如何保证无序不可重复的
就说HashSet吧。底层数据结构为哈希表，哈希表由数组＋链表结构组成，当数组中储存的元素超过八个时（jdk1.8以后），则会使用红黑树结构储存元素。而存入元素时，会调用Hashcode方法计算出该元素的哈希值，然后再到哈希表里匹配出储存位置。如果该位置上没有元素，则直接存入。若有，则通过equals方法与该位置上所有元素依次比较，返回true,则说明有重复元素，不存入。返回false则说明没有重复，存入。


3.我们为什么要重写HashCode( )和equals（）方法？
日常中两个事物的相同一般指的是这两事物所有属性相同。而Hash和equals在对元素进行储存与比较时是通过两对象返回的地址值来判断。这就无法保证元素的唯一性还有比较对象时无法确认两对象属性是否相同。因此重写这两方法有利于我们对元素的储存和比较进行判断。


4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,元素的哈希值并不是唯一的，多个不同元素可能拥有同样的哈希值，但是相同元素的哈希值一定是一样的。先判断哈希值可以提高我们的储存效率，若哈希表里没有该哈希值则直接存入，有的话再在与该哈希值所在位置上的所有元素通过equals方法比较。
简而言之就是提高效率


5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable内部比较器，实现了Comparable接口相当于在类中重写Comparaeto方法，定下了默认的比较规则，固定且不灵活，适用于永远不改的规则。
Comparator外部比较器。平日里我们比较对象的类若没有默认规则或者默认规则无法修改或不适用于当前场景，则可以通过匿名内部类创建该接口对象重写Comparae方法自定义新的比较规则，灵活多变。