今天我们继续了集合的学习，请根据自己的理解回答下面问题：
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接口下的集合是如何保证无序不可重复的
（1）首先计算存入元素的哈希值，根据哈希值算出存储位置，如果
该位置有元素。再比较哈希值。如果该位置没有元素，直接存储
（2）如果哈希值相同，调用equals方法比较元素的内容，如果内容
相同不存储，否则内容不同时存储该元素

2.我们为什么要重写HashCode( )和equals（）方法？
如过不用重写这HashCode()和equals()方法的话，就没有办法保证元素
的唯一不重复性

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
存入时应该先判断HashCode()，因为先存入元素的哈希值，根据位置比较是否
该存入此位置，然后元素的位置和哈希值都相同时再判断equals()内容是否相同，
若不相同时就不会存入此元素

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable（自然类）由实体类去实现接口，重写compareTo方法，定义比较规则
Comparator（比较器）在创建TreeSet集合的时候，作为实现类传递（匿名内部类）
（1）Comparable和Comparator重写的方法不一样
（2）前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期
维护，建议拆分，所以Comparator接口使用的多

5.什么是泛型？使用泛型有什么好处？
泛型是将集合存储元素，对元素进行类型强转，异常提前到了编译期
避免了强转的麻烦

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

1.Set接口下的集合是如何保证无序不可重复的
- 底层数据结构是哈希表

- 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
-
没有带索引的方法，所以不能使用普通for循环遍历

- 由于是Set集合，所以是不包含重复元素的集合

2.我们为什么要重写HashCode( )和equals（）方法？
保证元素的唯一性
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode
进行优化，提高程序的效率
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
重写方法不一样，
后者用的多
2.前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护，建议拆分
5.什么是泛型？使用泛型有什么好处？
1.将集合存储元素，对元素进行类型强转，异常提前到了编译期
2.避免了强转的麻烦

1.Set接口下的集合是如何保证无序不可重复的
底层数据结构有两个：哈希表和链表
由链表保证元素的有序，元素的存储和取出顺序是一致的
由哈希表保证元素的唯一，也就是说没有重复的元素

2.我们为什么要重写HashCode( )和equals（）方法？
通过方法重写HashCode( )，可以实现不同对象的哈希值是相同的
通过方法重写equals（），可以比较对象中的数据是否一致，而不是比较对象地址值

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
根据API源码，先判断哈希值，如果不同直接存入
如果相同，则进行数据对比，相同不存入，不同则存入元素

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
直接创建TreeSet()集合，在元素的类中实现了Comparable接口，定义排序规则
使用有参构造创建TreeSet(Compartor com)集合，需要传入Compartor实现类对象，在实现类中定义排序规则
第二种方式更好一些，第一种方式将自定义类和排序规则分开，更有利于后期的排序规则维护。

5.什么是泛型？使用泛型有什么好处？
将类型由原来具体的类型参数化，然后在使用/调用时传入具体的类型
好处：
将运行时期的异常提前到了代码编译时期
避免了强转的麻烦，而且可以使用元素持有的方法

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

1.Set接口下的集合是如何保证无序不可重复的
- 底层数据结构是哈希表

- 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
-
没有带索引的方法，所以不能使用普通for循环遍历

- 由于是Set集合，所以是不包含重复元素的集合

2.我们为什么要重写HashCode( )和equals（）方法？
保证元素的唯一性
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode
进行优化，提高程序的效率
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
重写方法不一样，
后者用的多
2.前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护，建议拆分
5.什么是泛型？使用泛型有什么好处？
1.将集合存储元素，对元素进行类型强转，异常提前到了编译期
2.避免了强转的麻烦

1.Set接口下的集合是如何保证无序不可重复的
底层数据结构有两个：哈希表和链表
由链表保证元素的有序，元素的存储和取出顺序是一致的
由哈希表保证元素的唯一，也就是说没有重复的元素

2.我们为什么要重写HashCode( )和equals（）方法？
通过方法重写HashCode( )，可以实现不同对象的哈希值是相同的
通过方法重写equals（），可以比较对象中的数据是否一致，而不是比较对象地址值

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
根据API源码，先判断哈希值，如果不同直接存入
如果相同，则进行数据对比，相同不存入，不同则存入元素

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
直接创建TreeSet()集合，在元素的类中实现了Comparable接口，定义排序规则
使用有参构造创建TreeSet(Compartor com)集合，需要传入Compartor实现类对象，在实现类中定义排序规则
第二种方式更好一些，第一种方式将自定义类和排序规则分开，更有利于后期的排序规则维护。

5.什么是泛型？使用泛型有什么好处？
将类型由原来具体的类型参数化，然后在使用/调用时传入具体的类型
好处：
将运行时期的异常提前到了代码编译时期
避免了强转的麻烦，而且可以使用元素持有的方法

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

set集合没有索引,因此无序

1.add()方法源码会首先先计算存入元素的哈希值，根据哈希值算出存储位置，如果该位置有元素，再比较哈希值，如果该位置没有元素，直接存储

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

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

普通实体类默认使用object类的HashCode( )和equals（）方法,需要使用实体类独有的方法,因此重写.

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

先判断HashCode(),如果对象属性较多情况下判断equals()效率较低,先判断HashCode()效率较高.

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

前者由实体类去实现接口，重写compareTo方法，定义比较规则

后者在创建TreeSet集合的时候，作为实现类传递（匿名内部类）

前者将比较规则和定义实体类绑定在了一起，耦合度高，不利于后期维护，建议拆分

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

- 将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
- 泛型定义格式
  - <类型>：指定一种类型的格式。这里的类型可以看成是形参
  - <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
  - 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

好处:

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

2.避免了强转的麻烦

潘绍平：
1.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接口下的集合是如何保证无序不可重复的
（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接口下的集合是如何保证无序不可重复的

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

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

保证元素的唯一性。

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

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

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

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

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

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

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接口下的集合是如何保证无序不可重复的
通过hashcode（）和equals（）方法保证元素的不可重复。
2.我们为什么要重写HashCode( )和equals（）方法？
HashCode( )和equals（）在默认的情况下表示的是Object的方法，HashCode( )得到的是对象地址的哈希值，equals（）默认比较的是地址值相同，所以我们要重写HashCode( )和equals（）让HashCode( )得到对象成员的哈希值，equals（）比较内容相同。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先比较HashCode()再判断equals（）由源码可知hashcode（）和equals（）是由&&连接的，
这样的好处是加大存储效率。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口要在实体类中实现并且重写compareTo（）方法，增加了实体类和排序方法的耦合性，不利于后续的维护。
Comparator接口可以用TreeSet的带参构造进行创建匿名对象在方法实现类只用一次的情况下大大的节省了性能，并且不会和实体类产生耦合性。
所以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接口下的集合是如何保证无序不可重复的

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

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

保证元素的唯一性。

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

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

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

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

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

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

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

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

Set集合是用哈希表存储数据的，所以是无序的；

Set集合是根据对象的哈希值计算存储位置

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

：   

当前元素的元素和已经存在的元素比较哈希值，如果哈希值不同，则将当前元素进行存储

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

：
  
通过equals()方法比较两个元素的内容，如果内容不相同，则将当前元素进行存储，如果内容相同，则不存储当前元素
。


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

因为HashSet的底层数据是哈希表，它是依赖于HashCode( )和equals（）来保证元素不重复的，所以要重写。


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

先判断HashCode()再先判断equals（）；因为HashCode()不同，元素就不同。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是定义在类内部，Comparator是定义在类外部；

Comparator使用的比较多，因为他是定义在类的外部，不影响类的属性，降低类的耦合度。


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

        是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数；
好处：

把运行时期的问题提前到了编译期间
，避免了强制类型转换
。

郑峰

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

2.我们为什么要重写HashCode( )和equals（）方法？
答：默认情况下，调用Object类中的hashCode()和equals()方法对对象的一致性进行比较，hashCode()返回对象地址相关的哈希码值，equals()方法比较对象地

址值，因此需要重写才能比较两对象的异同

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接口下的集合是如何保证无序不可重复的
答：Set接口下的HashSet实现类底层是哈希表结构，元素存储无序。
    HashSet通过重写hashCode()方法和equals()方法，保证存储元素的时候，对元素的哈希值和内容进行双重比较，当两者都相同时，可以确认两个元素是重复的，不存储，保证元素的唯一性。


2.我们为什么要重写HashCode( )和equals（）方法？
答：因为hashSet集合要保证存储元素的唯一性，必须重写hashCode()方法和equals()方法。


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：首先进行的是HashCode()的判断，因为不同的元素其哈希值是可能相同的，哈希值相同并不代表两个元素完全相同。
    所以接下来进行内容的比较，也就是equals()判断，如果内容也相同，那么可以确认两个元素是重复的，不存储；如果内容不同，那么可以确认两个元素不是重复的，可以存储。


4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable和Comparator重写的方法不一样
    前者将比较规则和定义实体类绑定在一起，耦合度高。
    两者量比较，后者更好，用的更多，因为它将自定义类和排序规则分开，更有利于后期的排序规则维护。


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

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

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

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

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

保证元素的唯一性。

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

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

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

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

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

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