黑马程序员技术交流社区

标题: 【厦门JavaEE就业5期-每日总结】List、Set [打印本页]

作者: 厦门校区 时间: 2018-12-22 18:45
标题: 【厦门JavaEE就业5期-每日总结】List、Set
1.List接口下都有哪些集合，他们各自有什么特点
2.Set接口下的集合是如何保证无序不可重复的
3.我们为什么要重写HashCode( )和equals（）方法？
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

作者: 李灵杰 时间: 2018-12-22 19:32
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

LinkedList:集合数据存储的结构是链表结构。方便元素添加、删除的集合。

Vector:Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。Vector 是同步的，可用于多线程。

2.Set接口下的集合是如何保证无序不可重复的
底层的实现其实是一个 java.util.HashMap 支持

3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),如果hash code相同,就没有必要使用equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator
以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

作者: 赵烈刚 时间: 2018-12-22 19:39
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:是一个长度可变的数组,它用于遍历数据,查询快,增删慢;
LinkedList:是以链表结构的形式存放数据的,所以增删快,查询慢;
Vector:是数组的祖宗,无上限,较为安全,随着元素的增加Vector长度也会自动增加,后逐渐被ArrayList取代了。
2.Set接口下的集合是如何保证无序不可重复的
是因为Set接口下的add方法每次增加前都重写了元素的HashCode()方法和equals()方法;
3.我们为什么要重写HashCode( )和equals（）方法？
这样才能保证了元素的不可重复性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
HashCode的效率相对比equals方法要高,所以每次重写equals方法前先用HashCode方法给元素一个逻辑地址(虚拟地址),再拿这个逻辑地址去跟集合里面的元素进行比较,如果没有相同的哈希值元素就添加,如果发生哈希碰撞这个时候就需要使用equals方法进行内容比较,这样才保证了元素的不可重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的比较多,因为Comparator方法较为简单,还可以在方法内实现一些较为复杂的可以通用的逻辑,从而达到节省重复的步骤.
Comparator和Comparable的区别:
Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
Comparator：相当于找一个第三方的裁判，比较两个

作者: 陈彬 时间: 2018-12-22 19:43

1.List接口下都有哪些集合，他们各自有什么特点
      ArrayList 增删速度慢，但是查找速度快，应为 ArrayList 底层是用数组来实现的，增删时，每次都要创建新的数组所以增删速度慢，但是应为是使用的数组，而数组都是带索引的，并且空间是连续的所以查询的速度快。
      LinkedList 增删速度快，但是查找速度慢，LinkedList底层是用链表实现的，链表有三个属性，一个是本元素的地址，一个是元素，还有一个是下一个元素的地址。当需要增删只需要改变相应的地址就行了，但是查找时，每次都是重头开始找，所以查找元素的速度较慢。
2.Set接口下的集合是如何保证无序不可重复的
      Set接口下的集合底层是用的是哈希表来实现的，当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较，如果链表中没有相同的哈希值，那么就可以确定集合中是没有重复的元素的，会先把哈希值存储在数组中，并且把对应的元素使用链表的方法保存在对应的哈希值下，如果两个元素有相同的哈希值，那么则会调用equals（）方法进行比较是否相等，如果元素不相等，则会添加到对应的哈希值的链表下，当链表的个数超过8个时，会转换成红黑树,以增加查找的速度。
3.我们为什么要重写HashCode( )和equals（）方法？
   应为Object类中的HashCode( )方法获取的对象的地址值，equals（）方法比较的是地址的值，如果我们不进行重写HashCode( )和equals（）方法，那么并不能保证元素的唯一性；
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
      先判断HashCode()， Set接口下的集合底层是用的是哈希表来实现的，当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较，如果链表中没有相同的哈希值，那么就可以确定集合中是没有重复的元素的，会先把哈希值存储在数组中，并且把对应的元素使用链表的方法保存在对应的哈希值下，如果两个元素有对应的哈希值，那么则会调用equals（）方法进行比较是否相等，如果元素不相等，则会添加到对应的哈希值的链表下
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
   Comparable的是对使用同一类的所有对象进行排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。
   Comparator接口使用的较多， Comparable的是对使用同一类的所有对象进行排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。可以对使用同一类的对象按不同的规则进行排序。

作者: zhuyiming 时间: 2018-12-22 19:43

1.List接口下都有哪些集合，他们各自有什么特点
1.LinkedList 底层是一个链表数据结构查询慢,增删快
2.ArrayList 底层是一个数组数据结构查询快,增删慢
3.Vector 老数据结构,安全性高
2.Set接口下的集合是如何保证无序不可重复的
前提: 存储的元素必须重写hashCode方法和equals方法
1,先用 HashCode 方法进行比较,如果哈希值相同在使用 equals()方法可以对对象的内容进行判断
如果不同表示不重复, 如果相同表示重复
3.我们为什么要重写HashCode( )和equals（）方法？
保证元素唯一性的方式依赖于：hashCode与equals方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值,如果哈希值不同,没有必要去判断equals方法, 如果哈希值相同,在使用equals方法判断内容是否相同,所以 HashCode先判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器.

作者: lj478360767 时间: 2018-12-22 19:51
1.List接口下都有哪些集合，他们各自有什么特点List接口下有ArrayList,LinkedList
ArrayList的特点是底层是数组结构,查询速度快,增删速度慢;
LinkedList的特点是底层是链表结构,查询速度慢,增删速度快;

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合的无序说的是存取顺序不同,这是因为Set接口下的集合是通过哈希值来存放存储的元素,把每个元素存放在对应的哈希值位置处.
取出时安装特定的规则取出,去存储的顺序无关,这就实现了集合的无序性.
Set接口下的集合通过重写HashCode方法和equals方法来实现他的不可重复性;

3.我们为什么要重写HashCode( )和equals（）方法？
因为默认的HashCode()方法和equals()方法是比较地址值,无法根据元素的内容进行深一步的比较,无法保证存储元素的不可重复性,所以需要重写;

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
首先判断HashCode()方法,因为哈希值不同2个元素肯定不同,所以先获取哈希值进行判断,提高效率;
而当哈希值相同的情况下,两个元素的内容有可能不同,所以这时候还需要进行equals()判断.

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

Comparable是强行对实现它的每个类的对象进行整体排序,。这种排序被称为类的自然排序，类的compareTo方法
被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或
Arrays.sort），从而允许在排序顺序上实现精确控制

作者: Chidori 时间: 2018-12-22 20:05

1.List接口下都有哪些集合，他们各自有什么特点
List接口下的集合有：
ArrayList:底层由数组的数据结构组成，集合特点和数组相同，查询快，增删慢
LinkedList:底层由链表的数据结构组成，集合特点和链表相同，查询慢，增删快
Vector：老牌的集合，安全性高，但是存储速度底下，已被ArrayList取代
2.Set接口下的集合是如何保证无序不可重复的
不可重复是依靠Set接口重写了继承自Object类中的HashCode方法和equals方法，先用hashcode方法判断哈希值是否相同，如果相同再用equals方法判断内容是否相同，如果相同，则放于储存在数组中的相同哈希值槽下
Set接口下的HashSet无序是因为它是单向链表，只有一条链子，不能保证存取时元素顺序相同
3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写这两个方法，则Set接口下的集合无法做到存储的元素不相同
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode再判断equals,因为equals方法是可以对对象内容进行判断的，但是效率低下！！！为了对equals方法进行优化，引入了HashCode方法和哈希值
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
使用Comparable接口必须先实现 Comparable接口才能使用compareTo方法也就是说要在不同类中使用，所以不能经常修改代码实现自己想要的顺序
而Comparator接口可以直接在同一个类中使用sort方法实现，使用匿名内部类直接对代码进行修改，就可以达到自己想要的目的

作者: 黄毅 时间: 2018-12-22 20:09
1.List接口下都有哪些集合，他们各自有什么特点ArrayList：有序，有索引，数据可重复，查询速度快，增删速度慢
LinkedList：有序，有索引，数据可重复，查询速度慢，增删速度快
2.Set接口下的集合是如何保证无序不可重复的
重写hashCode方法和equals方法；当存储数据时，先计算对应元素的哈希值，然后先通过哈希值进行比较，如果链表中没有相同的哈希值，会先把哈希值存储在数组中，并且把对应的元素使用链表的方法保存在对应的哈希值下，如果两个元素有相同的哈希值，那么则会调用equals（）方法进行比较是否相等，如果元素不相等，则会添加到对应的哈希值的链表下
3.我们为什么要重写HashCode( )和equals（）方法？保证元素的唯一性
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接口使用的较多， Comparable的是对使用同一类的所有对象进行排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。可以对使用同一类的对象按不同的规则进行排序。

作者: 吴少华 时间: 2018-12-22 20:13
1.List接口下都有哪些集合，他们各自有什么特点
①Arraylist ，查找速度快，增删慢，底层是数组实现的
②Linkedlist ，增删快，查找慢，底层链表实现
③vector
2.Set接口下的集合是如何保证无序不可重复的
通过对象的hashcode方法和equals方法来保证数据唯一，无序是根据某种规则的顺序存入的无序。
3.我们为什么要重写HashCode( )和equals（）方法？
通过重写hashcode方法和equals方法，给予数据一个十进制的模拟哈希值，当存入数据时，判断初始空间是有这个数据的模拟哈希值，没有就把哈希值存入空间，把数据挂在哈希值下面，如果有，且相同就判断数据内容是否相同，相同就不存储，不同就存储数据在这个哈希值的最下面。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为set集合存储空间是存储的数据给予的一个十进制的模拟哈希值，哈希值下面挂着数据，哈希值不同数据肯定不同，哈希值相同在判断数据内容是否相同，相同就不存储，不同就存储数据在这个哈希值的最下面。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是定义在类里，是对类的每个对象的自然排序，Comparator是定义在方法里的某个对象按照自己的规则排序，
Comparator的使用较多。
因为Comparable是定义在类里，是对类的每个对象都要进行排序，耦合性太高，浪费内存。
因此要进行Comparator的解耦，且Comparator可以一定程度上进行自定义排序，灵活性较高

作者: 周章强 时间: 2018-12-22 20:31

1.List接口下都有哪些集合，他们各自有什么特点

（1）arraylist，特点:底层结构是数组实现，查找速度快，增删速度慢。
（2）linkedlist，特点：底层是链表实现，增删速度快，查找速度慢。
（3）vector，特点：jdk早期使用的结构，安全型更高，效率低。

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

通过使用哈希表结构（数组+链表+红黑树）来实现的。
（1）首先要添加的元素的哈希值找到对应的数组位置，若哈希值对应的位置上没有元素直接添加。
（2）若已经有元素类，再通过equals判断元素是否重复，不重复才添加。

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

为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；
equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为哈希值不同的元素一定不相同。哈希值相同了才有必要继续通过equals（）比较。
这样可以减少运算量。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别：
Comparable：是对同一类下的所有对象进行排序： Comparator：是对单一对象进行排序。

Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。

作者: 陈佳鹏 时间: 2018-12-22 21:04
1.list接口下有ArrayList集合、LinkedList集合和Vector集合，ArrayList集合数据结构是数组，具有数组查询快，增删慢的特点；LinkedList集合数据结构为链表结构，增删快，查询慢；Vector具有安全单线程的特点。
2.Set接口下的集合存储数据结构用的是哈希表，存储数据时，数据先根据哈希值找到内存中的存储位置，当哈希值相同时，会进行equals方法的判断数据内容是否一致，不一致才会以链表结构存储在哈希值对应的位置下。取元素时是根据Set接口自定义的规则，所以无序。
3.HashCode( )获取的是对象地址值，equals（）方法比较的是对象地址值，没有意义，需要通过重写，获得内容哈希值，和内容的比较的方法。
4.先判断HashCode()方法，因为equals()方法效率差，浪费计算机资源，先通过HashCode( )方法比较则可以大大提高效率。
5.Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序

作者: 苏志祥 时间: 2018-12-22 21:18

1.List接口下都有哪些集合，他们各自有什么特点
List接口下有ArrayList<E>：底层是数组构造方法，具有查询速度快（有索引），增删速度慢（增删需要创建新的数组）的特点；
,LinkedList,底层是链表构造，具有增删速度快（链表有数据域跟指针域），查询慢（需要从头开始查找）的特点。
还有Vector：Vector与ArrayList一样是基于数组结构的List集合，但是该集合效率低，线程安全。

2.Set接口下的集合是如何保证无序不可重复的
set接口的底层是数组+链表+红黑树构成的，通过调用HashCode来确定对象的哈希值，如果哈希值没有重复，直接存入集合，如果哈希值发生哈希冲突，就调用equals确定内容是否一致；确保集合存入的元素是唯一的。

3.我们为什么要重写HashCode( )和equals（）方法？
为了确保set集合数据的不重复性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode 在判断equals,equals的内存消耗比较大，先判断地址值可以提高效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的机会比较广泛，Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结果的顺序，或者为那些没有自然顺序的对象collection提供排序。
Comparable 定义在类中，不能随意更改，使用不便。

作者: 续扬 时间: 2018-12-22 21:18
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：查询慢增删快，底层是数据结构
LinkedList：底层是链表结构，查询快增删慢；包含大量收尾操作；不能使用多态
Vector：一种稳定的集合，操作复杂被淘汰

2.Set接口下的集合是如何保证无序不可重复的
在存储前必须重写hashCode与equals方法，从地址值到内容双重确保不会出现重复内容

3.我们为什么要重写HashCode( )和equals（）方法？
因为默认的两种方法只是比较地址值，不能确定内容一致性

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为存入时先计算哈希值哈希值不同元素肯定不同，相同后再使用equals进一步判断

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable用自己和别人比较需要自己实现Comparable接口，重写比较规则方法，可以自动比较
Comparator是一个专用的比较器，当对象不支持自动比较时，写一个专用的比较起来判断大小，使用的较多

作者: 杨鑫棋 时间: 2018-12-22 21:19
1.List接口下都有哪些集合，他们各自有什么特点

ArrayList集合、LinkedList集合、Vector集合。

ArrayList集合：底层是一个数组的数据存储结构。由于数组的数据结构有索引值，所以对元素的查询快，但增删慢。
LinkedList集合：LinkedList底层是一个链表结构的数据结构类型，链表结构的特点是方便增删元素，可以直接通过地址值进行这一操作，但由于每次查询都要重头开始，所以查询慢。
Vector集合：安全性比较高。

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

通过重写hashCode方法和equals方法，在比较equals方法之前，先判断哈希值，通过重写的hashCode生成一串哈希值，如果哈希值不同，则直接存集合，如果哈希值相同，但内容不同，产生哈希值相同，就要进行equals比较。

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

因为默认的HashCode方法和equals方法比较的是地址值，而我们需要比较的是内容，所以需要对这兰格方法进行重写。

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

先判断HashCode（）。因为如果两个元素的哈希值不同，那这肯定是两个不同的元素，如果哈希值相同，再进行equals的判断。

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

Comparable：是强行对实现它的每个类的对象进行整体排序。是自然排序，compareTo方法是其比较方法，只能在类中实现一次且不能经常修改类的代码实现自己想要的排序。
Comparator：强行对某个对象进行整体排序，可以通过重写compare方法自定义排序方式。

作者: 黄海兵 时间: 2018-12-22 21:23
1：ArrayList底层是数组结构，增删慢，查询快。
LinkedList底层是链表结构，增删快，查询慢。
Vector线程安全效率低
2：无序是因为Set接口下的集合是通过哈希值来存放元素，把每个元素放在对应的哈希值位置。取出元素与存储的顺序无关，这就实现了集合的无序性。然后通过重写HashCode方法和equals方法实现不可重复
3：保证元素的唯一性
4：先判断HashCode（），因为存储数据时，先计算对应元素的哈希值，然后在通过哈希值进行比较，当哈希值相同的情况下两个元素的内容有可能不同，所以这时候还需要equals（）判断
5：Comparator接口使用的较多，Comparable是对使用同一类的所有对象进行排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。

作者: 许晓明 时间: 2018-12-22 21:26
1.List接口下都有哪些集合，他们各自有什么特点
答：List下有3种集合，分别是ArrayList类，LinkedList类，Vector类
ArrayList集合的特点为：因为底层是数组结构，所以查找快，增删慢
LinkedList集合的特点为：因为底层为链表结构，所以查找慢，增删快
Vector集合的特点：因为是单线程的集合，所以储存数据安全，但是效率低

2.Set接口下的集合是如何保证无序不可重复的
答：首先，Set接口下的集合储存的元素必须是重写equals方法和HashCode方法的。
在一开始进行储存元素之前，会对元素进行判断，先使用HashCode方法得到的哈希值去遍历集合，看是否有一样哈希值，如果没有的话，将元素直接存入集合；
如果哈希值存在一样的，则调用equals方法，把将存入的元素与集合中哈希值一样位置的元素进行对比，如果相同则不存入，如果不同则将元素存入集合；

3.我们为什么要重写HashCode( )和equals（）方法？
答：如果不重写HashCode()和equals()方法,HashCode方法给出的是系统随机给出的哈希值，equals方法判断的是两个对象的哈希值，则在判断元素是否相同时，因为创建对象给的哈希值都是唯一的，就算内容相同的元素一直都是判定为不相同的，则Set的实现类集合会存入重复的元素。因此需要重写HashCode和equals方法，让内容一样的元素判定为重复的，才能不存入Set接口的实现类集合中。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode。因为Set集合在储存元素时，会先判断元素的哈希值在集合中是否存在，因此要先执行HashCode()，当哈希值不一样时，就可以直接存入集合中，当哈希值一样时，在进行equals方法，判定元素的内容是否一样。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：comparable接口是在类中使用的，实现的效果是对实现该接口的类的每个对象进行自然排序，其中重写compareTo方法，就可以让类的每个对象按照所重写的方法规则排序。
comparator接口可以对单一对象实现按照某种规则排序。
comparator接口使用的比较多，因为comparable接口是对类所有的对象进行排序，而comparator接口只对单一对象排序，对于同一个类中的对象，可以使用不同中的排序规则。

作者: 吴洪标 时间: 2018-12-22 21:29
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是数组，因此元素增删慢，查找快；
LinkedList：底层的结构是链表结构，因此元素查找慢，增删快。

2.Set接口下的集合是如何保证无序不可重复的
当向set接口下的集合添加元素时，编译器会计算该元素的hashcode，按照hash值找到元素存储的内存区域，这样元素的存储就是无序的；同时，如果该元素的hash和集合内的某个元素一样，则调用equals方法对这两个元素进行比较，如果一致则不把该元素加入到集合中，这样就保证了元素不重复。

3.我们为什么要重写HashCode( )和equals（）方法？
Object类中的HashCode()方法返回的是元素的逻辑地址值，而我们希望用HashCode()对元素内容进行计算，以此来决定存储位置并进行初步判断元素的重复性；当待添加的元素和集合中的某个元素的hash值一样时，再调用方法equals()进行元素内容的比较，因此要重写equals()方法，否则比较的是地址值。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，其一是因为要根据hash值找到对应的存储位置，其二是因为hash冲突的概率很低，用hash值判断已经能区分大部分的元素，当hash值一样时再调用equals()方法，这样能提高程序运行效率。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator接口使用更多。因为Comparable接口的实现类中只能实现compareTo()一次，不能经常修改类的代码实现自己想要的排序；而Comparator接口可以以匿名内部类的方式使用，从而允许在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序，在灵活性上优于Comparable接口。

作者: 董志超Eric 时间: 2018-12-22 21:30
1.List接口下都有哪些集合，他们各自有什么特点
答：Arraylist类底层是数组查询快，增删慢

LinkedList类底层是链表增删块，查询慢

vactor类底层是数组是最早的单列集合，出现在jdk1.0版本里面，功能被Arraylist逐渐代替。

2.Set接口下的集合是如何保证无序不可重复的
答：通过重写了HashCode（）和equals（）方法，保证了集合的不可重复。而Set接口下的HashSet的底层是哈希表结构（数组+链表/红黑树）是无序的。
LinkedHashSet的底层是哈希表和链表的结构，多了条链表是为了记录元素顺序，所以是有序的。

3.我们为什么要重写HashCode( )和equals（）方法？
答：重写HashCode( )和equals（）方法是为了在Set集合中存入的元素唯一。在自定义的类中如果不重写这两个方法的话，会使用Object类的方法，HashCode
（）方法是操作系统随机给出的，而且equals（）方法比较的是地址值，所以不能保证set集合存入的元素是否唯一。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：是先判断HashCode()方法，因为如果HashCode（）相同的话一定是不同的元素，如果相同的话，才进行equals方法的比较。
如果先进行equals（）方法的比较，需要待存的元素和集合已有的元素一一比较，比较消耗内存（工作量太大）。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator这个借口用的比较多，是在对象中单独定义一个排序方法，重写compare（）方法。这样更加方便在各个对象中定义不同的排序规则。
而Comparable接口的使用需要自定义的类实现该接口，同时这个实现了Comparable接口的类，排序方式也相当于固定了，在其他地方使用时，也是这种排序方式。灵活性差，方法和类的耦合性太高，不方便使用。

作者: 刘荣城 时间: 2018-12-22 21:31
1.List接口下都有哪些集合，他们各自有什么特点
ArrarList:底层是数组构造，查询快，增删慢。
LinkedList：底层是链表结构，查询慢，增删快。
Vecter ：底层也是数组构造，线性安全。但没有比ArrayList方便。
这三种集合都也实现了List接口的特性，有序，有索引，可重复。

2.Set接口下的集合是如何保证无序不可重复的
Set接口下有一个HashSet集合，他无序，无索引，元素不可重复。
HashSet集合添加元素的时候要重写hashCode 和equals。
3.我们为什么要重写HashCode( )和equals（）方法？
HashSet（）不能有重复的元素，重写HashCose（）比较集合里对象的哈希值，如果不重写比较的是地址值，重写equals（）是为的比较集合里对象的内容。才能保证HashSet（）里没有重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
要先判断HashSet（），比较哈希值是否相同，如果相同而内容不同就存放在链表下面，当链表存到8个以上就会该存在红黑树。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自然排序。
Comparator是可以某个对象的内容进行排序。

作者: 林文悦 时间: 2018-12-22 21:39
1.List接口下都有哪些集合，他们各自有什么特点

ArrayList集合：增删慢；查询快；因为底层的数据结构是数组。

LinkedList集合：增删快；查询慢；因为底层的数据结构是链表。

vator集合：可以理解为老版ArrayList

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

Set接口下的集合底层是用的是哈希表来实现的，通过重写hashCode方法对元素对应的哈希值进行比较，如果哈希值不同，则为不同元素，如果相同，则再用重写的equals方法对元素进行判断，如果相等那么该元素为重复元素不添加，如果不相等则添加该元素。元素根据哈希值去找到元素存储的位置，因为元素的哈希值不一样，所以并没有按规律存的。

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

如果不重写HashCode( )和equals（）方法，那么比较的就是对象的地址值，每个new出来的对象地址值不一样，那么比较没啥意义。

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

先判断HashCode()因为要根据哈希值找到对应的存储位置，这样可以区分大多数元素了，因为冲突的相对比较少，然后当发生冲突时再判断equals（），这样可以提高操作效率。

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

Comparator接口使用更多。因为Comparable接口的实现类中只能实现compareTo()一次，不能经常修改类的代码实现自己想要的排序；而Comparator接口可以以匿名内部类的方式使用，从而允许在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序，在灵活性上优于Comparable接口

作者: 黄嘉宏 时间: 2018-12-22 21:39

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合和LinkedList集合，ArrayList集合查找快，增删慢，存储的结构是数组结构。LinkedList集合存储的是链表式结构，方便元素添加，删除。
2.Set接口下的集合是如何保证无序不可重复的？
依赖于hashcode方法和equals方法实现不可重复，先判断对象的哈希值是否相同，再判断对象内容是否相同。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证集合中元素唯一，如果集合中存入的是自定义的对象，那么久必须重写HashCode()和equals()方法建立属于当前对象的比较方式。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，才能知道此位置是否为空，元素存在后才能进行对比。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable强行对实现它的每个类的对象进行整体排序。
Comparator强行对某个对象进行整体排序。
Comparator接口使用的多，因为比较灵活，在排序上可以精确控制。

作者: 赖熙蒙 时间: 2018-12-22 21:40
本帖最后由赖熙蒙于 2018-12-22 21:41 编辑

1.List接口下都有哪些集合，他们各自有什么特点

答：ArrayList：ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快。
LinkedList：LinkedList集合数据存储的结构是链表结构。元素增删快，查找慢。

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

答：HashSet集合根据对象的哈希值来确定元素在集合中的存储位置，通过调用hashCode和equals方法来保证集合无序不可重复。

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

答：给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。

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

答：先判断HashCode()再判断equals()。因为Set集合中，哈希值不相同内容就一定不相同，能够提高判断的效率，而内容不相同哈希值有可能相同。先判断哈希值是否相同，如果不相同就直接放入集合，如果相同就继续判断内容是否相同。

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

答：Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
Comparator接口强行对某个对象进行整体排序。Comparator接口用的比较多，因为Comparator接口相对比较灵活，可以将Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构的顺序，或者为那些没有自然顺序的对象collection提供排序。

作者: Java中的莫Q哇啦 时间: 2018-12-22 21:42
1.List接口下都有哪些集合，他们各自有什么特点？

List接口下面有三个主要的实现类集合，分别是我们常用的Arraylist集合，LinkedList集合，还有一个元老级的集合Vector集合。其中，Arraylist集合底层源码是数组，所以它查询快，增删慢；LinkedList集合底层源码是链表结构，所以它增删快，查询慢；Vector集合底层源码是数组和单线程，与ArrayList类似，所以这个集合删减也是比较慢。

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

Set接口是通过哈希表来确保的，准确的说其实就是根据对象的hashCode和equals方法来判定的，每个元素都有固定的哈希值，哈希值不同的对象一定不相同，哈希值相同的对象不一定相同，所以要再根据equals方法来判定。

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

用来确保集合里面没有重复的元素，以及优化性能。因为每个元素都有固定的哈希值，哈希值不同的对象一定不相同，哈希值相同的对象不一定相同，所以要再根据equals方法来判定。其中因为equals方法太消耗系统性能，因此引进HashCode方法来为系统进行大部分的优化。

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

先判断HashCode()，因为HashCode()方法比equals（）方法更不消耗内存，而且哈希值不同的对象一定不相同，哈希值相同的对象不一定相同，所以先判断HashCode()方法。

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

Comparable接口需要在参数类里面进行重写方可使用，因为它是通过this和参数进行对比比较的。Comparator接口可以使用匿名类直接创建重写方法，它是通过相当于第三方中介来为参照物进行比较的，即匿名重写两个变量进行比较为规则。

Comparator用的比较多，因为Comparator可以直接在编码过程中创建匿名对象来新增排序规则，相对于Comparable接口要先对参数类进行实现接口再重写方法更方便。

============================================huangcc黄成成

作者: Java中的莫Q哇啦 时间: 2018-12-22 21:43
1.List接口下都有哪些集合，他们各自有什么特点？

List接口下面有三个主要的实现类集合，分别是我们常用的Arraylist集合，LinkedList集合，还有一个元老级的集合Vector集合。其中，Arraylist集合底层源码是数组，所以它查询快，增删慢；LinkedList集合底层源码是链表结构，所以它增删快，查询慢；Vector集合底层源码是数组和单线程，与ArrayList类似，所以这个集合删减也是比较慢。

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

Set接口是通过哈希表来确保的，准确的说其实就是根据对象的hashCode和equals方法来判定的，每个元素都有固定的哈希值，哈希值不同的对象一定不相同，哈希值相同的对象不一定相同，所以要再根据equals方法来判定。

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

用来确保集合里面没有重复的元素，以及优化性能。因为每个元素都有固定的哈希值，哈希值不同的对象一定不相同，哈希值相同的对象不一定相同，所以要再根据equals方法来判定。其中因为equals方法太消耗系统性能，因此引进HashCode方法来为系统进行大部分的优化。

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

先判断HashCode()，因为HashCode()方法比equals（）方法更不消耗内存，而且哈希值不同的对象一定不相同，哈希值相同的对象不一定相同，所以先判断HashCode()方法。

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

Comparable接口需要在参数类里面进行重写方可使用，因为它是通过this和参数进行对比比较的。Comparator接口可以使用匿名类直接创建重写方法，它是通过相当于第三方中介来为参照物进行比较的，即匿名重写两个变量进行比较为规则。

Comparator用的比较多，因为Comparator可以直接在编码过程中创建匿名对象来新增排序规则，相对于Comparable接口要先对参数类进行实现接口再重写方法更方便。

===============================黄成成

作者: 苏阿合 时间: 2018-12-22 21:45
1.List接口下都有哪些集合，他们各自有什么特点
List接口下都有ArrayList集合，LinedList集合，Vector集合。三个集合共同特点：1、元素有序，元素存入和取出顺序一致。2、有索引，内部包含了一些可以通过索引操作元素的方法。3、可存储重复的元素的。三个集合各自特点：ArrayList集合：多线程，底层是采用数组结构，数组有索引，所以查询快；数组长度不可变，所以增删慢。LinedList集合：多线程，底层采用双向链表结构，上个节点记录下个节点的地址值，增删元素对集合整体无影响，所以增删快，查询时每次都得从首地址开始查，所以查询慢。Vector集合：是单线程，所以线程安全，效率低。

2.Set接口下的集合是如何保证无序不可重复的。
Set接口底层是HashMap，采用哈希表方式进行存储元素，所有在存储元素会进行HashCode( )和equals（）方法判断元素是否相同，先比较元素内容的Hash值是否不同，则存入元素，如果相同，则进一步进行equals（）方法比较内容是否相同，相同则不存，不同则存储元素。所有Set接口下的集合元素都是无序不可重复的。

3.我们为什么要重写HashCode( )和equals（）方法？
我们要保证HashSet和LinkedHashSet集合中元素的唯一性，所以要重写HashCode( )和equals（）方法，让存储集合元素进行内容的比较，如果元素内容相同则不存，保证集合中的元素唯一，不重复。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据在存入时，是先将重写的HashCode()进行比较，因为equals（）方法比较效率低，重写的HashCode()比较可以初步对元素的内容的Hash值进行比较，如果hash值不同则存储进行，如果相同则再用重写的equals（）方法进一步比较判断内容是否相同。这样可以提高比较效率。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable和Comparator区别：Comparable接口是对实现它的每个类对象按自定义的排序方式进行整体排序。Comparator
接口是对实现它的某个对象进行按自定义的排序方式进行整体排序。Comparator接口使用的多，Comparable的耦合性高，我们在使用的要遵循低耦合，高内聚，使用一般使用耦合性低的Comparator相对多点。

作者: 骆颖权 时间: 2018-12-22 21:48

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList的特点：底层是数组结构,查询速度快,增删速度慢;
LinkedList的特点：底层是链表结构,查询速度慢,增删速度快;

2.Set接口下的集合是如何保证无序不可重复的
   当向set接口下的集合添加元素时，编译器会计算该元素的hashcode，按照hash值找到元素存储的内存区域，这样元素的存储就是无序的；同时，如果该元素的hash和集合内的某个元素一样，则调用equals方法对这两个元素进行比较，如果一致则不把该元素加入到集合中，这样就保证了元素不重复。

3.我们为什么要重写HashCode( )和equals（）方法？
      因为默认的HashCode()方法和equals()方法是比较地址值,无法根据元素的内容进行深一步的比较,无法保证存储元素的不可重复性,。为了保证数据的唯一性，需要重写HashCode( )和equals（）方法。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
   首先判断HashCode()方法,因为哈希值不同2个元素肯定不同,所以先获取哈希值进行判断。
而当哈希值相同的情况下,两个元素的内容有可能不同,所以这时候还需要进行equals()判断.

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的比较多。
   虽然用Comparable 简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,
但是需要修改源代码, 而用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义
的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 并且在Comparator 里面用户可以自
己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。

作者: 陈基林 时间: 2018-12-22 22:00
1.List接口下都有哪些集合，他们各自有什么特点List接口下有ArrayList、LinkedList、Vector等集合。ArrayList集合的因为是数组结构所以查询快增删慢；LinkedList集合的因为是链表结构所以增删快查询慢；而Vector因为集合因为执行效率低被ArrayList取代但是相对性的它的安全性更高。
2.Set接口下的集合是如何保证无序不可重复的
是通过底层哈希表来实现的，当有数据存储时，会调用hashCode（）方法去判断集合里面是否已经有了相同哈希值的元素，如果没有，就认为这个元素是没有重复的直接存储进来到对应的哈希值下面的链表中，如果有相同的哈希值元素，这时调用equals方法去比较两个元素的内容是否一致，一致的话就认为是同一元素不进行存储，否则就将该元素存储进相同的哈希值链表下，若某条链表元素达到8个之后该链表就会转换成红黑树，以提高元素查询效率。
3.我们为什么要重写HashCode( )和equals（）方法？
因为Object类中的这两个方法比较的都是对象的地址值，这样的比较在想要实现比较属性内容的时候没有意义，需要通过重写这两个方法来达到自己想要实现的功能。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
会先判断HashCode（）；因为set底层是通过哈希表来实现的，通过先判断哈希值是否相等再判断equals方法是否相等的方式去判断是否是相同元素。先判断哈希值再通过equals判断也能提高代码执行效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？

Comparable是对一个类中的所有对象进行默认排序，使用自己跟参数进行比较，也可以通过实现接口去重写方法进行自定义排序；Comparator是对其中一个对象进行比较，就像找了一个裁判去判定双方，也能自定义判断的方式；使用更多的是Comparator方法，因为Comparable的耦合度太高，在用的时候限制相对更大。

作者: 陈益源 时间: 2018-12-22 23:44
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层是数组，查询快，增删慢
LinkedList:底层是链表，查询慢，增删快；首尾查询快，有许多与首尾相关的方法
Vector: 安全性高；时间比较久，逐渐被ArrayList取代

2.Set接口下的集合是如何保证无序不可重复的
无序：存储时通过不同的哈希值进行对应的保存，在取出时是按照特定的规则取出
不重复：
（1）首先，equals（）方法可以对对象内容进行比较，但是效率低下；
（2）可以通过HashCode方法和哈希值对equals（）方法进行优化；
（3）在调用equals（）方法前，先判断哈希值，通过重写HashCode方法获得根据对象内容生成的一串哈希值；
（4）如果哈希值不相等，那么这两个对象的内容肯定不同，直接添加到集合中；
如果哈希值相等，那么这两个对象的内容有可能不同，调用equals()方法对这两个对象的内容进行比较，如比较结果不同，将此内容添加到同一个哈希值下的槽中

3.我们为什么要重写HashCode( )和equals（）方法？
因为要确保set集合存储不重复的元素的前提，就是要重写HashCode( )和equals（）方法，Object中的HashCode( )方法默认获取的是模拟的地址值，我们需要重写HashCode( )方法，让其根据对象的内容生产一串哈希值，再比较哈希值，快速判断两个对象的内容是否相同，如哈希值相同，就需要调用equals（）方法，而equals（）方法默认比较的是地址值，需要重写才能让其比较属性内容，最终达到存储元素不重复的效果。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode( )，因为如果使用equals（）方法，效率低下，对此引入了HashCode( )、哈希值进行优化，通过先判断两个元素的哈希值可以提高运行效率

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：排序的规则在类中已经规定完成，不能及时根据自身需求更改排序规则；调用是比较简单，可以通过Collections.sort进行排序
Comparator：可以在调用时根据自身需求更改排序规则；调用时格式相对复杂，需要指定比较器
Comparator接口用得多，因为Comparato在排序顺序上实现精确控制，还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

作者: 李柏刚 时间: 2018-12-23 00:14
1.List接口下都有哪些集合，他们各自有什么特点今天学到的List接口下的集合有3种。Arraylist集合，LinkedList集合，Vector集合；Array list是最常用的，但底层使用的是数组的原理，有索引所以查询快，增删元素时需要复制元素到新集合，所以增删慢。LinkedList集合是双向链表的结构，查询需要从头逐个获取元素，所以查询慢，但是增删快，而且包括了很多增删头尾元素的方法，需要频繁添加删除元素操作的可以使用这个类型的集合。Vector集合是相对比较古老的集合，比较少用，安全性比较高。

2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合底层原理是使用的哈希表进行存储元素的，哈希表的构造原理由：数组,链条,红黑树组成，所以元素的储存是无序的。当在添加新元素的时候，会先使用hashCode判断元素的哈希值是否相同，不同的情况下将元素直接添加到横向的数组单元格中，当对象的哈希值一样的情况下再使用equals方法对比元素属性是否都一致，只有在不相同的情况下才会将元素添加到竖列的链表中成功，并且在竖列链表数量超过8个的时候，会自动转换为红黑树来存储，保证了更快的查询速度，所以它是不可重复的。

3.我们为什么要重写HashCode( )和equals（）方法？
在没重写默认的情况下，我们只能够判断两个对象或集合的地址值是否相同，并不能满足于判断属性是否也都相同，并且当在向HashSet集合添加元素的时候也需要通过HashCode方法去判断哈希值是否相同，不同才添加，哈希值相同的情况下，再使用equals方法比较属性是否相同，不同才能完成添加，这些功能的实现都需要我们去重写自定义Hash Code和equals方法。

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断的HashCode，再判断equals。先使用Hash Code来比较地址值是否相同，因为地址值不同的情况下，元素的属性必然不同，就无需再判断equals，即可将元素添加到集合中，更加快速高效。

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

Comparable是通过对compareTo方法进行重写，可以对它所有的实现类提供制定好的一套排序规则，当很多集合或对象的时候有固定的排序规则就可以使用这个接口，一次定义，全部受用。
Comparator可以给单独的对象或集合，定义专属于它的一套排序规则，当元素没有什么自然顺序的情况下，会更多的使用这个方法，自定义排序规则，多重排序规则。
根据自己的使用需求，一般Comparator会使用得更多一些，毕竟它可以对不同对象实现不同的自定义排序规则，更加灵活。

作者: Wujainwei 时间: 2018-12-23 10:48

1.List接口下都有哪些集合，他们各自有什么特点
1.LinkedList 底层是一个链表数据结构查询慢,增删快
2.ArrayList 底层是一个数组数据结构查询快,增删慢
3.Vector 老数据结构,安全性高
2.Set接口下的集合是如何保证无序不可重复的
前提: 存储的元素必须重写hashCode方法和equals方法
1,先用 HashCode 方法进行比较,如果哈希值相同在使用 equals()方法可以对对象的内容进行判断
如果不同表示不重复, 如果相同表示重复
3.我们为什么要重写HashCode( )和equals（）方法？
保证元素唯一性的方式依赖于：hashCode与equals方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值,如果哈希值不同,没有必要去判断equals方法, 如果哈希值相同,在使用equals方法判断内容是否相同,所以 HashCode先判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器.

作者: 王宇鹏 时间: 2018-12-23 21:07
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList/vector(线程安全)===>底层是数组,查询快,增删慢
LinkedList===>底层是链表,查询慢,增删快

2.Set接口下的集合是如何保证无序不可重复的
通过重写hashCode方法和equals方法，在比较equals方法之前，先判断哈希值，通过重写的hashCode生成一串哈希值，如果哈希值不同，则直接存集合，如果哈希值相同，但内容不同，产生哈希值相同，就要进行equals比较。

3.我们为什么要重写HashCode( )和equals（）方法？
保证了元素的不可重复性

4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
要先判断HashSet（），比较哈希值是否相同，如果相同而内容不同就存放在链表下面，当链表存到8个以上就会该存在红黑树。

5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator接口使用多。因为comparable接口是对类所有的对象进行排序，而comparator接口只对单一对象排序，对于同一个类中的对象，可以使用不同中的排序规则。

作者: 李嘉福 时间: 2018-12-23 21:40

1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是数组，元素增删慢，查询快；
LinkedList：底层的结构是链表结构，元素查询慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
无序：存储时通过不同的哈希值进行对应的保存，在取出时是按照特定的规则取出
不重复：
（1）首先，equals（）方法可以对对象内容进行比较，但是效率低下；
（2）可以通过HashCode方法和哈希值对equals（）方法进行优化；
（3）在调用equals（）方法前，先判断哈希值，通过重写HashCode方法获得根据对象内容生成的一串哈希值；
（4）如果哈希值不相等，那么这两个对象的内容肯定不同，直接添加到集合中；
如果哈希值相等，那么这两个对象的内容有可能不同，调用equals()方法对这两个对象的内容进行比较，如比较结果不同，将此内容添加到同一个哈希值下的槽中
3.我们为什么要重写HashCode( )和equals（）方法？
因为默认的HashCode()方法和equals()方法是比较地址值,无法根据元素的内容进行深一步的比较,无法保证存储元素的不可重复性,所以需要重写
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode再判断equals,因为equals方法是可以对对象内容进行判断的，但是效率低下.
为了对equals方法进行优化，引入了HashCode方法和哈希值
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是定义在类里，是对类的每个对象的自然排序;
Comparator是定义在方法里的某个对象按照自己的规则排序，
Comparator的使用较多。
因为Comparable是定义在类里，是对类的每个对象都要进行排序，耦合性太高，浪费内存。
因此要进行Comparator的解耦，且Comparator可以一定程度上进行自定义排序，灵活性较高

作者: ab8846254 时间: 2018-12-24 11:50

1.List接口下都有哪些集合，他们各自有什么特点
答：1.ArrayList，特点：有序，有索引，可重复，底层是用数组实现的，所以具有索引，并且由于底层是数组结构，          有索引所以具有查询快的特点，遍历集合的话可以用迭代器，也可以用普通for循环
   2.LinkedList集合，特点：查询慢，增删快，可重复，有索引，底层使用的链表形式，前一个数据记住后一个数据的地址值，第二个数据记住第三个数据的地址       值，以此形成一个链条的形式，若需要增删元素的话只需要断掉之前的地址值，把前一个元素的地址值赋值给新加的地址值新加的元素地址值记住后面数据的          地址值就好了，若查询的话因为没有索引，需要重头开始挨个比较所以慢。
， 3.Vector集合：比较古老的集合，在jdk1.0就有了，目前已经被ArrayList取代，基本不用了2.Set接口下的集合是如何保证无序不可重复的
   答：1.因为Set接口下的集合添加元素的时候都会给元素生成一个哈希值，添加的时候底层代码会自动比较哈希值是否一致，若哈希值一致还会调用equlas方                   法，比较内容，若内容也一致则会返回false元素将添加不进去，反之则可以添加进去，若存储自定义应用类型，需要重写hashCode和equals方法。

3.我们为什么要重写HashCode( )和equals（）方法？
   答：1.重写HashCode( )和equals（）方法主要是作用是为了去重。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：1.数据存放进Set集合的时候先会生成一个哈希值，会先调用哈希值来比较集合中是否有相似的哈希值，若有相似的才会调用equals比较内容，因为有存在哈希值一样但是内容不一样的情况，先执行HashCode( )比较哈希值的原因是，如果哈希值都不一样了那数据肯定不一样，直接可以添加进集合，所以不用再次调用equals比较了，节省性能，貌似百度云的秒传功能就是用的类似的方法，我个人理解在百度云数据库里面我们每次上传的一些资源都会由百度的高深算法自动生成一段类似/或者干脆就是哈希值或者MD5值的一段数字，然后后期又有人上传的时候，在上传那一刻百度就会拿到这个文件的名称和这个文件的体积还有文件的一些其他信息根据相同的算法，生成一段哈希值最后（先）把这段哈希值传回了百度云的数据库，依托百度的强大算法（先）用这个值去比较当前数据库中是否存在相同的值，若存在相同的值则立即把找到的数据库A用户的数据地址值复制一份给B用户存到B的用户的账户中随后返回一个字符串提示B用户（文件秒传成功）其实文件本身根本就没有传输只是传输了一个值上去，以此来达到秒传，若由此推断百度云的数据库里面没有重复数据，用户都是保存的文件的地址值，上传相同的文件会直接复制地址值就好了。（自己试验过更改了文件的MD5值和哈希值后上传就不会秒传，不更改第二次上传则秒传）。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，一般我们使用Comparator较多，因为实现Comparable接口的方式比实现Comparator接口的耦合性要强一些

作者: 杨馥榕 时间: 2018-12-25 21:02
1.List接口下都有哪些集合，他们各自有什么特点
答：Arraylist：具有list的借口的特点，查询快，增删慢底层是数组。
linkedlist：具有list的借口的特点，查询慢，增删快底层是链表。
vectorlist：单线程，速度慢

2.Set接口下的集合是如何保证无序不可重复的
答：因为重写了底层的哈希表和equals，哈希值不同，就存入，不同就是找equals里会不会相等。
3.我们为什么要重写HashCode( )和equals（）方法？
答：因为不重写HashCode和equals，在obj中就只有默认的地址值，而地址值对于我们来说是毫无意义，所以才需要重写来比较他们的属性
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode，因为在hash底层就是哈希值，先同比较哈希值来看两个元素是否相同，不相同存入，相同则最后去比较Equals里面的两个元素属性是否相同
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。

作者: 艾卡西亚的惊喜 时间: 2018-12-29 21:59

林少伟

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2