1：用HashSet集合来储存


2：如果哈希值相同，调用equals方法比较元素的内容，如果内容相同不储存，否则内容不同存储


3：


4：区别：1.Comparable和Comparator重写的方法不一样
         2.前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护，建议拆分
            

        两者相比后者用的比较多：   因为： Comparable:由实体类去实现接口，重写compareTo方法，定义比较规则
   
            Comparator:在创建TreeSet集合的时候，作为实现类传递


5:    将集合存储元素，对元素进行类型强转，异常提前到了编译期


      好处：避免了强转的麻烦

1.Set接口下的集合是如何保证无序不可重复的
答： Set集合底层是数组+链表/红黑树的结构，存入元素时会先判断哈希值，
对应数组内哈希值的位置，然后判断内容，内容不一致就以链表形式连接在一起，一致则不存入，
因此它是无序且不可重复的。

2.我们为什么要重写HashCode( )和equals（）方法？
答：因为默认的HashCode（）和equals（）方法比较的是地址值，不能满足具体的使用。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode(),因为通过此方法将集合中的数据先进行分类，分配到链表的不同位置，在通过equals（）
判断同一个位置上的数据，大大提高了代码的运行效率。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator接口使用的比较多，因为使用使用Comparable接口需要在类中实现此接口，并重写
CompareTo方法，加强了类的耦合性，不利于程序的独立性。

5.什么是泛型？使用泛型有什么好处？
答：泛型可以认定为泛指一个类型的格式，可以看做形参。
      使用泛型可以将运行期的问题提前到编译期显示出来，也可以在使用到多种类型参数时
      避免多次定义和强制转换麻烦。

1.Set接口下的集合是如何保证无序不可重复的
        保证不可重复：Set底层是哈希表，每储蓄一个新元素都会和集合内的其他元素比较哈希值，如果不同，元素存入，如果哈希值相同，则再用equals方法比较内容是否一致，内容不同，新元素才可以被存入。
        保证无序：Set接口下集合元素储存位置是通过各元素的哈希值计算得到的，不同对象的哈希值不同，所以元素顺序是无序的。

2.我们为什么要重写HashCode( )和equals（）方法？
        如果不重写这两个方法，那么该类生成的两个对象（地址值不一样），即使内容一模一样，系统也会认为两个对象是不同的，那么HashSet集合会允许加入2个重复的对象，所以，重写这两个方法保证了集合对象的唯一性。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
        先判断HashCode（）。不同对象的哈希值是不同的，如果哈希值相同，那么这两个对象地址值一样，内容肯定也一样，那么也就不用继续进行equals（）判断，达到节省系统运行资源的作用。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
        Comparable接口是被对象的类直接继承，在定义类里改写compareTo方法；Comparator接口是在Set集合创建时实例化并通过参数传入，实例化时改写了compare方法。
        Comparator接口使用得多。因为该接口的方法重写在集合的构造方法中，维护修改代码方便；而Comparable接口是在对象的类中实现的，后期如果需要修改代码不方便。

5.什么是泛型？使用泛型有什么好处？
        泛型是提供编译时类型安全检测机制，如果类传入非定义的泛型，编译会报错。
        好处：把运行时期的问题提前到了编译期间；避免了强制类型转换

1.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合底层数据结构是用的是哈希表来实现的，当存储数据时，会走以下步骤：
1.先计算对应的对象哈希值，根据对象的哈希值计算存储位置
        如果当前位置没有元素则直接存入
        如果当前位置有元素存在，则进入第二步
2.当前的元素和已经存在的元素比较哈希值
        如果哈希值不同，则将当前元素进行存储
        如果哈希值相同，则进入第三步
3.通过equals()方法比较两个元素的内容
        如果内容不相同，则将当前元素进行存储
        如果内容相同，则不存储当前元素。
       
2.我们为什么要重写HashCode( )和equals（）方法？
答：Object类中的HashCode()方法获取的对象的地址值，equals()方法比较的是地址的值，
如果我们不进行重写HashCode()和equals()方法，那么就不能保证元素的唯一性；

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()因为返回的哈希值如果不同，那么元素一定不会相同，
        哈希值相同了才会去调用equals()去判断元素，保证了元素的唯一性。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：1.Comparable和Comparator重写的方法不一样
        2.前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护，建议拆分。
        Comparator接口使用多，因为Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响，
        有利于后期维护。
       
       
5.什么是泛型？使用泛型有什么好处？
答：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
                它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方
                法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具
                体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称
                为泛型类、泛型方法、泛型接口
泛型定义格式
        修饰符 class 类名<类型> { }
泛型的好处
        把运行时期的问题提前到了编译期间
        避免了强制类型转换

今天我们继续了集合的学习，请根据自己的理解回答下面问题：

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

（1），首先计算存入元素的哈希值，根据哈希值算出存储 位置，如果该位置有元素，再比较哈希值，如果该位置没有元素，直接存储
（2），如果哈希值相同，调用equals方法比较元素内容，如果内容相同不存储，

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

保证元素的唯一性。

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

先判断HashCode(),要通过HashCode（）获取对象的哈希值，判断该位置是否存在元素，若有相同哈希值的元素再调用equals（）来比较对象内容是否相等。

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

Comparator接口使用得比较多，前者将比较规则和定义类绑定在了一起，耦合度高，不利于后期的维护，建议拆分。

5.什么是泛型？使用泛型有什么好处？

泛型是将集合存储元素，对元素进行类型强转，异常提前到了编译期，避免了强转的麻烦。

1.Set接口下的集合是如何保证无序不可重复的
Set集合是用哈希表存储元素的所以是无序的;
Set在添加元素的时候 会先获取元素的哈希值,通过哈希值计算存储位置,再判断该位置是否有元素,没有元素直接添加;如果有元素,遍历比较所有元素分别比较哈希值和内容,只有哈希值不同或者内容不同时才会添加元素,所以元素是不重复的;

2.我们为什么要重写HashCode( )和equals（）方法？
HashCode()和equals()默认继承至Object;Object的计算和比较方式通常都不能满足我们的需求,所以需要重写;

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),因为两个元素的HashCode()不同时其内容一定不相同;可以直接存入Set中

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable定义在类的内部;Comparator 定义在类的外部;
Comparator使用的比较多,使用Comparator定义的比较方式不会影响类本身的属性,可以降低耦合性

5.什么是泛型？使用泛型有什么好处？
泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
泛型的好处:
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换

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

答：Set接口下的HashSet集合底层数据结构是哈希表，哈希表的底层是数组和链表/红黑树，
      当一个元素存储的时候，通过其哈希值计算存储的位置（无序），先判断此位置是否有元素，若无则存储；
      若有，则判断哈希值是否相同，如果哈希值不同则存储；
      若哈希值相同，则判断其内容是否相同，如果内容不同则存储；
      如果内容相同则不存储。
      由此来确保元素不可重复。

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

答：重写HashCode( )可以使不同的对象返回的哈希值相同，重写equals（）方法可以使其比较内容而不是地址，
       这样我们就可以比较不同对象的内容是否相同了。

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

答：先判断HashCode()，可以节省程序效率，提高效率。
       先比较哈希值，如果哈希值不同就可以直接存储，哈希值相同再去比较内容。

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

答：Comparable是自然排序，通过实现类来实现，并重写comparaTo()方法。
      Comparator是比较器排序，直接通过带参构造方法创建对象的时候使用匿名内部类实现，可以降低类和接口的耦合性，所以使用比较多。

5.什么是泛型？使用泛型有什么好处？

答：泛型是一种参数化类型，就是不指定具体数据类型，将来在使用/调用时传入具体类型即可。
       可以将运行时异常提前到编译时显现，还可以避免强转的麻烦。

1.Set接口下的集合是如何保证无序不可重复的
（1）首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，再比较哈希值，如果该位置没有元素，直接存储
（2）如果哈希值相同，调用equals方法比较元素的内容，如果内容相同不存储，否则内容不同存储

2.我们为什么要重写HashCode( )和equals（）方法？
重写hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
因为数据在存入Set集合的时候，是通过HashCode()找到数组中的元素，通过equals方法决定是否存储。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
使用Comparator使用的多些。
Comparable:强行对实现它的每个类的对象进行整体排序。这种排序称为自然排序，类中有一个compareTo方法称为自然方法，只能在类中实现compareTo（）方法一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表和数组可以通过Collections.sort和Arrays.sort进行自动排序，对象可以用作有序映射中的键值或有序集合中的元素，无需指定比较器。
Commparator：强行对谋改革对象进行整体排序，可以将Compararor传递给sort方法如Collections.sort或者Arrays.sort,从而允许在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构比如set或者有序映射的顺序，或者为那些没有自然排序的对象Collection提供排序。

5.什么是泛型？使用泛型有什么好处？
可以在类或方法中预支的使用未知的类型。
好处：把运行时期的ClassCastException问题提前到了编译期间、避免了强制类型转换

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

底层数据结构是哈希表
对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致

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

保证集合不重复。

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

先判断HashCode()。重写HashCode()方法就是为了避免数据过多，一个个比内容浪费性能，数据大部分的Hash值都不同，先做比较哈希值，不同添加，相同再比较内容，提高程序的效率。


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

Comparable是TreeSet无参构造的自然排序，重写方法在自定义类里面

Comparator是TreeSet有参构造的参数，实际是一个比较器，可以用匿名内部类的方法直接创建TreeSet对象的时候重写方法。

Comparator用的多，直接用匿名内部类重写方法，避免了在自定义内重写方法，测试类只用了一次，造成资源浪费。

5.什么是泛型？使用泛型有什么好处？

泛型的本质是参数化类型
好处：- 把运行时期的问题提前到了编译期间

      - 避免了强制类型转换

1.Set接口下的集合是如何保证无序不可重复的
首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，
再比较哈希值，如果该位置没有元素，直接存储，如果哈希值相同，调用equals方
法比较元素的内容，如果内容相同不存储，否则内容不存储
2.我们为什么要重写HashCode( )和equals（）方法？
为了保证集合的数据是无序且不可重复的。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode()，后判断equals()；通过先判断hashCode()将元素分到不同的链表上，
可以减少以后加入的元素调用equals()方法的次数，提高程序执行效率。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口由需要进行比较的实体类实现，重写的compareTo方法只要一个实体类类型的参数；
Comparator接口需要再写一个比较器实现类，与实体类分离，重写的compare方法需要两个实体类类型的参数。
Comparator使用的多，类的功能应该是单一的，在一个实体类里实现Comparable接口，将比较规则与实体类绑定在一起，会提高代码的耦合度，不利于后期维护
5.什么是泛型？使用泛型有什么好处？
泛型是在定义类、方法、接口时使用参数化的类型代替具体类型。
把运行时期的问题提前到编译时期，避免强制类型转换。

今天我们继续了集合的学习，请根据自己的理解回答下面问题：

1.Set接口下的集合是如何保证无序不可重复的
首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，再
比较哈希值，如果该位置没有元素，直接存储。如果哈希值相同，调用equals方法
比较元素内容，如果内容相同不存储，否则内容不同存储。
2.我们为什么要重写HashCode( )和equals（）方法？
重写hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
重写方法不一样。后者用的比较多，前者将比较规则和定义实体类绑定在一起，耦合度高，不利于后期维护
建议拆分。
5.什么是泛型？使用泛型有什么好处？
泛型是jdk5中引入的特性，他提供了编译时类型安全监测机制，该机制允许在编译时检查到非法类型。

好处是将集合存储元素，对元素进行类型强转，异常提前到了编译期，避免了强转的麻烦。

1.Set接口下的集合是如何保证无序不可重复的
在添加元素时重写了HashCode( )和equals（）
2.我们为什么要重写HashCode( )和equals（）方法？
不重写无法进行比较
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()调用的时候默认先调用这个方法,这样可以节省性能.
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable在实体类去实现接口，Comparator在创建TreeSet集合的时候;Comparator用的比较多,Comparable在实体类耦合性太高了,容易出错.
5.什么是泛型？使用泛型有什么好处？
将集合存储元素，对元素进行类型强转，好处是异常提前到了编译期

1.Set接口下的集合是如何保证无序不可重复的
答:   因为被HashSet实现所以能保证元素五序 ,  底层数据是哈希表所以元素不能重复


2.我们为什么要重写HashCode( )和equals（）方法？
答:  如果要保证集合内元素的唯一性就要重写HashCode( )和equals()方法


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答:  1.  先判断HashCode()然后再判断equals() ;  
      2.  因为数据存入得时候会先判断哈希码值是否相同 ,  如果相同再判断内容是否相同
     
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答: 1.  Comparable   是用无参构造方法使用的是自然排序对元素进行排序的 ,  在实体类写接口 重写compareTo方法
     2.  Comparator   是用有参构造方法使用的是自然排序对元素进行排序的 ,   创建集合的时候 , 作为实现类传递
     3.  Comparator用的比较多 ,   因为Comparable将比较规则和定义实体类绑定在了一起 ,  耦合度高 , 对后期维护不利



5.什么是泛型？使用泛型有什么好处？
答:  1.  泛型是JDK5中引入的特性,  提供了编译时类型安全检测机制 ,  该机制允许在编译时检测到非法的类型
      2.  好处:  把运行时的问题提前到编译期间 .   避免强制转换
       

1.Set接口下的集合是如何保证无序不可重复的
重写hashcode方法和equal方法

2.我们为什么要重写HashCode( )和equals（）方法？
当我们需要判断hash值是否一样,当hash值一样时我们需要判断内容是否与相同

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
Hashcode()方法, 因为set底层是源代码就是先判断hashcode()是否相同,如果不相同就直接存储元素,当相同时在比较内容值是否相同

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable需要实现类实现comparable()并重写comparto方法
Comparator可以直接使用匿名内部类创建实现类对象并重写方法
Comparator会比较简便,当实现类只要实现一次的时候我们就使用匿名内部类的方式来创建实现类对象

5.什么是泛型？使用泛型有什么好处？
存在<>里面的是泛型;
泛型的好处是,当我们定义泛型的类型后,如果在创建的类型不是泛型的类型时在编译其程序就会报错编译异常,强制我们修改异常

1.Set接口下的集合是如何保证无序不可重复的
首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，
再比较哈希值，如果该位置没有元素，直接存储，如果哈希值相同，调用equals方
法比较元素的内容，如果内容相同不存储，否则内容不存储
2.我们为什么要重写HashCode( )和equals（）方法？
为了保证集合的数据是无序且不可重复的。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode()，后判断equals()；通过先判断hashCode()将元素分到不同的链表上，
可以减少以后加入的元素调用equals()方法的次数，提高程序执行效率。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口由需要进行比较的实体类实现，重写的compareTo方法只要一个实体类类型的参数；
Comparator接口需要再写一个比较器实现类，与实体类分离，重写的compare方法需要两个实体类类型的参数。
Comparator使用的多，类的功能应该是单一的，在一个实体类里实现Comparable接口，将比较规则与实体类绑定在一起，会提高代码的耦合度，不利于后期维护
5.什么是泛型？使用泛型有什么好处？
泛型是在定义类、方法、接口时使用参数化的类型代替具体类型。
把运行时期的问题提前到编译时期，避免强制类型转换。

1.Set接口下的集合是如何保证无序不可重复的
答：
重写hashcode和equals方法


2.我们为什么要重写HashCode( )和equals（）方法？
答：
为了保证集合内的数据不重复，重写hashcode是为了比较两个对象的哈希值，重写equals方法是为了当两个对象哈希值相同时再比较元素内容是否相同


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：
是先判断hashcode，因为如果先判断equals的话当数据庞大时它需要于每一个元素做对比，这样浪费了系统性能，但是如果先判断hashcode方法因为每个数据都有相应的哈希值对比是否有重复比较简单快捷


4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：
Comparable：由实现类去实现接口并重写compareTo方法
Comparator：在创建TreeSet集合的时候，作为实现类传递
区别：
1.Comparable和Comparator重写的方法不一样
2.Comparable和定义类绑定在一起耦合度高，不利于后期维护，建议拆分

5.什么是泛型？使用泛型有什么好处？
答：
定义类，方法，接口的时候，指定的未知的数据类型，它的本质就是参数化类型。

