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

1.Set接口下的集合是如何保证无序不可重复的？
答：Set接口下的集合的底层存储原理是：1往Set接口下的集合中存储元素，先重写hashCode方法。
   （2）当调用add方法时候，先去调用重写的hashCode计算对象的值（字符串，数字，对象都可以计算）。
   （3）根据对象的hash值计算存储位置，如果存储位置没有元素，直接存储，如果有元素会比较hash值，不相同，直接存储。
   （4）如果有相同的hash值，调用equals方法进行比较，内容相同，不存储，内容不同，存储。
    所以Set接口下的集合元素的存储是无序且不可重复。

2.我们为什么要重写HashCode( )和equals（）方法？
答：重写equals方法，是为了比较对象的内容。equals方法是从object继承过来的 ，相当于比较运算符==，比较的是对象的地址值，如果不重写，是没有什么意义的。
    重写HashCode( )方法是为了提高元素存入集合的效率，保证对象内容的不一致。因为equals方法效率低，所以当集合存储元素时，集合性能非常差，在比较equals之前，先比较一下hashhashCode()方法也是从object类继承过来的，每次创建对象都会生成一个新的hash值，即使两个对象的内容是相同的，hash值也是不相同的，重写此方法之后，根据对象的内容生成一个hash值，先比较hash值是否相同，hash值不同，内容一定不同，如果hash值相同，再利用使用equals进行比较对象内容，提高运行效率。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：由set集合底层存储原理可知，是先调用hashCode()方法，先比较hash值，当此方法不能识别对象内容是否相同时，再去调用equals方法，因为equals()方法，计算量大，效率低下，这样设计可以提高代码的运行速度。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答;Comparable为自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法，一个实体只能实现一个接口，接口和类绑定。
   Comparator 是比较器排序，就是让集合构造方法接收Comparator的子类匿名对象，重compare(T o1,T o2)方法 ，直接在测试类中执行。
   Comparator接口用的比较多，对于自然排序，如果需求改变，要修改源代码，安全性低，扩展性差，而比较器排序，可以在一个实体对象实现复杂逻辑，且修改方便，代码的解耦性和独立性是比较强的，优先级高，隔离性好。

5.什么是泛型？使用泛型有什么好处？
答：泛型是定义类、方法、接口时，指定未知的的数据类型，可以分为泛型类、泛型方法、泛型接口。
好处：
   （1)将异常从运行期，提前到了编译期。
   （2)避免了强制类型转换。
    (3)编写一份代码，在调用的时候传入实际参数和返回值类型，提高了代码的复用性。

1.Set接口下的集合是如何保证无序不可重复的
答：Set集合底层是数组+链表/红黑树的结构，通过hashCode()方法获取哈希值，使用哈希值算出存储位置，该位置有元素再比较哈希值，
       哈希值相同的元素再通过equals()方法判断是否相同，不同则存入，相同不存。

2.我们为什么要重写HashCode( )和equals（）方法？
答：不重写hashCode( )和equals（）方法将会默认调用Object类的方法，Object的方法与地址值有关，与具体元素内容无关，不能保证存储的元素不重复。
       重写hashCode()方法，可以实现让不同对象的哈希值相同获取哈希值的代码
       重写equals()方法确保元素唯一

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，因为如果先判断equals（）需要每次都进行比较，浪费资源。
       先判断hashCode()，可以减少元素调用equals()方法的次数，提高程序执行效率。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：区别：Comparable接口由需要进行比较的实体类实现，重写的compareTo方法只要一个实体类类型的参数；
       Comparator接口使用的比较多，因为使用使用Comparable接口需要在类中实现此接口，并重写CompareTo方法，加强了类的耦合性，不利于后期维护。

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

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

1.Set接口下的集合是如何保证无序不可重复的
        答：通过哈希表，哈希表由数组和链表/红黑树组成。先计算元素的哈希值，根据哈希值计算一个地址，该地址没有元素直接储存，有的话再比较哈希值，如果哈希值相同再比较内容，如果哈希值和内容都相同就证明是相同元素，不储存，不然就储存，这样重复的元素就不会存入集合，因为储存的地址是根据数组长度取余获取，所以储存是没有顺序的。

