黑马程序员技术交流社区
标题: 【厦门JavaEE就业6期-每日总结】List、Set [打印本页]
作者: 厦门校区 时间: 2019-3-22 15:47
标题: 【厦门JavaEE就业6期-每日总结】List、Set
1.List接口下都有哪些集合，他们各自有什么特点
2.Set接口下的集合是如何保证无序不可重复的
3.我们为什么要重写HashCode( )和equals（）方法？
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
作者: 郑海波 时间: 2019-3-22 21:30
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：底层数据结构为数组，查询快：数组的是连续的，根据索引值就能查找元素；增删慢，因为数组的长度是固定的，要增加或者删除元素，无法在原数组上直接增加或者删除元素，都需要新建一个符合要求长度新数组，把原数组元素和要增加或者删除了元素的原数组按照索引放入新数组中，这样数组的增删速度慢。
LinkedList集合：1.底层数据结构是链表，查询慢：链表中地址不是连续的，每次查询元素，都必须从头开始查询；增删快：链表结构，增加/删除一个元素，对链表的整体结构没有影响，因此增删快；2.里边包含了大量操作首尾元素的方法；3.使用LinkedList集合特有的方法时，不能使用多态。
Vector集合：JAVA1.0的方法，数据存储效率较低，但是安全性高。
2.Set接口下的集合是如何保证无序不可重复的
Set集合底层是数组+链表/红黑树的结构，存入元素时会先判断哈希值，对应数组内哈希值的位置，然后判断内容，内容不一致就以链表形式连接在一起，一致则不存入，因此它是无序且不可重复的。
3.我们为什么要重写HashCode( )和equals（）方法？
不重写HashCode( )的话，只要new了一个新的自定义对象，不管内容是不是相同都会生成新的哈希值，这样存入到Set集合里就会产生重复内容，与要求不符，因此需要重写HashCode( )，使内容完全相同的对象哈希值也相同。
不重写equals（）方法的话，比较自定义对象时比较的就是地址值而不是自定义对象的内容，与需求不符。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()再判断equals（），因为当一个对象的内容过多时，equals（）需要频繁的进行字段的比较，这样就很耗费性能，而哈希值较为简单，且哈希值不同的对象内容肯定不同，因此一般先判断HashCode()，比较节省性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator和Comparable的区别：
Comparable:引用对象（自己）和别人(参数)比较,自己需要实现Comparable接口,因此需要在对象类中重写比较的规则compareTo方法
Comparator:找一个第三方对象来对两个人进行比较，写在类中方法内
Comparator使用的多，因为Comparable需要在类中重写，这样耦合性比较高，排序方式不同时，需要反复
作者: 陈伟彬 时间: 2019-3-22 21:31
1.List接口下都有哪些集合，他们各自有什么特点
答：
Arraylist集合：底层数组结构，增删慢，查询快；
LinkedList集合：底层是链表结构，增删快，查询慢；包含大量操作首尾方法；
Vector集合：数据存储效率低，但安全；
2.Set接口下的集合是如何保证无序不可重复的
答：
先创建一个数组，然后用hashCode方法计算对象的哈希值，与数组内部元素的哈希值比较，如果没有相同就添加进数组中；如果哈希值相同，就用equals方法比较两个元素的内容，如果不相同，就单向链表或红黑树连接在一起，如果内容相同就舍弃不存入数组；因此保证了集合无序不可重复；
3.我们为什么要重写HashCode( )和equals（）方法？
答：
HashCode( )：如果不重写，返回的是该对象的哈希值，而不是该对象内容的哈希值；而每次new出来的对象，不管内容一不一样其哈希值肯定不一样的，用这样的哈希值来比较就没有意义了；
equals（）：如果不重写，比较的是地址值而不是内容
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：
先判断HashCode()；
原因：相较于HashCode方法，equals方法非常耗费性能；先用HashCode方法进行筛选，如果出现哈希值相同的在用equals去判断内容，这样能更节省性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：
区别：
Comparable：自己和别人比较，需要自己现Comparable接口，重写CompareTo方法
Comparator：找第三方来比较两个对象
使用：Comparator使用得多；
因为：如果使用Comparable来控制，如果想换排序方法，就要经常在方法类中进行修改，耦合性很高；而Comparator则在匿名内部类中，耦合性低
作者: 陈驰煜 时间: 2019-3-22 21:31
1.List接口下都有哪些集合，他们各自有什么特点
LinkedList:底层是一个链表,提供了很多用于操作集合首尾数据的方法,查询慢,增删快
ArrayList:底层是一个数组,查询快,增删慢
Vector:JDK1.2以后被ArrayList取代,是不同步的,速度较慢
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合底层是哈希表(+链表),哈希表中用数组存储每个元素对应的哈希值,相同哈希值但内容不同的元素用链表或二叉树存储
调用add方法时, 会自动调用对象的hashCode和equals方法, hashCode不在集合中就直接存储, 相同则调用equals方法对比对象内容.
3.我们为什么要重写HashCode( )和equals()方法？
默认的HashCode()和equals()(也就是Object类中的)是对对象的逻辑地址值计算哈希值与比较,不能满足Set集合存储不重复对象的要求,而直接比较
两个对象的所有内容消耗资源太大,所以重写HashCode方法根据对象内容计算对象的哈希值,再重写equals方法,当对象哈希值相同时进行比较.
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals()，为什么？
先判断HashCode(),
若哈希值相同才调用equals方法可以节省equals方法比较两个对象所消耗的性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator接口使用更多, 因为Comparable方法需要在被比较的对象类中实现并重写compareTo方法, 这样的代码的耦合度较高, 当需求变更时
就要修改已经在使用的类,而Comparator接口没有这种困扰
作者: 陈志铖 时间: 2019-3-22 21:31
1.List接口下都有哪些集合，他们各自有什么特点
Vector:单线程,速度慢,数组结构
ArrayList:底层是一个数组结构,查询快,增删慢.多线程
LinkerList:数据存储 结构是链表结构.方便添加,删除.多线程
2.Set接口下的集合是如何保证无序不可重复的
底层是一个哈希表结构,哈希值会数组某个制定位置中,哈希值相同的元素会存储在同一条链中,重写hashCode和equals方法保证不可重复,当同类中的哈希值时,再用重写的equals方法比较内容是否相同
3.我们为什么要重写HashCode( )和equals（）方法？
一方面节省资源,另一方面如果不重写HashCode( )和equals（）方法,两个相同内容的对象会被当成不同元素储存
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode方法,当哈希值相同的时候再用equals方法判断内容是否相同,节约资源
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
Comparator用的多,减小代码耦合性
作者: 罗加铭 时间: 2019-3-22 21:31
1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下的集合：ArrayList,LinkedList,AbstractList, AbstractSequentialList, AttributeList, CopyOnWriteArrayList, RoleList, RoleUnresolvedList, Stack,Vector
特点：ArrayList元素增删慢，查找快；LinkedList集合方便元素添加、删除，提供大量首尾操作方法
2.Set接口下的集合是如何保证无序不可重复的
答：根据对象的哈希值来确定元素在集合中的存储位置，使用hashCode与queals方法来确保元素的唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
答：重写对象中的hashCode和equals方法，建立自己的比较方式，才能保
证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：首先判断HashCode()，如果不同就存入，如果相同再判断equals()，这样做可以提高存取和查找性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
作者: 陈弘帅 时间: 2019-3-22 21:32
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 管文祥 时间: 2019-3-22 21:32
1.List接口下都有哪些集合，他们各自有什么特点
答： ArrayList：底层结构是数组，元素增删慢，查找快。LinkedList：底层结构是链表结构，方便元素的添加、删除。Vector：可以实现可增长的对象数组，与数组一样，它包含可以使用整数索引进行访问的组件。
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合HashSet是根据存储对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能，而保证元素唯一性的方式依赖于hashCode()与 equals()方法。
3.我们为什么要重写HashCode( )和equals（）方法？
答：当我们给HashSet集合中存放自定义的元素或者对象时，必须重写对象中的hashCode和equals方法，才能保证HashSet集合中的对象唯一。如果不重写，比较的将是地址值。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode，因为如果哈希值不同，那么内容一定不同，哈希值相同，内容也可能不同，这种情况属于哈希冲突。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable是拿对象本身（this）与别人（参数）进行比较，需要实现Comparable接口，重写compareTo方法；
Comparator可以看做找一个第三方的裁判，传入两个参数进行比较，不需要实现Comparable接口，重写compareTo方法，降低了类的耦合性。
Comparator用的比较多，因为不需要实现Comparable接口，也不需要重写compareTo方法，还能降低程序代码的耦合性
作者: 陈鉴 时间: 2019-3-22 21:32
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 余建强 时间: 2019-3-22 21:33
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:可以存放有序可重复元素,有索引下标,元素增删慢,查找快,由于日常开发中使用最多的功能为查询数据,遍历数据,
所以ArrayList是最常用的集合
LinkedList:数据存储的结构是链表结构.方便元素添加,删除的集合,提供了大量首尾操作的方法
Vector:快被一起的集合
2.Set接口下的集合是如何保证无序不可重复的
因为HashSet 底层的实现其实是一个HashMap支持
3.我们为什么要重写HashCode( )和equals（）方法？
我们往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode()和equals()方法建立属于当前对象的比较方法
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()后判断equals(),因为当HashCode()不一致时,能判断出元素是否相等,如果判断HashCode值相等时,
就不必要使用equals,从而提高性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:强行对实现它的每一个类的对象进行整体排序.这种排序被称为类的自然排序,类的compareTo方法被
称为它的自然比较方法.只能在类中实现compareTo()一次,不能经常修改类的代码实现自己想要的
排序.实现此接口的对象列表(和数组)可以通过Collections.sort(和Arrays.sort)进行自动排序,对象可以用
作有序映射中的键或有序集合中的元素,无需指定比较器
Comparator:强行对某个对象进行整体排序.可以将Comparator来控制某些数据结构(如有序set或
有序映射)的顺序,或者为那些没有自然顺序的对象collection提供排序
Comparator用的比较多,因为便于程序员后期维护代码
作者: 黄杰南 时间: 2019-3-22 21:33
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容易造成耦合性过高，或排序方式可能出现需要改变的情况。
作者: 刘曾铭 时间: 2019-3-22 21:33
1.List接口下都有哪些集合，他们各自有什么特点？
因为都是List接口下的集合所以它们都有按顺序存取，有索引号
ArrayList集合：因为是数组数据结构所以元素查找快，增删慢。
LinkedList集合：因为底层是一个链表结构:查询慢,增删快。里边包含了大量操作首尾元素的方法。
Vector集合：是最初的集合，Vector 类可以实现可增长的对象数组。
2.Set接口下的集合是如何保证无序不可重复的?
因为set接口下底层是一个哈希表+红黑树，先用链表处理同个hash值都放在同
个链表内，同个链表内数据超过8个则转换成红黑树体系。最后通过HashCode( )找到链表再通过equals（）方法决定是否存储，所以最后存储的集合无序不可重复
3.我们为什么要重写HashCode( )和equals（）方法？
因为如果我们没重写equals（），则是两个地址值比较，如果不是同个对象则都为false，没有意义。而哈希值是一个十进制的整数,由系统随机给出即是对象的地址值,是一个逻辑地址,是模拟出来得到地址。而如果重写了则可以进行内容比较。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()再判断equals（），因为先需要判断HashCode()找到底层数组中链表，然后才通过equals（）；判断是否存储到集合当中。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable比较死板，Comparator比较灵活。所以Comparator使用比较多
因为Comparable在JAVA中已经被定义了规则如果再想换个规则排序就不可能修改源代码相对来说Comparator接口相当使用第三方仲裁判断可以在方法里作为匿名内部类
耦合度低又可以灵活判断修改排序规则所以Comparator接口使用的多。
作者: 林奕全 时间: 2019-3-22 21:33
1.List接口下都有哪些集合，他们各自有什么特点
Vector集合:是所有单列集合的开端
ArrayList集合:1.有序的集合2.可以存储重复元素3.有索引,包含带索引的方法
LinkedList集合:1.有序的集合2.可以存储重复元素3.有索引,包含带索引的方法
2.Set接口下的集合是如何保证无序不可重复的
前提是要重写HashCode方法和equals方法.
(1.)存储元素的时候,我们调用HashCode方法先得到元素的哈希值
(2.)再看哈希表的数组有没有这个哈希值,如果没有,就把对应的元素存进去.
(3.)如果数组里面已经有这个哈希值,则调用equals方法和对应的元素进行内容的比较,如果相同,则不存储;如果不相同,则存储在对应的元素链表下面.
总结:哈希值相同,equals比较内容也相同,则不再存储这个元素到数组中;
哈希值相同,equals比较的内容不相同,则把元素存储到相同内容元素的链表下面.
3.我们为什么要重写HashCode( )和equals（）方法？
保证Set接口下的单列集合存储元素不重复.
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,因为要先知道哈希表内的数组是否存在相同的哈希值,然后再决定存不存入.而equals是知道哈希值相同后再判断两个元素的内容是否相同
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator和Comparable的区别:
Comparable:自己(this)跟别人(参数)进行比较,自己需要实现Comparable接口,并重写ComparTo方法的定义规则
Comparator:等于找一个第三方的裁判来进行比较,它里面的方法sort(List,new Compartor)来进行比较
Comparator接口 使用的多,因为不用在实现类里面定义ComparTo方法规则,耦合度比较低,定义在实现类外部,删改数据比较方便.
作者: java基础6期刘伟 时间: 2019-3-22 21:33
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList LinkedList Vector
ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用多的功能为 查询数据、遍历数据，所以 ArrayList 是常用的集合。
LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
2.Set接口下的集合是如何保证无序不可重复的
是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能
。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）,因为如果哈希表不同的元素内容肯定不同，但是内容不同的元素哈希表不一定不同。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多 因为Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
或者为那些没有自然顺序的对象collection提供排序。
作者: 龚荣章 时间: 2019-3-22 21:33
1.List接口下都有哪些集合，他们各自有什么特点
(1)ArrayList集合:数据存储的结构是数组结构,元素增删慢,查找快
(2)LinkedList集合:数据存储的结构是链表结构,元素增删快,查找慢
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了确保自定义元素具有唯一性
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()是否存在哈希冲突,没有存在哈希冲突就会将数据存入集合,存在哈希冲突就会进行equals()判断两个元素是否相同,相同则认定两个元素相同就不会存储重复元素.
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 卢勇炜 时间: 2019-3-22 21:34
1.List接口下都有哪些集合，他们各自有什么特点
答:List接口的子类集合如下:
(1)ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快
(2)LinkedList 集合数据存储的结构是链表结构。增删速度快,提供大量首尾操作的方法。
(3)Vector 类可以实现可增长的对象数组,与数组一样，它包含可以使用整数索引进行访问的组件,Vector是同步的.
2.Set接口下的集合是如何保证无序不可重复的
答:重写HashCode( )和equals（）方法来保证元素的唯一性.
3.我们为什么要重写HashCode( )和equals（）方法？
答:我们需要对Object类继承过来的hashCode方法进行覆盖重写,不让他生成地址值,而是根据我们的内容,生成hash值,进行比较,比较hash值比equals方法容易得多.
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答:先判断HashCode(),再判断equals();哈希值不同,其对象的内容肯定不同;比较哈希值如果不同,直接存,如果相同,再调用equals方法进行内容比较;这样能够提高性能.
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答:(1)Comparable：强行对实现它的每个类的对象进行整体排序。
(2)Comparator强行对某个对象进行整体排序。
(3)Comparator接口使用的多.原因如下:
因为Comparable只能在类中实现compareTo方法一次,不能经常修改类的代码实现自己想要的排序.而Comparator可以将Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 陈前凌 时间: 2019-3-22 21:34
1.List接口下都有哪些集合，他们各自有什么特点
Vector集合:单线程，效率慢，但是安全
ArrayList集合:查询快，增删慢，底层是一个数组
LinkedList集合：查询慢，增删快，底层是一个链表
2.Set接口下的集合是如何保证无序不可重复的
（1）重写Object类中继承过来的hashCode方法，自定义，根据对象的内容生成的哈希值
（2）我们进行集合元素存储的时候，比如向HashSet集合添加元素的时候，会先调用hashCode方法，生成哈希值，不同对象的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象内容可能相同，可能不同
（4）比较哈希值如果不同，直接存，如果相同再调用equals方法进行比较
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；
equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，其一是因为要根据hash值找到对应的存储位置，其二是因为hash冲突的概率很低，用hash值判断已经能区分大部分的元素，当hash值一样时再调用equals()方法，这样能提高程序运行效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要在类中实现，耦合性强。
Comparator可以直接在测试类中用局部匿名实现类使用，所有Comparator用的比较多
作者: 黑马6期陈华 时间: 2019-3-22 21:34
1.List接口下都有哪些集合，他们各自有什么特点？
（1）ArrayList集合：
底层是数组，增删慢，查询快。
（2）LinkedList集合：
底层是一个链表，增删快，查询慢。多线程。不能使用多态方式创建，会导致无法使用链表特有的操作头尾的方法。
（3）Vector集合：
速度慢，但是线程安全。不常用，已基本被ArrayList替代。
2.Set接口下的集合是如何保证无序不可重复的？
在向Set集合中添加元素时，Set集合会先会先计算hash值然后进行比较，如果不同就不用比较了，直接存；相同的话，再调用equals方法比较对象的内容，如果都相同，则不存进去。哈希值不同，对 象的内容一定不同；哈希值相同，对象的内容有可能相同。
3.我们为什么要重写HashCode( )和equals（）方法？
两个对象需要判断内容是否相同，如果没有重写这两个方法，那么Set集合会默认调用equals方法进行比较，会很耗费性能。
例如我们想设计一个容器（Set集合），要求这个容器中的元素不 重复。我们如果没有重写对象类中的这两个方法，每次在存储的时候都将会需要调用equals方法进行比较：如果容器中的元素都不相 同，则存进去。这种情况下，如果一个对象的字段过多，那么就会频繁地进行字段的比较，非常耗费性能。
而如果重写这两种方法，根据对象内容分配hash值，比较hash值 比比较equals方法性能要高很多。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode。因为判断哈希值比使用equals方法判断对象内容是否相等性能要高很多。哈希值不同，对象的内容一定不同；哈希值相同，对象的内容有可能相同。所以Set集合一般采用先比较 哈希值的方案，如果不同就不用比较了，直接存；相同的话，再调用equals方法比较对象的内容，如果都相同，则不存进去。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparable：
定义在类中，不需要传入比较器，不能自定义规则来进行精准排序。
（2）Comparator：
定义在方法的内部类中，需要传入比较器，在类中可以自定义详细的规则来进行排序。
（3）Comparator用的更多，因为Comparable定义在类中，耦合度高，修改规则时会牵涉到类，维护性差，且不能自定义规则来进行精确的排序；而Comparator因为定义在方法的内部类中，耦合度低，维护性好，且可以自定义详细的排序规则。
作者: 林艺彬 时间: 2019-3-22 21:35
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：查询快，增删慢。接口的大小是可变数组的实现。实现不是同步的。
LinkedList：查询慢，增删快。接口是以链接列表实现。实现不是同步的。
Vector：可以实现可增长的对象数组。是同步的。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合是根据对象的某种规则来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。
3.我们为什么要重写HashCode( )和equals（）方法？
因为如果不重写HashCode( )和equals（）方法，默认继承的是Object的HashCode( )和equals（）方法，比较的是地址值没有意义。无法保证元素的唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为如果HashCode()中哈希值不同，则内容肯定不同，可直接添加内容，不用再判断equals（），如果哈希值相同，则会发生哈希冲突，再进行判断equals（）判断内容是否一致。且判断HashCode()运行更快。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（，从而允许在排序顺序上实现精确控制。
Comparator接口使用的多，可以降低程序的耦合性。
作者: 陈前凌 时间: 2019-3-22 21:35
1.List接口下都有哪些集合，他们各自有什么特点
Vector集合:单线程，效率慢，但是安全
ArrayList集合:查询快，增删慢，底层是一个数组
LinkedList集合：查询慢，增删快，底层是一个链表
2.Set接口下的集合是如何保证无序不可重复的
（1）重写Object类中继承过来的hashCode方法，自定义，根据对象的内容生成的哈希值
（2）我们进行集合元素存储的时候，比如向HashSet集合添加元素的时候，会先调用hashCode方法，生成哈希值，不同对象的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象内容可能相同，可能不同
（4）比较哈希值如果不同，直接存，如果相同再调用equals方法进行比较
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；
equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为哈希值不同的元素一定不相同。哈希值相同了才有必要继续通过equals（）比较。
这样可以减少运算量。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要在类中实现，耦合性强。
Comparator可以直接在测试类中用局部匿名实现类使用，所有Comparator用的比较多
作者: 高坂火龙果 时间: 2019-3-22 21:35
黄志斌：
1.List接口下都有哪些集合，他们各自有什么特点
List接口下有ArrayList和LinkedList两种集合，ArrayList的特点是它的结构是数组结构，元素增减慢、查找快，而LinkedList的特点是它的结构是链表结构，元素增减快，查找慢
2.Set接口下的集合是如何保证无序不可重复的
通过使用哈希表结构（数组+链表+红黑树）来实现的。
首先要添加的元素的哈希值找到对应的数组位置，若哈希值对应的位置上没有元素直接添加，若已经有元素类，再通过equals判断元素是否重复，不重复才添加。
3.我们为什么要重写HashCode( )和equals（）方法？
在给HashSet中存放自定义类型元素时，需要重新对象中的hashCode和eauals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()因为哈希值不同的元素一定不相同。哈希值相同了才有必要继续通过equals（）比较。
这样可以减少运算量。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：是对同一类下的所有对象进行排序： Comparator：是对单一对象进行排序。
Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。
作者: 李煜霖 时间: 2019-3-22 21:35
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 开心的小孩 时间: 2019-3-22 21:36
陈鹏涛
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，
1 底层是数组
LinkedListt 集合数据存储的结构是链表结构。
1底层是一个链表结构：查询快，增删慢
2里边包含了大量操作首尾元素的方法
方便元素添加、删除的集合。
2.Set接口下的集合是如何保证无序不可重复的
1. 不包含重复元素基于哈希表实现的
3.我们为什么要重写HashCode( )和equals（）方法？
如果两个对象需要判断是否内容相同，调用equals方法
如果一个对象的字段过多，那就会频繁的进行字段的比较，非常消耗性能
我们需要对Object类继承过来的hashcode方法进行覆盖重写，不让他生成地址值，
而是根据我们对象的内容，生成hash值进行比较，比较hash值比equals方法容易多了
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）重写objec类中继承过来的hashcold方法，自定义，根据对象的内容生成哈希值
（2）我们在进行集合元素存储的时候，比如hashset集合添加元素的时候，
会调用hashcode方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同：哈希值相同，对象的内容可能相同，有可能不同
（4）比较哈希值如果不同，直接存放，如果相同，在进行equals比较
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多；
Comparable：强行对实现它的每个类的对象进行整体排序。
这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法
Comparator强行对某个对象进行整体排序。可以将Comparator
传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制
作者: 厦门第六期刘鹏 时间: 2019-3-22 21:36
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是一个数组结构，查询快，增删慢
LinkedList特点：底层是一个链表结构，查询慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取
和查找性能。保证元素唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
比较元素是否相等
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么
？
先判断HashCode再判断equals 因为哈希值不同，对象的内容肯定不同；哈希值相同
，对象的内容相同，有可能不同
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的多，因为这个接口是在实现类里面，而不是抽象类里面。
作者: 李伟艺 时间: 2019-3-22 21:36
1.List接口下都有哪些集合，他们各自有什么特点？
（1）list接口常见实现类有ArrayList、LinkedList、Vector；
（2）各自的特点
1）ArrayList：底层采用数组结构，查询快，增删慢
2）Linked:底层采用链表结构，查询慢，增删快，对内存的空间利用率高
3）Vector:和Arraylist类似，区别在于它是线程安全型的，所以效率较低，栈内存设计使用到Vector,其它地方
很少使用
2.Set接口下的集合是如何保证无序不可重复的
（1）以TreeSet和HashSet为例
1）TreeSet的元素需要内部实现比较器或则创建TreeSet对象的时候传入比较器，通过比较器来判断两个元素的
大小，如果要存入的元素和原集合中的某个元素相同就不进行存储，从而保证唯一性
2）HashSet集合在存储元素时，会先调用元素的hashCode（）方法，判断当前要存储的元素hash值是否已经
在集合中存在，如果已经存在（可能是不同元素但是发生hash冲突），就调用equal方法，如果euqal判断
也是相等，则不进行存储
3.我们为什么要重写HashCode( )和equals（）方法？
（1）要存入HashSet集合的元素，必须重写这两个方法，因为HashSet会根据这两个方法判断要存入元素是否已经
在集合中存在，从而保证存储的唯一性，如果不重写，默认对地址比较，不对内容比较，这样地址不一样，但内
容一样的元素也会存储进来
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）先判断HashCode（），因为hashCode通过算法获取和内容相关的hash值，速度较快，equals判断速度较慢
而且hashCode不同肯定是不同的元素，相同可能是相同的元素，也可能是不同元素但是发生hash冲突，这个
时候再调用equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparator使用比较多，因为Comparator是外部比较器，在使用比较方法的时候当成参数传进去接口，比较
灵活，修改也比较方便，Comparable是内部比较器，在被比较的元素类定义时实现该接口，修改不方便。
作者: zhaizhile 时间: 2019-3-22 21:37
1.List接口下都有哪些集合，他们各自有什么特点
1,ArrayList
ava.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
2,LinkedList
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。
3,Vector
现在已经被ArrayList集合取代
2.Set接口下的集合是如何保证无序不可重复的
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能,保证元素唯一性的方式依赖于：hashCode与equals方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),如果一个对象的字段过多,那就会频繁的进行字段的比较,非常耗费性能,所以先判断HashCode(),只有在哈希值相同的时候,在判断equals()
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
1.List接口下都有哪些集合，他们各自有什么特点
1,ArrayList
ava.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
2,LinkedList
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。
3,Vector
现在已经被ArrayList集合取代
2.Set接口下的集合是如何保证无序不可重复的
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能,保证元素唯一性的方式依赖于：hashCode与equals方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),如果一个对象的字段过多,那就会频繁的进行字段的比较,非常耗费性能,所以先判断HashCode(),只有在哈希值相同的时候,在判断equals()
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 管文祥 时间: 2019-3-22 21:37
1.List接口下都有哪些集合，他们各自有什么特点
答： ArrayList：底层结构是数组，元素增删慢，查找快。LinkedList：底层结构是链表结构，方便元素的添加、删除。Vector：可以实现可增长的对象数组，与数组一样，它包含可以使用整数索引进行访问的组件。
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合HashSet是根据存储对象的哈希值来确定元素在集合中的存储位置，在调用add方法时会先调用添加元素的hashCode方法和equals方法，进行判断因此具有良好的存取和查找性能，而保证元素唯一性的方式依赖于hashCode()与 equals()方法。
3.我们为什么要重写HashCode( )和equals（）方法？
答：当我们给HashSet集合中存放自定义的元素或者对象时，必须重写对象中的hashCode和equals方法，才能保证HashSet集合中的对象唯一。如果不重写，比较的将是地址值。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode，因为如果哈希值不同，那么内容一定不同，哈希值相同，内容也可能不同，这种情况属于哈希冲突。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable是拿对象本身（this）与别人（参数）进行比较，需要实现Comparable接口，重写compareTo方法；
Comparator可以看做找一个第三方的裁判，传入两个参数进行比较，不需要实现Comparable接口，重写compareTo方法，降低了类的耦合性。
Comparator用的比较多，因为不需要实现Comparable接口，也不需要重写compareTo方法，还能降低程序代码的耦合性
作者: 叶振鹏 时间: 2019-3-22 21:37
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合底层是数组结构查找快，增删慢
LinkedList 底层采用链表结构查找慢（LinkedList集合添加了很多特有的方法来操作第一个和最后一个元素），增删快
2.Set接口下的集合是如何保证无序不可重复的
是通过HashCode( )和equals（）方法。
add方法在调用元素的hascode方法计算字符哈希值，会在集合中找有没有这个哈希值，
发现没有就会把元素存储到集合中，如果有会调用equals方法和哈希值相同的元素进行
比较返回布尔值，如果是true就不会把相同的元素存储到集合中，如果是false会把元素
加入相同哈希值的元素“下”
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，Set集合的底层数据结构是数组和链表，数组储存的是哈希值，而链表链接的是在这个哈希值下的元素
存数据时先判断哈希值是否存在集合中，没有则会把元素存入集合，如果有则会调用equals（）方法来判断内容是否一致
如果内容相同则判断为同一个元素，则不会把相同元素放入集合，如果没有则会把元素放在这个哈希值“下”
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
而要实现这个接口需要在自定义类中并必须重写compaerTo方法，这样不方便我们以后对这个方法的更改操作
Comparator：相当于找一个第三方的裁判,比较两个
可以使用匿名内部类来把方法抽离出来，更改起来影响不大
作者: 黑马六期-董安平 时间: 2019-3-22 21:37
1.List接口下都有哪些集合，他们各自有什么特点
答：
(1).ArrayList集合
特点：底层是一个数组结构，元素增删慢，查找快，元素都带有索引值，存储空间连续
(2).LinkedList集合
特点：底层是一个链表结构，元素增删快，查找慢，存储空间不连续，但是每个元素都带有链表，增删更快
(3).vector集合
特点;JDK早期使用的集合，已全面被ArrayList取代
2.Set接口下的集合是如何保证无序不可重复的
答：由于Set接口底下的集合重写了hashCode和equals方法，具备了哈希表，可以实现不可重复，原理如下：
hashCode方法重写后保证哈希值唯一，equals方法重写后会比较哈希值相同的两个元素内容是否相同，如果相同后一个元素不存入集合，如果不同则会添加到对应的哈希值链表下，两个方法叠加使用保证内部元素不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答:保证集合内部的元素的唯一性，HashCode()方法可以获取对象的哈希值；equals()方法比较的是对象的内容，如果不重写这两个方法可能会出现相同的元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，再判断equals()，因为一个元素的哈希值是系统随机赋予的唯一值，如果哈希值不相同，那么内容一定不相同，那么就不需要使用equals()方法，如果出现了哈希冲突，则会调用equals方法将冲突的数据进行比较，当认定两个元素相同时，后一个元素就会被丢弃，不会存入集合
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：区别在于Comparable是对同一类的所有对象进行强制排序，而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响
Comparator使用的比较多，因为使用Comparable是定义在类里面的，容易造成耦合性过高，而Comparator可以更灵活的调用部署，比如接收匿名内部类的内容，允许通过单一变量来排序，在灵活性上强于Comparab接口。
作者: 廖艺铭 时间: 2019-3-22 21:38
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：List接口的数组实现，元素增删慢、查找快，不是同步
Vector：jdk 1.2之前较常用，而后逐渐被ArrayList取代，同步
LinkedList：List接口的链表实现，元素增删快、查找慢，不是同步
2.Set接口下的集合是如何保证无序不可重复的
a.Set接口下的集合比如HashSet，它底层的数据结构是数组+链表+红黑树实现的哈希表，根据元素的哈希值决定存储位置，
所以是无序的；
b.根据hashCode和equals方法来保证HashSet集合元素的唯一性，先判断hashCode方法再判断equals方法，
如果都相等说明是重复元素，就不存储
3.我们为什么要重写HashCode( )和equals（）方法？
为了提高程序性能
原因：Set集合要保证容器中的元素不重复，那么需要调用重写的equals方法进行比较，而如果对象的字段较多，
会频繁的进行字段比较，自然非常耗性能，而相比之下，比较hash值比equals方法容易，所以需要对hashCode方法
进行重写，让它根据对象的内容来生成hash值，先调用hashCode方法再调用equals方法
a.重写hashCode方法，根据对象的内容生成哈希值
b.集合存储元素时，比如向HashSet集合添加元素时，会先调用hashCode方法，生成哈希值，不同对象生成的哈希值可能相同
c.哈希值不同，那么对象的内容肯定不同；哈希值相同，对象的内容可能相同，也可能不同
d.如果哈希值不同，直接存；如果相同，再调用equals方法进行内容比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode方法
原因：如果对象的字段较多，先判断equals方法会频繁的比较字段，耗费性能，而相比之下，比较hash值比equals方法容易，
所以重写hashCode方法让它根据对象内容生成哈希值后，那么哈希值不同，对象的内容肯定不同，就无需再判断equals方法，
从而提升程序性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
1)Comparable：对实现它的每个类的对象进行整体排序，通过类中实现compareTo方法自定义比较规则，
不能经常修改类的代码实现自己想要的排序，无需指定比较器
Comparator：对某个对象整体排序，直接将Comparator传递给sort方法，允许在排序顺序上实现精确控制，需要指定比较器
2)Comparator使用的多，因为Comparable是通过让类来实现它，重写compareTo方法来指定比较规则，那么如果比较规则变了，就需要改动Comparable实现类的源码，
维护代价较大，使用Comparable代码耦合性较高；
而使用Comparator，降低了代码耦合度，直接在程序中通过匿名内部类指定的比较规则，不需要在类中实现接口，易于后期维护
作者: 曾伟清 时间: 2019-3-22 21:40
1.List接口下都有哪些集合，他们各自有什么特点
答：有ArrayList，LinkedArrayList，Vector。他们三个都是可以重复，有序有索引；ArrayList和Vector底层是数组，查询快，增删慢，Vector是单线程，ArrayList是多线程；LinkedArrayList底层是链表，查询慢增删快。
2.Set接口下的集合是如何保证无序不可重复的
答：Set的add方法添加的元素的类有重写HashCode和equals方法，所以在添加元素的时候调用这两个方法可以保证存入数据不重复；而无序是因为元素是添加在哈希值对应的数组位置，哈希值在数组的前或者是后无法保证。
3.我们为什么要重写HashCode( )和equals（）方法？
答：为了确保Set集合存入的元素不重复。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，哈希值相同时再判断equals（）；Set集合添加元素时会调用这两个方法，判断添加的元素与集合中元素的哈希值是否相同，不同直接添加；相同的话添加的元素调用equals方法与相同哈希值的元素进行对比，返回false时添加，返回true不添加。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法；
Comparator:相当于找一个第三方的裁判,比较两个；
Comparator使用的比较多，因为Comparable要求所比较的类必须实现Comparable接口，重写compareTo方法比较规则，耦合性强，修改比较规则比较麻烦。
作者: 李伟艺 时间: 2019-3-22 21:40
1.List接口下都有哪些集合，他们各自有什么特点？
（1）list接口常见实现类有ArrayList、LinkedList、Vector；
（2）各自的特点
1）ArrayList：底层采用数组结构，查询快，增删慢
2）Linked:底层采用链表结构，查询慢，增删快，对内存的空间利用率高
3）Vector:和Arraylist类似，区别在于它是线程安全型的，所以效率较低，栈内存设计使用到Vector,其它地方
很少使用
2.Set接口下的集合是如何保证无序不可重复的
（1）以TreeSet和HashSet为例
1）TreeSet的元素需要内部实现比较器或则创建TreeSet对象的时候传入比较器，通过比较器来判断两个元素的
大小，如果要存入的元素和原集合中的某个元素相同就不进行存储，从而保证唯一性
2）HashSet集合在存储元素时，会先调用元素的hashCode（）方法，判断当前要存储的元素hash值是否已经
在集合中存在，如果已经存在（可能是不同元素但是发生hash冲突），就调用equal方法，如果euqal判断
也是相等，则不进行存储
3.我们为什么要重写HashCode( )和equals（）方法？
（1）要存入HashSet集合的元素，必须重写这两个方法，因为HashSet会根据这两个方法判断要存入元素是否已经
在集合中存在，从而保证存储的唯一性，如果不重写，默认对地址比较，不对内容比较，这样地址不一样，但内
容一样的元素也会存储进来
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）先判断HashCode（），因为hashCode通过算法获取和内容相关的hash值，速度较快，equals判断速度较慢
而且hashCode不同肯定是不同的元素，相同可能是相同的元素，也可能是不同元素但是发生hash冲突，这个
时候再调用equals判断
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
（1）Comparator使用比较多，因为Comparator是外部比较器，在使用比较方法的时候当成参数传进去接口，比较
灵活，修改也比较方便，Comparable是内部比较器，在被比较的元素类定义时实现该接口，修改不方便。
作者: Wyt1935 时间: 2019-3-22 21:41
吴元陶：
1.List接口下都有哪些集合，他们各自有什么特点
LinkedLlist集合：查询慢、增删快。底层是链表。
ArrayList集合：查询快、增删慢。底层是数组。
Vector集合：底层为数组，是单线程。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 徐代成 时间: 2019-3-22 21:41
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层是数组结构。元素增删慢，查找快
LinkedList: <1>底层是链表，查询慢，增删快
<2>里面有大量特有的首尾操作的方法
Vector: 早期的集合，存储数据比较安全
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合，在调用add方法的时候，add方法会调用元素的hashCode方法和equals方法，来判断元素是否重复
3.我们为什么要重写HashCode( )和equals（）方法？
如果我们不重写HashCode()和equals()方法，我们比较的均是对象的地址值，不是对象的内容，这样的比较没有意义
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断equals()方法。如果先判断equals()方法，首先equals方法比较的时候当遇到大量的字段时，会造成性能损耗，
其次，equals判断数据是否存在后再判断HashCode就没有任何意义了。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口是通过自己与对象进行比较进行排序
Comparator接口是通过第三方作裁判然后进行比较
Comparable接口使用的比较多，因为Comparable接口只能在类中实现compareTo()一次，不能经常修改类的代码实现自
己想要的排序。
Comparator接口比较灵活，可以定义在方法中，也可以用自定义的规则进行排序
作者: 林志鹏 时间: 2019-3-22 21:42
1.List接口下都有哪些集合，他们各自有什么特点
在API中可以看到List接口下有很多集合我们目前学习的有：
（1）Arraylist集合：特点是底层的结构是数组结构，所以增删速度慢，查找速度快
（2）LinkedList集合：特点是底层的结构是链表结构，所以增删速度快，查找速度慢
（3）Vector集合：JDK早期使用的结构，只不过现在被ArrayList淘汰；
特点是底层也是数组结构而且是单线程数组安全型更高，效率低
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合底层是一个哈希表结构（数组+链表/红黑树），会先调用HashCode计算哈希值；
如果哈希值没冲突则会添加存储元素；
如果哈希值冲突则会重写equals方法比较元素内容；
内容元素相同则不添加存储，不相同则就添加存储；
3.我们为什么要重写HashCode( )和equals（）方法？
是为了保证元素的唯一性；Object类中的HashCode方法获取的是对象的地址值；
equals方法比较的是地址的值。如果不进行重写可能会出现重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据在存入Set集合的时候会先判断HashCode；
因其底层结构是哈希表结构系统会随机生成一个十进制整数的虚拟地址；
判断完哈希值相同才会判断equals；
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：对同一类下的所有对象进行排序；
Comparator：是对单一对象进行排序；
Comparator使用的比较多。使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。
作者: 黄振明 时间: 2019-3-22 21:42
1.List接口下都有哪些集合，他们各自有什么特点
答：
ArrayList集合：查询快，增删慢。底层是数组，数组有索引值，所以查询的速度快，但数组要增删需要重新创建一个新数组对象，将其他的元素添加到新数组中
LinkedList集合：查询慢，增删快。底层是链表。链表一个节点包含了一个数据源（存储数组），两个指针域（存储地址），链表中地址不是连续的，每次查询都要从头开始。而增删对链表的整体结构没有影响。
Vector集合：查询快，增删慢
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合重写了Object类中的hashCode()和equals()方法，使元素先查询哈希值是否相同，哈希值不同，对象的内容不同，直接存进去。哈希值相同，内容可能相同，也可能不同。内容相同就不存，内容不同就存进去。
3.我们为什么要重写HashCode( )和equals（）方法？
答：因为如果两个对象需要判断是否相同内容，用equals方法比较，比较耗费性能。所以我们对Object类继承过来的hashCode()方法进行覆盖重写，不让他生成地址值，而是根据对象的内容生成hash值，进行比较，比较hash值比equals方法容易的多。
（1）重写Object类中继承过来的hashCode()方法，自定义，根据对象的内容生成的哈希值
（2）我们在进行集合元素存储的时候，比如先HashSet集合添加元素的时候，会先调用hashCode()的方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象的内容有可能相同，有可能不同。
（4）比较哈希值如果不同，直接存。如果相同，再调用equals方法进行内容比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，因为Set集合底层是用哈希表，哈希表=数组+链表/红黑树，会先计算元素的哈希值，然后通过哈希值比较，如果链表中没有相同的哈希值，直接存进去。如果有相同的哈希值，在判断equals()方法。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则ComparTo方法
Comparator：相当于一个比较器来比较两个元素
Comparator接口的使用多，因为Comparable只能在类中实现一次ComparaTo()，并不能经常修改类代码实现自己想要的排序。
作者: 钟扬辉 时间: 2019-3-22 21:42
1.List接口下都有哪些集合，他们各自有什么特点
Arraylist :元素增删慢，查找快
Iinkedlist：元素增删快，查找慢
Voctor:
2.Set接口下的集合是如何保证无序不可重复的
在set接口下的集合会重写HashCode（）和equals（）方法，如果哈希值相同那么就会用equals（）来判断内容是否相同，
如果equals（）判断相同，两个元素就是相同，只会存储一个元素。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet
集合中的对象唯一。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为equals()判断比较繁琐，先从哈希值来判断，要是不同，那么元素就是单一，相同的话再用equals来判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:强行对实现它的每个类的对象进行整体排序。
这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。
只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
实现 此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，
对象可以用作有序映射中 的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
或者为那些没有自然顺序的对象collection提供排序。
使用Comparator接口使用多，因为方便且不用定义一个类。
作者: 张广发 时间: 2019-3-22 21:42
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是一个数组结构，查询快，增删慢
LinkedList特点：底层是一个链表结构，查询慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取
和查找性能。保证元素唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
比较元素是否相等
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么
？
先判断HashCode再判断equals 因为哈希值不同，对象的内容肯定不同；哈希值相同
，对象的内容相同，有可能不同
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的多，因为这个接口是在实现类里面，而不是抽象类里面
作者: 黄振明 时间: 2019-3-22 21:43
1.List接口下都有哪些集合，他们各自有什么特点
答：
ArrayList集合：查询快，增删慢。底层是数组，数组有索引值，所以查询的速度快，但数组要增删需要重新创建一个新数组对象，将其他的元素添加到新数组中
LinkedList集合：查询慢，增删快。底层是链表。链表一个节点包含了一个数据源（存储数组），两个指针域（存储地址），链表中地址不是连续的，每次查询都要从头开始。而增删对链表的整体结构没有影响。
Vector集合：查询快，增删慢
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合重写了Object类中的hashCode()和equals()方法，使元素先查询哈希值是否相同，哈希值不同，对象的内容不同，直接存进去。哈希值相同，内容可能相同，也可能不同。内容相同就不存，内容不同就存进去。
3.我们为什么要重写HashCode( )和equals（）方法？
答：因为如果两个对象需要判断是否相同内容，用equals方法比较，比较耗费性能。所以我们对Object类继承过来的hashCode()方法进行覆盖重写，不让他生成地址值，而是根据对象的内容生成hash值，进行比较，比较hash值比equals方法容易的多。
（1）重写Object类中继承过来的hashCode()方法，自定义，根据对象的内容生成的哈希值
（2）我们在进行集合元素存储的时候，比如先HashSet集合添加元素的时候，会先调用hashCode()的方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象的内容有可能相同，有可能不同。
（4）比较哈希值如果不同，直接存。如果相同，再调用equals方法进行内容比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，因为Set集合底层是用哈希表，哈希表=数组+链表/红黑树，会先计算元素的哈希值，然后通过哈希值比较，如果链表中没有相同的哈希值，直接存进去。如果有相同的哈希值，在判断equals()方法。如果判断equals()的结果是不相同的，就存进去。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则ComparTo方法
Comparator：相当于一个比较器来比较两个元素
Comparator接口的使用多，因为Comparable只能在类中实现一次ComparaTo()，并不能经常修改类代码实现自己想要的排序。
作者: 李智梁 时间: 2019-3-22 21:43
1.List接口下都有哪些集合，他们各自有什么特点
(1)ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快
(2)LinkedList 集合数据存储的结构是链表结构。增删速度快,提供大量首尾操作的方法。
(3)Vector 类可以实现可增长的对象数组,与数组一样，它包含可以使用整数索引进行访问的组件,Vector是同步的。
2.Set接口下的集合是如何保证无序不可重复的？
答:Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
答:为了确保自定义元素具有唯一性.
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答:先判断HashCode(),再判断equals();哈希值不同,其对象的内容肯定不同;
比较哈希值如果不同,直接存,如果相同,再调用equals方法进行内容比较;
这样能够提高性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答:(1)Comparable：强行对实现它的每个类的对象进行整体排序。
(2)Comparator强行对某个对象进行整体排序。
(3)Comparator接口使用的多:因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。
作者: 林志鹏 时间: 2019-3-22 21:44
1.List接口下都有哪些集合，他们各自有什么特点
在API中可以看到List接口下有很多集合我们目前学习的有：
（1）Arraylist集合：特点是底层的结构是数组结构，所以增删速度慢，查找速度快
（2）LinkedList集合：特点是底层的结构是链表结构，所以增删速度快，查找速度慢
（3）Vector集合：JDK早期使用的结构，只不过现在被ArrayList淘汰；
特点是底层也是数组结构而且是单线程数组安全型更高，效率低
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合底层是一个哈希表结构（数组+链表/红黑树），会先调用HashCode计算哈希值；
如果哈希值没冲突则会添加存储元素；
如果哈希值冲突则会重写equals方法比较元素内容；
内容元素相同则不添加存储，不相同则就添加存储；
3.我们为什么要重写HashCode( )和equals（）方法？
是为了保证元素的唯一性；Object类中的HashCode方法获取的是对象的地址值；
equals方法比较的是地址的值。如果不进行重写可能会出现重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
数据在存入Set集合的时候会先判断HashCode；
因其底层结构是哈希表结构系统会随机生成一个十进制整数的虚拟地址；
判断完哈希值相同才会判断equals；
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：对同一类下的所有对象进行排序；
Comparator：是对单一对象进行排序；
Comparator使用的比较多。使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。
作者: javawjs 时间: 2019-3-22 21:44
王佳盛
1. List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是一个数组结构；查询快，增删慢。
LinkedList：底层是链表结构；查询慢，增删快。
Vector：底层也是数组结构，是单线程的。效率较低。
2. Set接口下的集合是如何保证无序不可重复的
Set接口下的集合在添加元素是会先调用HashCode（）方法，判断集合中是否存在哈希冲突，如果不存在哈希冲突，就将元素存入集合。如果存在，就调用equals（）方法，判断元素内容是否相同，不相同就存入集合。否则不存入集合。
3. 我们为什么要重写HashCode( )和equals（）方法？
在我们需要创建一个存储没有重复元素的集合（Set）时，我们自定义的类需要重写HashCode（）和equals（）方法，保证向集合添加自定义类的元素是唯一的。如果没有重写，则可能存储的元素内容相同。
4. 数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）方法，因为哈希值不同，对象内容肯定不同；哈希值相同，对象内容可能相同（例如“重地”和“通话”，哈希值相同，内容不同），可能不同；
5. Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
使用Comparator接口多，因为使用Comparable接口需要继承接口，重写compareTo（）方法，耦合度太高；而使用Comparator接口可以使用匿名内部类，比较灵活。
作者: javawjs 时间: 2019-3-22 21:44
王佳盛
1. List接口下都有哪些集合，他们各自有什么特点
ArrayList：底层是一个数组结构；查询快，增删慢。
LinkedList：底层是链表结构；查询慢，增删快。
Vector：底层也是数组结构，是单线程的。效率较低。
2. Set接口下的集合是如何保证无序不可重复的
Set接口下的集合在添加元素是会先调用HashCode（）方法，判断集合中是否存在哈希冲突，如果不存在哈希冲突，就将元素存入集合。如果存在，就调用equals（）方法，判断元素内容是否相同，不相同就存入集合。否则不存入集合。
3. 我们为什么要重写HashCode( )和equals（）方法？
在我们需要创建一个存储没有重复元素的集合（Set）时，我们自定义的类需要重写HashCode（）和equals（）方法，保证向集合添加自定义类的元素是唯一的。如果没有重写，则可能存储的元素内容相同。
4. 数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）方法，因为哈希值不同，对象内容肯定不同；哈希值相同，对象内容可能相同（例如“重地”和“通话”，哈希值相同，内容不同），可能不同；
5. Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
使用Comparator接口多，因为使用Comparable接口需要继承接口，重写compareTo（）方法，耦合度太高；而使用Comparator接口可以使用匿名内部类，比较灵活。
作者: 黄成龙 时间: 2019-3-22 21:46
1.List接口下都有哪些集合，他们各自有什么特点
（1）ArrayList，特点：底层结构是数组实现，查找速度快，增删速度慢。
（2）LinkedList，特点：底层是链表实现，增删速度快，查找速度慢。
（3）Vector，特点：jdk早期使用的结构，安全型更高，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证元素的唯一性。因为Object类中的HashCode( )方法获取的对象的地址值；equals（）方法比较的是地址的值。如果我们不进行重写可能会出现重复元素。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，其一是因为要根据hash值找到对应的存储位置，其二是因为hash冲突的概率很低，用hash值判断已经能区分大部分的元素，当hash值一样时再调用equals()方法，这样能提高程序运行效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：是对同一类下的所有对象进行排序； Comparator：是对单一对象进行排序。
Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况。
作者: 龙舟 时间: 2019-3-22 21:48
1.List接口下都有哪些集合，他们各自有什么特点
(1)ArrayList集合:数据存储的结构是数组结构,元素增删慢,查找快
(2)LinkedList集合:数据存储的结构是链表结构,元素增删快,查找慢
2.Set接口下的集合是如何保证无序不可重复的
（1）通过使用哈希表结构（数组+链表+红黑树）来实现的。
（2）首先要添加的元素的哈希值找到对应的数组位置，
若哈希值对应的位置上没有元素直接添加，若已经有元素类，
再通过equals判断元素是否重复，不重复才添加。
3.我们为什么要重写HashCode( )和equals（）方法？
在给HashSet中存放自定义类型元素时，需要重新对象中的hashCode和eauals方法，
建立自己的比较方式，才能保证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，
类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，
对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
作者: java基础6期刘伟 时间: 2019-3-22 21:48
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList LinkedList Vector
ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用多的功能为 查询数据、遍历数据，所以 ArrayList 是常用的集合。
LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
2.Set接口下的集合是如何保证无序不可重复的
是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能
。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）,因为如果哈希表不同的元素内容肯定不同，但是内容不同的元素哈希表不一定不同。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多 因为Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
或者为那些没有自然顺序的对象collection提供排序。
作者: 黑马林伟明 时间: 2019-3-22 21:49
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 唐彬桂 时间: 2019-3-22 21:51
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：
1.有序的集合,存储元素和取出元素的顺序是一致的
2.有索引,包含了一些带索引的方法
3.允许存储重复的元素
LinkedList集合：
1.底层是一个链表结构:查询慢,增删快
2.里边包含了大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
因为通过调用重写了HashCode和equals方法。
3.我们为什么要重写HashCode( )和equals（）方法？
因为Object类中的HashCode( )方法获取的对象的地址值，
equals（）方法比较的是地址的值，如果我们不进行重写HashCode( )和equals（）方法，
那么并不能保证元素的唯一性；
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode,因为
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是对使用同一类的所有对象进行排序，
Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。
Comparator使用的比较多，Comparable的是对使用同一类的所有对象进行排序，
而Comparator是对单个对象进行排序，对其他使用同一类的对象没有影响。
可以对使用同一类的对象按不同的规则进行排序。
作者: java基础6期刘伟 时间: 2019-3-22 21:51
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList LinkedList Vector
ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用多的功能为 查询数据、遍历数据，所以 ArrayList 是常用的集合。
LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
2.Set接口下的集合是如何保证无序不可重复的
是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能
。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）,因为如果哈希表不同的元素内容肯定不同，但是内容不同的元素哈希表不一定不同。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多 因为Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
或者为那些没有自然顺序的对象collection提供排序。
作者: 6期江岳 时间: 2019-3-22 21:52
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList：集合数据存储的结构是数组结构，元素增删慢，查找快
LinkedList：集合数据存储的结构是链表结构，元素增删快，查找慢
2.Set接口下的集合是如何保证无序不可重复的
HashSet 底层的实现其实是一个HashMap 支持，使得它存储的元素不可重复并且无序。
LinkedHashSet是HsahSet一个子类，所以同样元素不可重复并且无序。
3.我们为什么要重写HashCode( )和equals（）方法？
如果我们往集合中存放自定义的对象，那么对象的内容可以不同，难以保证存入的对象其唯一，
就必须复写hashCode和equals方法建立属于当前对象的比较方式，确定对象内容，进行具体比较。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashcode()
因为要先进行方法计算插入数组的索引值确定一个大的范围，再进行判断该范内元素是否存在即equals方法。这样执行的顺序查找效率高。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable已经把排序的规则写死了，不能像Comparator一样灵活的更改排序规则。
Comparator使用的多，因为可以根据实际情况进行规定排序规则。
作者: 蓝建华 时间: 2019-3-22 21:53
1.List接口下都有哪些集合，他们各自有什么特点
答：ArrayList :底层结构是数组实现，查找速度款，增删速度慢
linkedList：底层是链表实现的，增删速度快，查找速度慢
vector：jdk早期使用的结构，安全性 更高，效率低
2.Set接口下的集合是如何保证无序不可重复的
答：通过使用哈希表结构（数组+链表+红黑树）来实现的
1.首先要添加的元素的哈希值找到对应的数组位置，若哈希值对于的位置上没有元素直接添加
2.若已经有元素类，在通过equals判断元素是否重复，不重复蔡添加
3.我们为什么要重写HashCode( )和equals（）方法？
答：因为要保证元素的唯一性，因为Object类中的HashCode()方法获取的是对象的地址值，
equals（）方法比较的也是地址值，如果我们不进行重写的话就回出现相同的的元素
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HasCode()因为哈希值不用的元素一定不同，哈希值相同了才有必要继续通过equals()比较，这样就可以减少运行过程，增加性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable :是对同一类下的所有对象进行排序
Comparator:是对单一的对象进行排序
Comparator使用的比较多。因为使用comparable容易造成耦合性过高，或排序方式可能出现需要改变的情况
作者: JavaEE06蒋才东 时间: 2019-3-22 21:53
1.List接口下都有哪些集合，他们各自有什么特点
Vector:可以实现可增长的对象数组,相较于安全
ArrayList: 底层是一个数组结构，查找快，增删慢
LinkedList:底层是一个链表结构，查找慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
当向set接口下的集合添加元素时，编译器会计算该元素的hashcode，按照hash值找到元素存储的内存区域，这样元素的存储就是无序的；同时，如果该元素的hash和集合内的某个元素一样，则调用equals方法对这两个元素进行比较，如果一致则不把该元素加入到集合中，这样就保证了元素不重复。
3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写HashCode( )和equals（）方法的话，对象比较的是哈希值，所以需要重写HashCode( )和equals（）方法，使哈希值一样，其内容也一致
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()再判断equals()
因为要根据hash值找到对应的存储位置，当hash值一样时再调用equals()方法，这样能提高程序运行效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个
Comparator接口使用的多，因为Comparable接口的实现类中只能实现compareTo()一次，不能经常修改类的代码实现自己想要的排序；而Comparator接口可以以匿名内部类的方式进行排序在灵活性上优于Comparable接口。
作者: java基础6期刘伟 时间: 2019-3-22 21:53
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList LinkedList Vector
ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用多的功能为 查询数据、遍历数据，所以 ArrayList 是常用的集合。
LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
2.Set接口下的集合是如何保证无序不可重复的
是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能
。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保 证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（）,因为如果哈希表不同的元素内容肯定不同，但是内容不同的元素哈希表不一定不同。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多 因为Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
或者为那些没有自然顺序的对象collection提供排序。
作者: 王旭艺 时间: 2019-3-22 21:54
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快
LinkedListt 集合数据存储的结构是链表结构,查询快，增删
2.Set接口下的集合是如何保证无序不可重复的
1. 不包含重复元素基于哈希表实现的
3.我们为什么要重写HashCode( )和equals（）方法？
如果两个对象需要判断是否内容相同，调用equals方法
如果一个对象的字段过多，那就会频繁的进行字段的比较，非常消耗性能。
我们需要对Object类继承过来的hashcode方法进行覆盖重写，不让他生成地址值，
而是根据我们对象的内容，生成hash值进行比较，比较hash值比equals方法容易多了
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
（1）重写objec类中继承过来的hashcold方法，自定义，根据对象的内容生成哈希值
（2）我们在进行集合元素存储的时候，比如hashset集合添加元素的时候，
会调用hashcode方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同：哈希值相同，对象的内容可能相同，有可能不同
（4）比较哈希值如果不同，直接存放，如果相同，在进行equals比较
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多；
Comparable：强行对实现它的每个类的对象进行整体排序。
这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法
Comparator强行对某个对象进行整体排序。可以将Comparator
传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制
作者: omasoo 时间: 2019-3-22 21:55
李伟斌
1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下有vector：不常使用，已被 ArrayList替代；
ArrayList：查询快，增删慢。
LinkedList：查询慢，增删快。
2.Set接口下的集合是如何保证无序不可重复的
答：用为Set接口底层是链表结构，是无序的。并且Set接口底层有哈希值，因为哈希值是唯一的，如果重复将不存入Set集合中，所以Set接口不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：因为不重写Set接口将默认调用Object的HashCode（）和equals方法，比较的是对象的地址，这样做无法
确保Set接口里对象的唯一性，所以需要重写HashCode( )和equals（）方法，
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode（），确保哈希值是否一致，如果不一致将进行equals（）方法，如果equals（）方法比较结果一致，则不存入集合，如果不一致才存入集合中。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable接口是在类里面实现的，耦合度太高，不利于后期维护。
Comparator则通过创建匿名内部类的方式实现接口，代码耦合度低，利于后期维护。
工作中 Comparator接口用得较多，因为耦合度低，利于后期维护。
作者: 叶彬彬 时间: 2019-3-22 21:56
1.List接口下都有哪些集合，他们各自有什么特点
LinkedList集合：元素增删快，查找慢；适用于增删数据
ArrayList集合：元素增删慢，查找快；适用于查询数据，遍历数据
Vector集合：与新collection实现不同，Vector是同步的
2.Set接口下的集合是如何保证无序不可重复的
重写了HashCode()方法和equals()方法
不重写HashCode()方法得到的是对象的地址值，重写后能获取对应的哈希值；
不重写equals()方法比较的是两个对象的地址值，重写后比较两个对象的内容；
往集合中添加元素时，会先调用HashCode()方法，获取哈希值；在同一哈希值中，再用equals()方法比较两个对象的内容；这样能确保集合里的元素不重复
3.我们为什么要重写HashCode()和equals（）方法？
为了不让集合里的元素出现重复
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()；因为哈希表底层采用数组+链表实现，比较hash值比equals方法容易得多，耗费的性能更少。当HashCode()方法生成的哈希值相同时，才会调equals()方法进行内容比较。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。
Comparator：强行对某个对象进行整体排序。
Comparator接口使用的多；因为Comparable只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。而Comparator允许在排序顺序上实现精确控制。还可以用来控制某些数据结构的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 苏森鹏 时间: 2019-3-22 21:57
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:
数据存储的结构是数组结构，元素增删慢，查找快;
LinkedList:
数据存储的结构是链表结构。方便元素添加、删除的集合。
LinkedList是一个双向链表，其中提供了大量收尾操作的方法。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比
较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 叶彬彬 时间: 2019-3-22 21:57
1.List接口下都有哪些集合，他们各自有什么特点
LinkedList集合：元素增删快，查找慢；适用于增删数据
ArrayList集合：元素增删慢，查找快；适用于查询数据，遍历数据
Vector集合：与新collection实现不同，Vector是同步的
2.Set接口下的集合是如何保证无序不可重复的
重写了HashCode()方法和equals()方法
不重写HashCode()方法得到的是对象的地址值，重写后能获取对应的哈希值；
不重写equals()方法比较的是两个对象的地址值，重写后比较两个对象的内容；
往集合中添加元素时，会先调用HashCode()方法，获取哈希值；在同一哈希值中，再用equals()方法比较两个对象的内容；这样能确保集合里的元素不重复
3.我们为什么要重写HashCode()和equals（）方法？
为了不让集合里的元素出现重复
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()；因为哈希表底层采用数组+链表实现，比较hash值比equals方法容易得多，耗费的性能更少。当HashCode()方法生成的哈希值相同时，才会调equals()方法进行内容比较。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。
Comparator：强行对某个对象进行整体排序。
Comparator接口使用的多；因为Comparable只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。而Comparator允许在排序顺序上实现精确控制。还可以用来控制某些数据结构的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: 吴越 时间: 2019-3-22 21:58
1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下的集合有AbstractList, AbstractSequentialList, ArrayList,AttributeList,CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector。常用的两种是ArrayList和LinkedList，特点如下：
ArrayList：数据存储的结构是数组结构,元素增删慢,查找快，默认初始长度是10
LinkedList：数据存储的结构是一个双向链表，查询慢，增删快，包含了大量操作首尾元素的方法。
2.Set接口下的集合是如何保证无序不可重复的
答：无序性：仅使用哈希表存储数据，不添加额外的链表来记录元素顺序。
不可重复性：依赖于hashCode与equals 方法。Set类的集合在进行集合元素存储的时候，先重写Object类中继承过来的HashCode()方法，根据对象的内容生成的哈希值。比较哈希值，如果不同，直接存；如果相同，再调用equals方法进行内容比较，保证元素不重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：如果两个对象需要判断是否内容相同，可以调用equals方法进行比较，但如果一个对象的字段过多，那就会偏频繁的进行字段的比较，非常的耗费性能。我们可以对Object类继承过来的hashCode方法进行覆盖重写，不让他生成地址值，而是根据我们对象的内容，生成hash值进行比较。因为比较hash值比equals方法容易得多。如果hash值相同，再调用equals方法进行内容比较。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()。因为比较hash值比equals方法容易得多。如果一个对象的字段过多，那么对应的equals()方法就会偏频繁的进行字段的比较，非常的耗费性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator接口使用的多。因为要使用Comparable接口，需在源代码类中需要实现Comparable接口，重写compareTo方法，耦合性高，且比较标准变动时，不易修改，比较死板。而Comparator使用时，只需在Collections.sort方法中实现Comparator接口的匿名内部类，根据实际需求可以方便地改动，比较灵活，所以使用的多。
作者: 卢春旭 时间: 2019-3-22 21:58
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：
数据存储的结构是数组结构。元素增删慢，查找快。
LinkedList集合：
数据存储的结构是链表结构。方便元素添加、删除的集合。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合存储数据的时候，add（）方法会调用元素的hashCode和equals方法，判断元素是否重复。
首先会调用hashCode方法，将元素的哈希值与集合中元素的哈希值进行对比，如果不同，元素就会存储到集合当中；
如果相同，就会调用equals方法，对比两个哈希值相同的元素的值，相同则元素重复，不存储元素；
不同则元素不重复，将元素存储进集合当中。
3.我们为什么要重写HashCode( )和equals（）方法？
为了保证我们自定义类型元素具有唯一性。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），因为集合如果没有元素，判断数组索引值处为空时就可以直接存入数组，
如果有元素，再调用equals方法判断是否重复。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类
的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控
制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
作者: chenopen 时间: 2019-3-22 21:58
陈开明：
1.List接口下都有哪些集合，他们各自有什么特点
有Vector,ArrayList,LinkedList集合。
Vector:不能使用迭代器和增强for循环，如果要进行遍历，只能使用枚举方法
ArrayList:底层结构是数组。由于数组地址值是连续的，所以ArrayList的查询速度非常快，但由于数组的长度是固定的，所以ArrayList的增删操作非常麻烦，底层需要重新创建一个新数组，再将原来的数组值转移到新数组。
LinkedList:底层结构是双向链表，所以增删操作非常简单方便，有很多独有的首尾操作方法。但是查询速度慢，由于链表连接的地址值并不是连续的，所以查询某个具体值需要从首个地址开始一步步查询下去，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合：主要结构是数组+链表或红黑树。集合内元素的存储是根据每个元素的哈希值大小排列存储到数组中，导致存储到数组中的元素并非有序的。而元素的hashCode()和equals()方法重写保证了元素不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
因为要使Set集合元素不会重复，需要使用equals()方法判读元素是否相同，但由于有时元素内容非常多，导致使用equals()方法比较效率很低，因此重写HashCode()方法。这个方法是根据元素的内容生成哈希值。哈希值不同，元素必然不同，哈希值相同，元素可能相同可能不同，如果相同，再用equals()判读。
通过，重写这两个方法，可以使得存储效率提升。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()。这个方法是根据元素的内容生成哈希值。哈希值不同，元素内容必然不同，哈希值相同，元素内容可能相同可能不同，如果相同，再用equals()判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable接口是自己和别人参数比较，一般在定义类的时候，自己实现这个接口功能，需要重写比较的规则CompareTo方法，它强行对实现它的每个类的对象进行整体排序；Comparator属于第三方可以自己定义的比较器，比较灵活，不需要在定义类的时候就写死比较方式，可以自由写比较规则，它强行对某个对象进行整体排序。
作者: 吴越 时间: 2019-3-22 21:59
1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下的集合有AbstractList, AbstractSequentialList, ArrayList,AttributeList,CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector。常用的两种是ArrayList和LinkedList，特点如下：
ArrayList：数据存储的结构是数组结构,元素增删慢,查找快，默认初始长度是10
LinkedList：数据存储的结构是一个双向链表，查询慢，增删快，包含了大量操作首尾元素的方法。
2.Set接口下的集合是如何保证无序不可重复的
答：无序性：仅使用哈希表存储数据，不添加额外的链表来记录元素顺序。
不可重复性：依赖于hashCode与equals 方法。Set类的集合在进行集合元素存储的时候，先重写Object类中继承过来的HashCode()方法，根据对象的内容生成的哈希值。比较哈希值，如果不同，直接存；如果相同，再调用equals方法进行内容比较，保证元素不重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：如果两个对象需要判断是否内容相同，可以调用equals方法进行比较，但如果一个对象的字段过多，那就会偏频繁的进行字段的比较，非常的耗费性能。我们可以对Object类继承过来的hashCode方法进行覆盖重写，不让他生成地址值，而是根据我们对象的内容，生成hash值进行比较。因为比较hash值比equals方法容易得多。如果hash值相同，再调用equals方法进行内容比较。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()。因为比较hash值比equals方法容易得多。如果一个对象的字段过多，那么对应的equals()方法就会偏频繁的进行字段的比较，非常的耗费性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator接口使用的多。因为要使用Comparable接口，需在源代码类中需要实现Comparable接口，重写compareTo方法，耦合性高，且比较标准变动时，不易修改，比较死板。而Comparator使用时，只需在Collections.sort方法中实现Comparator接口的匿名内部类，根据实际需求可以方便地改动，比较灵活，所以使用的多。
作者: 吴越 时间: 2019-3-22 22:01
1.List接口下都有哪些集合，他们各自有什么特点
答：List接口下的集合有AbstractList, AbstractSequentialList, ArrayList,AttributeList,CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector。常用的两种是ArrayList和LinkedList，特点如下：
ArrayList：数据存储的结构是数组结构,元素增删慢,查找快，默认初始长度是10
LinkedList：数据存储的结构是一个双向链表，查询慢，增删快，包含了大量操作首尾元素的方法。
2.Set接口下的集合是如何保证无序不可重复的
答：无序性：仅使用哈希表存储数据，不添加额外的链表来记录元素顺序。
不可重复性：依赖于hashCode与equals 方法。Set类的集合在进行集合元素存储的时候，先重写Object类中继承过来的HashCode()方法，根据对象的内容生成的哈希值。比较哈希值，如果不同，直接存；如果相同，再调用equals方法进行内容比较，保证元素不重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：如果两个对象需要判断是否内容相同，可以调用equals方法进行比较，但如果一个对象的字段过多，那就会偏频繁的进行字段的比较，非常的耗费性能。我们可以对Object类继承过来的hashCode方法进行覆盖重写，不让他生成地址值，而是根据我们对象的内容，生成hash值进行比较。因为比较hash值比equals方法容易得多。如果hash值相同，再调用equals方法进行内容比较。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()。因为比较hash值比equals方法容易得多。如果一个对象的字段过多，那么对应的equals()方法就会偏频繁的进行字段的比较，非常的耗费性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparator接口使用的多。因为要使用Comparable接口，需在源代码类中需要实现Comparable接口，重写compareTo方法，耦合性高，且比较标准变动时，不易修改，比较死板。而Comparator使用时，只需在Collections.sort方法中实现Comparator接口的匿名内部类，根据实际需求可以方便地改动，比较灵活，所以使用的多。
作者: 沈松宏 时间: 2019-3-22 22:40
1.List接口下都有哪些集合，他们各自有什么特点
Arraylist:查询快,增删慢
Linkedlist:增删快,查询慢
vector集合:效率低,安全
2.Set接口下的集合是如何保证无序不可重复的
调用HashCode( )和equals（）方法
3.我们为什么要重写HashCode( )和equals（）方法？
保证集合不重复,
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),直接比较哈希值会更快,效率高
equals（）会比较浪费性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法
被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现
此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中
的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或
Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或
有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
作者: 沈松宏 时间: 2019-3-22 22:41
1.List接口下都有哪些集合，他们各自有什么特点
Arraylist:查询快,增删慢
Linkedlist:增删快,查询慢
vector集合:效率低,安全
2.Set接口下的集合是如何保证无序不可重复的
调用HashCode( )和equals（）方法
3.我们为什么要重写HashCode( )和equals（）方法？
保证集合不重复,
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode(),直接比较哈希值会更快,效率高
equals（）会比较浪费性能
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法
被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现
此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中
的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或
Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或
有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
作者: 小翔vvvv 时间: 2019-3-22 23:48
叶凌青
1.List接口下都有哪些集合，他们各自有什么特点
Arraylist :元素增删慢，查找快
Iinkedlist：元素增删快，查找慢
Voctor:
2.Set接口下的集合是如何保证无序不可重复的
在set接口下的集合会重写HashCode（）和equals（）方法，如果哈希值相同那么就会用equals（）来判断内容是否相同，
如果equals（）判断相同，两个元素就是相同，只会存储一个元素。
3.我们为什么要重写HashCode( )和equals（）方法？
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet
集合中的对象唯一。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，因为equals()判断比较繁琐，先从哈希值来判断，要是不同，那么元素就是单一，相同的话再用equals来判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable:强行对实现它的每个类的对象进行整体排序。
这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。
只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
实现 此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，
对象可以用作有序映射中 的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或 有序映射）的顺序，
或者为那些没有自然顺序的对象collection提供排序。
使用Comparator接口使用多，因为方便且不用定义一个类。
作者: LIUXIAOMING 时间: 2019-3-23 18:51
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：底层数据结构为数组，查询快：数组的是连续的，根据索引值就能查找元素；增删慢，因为数组的长度是固定的，要增加或者删除元素，无法在原数组上直接增加或者删除元素，都需要新建一个符合要求长度新数组，把原数组元素和要增加或者删除了元素的原数组按照索引放入新数组中，这样数组的增删速度慢。
LinkedList集合：1.底层数据结构是链表，查询慢：链表中地址不是连续的，每次查询元素，都必须从头开始查询；增删快：链表结构，增加/删除一个元素，对链表的整体结构没有影响，因此增删快；2.里边包含了大量操作首尾元素的方法；3.使用LinkedList集合特有的方法时，不能使用多态。
Vector集合：JAVA1.0的方法，数据存储效率较低，但是安全性高。
2.Set接口下的集合是如何保证无序不可重复的
Set集合底层是数组+链表/红黑树的结构，存入元素时会先判断哈希值，对应数组内哈希值的位置，然后判断内容，内容不一致就以链表形式连接在一起，一致则不存入，因此它是无序且不可重复的。
3.我们为什么要重写HashCode( )和equals（）方法？
不重写HashCode( )的话，只要new了一个新的自定义对象，不管内容是不是相同都会生成新的哈希值，这样存入到Set集合里就会产生重复内容，与要求不符，因此需要重写HashCode( )，使内容完全相同的对象哈希值也相同。
不重写equals（）方法的话，比较自定义对象时比较的就是地址值而不是自定义对象的内容，与需求不符。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()再判断equals（），因为当一个对象的内容过多时，equals（）需要频繁的进行字段的比较，这样就很耗费性能，而哈希值较为简单，且哈希值不同的对象内容肯定不同，因此一般先判断HashCode()，比较节省性能。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator和Comparable的区别：
Comparable:引用对象（自己）和别人(参数)比较,自己需要实现Comparable接口,因此需要在对象类中重写比较的规则compareTo方法
Comparator:找一个第三方对象来对两个人进行比较，写在类中方法内
Comparator使用的多，因为Comparable需要在类中重写，这样耦合性比较高，排序方式不同时，需要反复
作者: 魏政 时间: 2019-3-23 21:02
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：查询快，增删慢。底层是数组，数组有索引值，所以查询的速度快，但数组要增删需要重新创建一个新数组对象，将其他的元素添加到新数组中
LinkedList集合：查询慢，增删快。底层是链表。链表一个节点包含了一个数据源（存储数组），两个指针域（存储地址），链表中地址不是连续的，每次查询都要从头开始。而增删对链表的整体结构没有影响。
Vector集合：查询快，增删慢
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合重写了Object类中的hashCode()和equals()方法，使元素先查询哈希值是否相同，哈希值不同，对象的内容不同，直接存进去。哈希值相同，内容可能相同，也可能不同。内容相同就不存，内容不同就存进去。
3.我们为什么要重写HashCode( )和equals（）方法？
因为如果两个对象需要判断是否相同内容，用equals方法比较，比较耗费性能。所以我们对Object类继承过来的hashCode()方法进行覆盖重写，不让他生成地址值，而是根据对象的内容生成hash值，进行比较，比较hash值比equals方法容易的多。
（1）重写Object类中继承过来的hashCode()方法，自定义，根据对象的内容生成的哈希值
（2）我们在进行集合元素存储的时候，比如先HashSet集合添加元素的时候，会先调用hashCode()的方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象的内容有可能相同，有可能不同。
（4）比较哈希值如果不同，直接存。如果相同，再调用equals方法进行内容比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，因为Set集合底层是用哈希表，哈希表=数组+链表/红黑树，会先计算元素的哈希值，然后通过哈希值比较，如果链表中没有相同的哈希值，直接存进去。如果有相同的哈希值，在判断equals()方法。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则ComparTo方法
Comparator：相当于一个比较器来比较两个元素
Comparator接口的使用多，因为Comparable只能在类中实现一次ComparaTo()，并不能经常修改类代码实现自己想要的排序。
作者: 魏政 时间: 2019-3-23 21:16
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合：查询快，增删慢。底层是数组，数组有索引值，所以查询的速度快，但数组要增删需要重新创建一个新数组对象，将其他的元素添加到新数组中
LinkedList集合：查询慢，增删快。底层是链表。链表一个节点包含了一个数据源（存储数组），两个指针域（存储地址），链表中地址不是连续的，每次查询都要从头开始。而增删对链表的整体结构没有影响。
Vector集合：查询快，增删慢
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合重写了Object类中的hashCode()和equals()方法，使元素先查询哈希值是否相同，哈希值不同，对象的内容不同，直接存进去。哈希值相同，内容可能相同，也可能不同。内容相同就不存，内容不同就存进去。
3.我们为什么要重写HashCode( )和equals（）方法？
因为如果两个对象需要判断是否相同内容，用equals方法比较，比较耗费性能。所以我们对Object类继承过来的hashCode()方法进行覆盖重写，不让他生成地址值，而是根据对象的内容生成hash值，进行比较，比较hash值比equals方法容易的多。
（1）重写Object类中继承过来的hashCode()方法，自定义，根据对象的内容生成的哈希值
（2）我们在进行集合元素存储的时候，比如先HashSet集合添加元素的时候，会先调用hashCode()的方法，生成哈希值，不同对象生成的哈希值可能相同
（3）哈希值不同，对象的内容肯定不同；哈希值相同，对象的内容有可能相同，有可能不同。
（4）比较哈希值如果不同，直接存。如果相同，再调用equals方法进行内容比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()，因为Set集合底层是用哈希表，哈希表=数组+链表/红黑树，会先计算元素的哈希值，然后通过哈希值比较，如果链表中没有相同的哈希值，直接存进去。如果有相同的哈希值，在判断equals()方法。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则ComparTo方法
Comparator：相当于一个比较器来比较两个元素
Comparator接口的使用多，因为Comparable只能在类中实现一次ComparaTo()，并不能经常修改类代码实现自己想要的排序。
作者: 庄家琦 时间: 2019-3-23 21:52
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合（底层数组）：查询快 增删慢
LinkedList集合（底层链表）：查询慢 增删快
2.Set接口下的集合是如何保证无序不可重复的
set接口底层是哈希表是由每个元素会生成一个哈希值
会先判断哈希值知否相同如果相同进入下一个判断equals如果都相等就重复
会被替换掉
Set接口底层由哈希表排序并不是按照输入顺序排序的
3.我们为什么要重写HashCode( )和equals（）方法？
省资源
这两个方法是为了实现哈希值比较
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()在判断equals（）
比较equals（）耗费资源内容短的对象还好.可是内容非常长的对象是很浪费资源的.不如哈希值比较
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
被排序的集合里面存储的元素 必须实现Comparable接口重写ComparablTo
排序规则:自己(this)-参数;升序
参数-this;降序
sore(集合,new Comparator)
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |