黑马程序员技术交流社区
标题: 【厦门JavaEE就业三期-每日总结】List、Set [打印本页]
作者: 厦门校区 时间: 2018-8-14 20:49
标题: 【厦门JavaEE就业三期-每日总结】List、Set
1.List接口下都有哪些集合，他们各自有什么特点
2.Set接口下的集合是如何保证无序不可重复的
3.我们为什么要重写HashCode( )和equals（）方法？
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
作者: 张煜兴 时间: 2018-8-14 21:02
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是第三方，也就是比较器，不需要实现接口，灵活制定比较规则
作者: sulaymanfan 时间: 2018-8-14 21:05
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的比较多,因为随便的修改类中的方法不推荐. |
|
作者: 丶黑白 时间: 2018-8-14 21:11
余志斌
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，因为它是外部比较器，不用实现接口。且规则可以再类中直接重写改变排序规则。
作者: 练志成 时间: 2018-8-14 21:12
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合查找快，增删慢，
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
没有索引，所有是一个无序集合
3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法默认比较的是两个对象的地址值，无意义，所有需要重新写
HashCode( )方法，防止哈希碰撞情况发生
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值，因为哈希值判断完之后还会判断内容是否相等
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别在于一个已经定义好的，一个需要自己定义的，
如果没有特殊必要Comparable使用较多，
如非必要，基本不使用Comparator。
作者: 黄伟佳 时间: 2018-8-14 21:12
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList/LinkedList/Vector
ArrayList元素真删慢，查找快。LinkedList方便添加删除。
2.Set接口下的集合是如何保证无序不可重复的
主要是依赖于hashCode和equals方法。
3.我们为什么要重写HashCode( )和equals（）方法？
不重写就不能做到不可重复的元素。防止哈希值碰撞，
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode（），哈希值如果相同再判断元素属性。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的多，比较方便- -。
作者: weimengchao 时间: 2018-8-14 21:13
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
作者: 张剑猛 时间: 2018-8-14 21:15
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
作者: 沈智桂 时间: 2018-8-14 21:16
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是重写类中的方法
作者: 罗荣贵 时间: 2018-8-14 21:18
1.list接口下有ArrayList LinkedList vectory 集合 ，ArrayList 的底层是数组，搜索快，增删慢，LinkedList 是链表数据结构，增删快，搜索慢， vectory是ArrayList 的前身，是数组数据结构，搜索快，增删慢
2.set接口下的HshSet 的数据结构是单链表，是无序的，在添加元素时会调用hascode方法对比哈希值，如果哈希值相同，则调用equals方法进行内容对比，确保元素的唯一
3.当我们想让元素按照我们自己的计算方法来计算哈希值的时候，重写hascode方法，重写equals方法是因为有些对象的地址值不同，但内容相同，根据生活实际情况，这种情况下我们认为这两个对象为同一对象，所以我们重写方法对比对象内容
4.先判断hascode方法 ，哈希值相同再判断equals方法。
5.Comparator用的比较多，因为它可以更改已经有的默认排序，并且不需要进行接口实现类的创建，更加灵活
作者: 李伟javaee03 时间: 2018-8-14 21:19
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使用较多，自己可以定义排序规则，不用实现接口，使用比较灵活；
作者: 刘建宝 时间: 2018-8-14 21:20
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）类型使用
作者: 陈张辉 时间: 2018-8-14 21:21
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两个接口的区别，哪种接口使用的多，为什么？
一个类中实现 一个不在类中实现 用匿名内部类 第二个用的多 如果要经常对一个类排序 则选用第一种
作者: 林靖 时间: 2018-8-14 21:21
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList 元素增删慢，查找快
Vector 已过时
LinkedList 链表结构 方便元素添加、删除
2.Set接口下的集合是如何保证无序不可重复的
添加元素的add方法默认使用了HashCode方法
3.我们为什么要重写HashCode( )和equals（）方法？
equals方法没有重写的话比较的是地址值没意义
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode() 因为要先判断地址是否唯一
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自然排序
Comparator可以自己定义排序
作者: 林嘉志 时间: 2018-8-14 21:22
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用的多，因为比较灵活
作者: Michcale 时间: 2018-8-14 21:22
---------------------吴齐宾-------------------------
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接口使用的比较多.因为适用范围广,能根据我们的重写方法对比很多的对像.
作者: 陈捷 时间: 2018-8-14 21:23
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即可。
作者: 铜墙铁壁花无缺 时间: 2018-8-14 21:24
余金龙
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
作者: 陈张辉 时间: 2018-8-14 21:26
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。
作者: yangshixian 时间: 2018-8-14 21:26
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更为简洁
杨式贤
作者: 罗建辉 时间: 2018-8-14 21:27
1.List接口下都有哪些集合，他们各自有什么特点
(1)ArrayList:数据存储的结构是数组结构,元素有序,允许重复元素,增删慢,但查找快.
(2)LinkedList:是一个双向链表,集合数据存储的结构是链表结构.元素有序.方便元素增删,但查找慢.。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用.
2.Set接口下的集合是如何保证无序不可重复的
调用被添加元素的hashCode()，和HashSet中已有元素的hashCode比较是否相同,如果不相同，直接存储, 如果相同，调用equals方法比较是否相同,不相同，直接存储元素,相同，认为是同一元素.不存储
3.我们为什么要重写HashCode( )和equals（）方法？
因为给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode(),如果hashcode相同在判断equals().二者都相同才会判定元素相同,这样做的方法效率高,而且避免的hash碰撞导致误判元素重复.
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
(1)区别:
Comparable强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法
被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法
（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
(2)Comparator使用的多,因为comparable要修改比较方式的话要直接修改类,这样的做法对代码的维护很不有好
作者: 苏华琛 时间: 2018-8-14 21:27
1.List接口下都有哪些集合，他们各自有什么特点
有ArrayList集合，特点：查找快，增删慢
LinkedList集合，特点：查找慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
在数组 + 链表/红黑树的多重判断下
3.我们为什么要重写HashCode( )和equals（）方法？
HashCode（）：为了防止哈希碰撞
equals（）：该方法对比的是对象的地址值，没有太大意义
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值，因为如果出现了哈希碰撞，需要equals再次判断内容是都相同
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是原本就定义好的，而Comparator需要自己定义。
Comparable接口使用的多，理由如上，普通情况下使用比较方便。
作者: spik 时间: 2018-8-14 21:28
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层居于数组的栈类型结构，查询速度快，增删效率低。
LinkedList:底层居于链表格式类型的结构，查询速度慢，增删快。
Vector:同ArrayList，但是操作是单线程的，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set通过hashCode和equals方法实现元素不重复。
由于是通过哈希值来确定元素的存储位置，所以是无序的。
3.我们为什么要重写HashCode( )和equals（）方法？
默认的HashCode（） 方法比较的是默认的对象地址值，为了确保对象的唯一性，需要重写HashCode（）和equals（）方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，在HashCode不同的时候才调用equals（）方法。hashcode是调用根据哈希算法的本地方法产生哈希值，比较能确保唯一性，效率高。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable 强行对实现它的每个类的对象进行整体排序，不能修改类的代码实现自己想要的排序，
用Collections.sort或者Arrays.sort进行自动排序，无需指定比较器
Comparator 可以将 Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。
lijionghua
作者: spik 时间: 2018-8-14 21:29
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层居于数组的栈类型结构，查询速度快，增删效率低。
LinkedList:底层居于链表格式类型的结构，查询速度慢，增删快。
Vector:同ArrayList，但是操作是单线程的，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set通过hashCode和equals方法实现元素不重复。
由于是通过哈希值来确定元素的存储位置，所以是无序的。
3.我们为什么要重写HashCode( )和equals（）方法？
默认的HashCode（） 方法比较的是默认的对象地址值，为了确保对象的唯一性，需要重写HashCode（）和equals（）方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，在HashCode不同的时候才调用equals（）方法。hashcode是调用根据哈希算法的本地方法产生哈希值，比较能确保唯一性，效率高。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable 强行对实现它的每个类的对象进行整体排序，不能修改类的代码实现自己想要的排序，
用Collections.sort或者Arrays.sort进行自动排序，无需指定比较器
Comparator 可以将 Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。
lijionghua
作者: 赵烈刚 时间: 2018-8-14 21:29
1.List接口下都有哪些集合，他们各自有什么特点
(ArrayList)用于查询数据，遍历数据，增删慢。
（LinkedList）数据存储的机构是链表结构，便于增加/删除集合元素。
（Vector）类提供额外的方法来增加、删除元素，比数组操作高效。 使用的时候无须声明上限，随着元素的增加，Vector的长度会自动增加。
2.Set接口下的集合是如何保证无序不可重复的
hashCode 与 equals 方法保证元素唯一性；HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的
作者: spik 时间: 2018-8-14 21:30
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层居于数组的栈类型结构，查询速度快，增删效率低。
LinkedList:底层居于链表格式类型的结构，查询速度慢，增删快。
Vector:同ArrayList，但是操作是单线程的，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set通过hashCode和equals方法实现元素不重复。
由于是通过哈希值来确定元素的存储位置，所以是无序的。
3.我们为什么要重写HashCode( )和equals（）方法？
默认的HashCode（） 方法比较的是默认的对象地址值，为了确保对象的唯一性，需要重写HashCode（）和equals（）方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，在HashCode不同的时候才调用equals（）方法。hashcode是调用根据哈希算法的本地方法产生哈希值，比较能确保唯一性，效率高。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable 强行对实现它的每个类的对象进行整体排序，不能修改类的代码实现自己想要的排序，
用Collections.sort或者Arrays.sort进行自动排序，无需指定比较器
Comparator 可以将 Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。
lijionghua
作者: 迪亚波罗 时间: 2018-8-14 21:31
1。ArrayList集合查询快,增删慢 LinkedList查找慢,增删快
2.根据hashCode与equals方法
3.hasCode 比较的是哈希值. equals比较的是对象地址值
4.先判断hashCode在判断equals, 先判断哈希值是否重复,在比较内容是否相同
5.Comparable是自已完成比较，Comparator是外部程序实现比较。Comparable接口使用的多，理由如上，普通情况下使用比较方便
孙享
作者: 小悦悦 时间: 2018-8-14 21:33
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList，LinkedList。有序，可重复，有索引。
2.Set接口下的集合是如何保证无序不可重复的
根据哈希值来确定元素在集合中的位置，根据Hascode和equals方法来保证元素的唯一性
3.我们为什么要重写HashCode( )和equals（）方法？
因为在集合中每次创建出的对象都有唯一的地址值，所以即使内容完全一样也无法来判断是否内容重复。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()。HashCode()判断的是地址值，地址值是唯一的，可以提高速度。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable为自然排序、
Comparator可以实现精确控制，也可以为那些没有自然顺序的对象提供排序。
如果使用频率高使用comparable
如果需要制定特殊的比较规则这使用comparator
--李翔
作者: 张子建 时间: 2018-8-14 21:33
1.List接口下都有哪些集合，他们各自有什么特点
(1)Arrraylist集合时用的最多的集合 是数组结构 查找快 增删慢
LinkedList集合是双向链表 增删快 查找慢 所以有一些操作首尾的方法
2.Set接口下的集合是如何保证无序不可重复的
用hashCode方法和equals方法
3.我们为什么要重写HashCode( )和equals（）方法？
为了防止集合中元素重复
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，若是哈希值相同，再判断equals（）方法，因为哈希值不同就直接不用存储
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable是自己和别人比，比较需要实现接口Comparable，重写compareTo方法，适用于高频率排序的类，不用找比较器
Comparator是第三方，也就是比较器，不需要实现接口，灵活制定比较规则
作者: 郭生发 时间: 2018-8-14 21:35
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList 是以数组结构存储数据的
LinkedList 是以链表结构存储数据的
2.Set接口下的集合是如何保证无序不可重复的
Set接口下的集合是按照某种规则排列。无索引，所以称为无序。
通过哈希值的比较和内容的比较去除相同的元素。
先比较元素的哈希值，不同则直接存储，相同再用equals方法比较内容，如果仍相同则不储存，不同则储存。
3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法原来是比较地址值，没有意义，重写后为比较内容。
HashCode()方法原是本地方法给的哈希值，当内容相同时哈希值可能不同，不适用，重写后当内容相同时，所得的哈希值相同，可以排重更适用。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，后判断
equals（），因为比较值的执行效率比比较内容的效率更高，运行更快。
当HashCode()不同时，就不用再判断equals()方法了。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要被实现，才能使用。
Comparator不需实现。
Comparator接口使用的多，因为它不需实现接口，更灵活。
作者: 谢君昇 时间: 2018-8-14 21:41
1.List接口下都有哪些集合，他们各自有什么特点
Vector；ArrayList；LinkedList;
1、有序；2、可以有重复元素；3、有索引值；
2.Set接口下的集合是如何保证无序不可重复的
重写hashCode（）和equals（）方法，当哈希值不同是直接储存元素，否则调用equals（）比较内容，内容相同时不储存，不同是储存元素；
3.我们为什么要重写HashCode( )和equals（）方法？
只有重写重写hashCode（）和equals（）方法才能保证元素的唯一性；
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode（），当哈希值相同时才判断equals（），哈希值为int类型，判断更快速；
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
一定要实现comparable接口和重写comparaTo（）方法才能使用sort（）方法，
而Comparator不需要实现。comparator接口使用的多，因为可以使用内部匿名类而不用到类中修改判断条件； |
|
作者: shenxiaogan 时间: 2018-8-14 21:41
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合查找快，增删慢，
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
没有索引，所有是一个无序集合
3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法默认比较的是两个对象的地址值，无意义，所有需要重新写
HashCode( )方法，防止哈希碰撞情况发生
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断哈希值，因为哈希值判断完之后还会判断内容是否相等
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
区别在于一个已经定义好的，一个需要自己定义的，
如果没有特殊必要Comparable使用较多，
如非必要，基本不使用Comparator。
作者: spik 时间: 2018-8-14 21:41
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList: 底层居于数组的栈类型结构，查询速度快，增删效率低。
LinkedList:底层居于链表格式类型的结构，查询速度慢，增删快。
Vector:同ArrayList，但是操作是单线程的，效率低。
2.Set接口下的集合是如何保证无序不可重复的
Set通过hashCode和equals方法实现元素不重复。
由于是通过哈希值来确定元素的存储位置，所以是无序的。
3.我们为什么要重写HashCode( )和equals（）方法？
默认的HashCode（） 方法比较的是默认的对象地址值，为了确保对象的唯一性，需要重写HashCode（）和equals（）方法。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，在HashCode不同的时候才调用equals（）方法。hashcode是调用根据哈希算法的本地方法产生哈希值，比较能确保唯一性，效率高。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
comparable 强行对实现它的每个类的对象进行整体排序，不能修改类的代码实现自己想要的排序，
用Collections.sort或者Arrays.sort进行自动排序，无需指定比较器
Comparator 可以将 Comparator 传递给sort方法，从而允许在排序顺序上实现精确控制。
lijionghua
作者: 黄艺纯 时间: 2018-8-14 21:42
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:底层的数据结构使用的是数组结构；特点：查找快，但增加删除慢。
LinkedList：底层使用的是链表数据结构；特点：增删速度快，但是查找修改慢。
Vector：底层是数组结构，和ArraysList功能一样，但是Vector是同步的，ArraysList是不同步。被ArrayList替代。
2.Set接口下的集合是如何保证无序不可重复的
Set是一个接口，常用的Set实现类那就是HashSet了。
-------------------------------------------------
public HashSet() {
map = new HashMap<E,Object>();
}
-------------------------------------------------
这是HashSet的构造方法。 可以看到HashSet内部其实就是一个HashMap 。
因为HashMap在put一个Key时会判断，将要放进去的Key的hash值与目前HashMap中定位到的那个Key的hash值比较。
如果hash值相当，继续比较 这两个对象的地址或者内容是否相当。
如果相当：判断出来要添加的Key与HashMap中的Key重复，把Value的值给替换成最新的。
HashSet中的Value是一个固定值PRESENT。 所以修改不修改无所谓。
3.我们为什么要重写HashCode( )和equals（）方法？
首先equals与hashcode间的关系是这样的：
1、如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；
2、如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)
由于为了提高程序的效率才实现了hashcode方法，先进行hashcode的比较，如果不同，那没就不必在进行equals的比较了，这样就大大减少了equals比较的次数，这对比需要比较的数量很大的效率提高是很明显的，一个很好的例子就是在集合中的使用；
我们都知道java中的List集合是有序的，因此是可以重复的，而set集合是无序的，因此是不能重复的，那么怎么能保证不能被放入重复的元素呢，但靠equals方法一样比较的话，如果原来集合中以后又10000个元素了，那么放入10001个元素，难道要将前面的所有元素都进行比较，看看是否有重复，这个效率可想而知，因此hashcode就应遇而生了，java就采用了hash表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据只要看对应的hashcode地址上是否有值，那么就用equals比较，如果没有则直接插入，只要就大大减少了equals的使用次数，执行效率就大大提高了。
继续上面的话题，为什么必须要重写hashcode方法，其实简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
就跟之前题目提到的为什么重写hashCode和equals里面说到的，hashCode的重写保证了元素的唯一性，而hashCode的值是int类型，数值比较的运算速度远远快于内容的比较速度，越是优秀的算法，哈希碰撞的概率越小，这样就大大减少了equals的使用次数，执行效率
就大大提高了。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
Compatator使用的多，因为可以实现自己想要的排序的排序方法，而Comparable，只有自一种然比较方法，不能满足我们不同的排序需求。
作者: 林胜强 时间: 2018-8-14 21:42
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList集合查找快，增删慢，
LinkedList集合1.底层是一个链表结构，查找慢，增删快。里面包含大量操作首尾元素的方法
2.Set接口下的集合是如何保证无序不可重复的
先比较hash值，相同再equal比较true则元素相同不存储
3.我们为什么要重写HashCode( )和equals（）方法？
重写HashCode( )方法给元素唯一的哈希值，equals（）不重写比较的是地址值无意义。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode()，Hash值是唯一值，只有发生哈希碰撞时才需要对元素进行内容判断，更省内存
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。Comparator：强行对某个对象进行整体排序。
Comparator用的多，方法的重写只对当前对象产生影响，更加灵活。
作者: 郑颖锋 时间: 2018-8-14 21:42
1.List接口下都有哪些集合，他们各自有什么特点
list接口下有：
ArrayList :
底层是数组结构，查询快，增删慢
LinkedList:
特点：1.底层是双向链表结构，查询慢，增删快
2.包含大量操作首尾元素的方法
3.不能使用多态
2.Set接口下的集合是如何保证无序不可重复的
保证元素唯一性的方式依赖于： hashCode 与 equals 方法。
先判断hashcode()，如果不相同直接存储，相同再比较equals（），不相同继续存储，如果还相同就不存储。
3.我们为什么要重写HashCode( )和equals（）方法？
HashCode( )和equals（）是系统默认给出的随机哈希值，容易发生哈希碰撞，所以需要重写。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashcode()，如果不相同直接存储，相同再比较equals（），不相同继续存储，如果还相同就不存储。
不同就直接存储，提高存储效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator使用的多，因为Comparator不需要实现接口，更加灵活。
作者: 李志超 时间: 2018-8-14 21:45
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:数组集合，查询快，增删慢。 LinkedList：链表集合，查询慢，增删快。
2.Set接口下的集合是如何保证无序不可重复的
通过hash值和equals方法进行判定重复性
3.我们为什么要重写HashCode( )和equals（）方法？
为了制定我们想要的规则
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode，因为该值是基本数据类型，判断更迅捷。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么
Comparator用的多，因为改变规则时不需要在实现类中修订/重写方法。
作者: 赖良峰 时间: 2018-8-14 21:46
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList:有序,有索引,元素可重复,数据结构是数组,查询快,增删慢
LinkedList:有序,有索引,元素可重复,数据是链表结构,查询慢,增删快
Vector:有序,有索引,元素可重复,
2.Set接口下的集合是如何保证无序不可重复的
使用hashcode方法和equals方法
3.我们为什么要重写HashCode( )和equals（）方法？
保证set接口下的集合中的元素不会重复
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashcode();哈希值是十进制的,判断起来比较节约系统资源,
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator:相当于找一个第三方的裁判比较两个;Comparable:自己(this)和别人(参数)比较,自己需要实现 Comparable接口,重写比较的规则compareto方法,
comparator用的比较多,因为他制定规则比较灵活
|
|
作者: 赵烈刚 时间: 2018-8-14 21:49
3.我们为什么要重写HashCode( )和equals（）方法？
答：如果我们往集合中存放自定义的对象，那么保证其唯一， 就必须复写hashCode和equals方法建立属于当前对象的比较方式。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode（），只有HashCode返回值冲突的时候才会调用equals方法进行判断。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
答：Comparator：相当于找一个第三方的裁判，比较两个
作者: 黄晨伟 时间: 2018-8-14 21:49
1.ArrayList合集数据存储的结构是数组结构。特点:元素增删慢，查找快。
LinkedList合集数据的结构是链表结构。特点：方便元素添加,删除的合集。
2.HashSet是Set接口的一个现实类,它所存储的元素是不可重复的（是由hashCode和equals方法决定的），并且元素都是无序的
3.因为Object的equal方法默认是两个对象的引用的比较，意思就是指向同一内存,地址则相等，否则不相等；如果你现在需要利用对象里面的值来判断是否相等，则重载equal方法。 当equal相等时，hashCode必 须相等，而且如果是object对象，必须重载hashCode和equal方法
4.先判断HashCode()因为不同的对象可能会生成相同的hashcode值,如果要判断两个对象是否真正相等，必须通过equals方法。
5.
作者: 冰是睡着的水 时间: 2018-8-14 21:50
1.List接口下都有哪些集合，他们各自有什么特点
答：LinkedList集合与ArrayList集合。LinkedList查找慢，增删快，是以链表结构存储数据的。
ArrayList查找快，增删慢，是以数组结构存储数据的。
2.Set接口下的集合是如何保证无序不可重复的
答：Set接口下的集合在保存时有覆盖重写equals（）方法和hashCode（）方法，双重把关，
保证集合元素无序不可重复。
3.我们为什么要重写HashCode( )和equals（）方法？
答：保证Set接口下的集合元素无序不可重复。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
答：先判断HashCode()的返回值，若返回值为0，则判断equals（）的返回值是true还是false。
因为HashCode()的返回值是整型，运行快，所以先判断HashCode()。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
答：Comparable是强行对实现它的每个类的对象进行整体排序，无需指定比较器，适用于高频率排序的类。
Comparator是强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），
从而允许在排序顺序上实现精确控制。
（黄嘉欣）
作者: ZNBran 时间: 2018-8-14 21:51
1.List接口中有ArrayList集合，LinkedList集合，Vector集合等
ArrayList集合增删慢，查询快是最常用的集合，LinkedList集合增删快查找慢，Vector集合实现是同步的。
2Set在增加数据是会调用hashCode方法和equals方法，来判断数据是否重复
3可以用自己的方式重写hashCode方法和equals方法减少哈希碰撞保证数据在集合中的唯一性
4先调用hashCode方法如果哈希值相同再使用equals方法判断数据是否相同，先使用hashCode方法因为方法给定的值一般情况下是唯一的如果出现哈希碰撞再调用equals方法来判断两个数据是否相同
5Comparable和Comparator：区别在于Comparator进行排序需要自己定义比较方式来进行比较，
Comparable则是拿参数与自身进行比较，所以一般情况下Comparable用的多
------------------------------------------------------------------------------------------- 周楠
作者: MJ11 时间: 2018-8-14 21:52
1.List接口下都有哪些集合，他们各自有什么特点？
list接口下有ArrayList集合，LinkedList集合
ArrayList的集合特点：集合数据存储的结构是数组结构。元素增删慢，查找快
LinkedList集合的特点：底层是一个链表结构，查询慢，增删快，双向链表，有序集合
2.Set接口下的集合是如何保证无序不可重复的？
Set接口下的集合没有索引值，元素无序，会以某种规则保证存入的元素不出现重复不允许存储重复元素。
3.我们为什么要重写HashCode( )和equals（）方法？
方法中两个对象默认比较的是地址值，无法比较对象的内容，无意义。HashCode( )和equals（）能比较对象的内容
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
向set集合中存入元素的时候 1.先比较哈希值 2.如果发生了哈希碰撞的话就会调用equals方法进行内容比较
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。 Comparable接口使用得比较多，能进行自动排序，无序指定比较器
田浪
作者: 仰望｀星空 时间: 2018-8-14 21:53
郭林源
1.List接口下都有哪些集合，他们各自有什么特点--->所学的有LinkedList（提供了大量操作首尾元素的方法）,ArrayList（大小可变的数组）Vector（单线程的，速度慢），List接口特点：集合有索引值，有序排列，元素可重复
2.Set接口下的集合是如何保证无序不可重复的--->利用HashSet哈希算法生成哈希值，确保每个集合元素的唯一性
3.我们为什么要重写HashCode( )和equals（）方法？--->如果不重写它们，哈希值默认比较的是地址值，如果出现哈希碰撞，再调用equals方法时，比较的也是地址值，无法确保集合元素的唯一性
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？-->先判断哈希值，哈希表由数组+链表+红黑树组成，先判断其哈希值是否一致，如果出现哈希碰撞，可能该数组位置上有两个哈希值相同的元素，再用equals判断是否是同样内容的元素
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？-->Comparator使用的最多，Comparable只能在类中实现compareTo()一次 ，不能经常修改类的代码实现自己想要的排序，而Comparator直接创建匿名内部类后，可直接进行排序规则修改
作者: 小鱼七 时间: 2018-8-14 21:55
本帖最后由 小鱼七 于 2022-3-4 09:34 编辑
1.List接口下都有哪些集合，他们各自有什么特点ArrayList集合，底层是数组查找快，增删慢
LinkedList集合，底层是链表结构，查找慢，增删快
2.Set接口下的集合是如何保证无序不可重复的
利用重写的hashCode和equals方法，如hashCode判断已经存在此哈希吗，则equals判断内容是否一致，如一致则是同一元素，如不一致则发生哈希碰撞
3.我们为什么要重写HashCode( )和equals（）方法？
当集合中的元素的对象是需要重写hashCode,生产哈希值，重写equals判断内容是否一致
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断hashCode,可以提高效率
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable需要类中重写comparaTo方法，不能需改比较的方式
Comparator可以方便修改比较方式，Comparator用的多
作者: 陈锦祥 时间: 2018-8-14 21:56
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList ：底层是数组结构 查询快 增删慢
LinkedList： 底层是链表结构 查询慢 增删快
Vector Stack 等等。。。
2.Set接口下的集合是如何保证无序不可重复的
通过 hash 值进行比较 不一样的话直接储存 如果一样 再进行equals 比较 不一样 储存 一样不储存
保证元素唯一
3.我们为什么要重写HashCode( )和equals（）方法？
equals（）方法默认比较的是两个对象的地址值，没有实际意义，所以需要重新写
HashCode( )方法，防止哈希碰撞情况发生
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode( ) 如果hash值一样 在用equals 比较内容
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，无需指定比较器。Comparator：强行对某个对象进行整体排序。创建第三方实现Comparator接口重写 compare方法 的对象 将 对象 传递给sort方法（如Collections.sort或 Arrays.sort）， 比较常用 |
|
作者: 吴鑫佳 时间: 2018-8-14 21:56
1.List接口下都有哪些集合，他们各自有什么特点
ArrayList，LinkList等，ArrayList由于底层是有数组组成的，所以具有查询快，增删慢的特点，Linklist底层有链表的组成，所以有具有查询慢增删快的特点。他们都有序，有索引，可重复的特点。
2.Set接口下的集合是如何保证无序不可重复的
通过特定算法生成HashSet值，如果出现碰撞还可以通过equals来判断是否相等，所以确保了元素的唯一性。
3.我们为什么要重写HashCode( )和equals（）方法？
当出现哈希值一样的的时候并不代表元素是一样的，所以需要重写HashCode( )，equeals默认比较的是对象的地址值，要比较内容才能判断是否一样，所以也要重写。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断 HashCode()，因为生成HashCode()的运行资源较少而且较快，当HashCode()一样的时候再去判断equals（）并不会增加很大负担。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparator用的比较多，因为Comparator比较灵活，不需要在对象类中重写方法也不需要实现接口。而且如果要修改也会方便的多。
作者: zouyitao 时间: 2018-8-14 21:57
邹毅涛
1.List接口下都有哪些集合，他们各自有什么特点
List接口下都有ArrayList 、LinkedList、Vector。在1.2版本之后ArrayList取代了Vector，特点是查找快增删慢，LinkedList特点是增删快查找慢。
2.Set接口下的集合是如何保证无序不可重复的
Set通过哈希值保证无序，通过HashCode()和equals方法避免重复。
3.我们为什么要重写HashCode( )和equals（）方法？
Object类中的equals只比较了对象的地址值，重写使其比较内容是否相等，HashCode防止哈希碰撞。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，如果哈希值相同，在判断equals。HashCode是将对象的内部地址转换成十进制整数返回。提高查找效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator需要自己定义。比较灵活。
作者: liebstch 时间: 2018-8-14 21:59
陈建秋
1.List接口下都有哪些集合，他们各自有什么特点 ArrayList，底层为数组，查询快，增删慢，线程不安全。
LinkedList，底层为链表，增删快，查询慢，线程不安全。
Vector，线程同步安全，但是效率低。
2.Set接口下的集合是如何保证无序不可重复的
无序：Set集合底层是哈希表，元素的存放根据哈希值指定存放的位置，所以数据是无序的。
不可重复：
1.先对哈希值进行比较，哈希值不同才能添加进集合，如果哈希值碰撞了。
2.使用equals方法对指定的内容进行比较，只有内容也不相等的才能加入集合。
3.我们为什么要重写HashCode( )和equals（）方法？
如果不重写equals方法比较的是地址值，每个new出来的对象的地址都是不同比较没有意义，如果不重写Hashcode方法，返回的Hash值也是不同地址值的10进制表示，如果默认对象某些内容相同为同一对象，但是由于哈希值不同，就会判定两个对象不同，会产生歧义。
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCod因为哈希值比较的是数值判断效率高，而且好的哈希算法的哈希碰撞是很少的，可以大量的减少equals的比较次数，确保了数据
的效率。
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
Compator接口使用较多应为它使用灵活，可以根据不同的需求进行排序，只需要通过重写接口方法就可以实现，而Comparable则需要修改原来的类。
作者: 舟sir 时间: 2018-8-14 23:04
1.List接口下都有哪些集合，他们各自有什么特点 有序，有索引，元素可重复
- LinkedList：双向链表结构
- ArrayList：多线程，底层是数组结构
- Vector：单线程，同步，底层是数组，迭代器和前两个不一样
2.Set接口下的集合是如何保证无序不可重复的
通过HashCode方法判断，哈希值不一样直接存储，当发生哈希碰撞时，会调用equals方法判断内容是否一致，一致不添加，不一致存储；
3.我们为什么要重写HashCode( )和equals（）方法？
equals 对于系统比较的是地址值，需要改写比较对象的属性和内容
HashCode方法地址是本地系统的，内容一样的时候可能地址不一样，这时需要改写HashCode方法让内容一样的对象返回一样的地址值；
4.数据在存入Set集合的时候，是先判断HashCode()还是先判断equals（），为什么？
先判断HashCode，效率高速度快
5.Comparable和Comparator两个接口的区别，哪种接口使用的多，为什么？
Comparable：对所有类的对象进行排序，一般不随便修改，不能按自己随意的方式排序；
Comparator：对对象进行排序，可以更改已有的默认排序和对没有排序的LIst对象定义排序，可以定义自己想要的排序方式，进行多级的排序规则
Comparator用的多，简便，一般排序用的频繁的情况下使用Comparable接口
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |