1.List接口下都有哪些集合，他们各自有什么特点
2.Set接口下的集合是如何保证无序不可重复的
3.我们为什么要重写HashCode( )和equals（）方法？
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

1.List接口下都有哪些集合，他们各自有什么特点
有索引，可以普通for循环；
元素可重复；
存储遍历有序

2.Set接口下的集合是如何保证无序不可重复的
这些集合由数组 + 链表/红黑树 组成

根据hashCode判断每个元素的哈希值是否相同，若相同，根据equals进一步判断内容，来判断是否存储该元素

3.我们为什么要重写HashCode( )和equals（）方法？
父类Object里的HashCode( )和equals（）方法默认给new出的对象随机哈希值，默认对象相等；

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode( ），若是哈希值相同，再判断equals（）方法，因为哈希值不同就直接不用存储

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自己和别人比，比较需要实现接口Comparable，重写compareTo方法，适用于高频率排序的类，不用找比较器
Comparator是第三方，也就是比较器，不需要实现接口，灵活制定比较规则

1.List接口下都有哪些集合，他们各自有什么特点     list集合下有ArrayList ,vector,linkedlist,     ArrayList 和vector底层都数组,  索引查询快,增删慢     linkedlist底层是链表,增删快 查询慢 2.Set接口下的集合是如何保证无序不可重复的      set接口下的集合是通过hascode和equals 来确定元素的唯一. 3.我们为什么要重写HashCode( )和equals（）方法？      因为HashCode( )可以提供一个唯一的伪地址值,但是因为算法的原因,可能会出现hash碰撞,当发生hash碰撞时可以利用equals（）方法对元素的内容进行判断 4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？      先判断hashcode因为HashCode返回的是int类型的值,判断起来比较快, 5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？     Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。          Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法,     实际应用中用Comparator的比较多,因为随便的修改类中的方法不推荐.

余志斌
1.List接口下都有哪些集合，他们各自有什么特点
List接口下有ArrayList、LinkList、Vector。
Vector是单线程（同步）运行。
ArrayList 底层是数组结构 增删慢，查找快
LinkList 底层是链结构，增删快，查找慢
2.Set接口下的集合是如何保证无序不可重复的
先用hash值比较，再用equals方法。
所谓无序并不是随机，是根据自身算法计算出的顺序
3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写比较的是地址值，重写后才是比较具体的hash值。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（），hash值具有相对唯一性，equals是用来防止hash对冲的防护措施。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么
Comparator，因为它是外部比较器，不用实现接口。且规则可以再类中直接重写改变排序规则。

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合查找快，增删慢，
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
没有索引，所有是一个无序集合
3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法默认比较的是两个对象的地址值，无意义，所有需要重新写
HashCode( )方法，防止哈希碰撞情况发生
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值，因为哈希值判断完之后还会判断内容是否相等
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别在于一个已经定义好的，一个需要自己定义的，
如果没有特殊必要Comparable使用较多，
如非必要，基本不使用Comparator。

1.List接口下都有哪些集合，他们各自有什么特点
  ArrayList/LinkedList/Vector   
ArrayList元素真删慢，查找快。LinkedList方便添加删除。


2.Set接口下的集合是如何保证无序不可重复的
主要是依赖于hashCode和equals方法。


3.我们为什么要重写HashCode( )和equals（）方法？
不重写就不能做到不可重复的元素。防止哈希值碰撞，


4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（），哈希值如果相同再判断元素属性。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的多，比较方便- -。

1.List接口下都有哪些集合，他们各自有什么特点
Arraylist 按照插入顺序保存元素，可以快速通过下标查询到值
LinkedList通过节点彼此连接实现集合，每一个节点包含前一个和后一个节点的值，所以增删快
vector线程安全
2.Set接口下的集合是如何保证无序不可重复的
存入数据时，调用对象的hashCode（）函数计算一个哈希值，根据哈希值确定一个存放位置，如果该存放位置有元素，再调用equal（）方法对两个对象进行比较，如果相同则舍弃新加入元素，没有则以链表形式存在相同的位置
3.我们为什么要重写HashCode( )和equals（）方法？
Object的原方法，无法满足现实项目中对象的唯一性比对需求
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）
基本数据类型计算速度快，哈希值相同直接舍弃存入的对象，不再调用equals（），提高程序的效率
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用更多
Comparable写在类中，一旦类写完一般不再进行修改
Comparator更加灵活，可以重写比对方法
--危mengchao

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList存储是数组结构元素增删慢，查找块、LinkedList是链表结构查询慢，增删块、Vector也是数组结构，但是单线程，速度比较慢
2.Set接口下的集合是如何保证无序不可重复的
利用hashCode 与 equals 方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保
证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()再判断equals（），比较int类型比比较对象节省资源。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么
Comparable：强行对实现它的每个类的对象进行整体排序。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或
Arrays.sort），从而允许在排序顺序上实现精确控制。一般使用Comparator

1.List接口下都有哪些集合，他们各自有什么特点
Arraylist和linked集合和vector集合，有序可以存储重复元素和有索引
2.Set接口下的集合是如何保证无序不可重复的
调用被添加元素的hashcode（），和list集合的hashcode比较，如果不一样直接存储，如果一样调用equals比较内容是否一样，不相同就存储元素，相同则不存储
3.我们为什么要重写HashCode( )和equals（）方法？
不重写比较的是地址值
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（），因为先看Hashcode值一样了才需要判断equals（），看看内容是不是一样
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparator用的比较多，因为这个接口的是用匿名内部类重写comparaTo方法，而comparable是重写类中的方法

1.list接口下有ArrayList  LinkedList  vectory 集合 ，ArrayList 的底层是数组，搜索快，增删慢，LinkedList 是链表数据结构，增删快，搜索慢， vectory是ArrayList 的前身，是数组数据结构，搜索快，增删慢
2.set接口下的HshSet 的数据结构是单链表，是无序的，在添加元素时会调用hascode方法对比哈希值，如果哈希值相同，则调用equals方法进行内容对比，确保元素的唯一
3.当我们想让元素按照我们自己的计算方法来计算哈希值的时候，重写hascode方法，重写equals方法是因为有些对象的地址值不同，但内容相同，根据生活实际情况，这种情况下我们认为这两个对象为同一对象，所以我们重写方法对比对象内容
4.先判断hascode方法 ，哈希值相同再判断equals方法。
5.Comparator用的比较多，因为它可以更改已经有的默认排序，并且不需要进行接口实现类的创建，更加灵活

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:底层是数组结构，比较常用，增删慢，查找快；
LinkList：底层是链表结构，增删快，查找慢，有独立操作首尾的方法；
Vector：底层也是数据结构，效率低，线程安全；
2.Set接口下的集合是如何保证无序不可重复的
先通过对象的哈希值确定，若发生哈希碰撞，则调用equals方法进行内容比较
3.我们为什么要重写HashCode( )和equals（）方法？
若不进行重写HasbCode()和equals()方法会以地址值是否重复比较，重写之后才会进行内容比较，确保数据唯一性；
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，确认哈希值来确保储存和查找性能，当发生哈希碰撞时才会调用equals方法；
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compara To方法
Comparator:相当于找一个第三方裁判，比较两个
Comparator使用较多，自己可以定义排序规则，不用实现接口，使用比较灵活；

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 数组结构组成的集合，查询快
LinkedList：链表组成的集合，查询慢，增删快
Vector: Vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

2.Set接口下的集合是如何保证无序不可重复的
先使用HashCode()方法判断内容是否重复，不相同存储，相同在使用equals方法判断是否相同，不相同就存储，相同不存储

3.我们为什么要重写HashCode( )和equals（）方法？
为了保证HashSet集合中元素的唯一性

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
HashCode()先判断
先用大部分元素地址值（哈希值）不相同，先用HashCode()方法判断，排除大部分的相同元素
在使用equals()方法判断哈希值相同下，内容不同，节约时间

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
Comparator 不用实现接口，灵活
Comparable 在需要排序一些固定简易类似（int）类型使用

1.List接口下都有哪些集合，他们各自有什么特点
       ArrayList  有序（先进先出）底层数据结构是数组  查询块 增删慢 线程不安全
       LinkedList  有序（先进先出）底层数据结构是链表  查询慢 增删块 线程不安全
       Vector     有序(先进先出)   底层数据结构是数组   查询块 增删慢   线程安全  是最早的集合
2.Set接口下的集合是如何保证无序不可重复的
     通过  重写 HashCode和equals方法
     而add 等添加方法   需要对其进行判断   这样就保证了元素的唯一性。
    无序是由底层的数据结构保证的
3.我们为什么要重写HashCode( )和equals（）方法？
    不重写的话是根据地址值分配的hash值   我们要的是hash值跟对象属性挂钩
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
   先hashCode    hashCode要比equals省资源  而且  equals 判断比hashCode更全  hash碰撞时候再用
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
一个类中实现   一个不在类中实现   用匿名内部类    第二个用的多    如果要经常对一个类排序 则选用第一种

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList    元素增删慢，查找快
Vector        已过时
LinkedList   链表结构  方便元素添加、删除
2.Set接口下的集合是如何保证无序不可重复的
添加元素的add方法默认使用了HashCode方法
3.我们为什么要重写HashCode( )和equals（）方法？
equals方法没有重写的话比较的是地址值没意义
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode() 因为要先判断地址是否唯一
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自然排序
Comparator可以自己定义排序

1.List接口下都有哪些集合，他们各自有什么特点
(1)Arrraylist集合和(2)LinkedList集合
(1)集合时用的最多的集合 是数组结构 查找快 增删慢
(2)集合是双向链表 增删快 查找慢 所以有一些操作首尾的方法
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合保证唯一性的方式是hashCode和equals
hashCode比较的是地址值，如果相同再比较内容
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,因为哈希值代表的是地址值，地址值具有唯一性，所以先判断地址在判断内容
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现 此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中 的键或有序集合中的元素，无需指定比较器。

Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序

我觉的Comparator用的多，因为比较灵活

---------------------吴齐宾-------------------------
1.List接口下都有哪些集合，他们各自有什么特点
1)Arraylist     增删慢，查找快
2)LinkedList  增删快,查找慢
3)Vector     不重要
2.Set接口下的集合是如何保证无序不可重复的
是通过改写HashCode和equals方法进行的.
3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写的话,这两个方法比较的都是地址值.,没有意义!
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,因为HashCode是在本地栈中进行的.可以加快运行速度.节省内存运算资源
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable比较死板.对于有很多元素的对像不能进行对比.
而Comparator是我们队Comparable的重写.可以根据具体的需求进行重写覆盖.
Comparator接口使用的比较多.因为适用范围广,能根据我们的重写方法对比很多的对像.

1.List接口下都有哪些集合，他们各自有什么特点？
ArrayList集合查找快，增删慢；
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法。
2.Set接口下的集合是如何保证无序不可重复的？
        调用被添加元素的hashCode()，和HashSet中已有元素的hashCode比较是否相同；
        如果不相同，直接存储；
        如果相同，调用equals方法比较是否相同；
        不相同，直接存储元素；
        相同，认为是同一元素.不存储。
3.我们为什么要重写HashCode( )和equals（）方法？
        方法默认比较的是两个对象的地址值，无意义，所有需要重新写。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
        先判断HashCode后判断equals，程序判断HashCode所需资源更少。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator是第三方，也就是比较器，不需要实现接口，灵活制定比较规则，除非遇到高频率排序的类否则只需要用Comparator即可。

余金龙

1答;List接口下有Arraylist集合，linkedlist集合
Arraylist集合是list接口的一个实现类，在Arraylist集合内部封装成一个长度可以变化的数组集合
linkedlist集合是实现List接口底层是一个链表结构，所以查询快，增删快
共同特点：1 允许存储重复的元素  2有索引值 3 是有序的集合
2.Set接口下的集合是如何保证无序不可重复的
答 通过计算HashCode实现的
3.我们为什么要重写HashCode( )和equals（）方法？
hashCode()方法是一个本地native方法，返回的是对象引用中存储的对象的内存地址，
而equals方法是利用==来比较的也是对象的内存地址。从上边我们可以看出，hashCode方法和equals方法是一致的。
再简单的翻译一下第二三点就是：hashCode()和equals()保持一致，如果equals方法返回true，那么两个对象的hasCode()返回值必须一样。如果equals方法返回false，hashcode可以不一样，但是这样不利于哈希表的性能，一般我们也不要这样做。重写equals()方法就必须重写hashCode()方法的原因也就显而易见
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答;先判断hashCode值 ，先确定地址是否相同在确定内容是否一样
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：Comparable：自己和别人（参数）比较，自己的需要实现Comparable接口，重写比较的规则comparaTo方法
Comparator：相当于找一个第三方裁判，比较两个重写的比较规则（叫外部比较器）
Comparator使用比较多，想要改变默认排序的时候或者压根没排序规则的时候都可以用Comparator

1.List接口下都有哪些集合，他们各自有什么特点
(1)Arrraylist集合和(2)LinkedList集合
(1)集合时用的最多的集合 是数组结构 查找快 增删慢
(2)集合是双向链表 增删快 查找慢 所以有一些操作首尾的方法

2.Set接口下的集合是如何保证无序不可重复的？
        调用被添加元素的hashCode()，和HashSet中已有元素的hashCode比较是否相同；
        如果不相同，直接存储；
        如果相同，调用equals方法比较是否相同；
        不相同，直接存储元素；
        相同，认为是同一元素.不存储。

3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法默认比较的是两个对象的地址值，无意义，所有需要重新写
HashCode( )方法，防止哈希碰撞情况发生
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值，因为哈希值判断完之后还会判断内容是否相等
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别在于一个已经定义好的，一个需要自己定义的，
如果没有特殊必要Comparable使用较多，
如非必要，基本不使用Comparator。

1.List接口下都有哪些集合，他们各自有什么特点ArraayList、LinkedList、Vector
ArraayList 查询快，增删慢
LinkedList 查询慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
先根据HashCode()方法计算对象的哈希值，根据哈希值计算对象的存储位置是否有对象存在，若不存在，则将该对象存入集合
若是存在，调用equals方法比较对象与存储位置的对象是否相等，若不相等，则将该对象存入集合，若是相等，舍弃该对象
3.我们为什么要重写HashCode()和equals()方法？
自定义的类，若不重写HashCode()方法，则在加入Set集合时，因为不同对象的哈希值不同，则无论对象是否相等都会被直接加入集合
重写equals方法是让系统在调用equals方法对比时，系统可根据equals重写的方法判别是否相等
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()方法
一、因为哈希值也作为地址值，在进行查询时，要先通过哈希值寻找对象才能进行比较，先比较哈希值再进行查询比较可以节省内存
二、因为哈希值不同，其必然为不同的对象，可直接加入。不需要再调用equals方法进行判别，节省资源
二、HashCode()比较的是Int数字，对比equals方法比较对象，更为简单直接
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用得更多
一、若需要重新修改比较方法，使用Comparator可以直接更改，Comparable不行二、Comparator可以通过匿名内部类直接写在主方法中，配合Lambda表达式，对比Comparable更为简洁

杨式贤