2.我们为什么要重写HashCode( )和equals（）方法？
        答：默认的equals（）方法比较的是地址，想要比较对象内容就需要重写。默认的HashCode( )方法是通过地址值来计算哈希值，所以不同的对象的哈希值肯定不同，但是我们想要不同的对象只要内容相同，就判断为同一个对象，就需要重写HashCode( )方法，通过对象的内容来计算哈希值。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
        答：先判断HashCode()，因为判断equals()在对象内容较多时更花费时间。判断哈希值不同，对象内容肯定不同，就不用再判断equals()了。

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

5.什么是泛型？使用泛型有什么好处？
        答：1、泛型当作数据类型时，可以接受各种数据类型，提高了代码的复用性。2、泛型参数在被赋值时就固定为传入的数据类型，不需要再进行强转。3.因为传递的数据类型被锁定，如果输入的数据类型不对，编译期间就能看到。

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

   答: Set集合是按照hash表的遍历去找的，把数据存放在固定位置，hash表是用算法把不同的数据按照规则放在对应的地址，哈希表是无序的，也就是第一个放进去的值它是在最后才读取出来的，也就是先进后出，后进先出的是没有顺序的,保证了无序,,
   当向Set集合存入数据时，会根据对象的哈希值计算存储位置,如果当前位置没有元素则直接存入,存入的元素会和集合里的元素做比较,会先比较hashCode()的哈希值，如果不同那么,就会认为这是两个不同的数据就会直接加入，如果hashCode()的值相同，接着就会调用equals()方法做比较，如果相同就会判定为同一个数据，否则就是两个数据（当hashCode()的值不同就不会调用equals()方法）前提是要重写HashCode( )和equals（）方法.

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

    答: 重写HashCode( )和equals（）方法,是为了确保不会存入两个相同的数据,当存入数据时会先调用hashCode()方法获取哈希值,再与存入的下一个数据进行比较如果不同则存入数据, 当哈希值相同时会再调用equals（）方法,进行比较 如果这两个方法与存入的数据比较,结果都相等的话,则判定为是同一个元素,便不会存入集合中.

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

   答:往Set中存储元素,一定要重写hashCode方法和equals（）方法,重写了两个方法之后,会优先获取对象的哈希值参与计算是否相同,相同则在调用 equals方法,减少了equals()方法的使用次数,不重写光使用equals方法比较内容,在元素多的情况下使用equals()方法进行比较,执行效率极低,例如集合中已经有10000多个元素,那么第10001个数据存入集合时,就需要调用10000次equals（）方法,大大降低了效率..如果光使用一个方法就不能实现Set集合的共性特点,(不允许出现重复元素),两个方法配合使用,确保了存入数据的唯一性.

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

   答: 用Comparable比较简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比较大小, 并且在Comparator里面可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复步骤,例如想按名字同时又按年龄排序，这种情况我们用 Comparable无法同时满足两种情况，那么我们就需要 Comparator接口，Comparable接口里面的方法只需要1个参数，因为另一个参数就是这个 A 类实例自己，而Comparator需要2个参数，它是第三方比较器，接收2个参数。Comparator使用的比较多

5.什么是泛型？使用泛型有什么好处？
   答:泛型是JDK-5 之后引入的新特性,有泛型类、泛型接口、泛型方法三种.,他的本质类型是参数化类型,就是将原本具体的类型参数化,在调用的时候传入具体类型,泛型可以自定义类型为26个大写英文字母,返回值类型为调用的自定义类型.常用的为(T,E,K,V)..
    使用泛型有三大好处 :
    1 能够把运行期间出现的异常提前到编译期,就可以节省调试程序的时间，这样编译错误可以比较容易和快速地被发现和修复.
    2 避免了强制类型转换,
    3 可以做到只编写一份代码,这份代码的参数和返回值类型都是可变的,提高代码的复用性

1.Set接口下的集合是如何保证无序不可重复的
①无序：无索引值,底层数据结构是哈希表，是数组+链表（红黑树）
②不可重复：Set接口底层是Map集合，
添加元素时会调用Map.put<K,V>方法,put方法中使用HashCode()方法比较了哈希值，
如果哈希值不同，则存入，不相同会调用equals()方法再次比较元素内容，如果内容不同则存入，相同则不存。


2.我们为什么要重写HashCode( )和equals（）方法？
①在Set集合中，是不能存储重复元素的，而重新HashCode（）和equals（）方法是保证了存入集合中每个元素的不同。
②虽然单独写equals（）方法也可以进行判断重复，但是添加了HashCode（）方法可以提高判断的效率。


3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（），因为HashCode（）方法在比较的效率上比equals（）快的多，
判断完哈希值，基本上可以排除大多数的元素是否重复，单独写equals（）方法也可以进行判断重复，但是效率低。当哈希值是相同时，才再会使用equals（）方法去比较其中的内容。


4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
①Comparable使用在TreeSet的无参构造方法中，集合元素中的数据类型必须实现Comparable这个接口，并且重写CompareTo(T o)方法。
②Comparator使用在TreeSet的有参构造方法中的参数列表中，可以直接在创建TreeSet集合的时候直接使用匿名内部类的方式去传递Comparator的实现类对象，并且重写比较方法Compare（T o1,T o2);
③Comparator使用的比较多，因为可以在创建对象的时候直接修改比较方法，比较灵活，而Comparable接口的耦合性就比较强，如果多次创建对象就不是实用。


5.什么是泛型？使用泛型有什么好处？
①泛型：在定义类、方法、接口时指定的未知的数据类型，本质是数据参数化。
③泛型的好处
把运行时期的问题提前到了编译期间
避免了强制类型转换
代码复用

1.Set接口下的集合是如何保证无序不可重复的
set接口下的集合是通过继承Object类中的hashCode方法,计算出该对象的一串数字类型虚的拟地址值,将元素存入集合之前,重写HashCode和equals方法,比较元素的地址值是否相等,如果地址值不同,则将元素存入集合,如果地址值相等,再比较元素的具体内容,如果元素内容也相同,则是同一个元素,不存入集合,提高了代码的存储效率

2.我们为什么要重写HashCode( )和equals（）方法？
重写HashCode方法是为了获取元素内容的hash值,重写equals方法是为了避免hash值相同而元素内容不同的情况

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据在存入Set集合的时候,先判断HashCode(),因为元素内容的地址值只有一个,而元素的内容可以有很多,如果hash值不同,那么两个元素一定不同,可以提高代码运算效率

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口是通过标准类继承实现默认排序,将排序方法重写在标准类中,增强了代码的耦合性
Comparator接口通过匿名内部类的形式在在测试类中实现,将排序方法重写在测试类中,提高了代码的灵活性高
平时Comparator接口使用的较多,因为代码灵活性更高

5.什么是泛型？使用泛型有什么好处？
泛型是指定义一个类 方法 接口时,指定的未知数据类型
泛型的好处:把运行期的异常问题提前到了编译期,避免了数据类型的强制转换,代码复用

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

答： Set集合的存储流程是
    （1）首先往hashCode中存储的元素，一定要重写hashCode方法
    （2）当调用add方法时，要调用重写hashCode方法计算该对象的hash值
    （3）先去集合中看有没有相同hash值的元素，如果没有就直接存储
    （4）如果集合中存在相同的hash值元素，需要调用equals方法进行比较
    （5）调用equals方法进行比较，如果equals返回的是false，内容不重复，可以存储
    （6）调用equals方法比较，如果equals返回的是true，内容重复，不可以存储
     所以Set接口下的集合是无序不可重复的

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

答：重写HashCode()的原因：因为想要实现hashSet集合元素存储内容不重复，但是如果使用equals进行比较的话，效率非常低，所有当集合中存储的元素增多时，集合的性能非常差，想到通过在比较hashCode后再比较equals这个方法来解决，当子类重写hashCode方法，来根据对象的内容生成一个hashCode值，就可以先比较hashCode值在比较equals。

    重写equals（）的原因：如果哈希值不同，对象的内容肯定不同，哈希值相同，内容不一定相同，则需要equals在对内容进行比较，hashCode方法虽然能够极大程度上减少对象内容的比较，但是不能完全避免，如果hash值相同，此时就不能根据哈希值确定内容是否相同，必须使用equals比较。


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

答： 先判断HashCode()再判断equals（）
     因为HashCode()先对对象的内容的进行哈希值计算，然后通过Hash值的判断，如果哈希值不同，对     象的内容肯定不同，不需要调用equals（）方法，若哈希值相同，内容不一定相同，则需要equals     在对内容进行比较。hash值的比较比equals的比较提高了效率。

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

答：Comparable是需要实现类来重写接口中的compareTo（）方法，而Comparator可以通过匿名类的方式    来重写compareTo（）方法
    Comparator接口使用的多，因为这个接口不会因为在类中实现而造成比较排序的方式固定，降低了代    码的灵活性，可以在不同的需求下对比较器进行修改。

5.什么是泛型？使用泛型有什么好处？
  答：在定义类、方法、接口时指定的未知的数据类型
        好处：把运行时期的问题提前到了编译器件，可以提前解决；
                  避免了强制类型转换；
                  只编写了一份代码，代码的参数和返回值都是可变的，提高了代码的复用性；

1.重写hashCode()和equals()方法，保证数据不可重复，使用底层使用hash表存储实现无序

2.重写HashCode()方法可以提高存储效率，判断对象地址值是否相等，equals()方法可以判断两个对象的内容是否相同

3.先判断HashCode()再判断equals()，因为这可以提高存储效率，地址值不同两个对象就一定不同，地址相同内容可能不同所有再调用equals()

4.Comparable：对实现该接口的对象，进行整体排序的接口
Comparator：对某个对象 collection 进行整体排序的比较接口
Comparator使用更多，具有解耦合效果

5.在不确定使用的数据的数据类型时，先用占位符替代，等实际使用时，再传递实际数据类型替换该占位符
，该占位符所表示的类型称为泛型。使用泛型可以提高代码的复用性，将运行时问题提前到编译期，避免强制类型转换。

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

通过哈希表结构保证无序，通过HashCode()和equals()保证了元素不可重复性

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

因为默认的HashCode（）和equals（）方法比较的是地址值，不能满足具体的使用。

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

先判断HashCode()，因为哈希值不同则元素一定不同，无需进行内容比较，可提高比较效率

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

Comparable需在调用的类中实现该接口，耦合度较高；
Comparator耦合度较低，可通过匿名内部类的形式调用；
Comparator使用更多，更符合程序设计解耦合的原则，不会影响调用类的独立性，匿名内部类的调用方式重写也更方便。



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

泛型本质是参数化类型，即所操作的数据类型被指定为一个参数。
好处：
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换

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

   答: Set集合是按照hash表的遍历去找的，把数据存放在固定位置，hash表是用算法把不同的数据按照规则放在对应的地址，哈希表是无序的，也就是第一个放进去的值它是在最后才读取出来的，也就是先进后出，后进先出的是没有顺序的,保证了无序,,
   当向Set集合存入数据时，会根据对象的哈希值计算存储位置,如果当前位置没有元素则直接存入,存入的元素会和集合里的元素做比较,会先比较hashCode()的哈希值，如果不同那么,就会认为这是两个不同的数据就会直接加入，如果hashCode()的值相同，接着就会调用equals()方法做比较，如果相同就会判定为同一个数据，否则就是两个数据（当hashCode()的值不同就不会调用equals()方法）前提是要重写HashCode( )和equals（）方法.

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

    答: 重写HashCode( )和equals（）方法,是为了确保不会存入两个相同的数据,当存入数据时会先调用hashCode()方法获取哈希值,再与存入的下一个数据进行比较如果不同则存入数据, 当哈希值相同时会再调用equals（）方法,进行比较 如果这两个方法与存入的数据比较,结果都相等的话,则判定为是同一个元素,便不会存入集合中.

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

   答:往Set中存储元素,一定要重写hashCode方法和equals（）方法,重写了两个方法之后,会优先获取对象的哈希值参与计算是否相同,相同则在调用 equals方法,减少了equals()方法的使用次数,不重写光使用equals方法比较内容,在元素多的情况下使用equals()方法进行比较,执行效率极低,例如集合中已经有10000多个元素,那么第10001个数据存入集合时,就需要调用10000次equals（）方法,大大降低了效率..如果光使用一个方法就不能实现Set集合的共性特点,(不允许出现重复元素),两个方法配合使用,确保了存入数据的唯一性.

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

   答: 用Comparable比较简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比较大小, 并且在Comparator里面可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复步骤,例如想按名字同时又按年龄排序，这种情况我们用 Comparable无法同时满足两种情况，那么我们就需要 Comparator接口，Comparable接口里面的方法只需要1个参数，因为另一个参数就是这个 A 类实例自己，而Comparator需要2个参数，它是第三方比较器，接收2个参数。Comparator使用的比较多

5.什么是泛型？使用泛型有什么好处？
   答:泛型是JDK-5 之后引入的新特性,有泛型类、泛型接口、泛型方法三种.,他的本质类型是参数化类型,就是将原本具体的类型参数化,在调用的时候传入具体类型,泛型可以自定义类型为26个大写英文字母,返回值类型为调用的自定义类型.常用的为(T,E,K,V)..
    使用泛型有三大好处 :
    1 能够把运行期间出现的异常提前到编译期,就可以节省调试程序的时间，这样编译错误可以比较容易和快速地被发现和修复.
    2 避免了强制类型转换,
    3 可以做到只编写一份代码,这份代码的参数和返回值类型都是可变的,提高代码的复用性

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

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

HashSet由哈希表保证唯一性（通过重写hashcode()和equals）
无序，因为它没有索引，不能通过索引遍历
每次取出的顺序都有可能是不同的

（哈希表是一个元素是链表/红黑树的数组，初始长度是16，扩容因子是0.75，
当数组的一个元素的链表长度超过8时，该条链表会被转换为红黑树结构，提高查询效率）  

TreeSet底层数据结构是具有自平衡的红黑二叉树，保证了唯一性，
其可以按照一定的规则排序。
没有索引，不能通过索引遍历。


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

保证集合元素的唯一性。
默认new的不同对象的hashcode()都不一样，所以要重写对象的hashcode()。
即使hashcode()相同，对象内容也会不同，所以要重写对象的equals()方法。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
   
   先判断HashCode()，如果哈希值不同，则不再判断equals() 直接添加元素;
   如果哈希值相同，再判断equals(),如果equals()也相同，则为同一个元素，不添加。


4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
  
  Comparable是在类中实现，根据其元素的自然排序进行排序
  Comparator是在构造方法中实现，创建集合的时候根据指定的比较器进行排序
  通常使用Comparator,便于维护代码，提高代码的复用性，因为标准类制作完成后，不要轻易去修改类中的代码。


5.什么是泛型？使用泛型有什么好处？
  
  泛型本质就是参数化类型。通常用T表示，指代各种参数类型
  使用泛型，可以把运行时期的问题提前到了编译时期
  避免了强制类型转换，可以简化代码，提取出通用的方案。
  

1.Set接口下的集合是如何保证无序不可重复的
答：其有hashCode方法和equals方法能够在添加元素的时候判断是否和集合中已有元素重复，先判断哈希值，后判断内容，同时存储的地址是根据哈希值进行计算，放置在对应的地址上，以此来达到无序不可重复。

2.我们为什么要重写HashCode( )和equals（）方法？
答：因为重写hashCode为了提高比较效率，保证存入的内容不重复。但有时不同内容的哈希值会一样，所以还需要重写equals()来进行比较。

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断hashCode方法，后判断equals方法，因为不同哈希值表明元素不同，能够提高比较效率，当哈希值相同时，再用equals方法判断。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：区别是重写的方法不一样，一个是compareTo()，一个是compare(),一个是在类中实现接口，另一个是使用匿名内部类。
一般比较器排序用的多，因为比较器排序能够方便操作，不用去增强耦合性，便于修改。

5.什么是泛型？使用泛型有什么好处？
答：泛型就是在定义类、方法、接口时，指定的未知的数据类型。
好处是1.将运行时期的异常提前到了编译期。2.避免使用强转。3.提高代码的复用性。

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

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

因为Set接口下的集合懂重写了hashcode和equals方法


因为Set底层是哈希表，继承了Object类中过得hashcode（）方法通过写hashcode（）方法，计算哈希值，不同对象的哈希值是 不同的

当使用add（）添加元素的时候，会调用hashcode方法，计算哈希值，和集合中所有元素比较哈希值，相同调用equals比较，不同直接存储

因为存储元素的地址是根据哈希值计算的，存入对应的地址，所以是无序的



2.我们为什么要重写HashCode( )和equals（）方法？
因为想要实现hashset集合元素存储内容不重复，一开始考虑之需要重写equals（）就可以实现，
但是！！！如果使用equals进行比较的话，效率是非常低的，所以当集合中存储的元素增多的时候，
集合的性能非常差

因为Objectr继承过来的hashcode（）方法，返回的是对象的地址值。
子类重写hashcode（）方法就会根据对象的内容生成一个hashcode值，就可以先比较一次hashcode值，
如果hashcode值不相同就会直接添加到集合中，如果hashcode值不同，再用equlas（）方法比较

因为单靠hashcode（）方法，虽然能够极大程度上减少了对象内容的比较，
但是不能完全避免，如果hash值相同， 此时就不能根据哈希值确定俩个对象内容是否相同，就必须根据equals比较
3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？


先判断的是hashcode（）后判断的是equlas（）
因为我们先比较的是hashcode值，如果hashcode值相同，然后就比较equlas；
这样大大提高了大妈的效率

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：位置不同，一个类中，一个构造方法中。
        按照解耦合的思想，建议使用自定义比较器也就是Comparator



5.什么是泛型？使用泛型有什么好处？
泛型就是没定义的参数，并且将运行时异常提前到了编译时异常
泛型的好处是：
避免强转
代码复用

泛型简单易用

类型安全 泛型的主要目标是实现java的类型安全。 泛型可以使编译器知道一个对象的限定类型是什么，这样编译器就可以在一个高的程度上验证这个类型

消除了强制类型转换 使得代码可读性好，减少了很多出错的机会

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

   答: Set集合是按照hash表的遍历去找的，把数据存放在固定位置，hash表是用算法把不同的数据按照规则放在对应的地址，哈希表是无序的，也就是第一个放进去的值它是在最后才读取出来的，也就是先进后出，后进先出的是没有顺序的,保证了无序,,
   当向Set集合存入数据时，会根据对象的哈希值计算存储位置,如果当前位置没有元素则直接存入,存入的元素会和集合里的元素做比较,会先比较hashCode()的哈希值，如果不同那么,就会认为这是两个不同的数据就会直接加入，如果hashCode()的值相同，接着就会调用equals()方法做比较，如果相同就会判定为同一个数据，否则就是两个数据（当hashCode()的值不同就不会调用equals()方法）前提是要重写HashCode( )和equals（）方法.

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

    答: 重写HashCode( )和equals（）方法,是为了确保不会存入两个相同的数据,当存入数据时会先调用hashCode()方法获取哈希值,再与存入的下一个数据进行比较如果不同则存入数据, 当哈希值相同时会再调用equals（）方法,进行比较 如果这两个方法与存入的数据比较,结果都相等的话,则判定为是同一个元素,便不会存入集合中.

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

   答:往Set中存储元素,一定要重写hashCode方法和equals（）方法,重写了两个方法之后,会优先获取对象的哈希值参与计算是否相同,相同则在调用 equals方法,减少了equals()方法的使用次数,不重写光使用equals方法比较内容,在元素多的情况下使用equals()方法进行比较,执行效率极低,例如集合中已经有10000多个元素,那么第10001个数据存入集合时,就需要调用10000次equals（）方法,大大降低了效率..如果光使用一个方法就不能实现Set集合的共性特点,(不允许出现重复元素),两个方法配合使用,确保了存入数据的唯一性.

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

   答: 用Comparable比较简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比较大小, 并且在Comparator里面可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复步骤,例如想按名字同时又按年龄排序，这种情况我们用 Comparable无法同时满足两种情况，那么我们就需要 Comparator接口，Comparable接口里面的方法只需要1个参数，因为另一个参数就是这个 A 类实例自己，而Comparator需要2个参数，它是第三方比较器，接收2个参数。Comparator使用的比较多

