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

1.Set接口下的集合是如何保证无序不可重复的
Set接口的集合实现类对象比如说HashSet和TreeSet，依靠哈希值作为对象属性值的唯一判断，继承Object重写了父类的hashcode()方法，
可以根据对象的哈希值计算存储位置
1根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步
当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步
通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素，舍弃当前元素



2.我们为什么要重写HashCode( )和equals（）方法？
默认情况下是按照父类的hashcode以及equals，前者是返回一个对象在内存中的地址值，后者是比较两个对象的地址值
根据实际意义上必须继承父类的这两个方法并且重写，可以作为对象的属性值的判断，而且比较哈希值以后，通过重写equals方法，也可以比较属性值的内容，层层把关。


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，哈希表的底层是数组和链表结构。先通过调用HashCode方法来计算对象的哈希值，然后计算存储位置，位置是空的就直接存储进去，之后再做其他判断。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable接口是实现它的抽象方法compareTo方法，并且重写这个方法；
Comparator接口是实现它的compare方法，第二种方法使用比较多，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法。

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

泛型就是1.5版本引入的特性，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换，

1.Set接口下的集合是如何保证无序不可重复的
（1）在Set中，元素的存储是通过元素的哈希值来计算出的索引值来存储的，在存入对应的哈希槽时，可能会与存入时的顺序不同。
（2）如何保证元素的不可重复：
     【1】看此哈希槽中是否有元素，如没有则直接存储元素，有则进行下一步
     【2】判断元素的哈希值是否相等，不相等则直接存储元素，相等则进行下一步
     【3】判断元素的内容是否相等，不相等则直接存储元素，相等则不存储元素

2.我们为什么要重写HashCode( )和equals（）方法？
如果想保证存入到Set集合中的元素不重复，那么该类就必须重写HasCode()和equals()

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）先判断HashCode()，因为哈希值代表了元素的地址值，所以哈希值不同时，元素一定不相同，而哈希值相同时，元素不一定相同
（2）而equals（）是直接判断元素的内容是否相同，应该放在最后判断

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparable接口
自然排序，在类中实现接口，并重写compareTo方法，从而实现接口功能，并在main中通过TreeSet对象调用
（2）Comparator接口
自定义比较器，直接在创建TreeSet对象时，通过构造方法参数传入该接口的实现类对象，并重写compare方法实现功能
（3）Comparator接口比Comparable接口使用的多
因为比起Comparable接口来说，使用Comparator接口编写代码效率更高

5.什么是泛型？使用泛型有什么好处？
（1）泛型概述：泛型是在定义类的时候，不确定的数据类型
（2）泛型的好处
     【1】使用泛型可以对程序进行数据类型的规范，让在运行期间出现的错误提前到了编译期
     【2】避免了强制转换的麻烦
     【3】提高代码复用性

——张柠
      

1.Set接口下的集合是如何保证无序不可重复的
Set接口的集合实现类对象比如说HashSet和TreeSet，依靠哈希值作为对象属性值的唯一判断，继承Object重写了父类的hashcode()方法，
可以根据对象的哈希值计算存储位置
1根据对象的哈希值计算存储位置
如果当前位置没有元素则直接存入
如果当前位置有元素存在，则进入第二步
当前元素的元素和已经存在的元素比较哈希值
如果哈希值不同，则将当前元素进行存储
如果哈希值相同，则进入第三步
通过equals()方法比较两个元素的内容
如果内容不相同，则将当前元素进行存储
如果内容相同，则不存储当前元素，舍弃当前元素



2.我们为什么要重写HashCode( )和equals（）方法？
默认情况下是按照父类的hashcode以及equals，前者是返回一个对象在内存中的地址值，后者是比较两个对象的地址值
根据实际意义上必须继承父类的这两个方法并且重写，可以作为对象的属性值的判断，而且比较哈希值以后，通过重写equals方法，也可以比较属性值的内容，层层把关。


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，哈希表的底层是数组和链表结构。先通过调用HashCode方法来计算对象的哈希值，然后计算存储位置，位置是空的就直接存储进去，之后再做其他判断。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable接口是实现它的抽象方法compareTo方法，并且重写这个方法；
Comparator接口是实现它的compare方法，第二种方法使用比较多，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法。

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

泛型就是1.5版本引入的特性，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换，

1.Set接口下的集合是如何保证无序不可重复的
1.存入的对象需要重写hashcode和equals方法
2.当元素存入集合时,会先调用hashcode方法去计算元素的哈希值.,就可以根据哈希值进行判断
3.如果哈希值相同,调用equals方法进行俩个元素内容比较

2.我们为什么要重写HashCode( )和equals（）方法？
如果没有重写这俩方法,默认使用的是object类中的方法得到的是对象的地址值,不管是否数据相同都会得到不同的hashcode值


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
是先判断Hashcode(),如果不同直接存入,如果hashcade()值相同在调用equals()方法比较内容是否相同



4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable 重写comparaTo()方法,重写方法时必须按照要求的主次要条件来写
Comparator:比较器排列让集合构造方法接收Comparator的实现类对象,重写compara的方法

5.什么是泛型？使用泛型有什么好处？
泛型约束传入集合的数据类型,更切确的说是在定义类时不确定数据类型
好处:使用泛型可以让程序数据类型更规范,在运行期间的错误提前到了编译期
避免了强制转换的麻烦

1.Set接口下的集合是如何保证无序不可重复的
   
    首先用hashCode方法获取元素的哈希值,然后用哈希值 % 16获取元素储存地址,如果存入的哈希值不同就可以存入,如果两个值不同,则调用equals方法进行元素的内容进行比较不同则可以存入否则不存

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

   如果不从写这两个方法默认会调用Object的方法获取的是地址值,而我们要比较是内容,当我们想确保元素的唯一性的时候就必须重写这两个方法
  
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？

     是先判断HashCode(),因为可以提高数据存储的效率,如果HashCode()相同说明两个元素是相同的就不存入数据.不同时再用equals（）判断内容相同就不存不同就存
  
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

    Comparator接口用得多,因为Comparable接口必须有实现类和重写comparaTo方法比较规则和类绑在一起使用起来不方便,而Comparator则无需在类中定义比较规则,可以用使用匿名内部类来定义规则

5.什么是泛型？使用泛型有什么好处？
   
    是一种不确定的类型,可以在类,方法和接口中使用
    好处:(1).可以将运行期异常提前到编译期
         (2).避免强制类型的麻烦
         (3).使用泛型可以在创建的时候定义类型,不同数据类型的方法,类,接口,可以重复调用泛型

1.Set接口下的集合是如何保证无序不可重复的
set集合底层是数组+链表/红黑树的结构，存入元素时会先判断哈希值，对应数组内哈希值的位置，然后判断内容，内容不一致就以链表的形式连接在一起，一致则不存入。因为存入是用哈希值%16得到的余数作为数组的索引值，所以存放是无序的。

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

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据存放入set集合的时候是先判断哈希值是否相同，将数据先进行分类，分配到链表的不同位置，再根据equals（）方法判断同一个位置上的数据，这样可以提供代码的执行效率。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparato接口用的多，因为使用Comparable接口需要再类中实现此接口并重写CompareTo，大大增加了类的耦合性，不利于程序的独立性，而Comparator接口是在调用类的时候直接通过匿名内部类实现比较功能，降低了耦合性。

5.什么是泛型？使用泛型有什么好处？
泛型是在定义类的时侯，不确定的数据类型，用来约束存入集合元素的数据类型
      使用泛型可以将运行期的问题提前到编译期显示出来，也可以在使用到多种类型参数时
      避免多次定义和强制转换麻烦。

1.Set接口下的集合是如何保证无序不可重复的
【1】计算存入对象的哈希值。对哈希值取模操作，看哈希槽中是否有元素，没有，可以存储，否则比较哈希值
【2】比较哈希值，如果哈希值不相同直接存储，如果哈希值值相同，我们将采取equals方法进行比较
【3】比较equals,如果返回的是true，舍弃，如果返回的时false,将对象存储。
2.我们为什么要重写HashCode( )和equals（）方法？
【1】为了保证存入Set集合的元素
【2】不重写HashCode()值和equals()，比较的时对象的地址值
【3】重写HashCode()值能提高元素的储存效率
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()值，再可能判断equals(),当数据比较大的时候，equals()判断效率很低，
每次添加都的进行对每个对象进行判断，先判断HashCode（）能极大的提高元素存储效率。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：
【1】Comparable在类中需要实现Comparable接口，并且重写CompareTo方法
Comparator作为创建对象传入的参数传入，通过匿名内部类最为该接口实现类对象传入。
【2】CompareTo方法在CompareTo方法定义排序规则，Comparator在Compare方法中定义排序规则。
Comparator比较器用的比较多，因为自然排序，类和排序规则绑定在一起，耦合性太强。
推荐使用比较器排序，因为比较器排序，对象和排序规则是解耦的，分开的。可以自由组合。
5.什么是泛型？使用泛型有什么好处？
泛型就是在定义类，方法，接口的时候，未知的数据类型
好处：
【1】将运行异常提前到编译异常
【2】避免类型转换的麻烦
【3】类中的代码可以重复使用

今天我们继续了集合的学习，请根据自己的理解回答下面问题：
1.Set接口下的集合是如何保证无序不可重复的

        无序：因为存入元素时，需要根据元素hashCode所得的哈希值区进行取模操作进行储存位置，所以会出现添加顺序和保存在哈希表中的顺序不一致。

        不可重复：先用hashCode进行取模操作的到余数，如果此余数空间中没有元素则直接存储，如果有则继续判断equals方法如果结果为ture则舍弃此元素，反之则添加此元素到此空间的链表上。因此保证了不可重复性

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

              不被重写（原生）的hashCode值是根据内存地址换算出来的一个值。

              不被重写（原生）的equals方法是严格判断一个对象是否相等的方法（object1 == object2）。

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

        重写hashCode和equals之后，其实是可以用equals直接比较，但是一个类中的属性太多，如果一个个属性直接判断的话，效率极低，因此引入了hashCode的概念，重写之后hashCode是跟根据底层各种码表来计算出hashCode值，大多数情况下每个对象都有不同的属性hashCode基本都不会相同，可以用来筛选不同的对象。hashcode相比于equlas方法来说大大的提高了效率，所以先进行hashCode的比较，在进行equlas比较

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

        Comparable：此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

        Comparator:根据指定的比较器进行排序。无需在类中定义比较规则。

        第二个接口使用的比较多，因为，如果需要更换比较规则，只需要更换一个对象就可以了，无需重新修改类中的代码。

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

        泛型：泛型是指在定义类的时候，不确定的数据类型；

        泛型的好处：1.使用泛型可以对程序进行数据类型的规范。

                    2.避免了强制类型转化的麻烦。

                    3.使用泛型，可以在创建对象的时候确定类型，那么类中可以只写一段代码，重复使用。
                    

1.Set接口下的集合是如何保证无序不可重复的
Set接口的实现类，HashSet和TreeSet使用Object类的hashCode的方法来获得哈希值。
<1>：用获取的哈希值对16取余，获得的余数就是存储位置保证了无序性。
<2>：获取位置后，如果位置中没有元素就直接存入，如果位置中有元素就先判断元素的哈希值是否相同，值不同直接存入。值相同调用equals方法了判断内容是否相同，内容相同则去除元素，内容不相同就出入。保证了不可重复性。

2.我们为什么要重写HashCode( )和equals（）方法？
没有重写HashCode( )和equals（）方法他们比较的是地址值，而重写后比较的是内容。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
  先判断HashCode()，哈希值是根据输入的元素得到的，如果哈希值不一样那么内容就不一样再就哈希值取余得到了储存的位置。
  如果元素中的内容很多的话，equals()比较的内容的方式太繁琐，效率太低。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
<1>：Comparable 需要实现Comparable，重写方法comparaTo()方法，
<2>：Comparator 可以传递匿名内部类作为该接口的实现类对象。
  Comparator接口用的多，因为自然排序，类和排序规则绑定在一起了，耦合性太强。
比较器排序，对象和排序规则是分开的。

5.什么是泛型？使用泛型有什么好处？
  泛型：在定义类、方法、接口的时候，位置的数据类型。
  好处有：
1.        将运行期的异常提前到了编译期。
2.        避免了类型装换的麻烦。
3.        类中的代码可以重复利用。

