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

1.Set接口下的集合是如何保证无序不可重复的
因为Set接口下的集合的底层是哈希表。
而哈希表会根据对象的哈希值计算元素的存储位置，如果当前位置没有元素，就进行存储，
如果当前位置存在元素，就和已存在的元素比较哈希值，如果哈希值不相等，就将新元素
进行存储，如果哈希值相等，就与当前位置已存储元素比较内容，如果内容不相等，就进
行存储，如果内容相同，就不存储。

2.我们为什么要重写HashCode( )和equals（）方法？
为了调用HashCode()方法获取对象的哈希值。
equals（）方法：为了比较对象的内容是否相同。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为如果先判断equals（）需要每次都进行比较，比较浪费资源。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：1.Comparable和Comparator重写的方法不一样
2.前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护，建议拆分
Comparator接口使用的多，该接口耦合度较低。

5.什么是泛型？使用泛型有什么好处？
定义类、方法、接口的时候指定的未知的数据类型。
好处：1.将运行期的异常提前到编译期。
2.对元素进行强转，避免了强转的麻烦。

1.Set接口下的集合是如何保证无序不可重复的
通过hashCode()方法获取哈希值，使用哈希值算出存储位置，该位置有元素再比较哈希值，哈希值相同的元素再通过equals()方法判断是否相同，不同则存入，相同不存。

2.我们为什么要重写HashCode( )和equals（）方法？
不重写hashCode( )和equals（）方法将会调用Object类的方法，Object的方法与地址值有关，与具体元素内容无关，不能保证存储的元素不重复。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode()，后判断equals()；通过先判断hashCode()将元素分到不同的链表上，可以减少以后加入的元素调用equals()方法的次数，提高程序执行效率。

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

5.什么是泛型？使用泛型有什么好处？
泛型是在定义类、方法、接口时使用参数化的类型代替具体类型。
（1）把运行时期的问题提前到编译时期
（2）避免强制类型转换

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

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

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

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

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接口下的集合是如何保证无序不可重复的
   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接口下的集合是如何保证无序不可重复的
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.什么是泛型？使用泛型有什么好处？
泛型：编译时类型检测机制，本质参数化类型。
好处：①把运行期间问题提到了编译期（解决隐藏类型转换异常的问题）②避免了强制类型转换，可以使用子类特有方法。

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

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

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

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

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

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

2.我们为什么要重写HashCode( )和equals（）方法？
答：不重写hashCode( )和equals（）方法将会调用Object类的方法，Object的方法与地址值有关，与具体元素内容无关，不能保证存储的元素不重复。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断Hashcode（） 如果先判断equals（），则还要用HashCode方法去找存储位置，而先用HashCode如果先判断到存储位置为空，
则不用接着判断equals（），可以直接存入。

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

答：Comparable接口要在实体类中实现并且重写compareTo（）方法，增加了实体类和排序方法的耦合性，不利于后续的维护。
Comparator接口可以用TreeSet的带参构造进行创建匿名对象在方法实现类只用一次的情况下大大的节省了性能，并且不会和实体类产生耦合性。
所以Comparator接口使用得比较多
5.什么是泛型？使用泛型有什么好处？
答：可以在类或方法中预支的使用未知的类型。
好处：把运行时期的ClassCastException问题提前到了编译期间、避免了强制类型转换

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）.避免了强转的麻烦

.Set接口下的集合是如何保证无序不可重复的
HashSet集合的特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是Set集合，所以是不包含重复元素的集合

2.我们为什么要重写HashCode( )和equals（）方法？
答：因为我们要比较的是具体的内容，而不是地址值。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答:先判断HashCode()

        1.根据对象的哈希值计算存储位置

            如果当前位置没有元素则直接存入

            如果当前位置有元素存在，则进入第二步

    2.当前元素的元素和已经存在的元素比较哈希值

            如果哈希值不同，则将当前元素进行存储

            如果哈希值相同，则进入第三步

    3.通过equals()方法比较两个元素的内容

            如果内容不相同，则将当前元素进行存储

            如果内容相同，则不存储当前元素

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：
无参构造使用：Comparable
有参构造使用：Comparator
Comparator使用的多，因为Comparable和类的耦合性太高，不便于后期代码维护。
Comparator自定义类和排序规则分开，更有利于后期的排序规则维护。
5.什么是泛型？使用泛型有什么好处？
答：它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。
好处：        - 把运行时期的问题提前到了编译期间
                - 避免了强制类型转换

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

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

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

1.Set接口下的集合是如何保证无序不可重复的
先用哈希值算元素的存储位置，如果位置为空则存入这个位置，如果位置不为空，则与存在的元素比较哈希值，
如果不同则存入，相同则通过equals方法比较两个元素的内容，如果不同则存入，相同不存入。

2.我们为什么要重写HashCode( )和equals（）方法？
当我们使用Set集合的时候，所创建的对象内没有HashCode( )和equals（）方法，则会把重复的元素存入集合中，所以要重写HashCode( )和equals（）方法，保证数据唯一。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断Hashcode（） 如果先判断equals（），则还要用HashCode方法去找存储位置，而先用HashCode如果先判断到存储位置为空，
则不用接着判断equals（），可以直接存入。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable由实体类去实现接口，重写compareto方法，Comparator在创建TreeSet集合的时候作为实现类传递（匿名内部类），重写的方法不一样。
Comparator接口使用的多，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接口下的集合是如何保证无序不可重复的
在添加元素时重写了HashCode( )和equals（）
2.我们为什么要重写HashCode( )和equals（）方法？
不重写无法进行比较
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()调用的时候默认先调用这个方法,这样可以节省性能.
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable在实体类去实现接口，Comparator在创建TreeSet集合的时候;Comparator用的比较多,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接口下的集合是如何保证无序不可重复的
答：
哈希表保证的。

2.我们为什么要重写HashCode( )和equals（）方法？
答：
要保证Set集合的元素不可重复

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：
先判断HashCode()。因为先判断equals（）的话，它会判断每一个数据的值，会减慢程序运行的效率，引入HashCode()可以先比较哈希值，如果哈希值相同则不需要比较每一个数据的值，大大提升了程序运行的效率。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：
Comparable接口需要类先继承它，然后重写Comparetor方法
Comparator接口根据匿名内部类的形式创建，
Comparator接口使用的多，因为Comparable的耦合性太强

5.什么是泛型？使用泛型有什么好处？
答：
定义类、方法、接口的时候，指定的未知的数据类型
好处：
1、将运行时期的异常提前到了代码编译时期
2、避免了强转的麻烦，而且可以使用元素特有的方法

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接口下的集合是如何保证无序不可重复的
首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，
再比较哈希值，如果该位置没有元素，直接存储，如果哈希值相同，调用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接口下的集合是如何保证无序不可重复的
首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，
再比较哈希值，如果该位置没有元素，直接存储，如果哈希值相同，调用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方法和equal方法

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

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

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

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