5.什么是泛型？使用泛型有什么好处？
   答:泛型是JDK-5 之后引入的新特性,有泛型类、泛型接口、泛型方法三种.,他的本质类型是参数化类型,就是将原本具体的类型参数化,在调用的时候传入具体类型,泛型可以自定义类型为26个大写英文字母,返回值类型为调用的自定义类型.常用的为(T,E,K,V)..
    使用泛型有三大好处 :
    1 能够把运行期间出现的异常提前到编译期,就可以节省调试程序的时间，这样编译错误可以比较容易和快速地被发现和修复.
    2 避免了强制类型转换,
    3 可以做到只编写一份代码,这份代码的参数和返回值类型都是可变的,提高代码的复用性

1.Set接口下的集合是如何保证无序不可重复的
      无序：存入和去除的顺序不一致，无索引值
      不可重复：使用了HashCode( )和equals（）方法

2.我们为什么要重写HashCode( )和equals（）方法？
      因为想要实现hashSet集合元素存储内容不重复，一开始考虑只需要重写equals就可以实现，但是如果使用equals进行比较的话，效率是非常低的，所以当即和中存储的元素增多时，集合的性能非常差

3.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
      先判断HashCode()，先比较一次hashCode值，如果hash值相同，再比较equals()，这样可以提高效率。

4.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
      区别：
          Comparable是在类中实现，重写compateTo比较的。
          Comparator是在构造方法中，使用匿名内部类实现的。
Comparator接口使用比较多，因为Comparable是在类中实现，如果该实现类的重写方法被修改，则所有引用此类的对象都会被修改。Comparator则不会出现这种情况。

5.什么是泛型？使用泛型有什么好处？
      泛型：就是在定义类、方法、接口时，指定的位置的数据类型
      好处：
          将异常从运行期，提前到了编译器（能提前知道出现的异常）
          避免强制类型转换的麻烦
          只编写了一份代码，但是这份代码的参数的和返回值类型都是可变的（代码复用性）

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

使用Set接口下的HashSet就能够保证无序不可重复


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

        如果不重写这两种方法，那么返回的是对象地址值而不是对象内容。

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

        子类重写hashCode和equals后，想根据对象的内容生成一个hashCode值，可先比较hashCode值，若hash值相同，再比较equals

        因为能够提高效率

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

Comparable：用该方法要在定义类中实现Comparable接口，在该类中重写compareTo方法，才能在测试类里面使用

Comparator：能够直接用匿名内部类在测试类里面使用，一般这个接口使用的多，因为Comparable有耦合性，对后期代码修改造成麻烦


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

泛型是规定结合存储的数据类型的包装类

就是在定义类、方法、接口时，指定的位置的数据类型

集合中，如果不指定泛型，默认使用Object类型进行元素的存储，元素不能调用自己的方法

好处：

1.将异常从运行期，提前到编译期

2.避免强制类型转换的麻烦

3.只编写了一份代码，但是这份代码的参数和返回值类型都是可变的（复用性）