.Set接口下的集合是如何保证无序不可重复的
其是利用所对应元素的哈希值来储存的，可以分为以下几步：一、获取哈希值计算应该储存的位置，看是否有元素，若没有，则存入；二、若有元素，则比较哈希值，哈希值不同则存入，相同时则进入下一步；
三、使用equals方法比较内容是否相同，不同就存入，相同则不存入。
2.我们为什么要重写HashCode( )和equals（）方法？
为了避免储存的元素重复或者得到不想要的结果，所以重写这两个方法。
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()得到其可以储存的位置，在执行完一定的操作后，再来判断equals（），看是否能不能存储，这样能提高代码的执行效率。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator这个接口使用更多，在使用Comparable时需要重写，操作比较繁琐，且提高了代码的耦合性，而Comparator则不涉及到这些问题，其直接使用一个匿名内部类提高了操作效率。
5.什么是泛型？使用泛型有什么好处？
其是在定义类，方法，接口时不确定的数据类型。
将运行期间的问题提前到了编译期，并且避免了强制类型转换。

1.Set接口下的集合是如何保证无序不可重复的
  (1)首先根据元素计算出哈希值
（2）然后通过哈希值就算出元素应该存放的位置，如果该位置没有任何元素，就直接存放进去，如果该位置有元素，就
对比哈希值
（3）通过比较哈希值，如果哈希值不同，就把元素存放进去，如果哈希值相同，就通过equals进行比较
（4）通过equals比较元素内容，如果元素内容不同，就把元素存放进去，如果相同，就舍弃
2.我们为什么要重写HashCode( )和equals（）方法？
创建Set集合时，要保证集合中元素的唯一性，所以需要重写Hashcode()和equals()方法
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为创建的每一个元素对象的哈希值都是不同，如果哈希值不同了，就可以直接把元素存放到集合中，不需要再判断equals()方法了，如果哈希值相同，再判断equals()方法。
4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的更多，应为使用Comparable接口进行排序，提高了代码的耦合性，而Comparator没有这种情况，直接使用匿名内部类，提高代码的操作效率。
5.什么是泛型？使用泛型有什么好处？
泛型：在定义类的时候，没有确定具体的数据类型
好处：
（1）避免了强转的麻烦
（2）让运行期间出现的错误提前到了编译器
（3)使用泛型可以在创建对象的时候确定数据类型，那么类中只写一段代码，可以重复使用，提高代码的重复性

1.Set接口下的集合是如何保证无序不可重复的
通过哈希表实现的,哈希表是由链表和数组以及红黑树构成的,要添加元素时会计算元素的哈希值,再通过元素的哈希值计算元素储存的地址,如果该地址没有元素则将元素储存进去,有元素则对比两者哈希值,哈希值不一样再比较内容,如果都相同,则舍弃该元素,否则就将元素存进去,这样就可以保证元素不可重复,储存的地址是通过哈希值取余算出的,所以储存也是无序的.

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

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode();因为每次先判断equals()来比较会耗费资源,效率低下,而先判断HashCode可以减少调用equals()方法的次数,提高程序的执行效率

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自然排序,需要排序的对象的所属类需要继承Comparable接口，并重写compareTo()比较方法。Comparator是比较器排序，需要排序的对象的所属类不需要继承Comparator接口，compare()比较方法重写在另一个实现Comparator接口的类中。
Comparator接口使用的多，因为compare()比较方法不在需要排序的对象类中，可以根据不同的排序需求写不同的比较器方法，自然排序只能写一个。

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

1.Set接口下的集合是如何保证无序不可重复的
通过哈希表实现的,哈希表是由链表和数组以及红黑树构成的,要添加元素时会计算元素的哈希值,再通过元素的哈希值计算元素储存的地址,如果该地址没有元素则将元素储存进去,有元素则对比两者哈希值,哈希值不一样再比较内容,如果都相同,则舍弃该元素,否则就将元素存进去,这样就可以保证元素不可重复,储存的地址是通过哈希值取余算出的,所以储存也是无序的.

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

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode();因为每次先判断equals()来比较会耗费资源,效率低下,而先判断HashCode可以减少调用equals()方法的次数,提高程序的执行效率

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自然排序,需要排序的对象的所属类需要继承Comparable接口，并重写compareTo()比较方法。Comparator是比较器排序，需要排序的对象的所属类不需要继承Comparator接口，compare()比较方法重写在另一个实现Comparator接口的类中。
Comparator接口使用的多，因为compare()比较方法不在需要排序的对象类中，可以根据不同的排序需求写不同的比较器方法，自然排序只能写一个。

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