1.Set接口下的集合是如何保证无序不可重复的
   Set集合是用哈希表存储元素的所以是无序的;
（1）首先先计算存入元素的哈希值，根据哈希值算出存储位置，
如果该位置有元素，再比较哈希值，如果该位置没有元素，直接存储
（2）如果哈希值相同，调用equals方法比较元素的内容，
如果内容相同不存储，否则内容不同存储


2.我们为什么要重写HashCode( )和equals（）方法？
HashCode()和equals()默认继承至Object;
Object的计算和比较方式通常都不能满足我们的需求,所以需要重写;

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

数据在存入Set集合的时候，先判断HashCode()
因为哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值，
若哈希值不同则对象一定不相同，与equals（）方法相比效率高，在哈希值相同

的情况下才判断equals（），判断对象内容是否相同


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

Comparable：实体类实现此接口，重写compare To（T o）方法,定义比较规则
Comparator：测试类中采用匿名内部类方式创建，重写compare（T o1，T o2）方法，定义比较规则
Comparator接口使用的较多，因为Comparable比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护

5.什么是泛型？使用泛型有什么好处？
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
（1）.将集合存储元素，对元素进行类型强转，异常提前到了编译期
（2）.避免了强转的麻烦

1.Set接口下的集合是如何保证无序不可重复的
首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，
再比较哈希值，如果该位置没有元素，直接存储，如果哈希值相同，调用equals方
法比较元素的内容，如果内容相同不存储，否则内容不存储
2.我们为什么要重写HashCode( )和equals（）方法？
为了保证集合的数据是无序且不可重复的。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode()，后判断equals()；通过先判断hashCode()将元素分到不同的链表上，
可以减少以后加入的元素调用equals()方法的次数，提高程序执行效率。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口由需要进行比较的实体类实现，重写的compareTo方法只要一个实体类类型的参数；
Comparator接口需要再写一个比较器实现类，与实体类分离，重写的compare方法需要两个实体类类型的参数。
Comparator使用的多，类的功能应该是单一的，在一个实体类里实现Comparable接口，将比较规则与实体类绑定在一起，会提高代码的耦合度，不利于后期维护
5.什么是泛型？使用泛型有什么好处？
泛型是在定义类、方法、接口时使用参数化的类型代替具体类型。
把运行时期的问题提前到编译时期，避免强制类型转换。

1.Set接口下的集合是如何保证无序不可重复的
（1）首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，再比较哈希值，如果该位置没有元素，直接存储
（2）如果哈希值相同，调用equals方法比较元素的内容，如果内容相同不存储，否则内容不同存储

2.我们为什么要重写HashCode( )和equals（）方法？
重写hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一.
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),因为两个元素的HashCode()不同时其内容一定不相同;可以直接存入Set中
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable定义在类的内部;Comparator 定义在类的外部;
Comparator使用的比较多,使用Comparator定义的比较方式不会影响类本身的属性,可以降低耦合性
5.什么是泛型？使用泛型有什么好处？
泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
泛型的好处:
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换

1.Set接口下的集合是如何保证无序不可重复的
1).根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步
2).当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步
3).通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素

2.我们为什么要重写HashCode( )和equals（）方法？
重写hashCode()方法，可以实现让不同对象的哈希值相同
获取哈希值的代码
重写equals()方法确保元素唯一

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),因为数据在存入Set集合的时候，是通过HashCode()找到数组中的元素，通过equals方法决定是否存储。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口由需要进行比较的实体类实现，重写的compareTo方法只要一个实体类类型的参数；
Comparator接口需要再写一个比较器实现类，与实体类分离，重写的compare方法需要两个实体类类型的参数。
Comparator使用的多，类的功能应该是单一的，在一个实体类里实现Comparable接口，将比较规则与实体类绑定在一起，会提高代码的耦合度，不利于后期维护。

5.什么是泛型？使用泛型有什么好处？
泛型：编译时类型检测机制，本质参数化类型。
好处：①把运行期间问题提到了编译期（解决隐藏类型转换异常的问题）②避免了强制类型转换，可以使用子类特有方法。