概述
通过该笔记的整理,对 JAVA
的 Collection
(集合)的基本使用和一些常见的使用场景、底层源码等知识点进行巩固,以达到 “温故知新” 的目的。
目录
主要内容
0x01:集合框架的概述
面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。另一方面,使用 Array
存储对象方面具有一些弊端,而Java
集合就像一种容器,可以动态地把多个对象的引用放入容器中。
- 数组在存储多个数据方面的特点:
- 一旦初始化以后,其长度就确定了。
- 数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
- 数组在存储多个数据方面的缺点:
- 一旦初始化以后,其长度就不可修改。
- 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
- 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
- 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。
使用集合可以解决上述数组在储存多个数据时的缺点。
而 Java
集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。
Java
集合可分为 Collection
和 Map
两种体系
- Collection接口: 单列数据, 定义了存取一组对象的方法的集合
- List: 元素有序、可重复的集合
- ArrayList、LinkedList、Vector
- Set: 元素无序、不可重复的集合
- HashSet、LinkedHashSet、TreeSet
- List: 元素有序、可重复的集合
- Map接口: 双列集合,可以储存双列数据,保存具有映射关系 “key-value” 的集合
- HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Collection接口继承树
Map接口继承树
0x02:Collection接口中的常用方法
Collection 接口是 List
、 Set
和 Queue
接口的父接口,该接口里定义的方法既可用于操作 Set
集合,也可用于操作 List
和 Queue
集合。
JDK
不提供此接口的任何直接实现,而是提供更具体的子接口 (如: Set
和 List
)实现。
在 JDK5
之前, Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成 Object
类型处理; 从 JDK 5.0
增加了泛型以后, Java
集合可以记住容器中对象的数据类型。
一些常用的方法如下
1、 添加
-
add(Object obj)
-
addAll(Collection coll)
2、 获取有效元素的个数
int size()
3、 清空集合
void clear()
4、 是否是空集合
boolean isEmpty()
5、 是否包含某个元素
-
boolean contains(Object obj)
:是通过元素的equals方法来判断是否是同一个对象
-
boolean containsAll(Collection c)
:也是调用元素的equals方法来比较的。 拿两个集合的元素挨个比较。
6、删除
-
boolean remove(Object obj)
:通过元素的equals方法判断是否是要删除的那个元素。 只会删除找到的第一个元素
-
boolean removeAll(Collection coll)
:取当前集合的差集
7、取两个集合的交集
-
boolean retainAll(Collection c)
:把交集的结果存在当前集合中,不影响c
8、 集合是否相等
boolean equals(Object obj)
9、 转成对象数组
Object[] toArray()
10、获取集合对象的哈希值
hashCode()
11、遍历
-
iterator()
:返回迭代器对象,用于集合遍历
部分用例代码如下
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//add(Object e):将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
//size():获取添加的元素的个数
System.out.println(coll.size());//4
//addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
coll.addAll(coll1);
System.out.println(coll.size());//6
System.out.println(coll);
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty());
}
}
0x02:Iterator 迭代器
概述
Iterator
对象称为迭代器(设计模式的一种),主要用于遍历Collection
集合中的元素。GOF
给迭代器模式的定义为:提供一种方法访问一个容器(container
)对象中各个元素,而又不需暴露该对象的内部细节。 迭代器模式,就是为容器而生。 类似于“公交车上的售票员”、“火车上的乘务员”、 “空姐” 。- Collection 接口继承了
java.lang.Iterable
接口,该接口有一个iterator()
方法,那么所有实现了Collection
接口的集合类都有一个iterator() 方法,用以返回一个实现了Iterator
接口的对象。
遍历
使用 iterator
(迭代器)遍历集合
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
输出结果
123
456
Person{name='Jerry', age=20}
Tom
false
迭代器的遍历原理:
-
获取集合的迭代器对象
-
每次调用迭代器的
.next()
方法时,先使用hasNext
下一个对象是否存在,再将指针(游标)指向迭代器中的下一个对象,然后返回当前指向的对象的值,如下图
Iterator 仅用于遍历集合, Iterator
本身并不提供承装对象的能力。如果需要创建 Iterator
对象,则必须有一个被迭代的集合。
错误的示范:
//错误方式一:
Iterator iterator = coll.iterator();
while((iterator.next()) != null){
System.out.println(iterator.next());
}
//错误方式二:
//集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
while (coll.iterator().hasNext()){
System.out.println(coll.iterator().next());
}
集合对象每次调用 iterator()
方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。所以 hasNext()
和 next()
都调用都必须处于同一个迭代器对象下。
使用foreach进行遍历
Java 5.0
提供了 foreach
循环迭代访问 Collection和数组。
- 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
- 遍历集合的底层调用
Iterator
完成操作。 - foreach还可以用来遍历数组。
编辑集合
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//for(集合元素的类型 局部变量 : 集合对象)
//内部仍然调用了迭代器。
for(Object obj : coll){
System.out.println(obj);
}
遍历数组
int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象)
for(int i : arr){
System.out.println(i);
}
练习题:使用 foreach
遍历的数组,重新赋值不会影响原数组的值,如下
String[] arr = new String[]{"MM","MM","MM"};
//方式一:普通for赋值
for(int i = 0;i < arr.length;i++){
arr[i] = "GG";
}
//方式二:增强for循环
for(String s : arr){
s = "FF";
}
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
输出结果
GG
GG
GG
原因:使用foreach遍历数组时,遍历时会产生新的对象用于接收原有的值
移除
- 调用
.remove()
方法
//删除集合中"Tom"
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
//iterator.remove();
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
//iterator.remove();
}
}
//遍历集合
iterator = coll.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
注意:
Iterator
可以删除集合的元素, 但是是遍历过程中通过迭代器对象的remove
方法, 不是集合对象的remove
方法。- 如果还未调用
next()
或在上一次调用next
方法之后已经调用了remove
方法,再调用 remove 都会报IllegalStateException
。
0x03:List接口
概述
鉴于 Java
中数组用来存储数据的局限性,我们通常使用List替代数组
List
集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
List
容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
JDK API
中 List
接口的实现类常用的有: ArrayList、 LinkedList和Vector。
实现类:ArrayList
JDK7
与 JDK8
的情况会有些不同,我们继续具体的分析
JDK7 的情况下:
初始化 ArrayList
ArrayList list = new ArrayList();
底层创建了长度是 10
的 Object[]
数组elementData
如下图
接着往list内添加数据
list.add(123); //elementData[0] = new Integer(123);
如果此时继续向 list
内添加数据,导致底层 elementData
数组容量不够,则会进行扩容。
默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
扩容的方式与SpringBuilder类似
结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)
,并指定一个预期的容量大小,以减少扩容的次数。
JDK8 的情况下:
初始化 ArrayList
ArrayList list = new ArrayList();
此时底层 Object[] elementData
初始化为 {}
.并没有创建长度为 10
的数组
在JDK8的源码的当中,代码改了,但是注释没改 😂
list.add(123); //向list添加数据
第一次调用 add()
时,底层才创建了长度 10
的数组,并将数据 123
添加到 elementData[0]
后续的添加和扩容操作与 jdk 7
无异。
小结:
jdk7
中的 ArrayList
的对象的创建类似于单例的 “饿汉式” ,而 jdk8
中的 ArrayList
的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
实现类:LinkedList
对于频繁的插入或删除元素的操作,建议使用 LinkedList
类,效率较高,对于需要频繁读取(查询)的操作,还是建议使用 ArrayList
LinkedList: 双向链表, 内部没有声明数组,而是定义了 Node
类型的 first
和last
,用于记录首末元素。同时,定义内部类 Node
,作为 LinkedList
中保存数据的基本结构。 Node
除了保存数据,还定义了两个变量:
- prev 变量记录前一个元素的位置
- next 变量记录下一个元素的位置
源码如下
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
新增方法:
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getLast()
- Object removeFirst()
- Object removeLast()
实现类:Vector
Vector
是一个古老的集合, JDK1.0
就有了。大多数操作与 ArrayList
相同,区别之处在于 Vector
是线程安全的。
jdk7
和 jdk8
中通过 Vector() 构造器创建对象时,底层都创建了长度为 10
的数组。在扩容方面,默认扩容为原来的数组长度的 2
倍。
在各种 list
中,最好把 ArrayList
作为缺省选择。当插入、删除频繁时,使用LinkedList, Vector
总是比 ArrayList
慢,所以尽量避免使用。
新增方法:
-
void addElement(Object obj)
-
void insertElementAt(Object obj,int index)
-
void setElementAt(Object obj,int index)
-
void removeElement(Object obj)
-
void removeAllElements()
常用的方法及使用
-
void add(int index, Object ele)
:在index位置插入ele元素
-
boolean addAll(int index, Collection eles)
:从index位置开始将eles中的所有元素添加进来
-
Object get(int index)
:获取指定index位置的元素
-
int indexOf(Object obj)
:返回obj在集合中首次出现的位置
-
int lastIndexOf(Object obj)
:返回obj在当前集合中末次出现的位置
-
Object remove(int index)
:移除指定index位置的元素,并返回此元素
-
Object set(int index, Object ele)
:设置指定index位置的元素为ele
-
List subList(int fromIndex, int toIndex)
:返回从fromIndex到toIndex位置的子集合
使用案例 ①
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
System.out.println(list);
//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB");
System.out.println(list);
//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
//list.add(list1);
System.out.println(list.size());//9
//Object get(int index):获取指定index位置的元素
System.out.println(list.get(0));
}
输出结果
[123, 456, AA, Person{name='Tom', age=12}, 456]
[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
9
123
Process finished with exit code 0
使用案例②
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
//int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在,返回-1.
int index = list.indexOf(4567);
System.out.println(index);
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在,返回-1.
System.out.println(list.lastIndexOf(456));
//Object remove(int index):移除指定index位置的元素,并返回此元素
Object obj = list.remove(0);
System.out.println(obj);
System.out.println(list);
//Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
List subList = list.subList(2, 4);
System.out.println(subList);
System.out.println(list);
}
输出结果
-1
4
123
[456, AA, Person{name='Tom', age=12}, 456]
[456, CC, Person{name='Tom', age=12}, 456]
[Person{name='Tom', age=12}, 456]
[456, CC, Person{name='Tom', age=12}, 456]
Process finished with exit code 0
使用案例③
@Test
public void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
//方式一:Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("***************");
//方式二:增强for循环
for(Object obj : list){
System.out.println(obj);
}
System.out.println("***************");
//方式三:普通for循环
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
}
输出结果
123
456
AA
***************
123
456
AA
***************
123
456
AA
Process finished with exit code 0
常用方法总结:
增:add(Object obj)
删:remove(int index) / remove(Object obj)
改:set(int index, Object ele)
查:get(int index)
插:add(int index, Object ele)
长度:size()
遍历:
- ①
Iterator
迭代器方式 - ② 增强
for
循环(foreach) - ③ 普通的循环
拓展
1、ArrayList、LinkedList、Vector 各有优缺点,下面我们来具体分析
相同的
- 三个类都实现了 List 接口,储存数据的特点相同:储存有序的、可重复的
不同之处
ArrayList
:-
作为List接口的主要实现类,线程不安全的,效率高。
-
适用于频繁读取的使用场景,而当数量大时进行插入和删除的操作效率较低,因为 ArrayList 在进行写入、删除等操作时需要向后移动数据。当数据量巨大时,开销也是巨大的。
-
底层使用
Object[] elementData
存储
-
LinkedList
:-
对于频繁的插入、删除操作,使用此类效率比ArrayList高,但是查询效率相对较低,原因LinkedList在查询时要移动指针。
-
底层使用双向链表存储
-
Vector
:- 作为
List
接口的古老实现类;线程安全的,效率低; - 底层使用
Object[] elementData
存储 - Vector 中大量的使用了 synchronized,属于强同步类。因此开销就比
ArrayList
要大,访问要慢。 - Vector 每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。
- 作为
2、区分List中 remove(int index)
和 remove(Object obj)
@Test
public void testListRemove() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);//
}
private void updateList(List list) {
//删除下标为2的对象
list.remove(2);
//删除值为2的对象
list.remove(new Integer(2));
}
0x04:Set接口
概述
- Set接口是
Collection
的子接口, set接口没有提供额外的方法。 - Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。
- Set 判断两个对象是否相同不是使用 == 运算符,而是根据
equals()
方法
总结:Set接口:存储无序的、不可重复的数据
Set接口下有3个子类的实现:
-
HashSet
:作为Set接口的主要实现类;线程不安全的;可以存储null值
-
LinkedHashSet
:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历,对于频繁的遍历操作,LinkedHashSet效率高于HashSet.
-
TreeSet
:可以按照添加对象的指定属性,进行排序。
下面我们来深入了解一下 Set
接口下的这几个子类的基本使用以及其实现原理。
实现类:HashSet
HashSet
是 Set
接口的典型实现,它按 Hash
算法来存储集合中的元素,因此具有很好的存取、查找、删除性能,所以作为 Set
的主要实现类
HashSet
底层也是数组, 初始容量为 16
, 当如果使用率超过 0.75
, (16*0.75=12)就会扩大容量为原来的 2
倍。例如 16
扩容为 32
, 依次为64,128....等)
HashSet
具有以下特点:
- 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的。
- 不可重复性:保证添加的元素按照
equals()
判断时,不能返回true
,即:相同的元素只能添加一个。 - HashSet 不是 “线程安全” 的
- 集合元素可以是
null
HashSet 集合判断两个元素相等的标准
- 两个对象通过
hashCode()
方法比较相等,并且两个对象的equals()
方法返回值也相等。 - 对于存放在
Set
容器中的对象, 对应的类一定要重写equals()
和hashCode(Objectobj)
方法,以实现对象相等规则。即: “相等的对象必须具有相等的散列码” 。
一个简单的使用案例
@Test
public void test1(){
Set set = new HashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
向 HashSet 中添加元素的过程
假设我们向 HashSet
中添加元素 a
,首先调用元素 a
所在类的 hashCode(
) 方法,计算元素a
的 “哈希值”,此哈希值接着通过某种算法计算出在 HashSet
底层数组中的存放位置(即为:索引位置),接下来判断数组的此位置上是否已经有元素:
- 如果此位置上没有其他元素,则元素a添加成功。(情况1)
- 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素
a
与元素b
的hash
值:- 如果hash值不相同,则元素a添加成功。(情况2)
- 如果hash值相同,进而需要调用元素a所在类的
equals()
方法:equals()
返回true
,元素a添加失败equals()
返回false
,则元素a添加成功。(情况3)
对于添加成功的 “情况2” 和 “情况3” 而言:元素 a
与已经存在指定索引位置上数据以链表的方式存储。但如果是在情况 3
,在添加新的元素时原有的位置已经存在元素,在 JDK7
与 JDK8
的储存方式会有些不同
- jdk 7 : 新加入的元素放到数组中,指向原来的元素。
- jdk 8 : 原来的元素在数组中,指向新加入的元素
- 总结:七上八下(新元素相较于旧元素的位置方向)
综上可知,HashSet
是数组和链表的结合体,如下图
关于hashCode()与equals()的重写
- 要求1:向Set (主要指:HashSet、LinkedHashSet)中添加的数据,其所在的类一定要重写
hashCode()
和equals()
- 要求2:重写的
hashCode()
和equals()
尽可能保持一致性:相等的对象必须具有相等的散列码
1、重写 hashCode()
方法的基本原则
- 在程序运行时,同一个对象多次调用 hashCode() 方法应该返回相同的值。
- 当两个对象的 equals() 方法比较返回 true 时,这两个对象的 hashCode()方法的返回值也应相等。
- 对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。
2、重写 equals()
方法的基本原则
以自定义的 Customer
类为例,何时需要重写 equals()
?
- 当一个类有自己特有的“逻辑相等”概念,当改写
equals()
的时候,总是要改写hashCode()
,根据一个类的equals
方法(改写后),两个截然不同的实例有可能在逻辑上是相等的,但是, 根据Object.hashCode()
方法,它们仅仅是两个对象。 - 因此,违反了“相等的对象必须具有相等的散列码”。
- 结论:复写equals方法的时候一般都需要同时复写hashCode方法。 通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
3、重写的案例
public class User{
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() { //return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
日常开发中,我们可以使用 idea
等开发工具一键生成
按下 Alt
+ Insert
键可以一键生成 equals()
和 hashCode()
的重写方法
LinkedHashSet
- LinkedHashSet 作为
HashSet
的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据前一个数据和后一个数据的索引位置。 - LinkedHashSet 根据元素的
hashCode
值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。
优点:对于频繁的遍历操作,LinkedHashSet
效率高于 HashSet
缺点:LinkedHashSet
插入性能略低于 HashSet
简单的使用案例
@Test
public void test2(){
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add("CC");
set.add(new User("Tom",12));
set.add(new User("Tom",12));
set.add(129);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
底层结构图
实现类:TreeSet
TreeSet
储存的对象必须是同一个类型的
两种排序方式:自然排序(实现Comparable接口)、定制排序(Comparator)
-
自然排序中,比较两个对象是否相同的标准为:compareTo()返回0,不再是equals()
-
定制排序中,比较两个对象是否相同的标准为:compare()返回0,不再是equals()
1、自然排序(Comparable)在TreeSet中的使用案例
@Test
public void test1(){
TreeSet set = new TreeSet();
//失败:不能添加不同类的对象
// set.add(123);
// set.add(456);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",12));
//举例一:
// set.add(34);
// set.add(-34);
// set.add(43);
// set.add(11);
// set.add(8);
//举例二:
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
User类
public class User implements Comparable{
private String name;
private int age;
// ... ...
// 省略构造器和Geter、Seter的代码
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() { //return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//按照姓名从大到小排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof User){
User user = (User)o;
// return -this.name.compareTo(user.name);
int compare = -this.name.compareTo(user.name);
if(compare != 0){
return compare;
}else{
return Integer.compare(this.age,user.age);
}
}else{
throw new RuntimeException("输入的类型不匹配");
}
}
}
执行结果
User{name='Tom', age=12}
User{name='Mike', age=65}
User{name='Jim', age=2}
User{name='Jerry', age=32}
User{name='Jack', age=33}
User{name='Jack', age=56}
2、定制排序(Comparator)在 TreeSet
中的使用案例
@Test
public void test2(){
Comparator com = new Comparator() {
//按照年龄从小到大排列
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
}else{
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
set.add(new User("Jim",2));
set.add(new User("Mike",65));
set.add(new User("Mary",33));
set.add(new User("Jack",33));
set.add(new User("Jack",56));
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
拓展
练习1:在List中去除重复的数字值
public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
@Test
public void test2(){
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add("ddd");
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
}
}
输出结果
1
2
4
ddd
思路:使用 HashSet
实现过滤重复
练习2:解释下面例子的输出结果
@Test
public void test3(){
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
System.out.println(set);
//情况1:
p1.name = "CC";
set.remove(p1);
System.out.println(set);
//情况2:
set.add(new Person(1001,"CC"));
System.out.println(set);
//情况3:
set.add(new Person(1001,"AA"));
System.out.println(set);
}
输出结果
[Person{id=1002, name='BB'}, Person{id=1001, name='AA'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
情况1:由于修改了 p1
对象的属性值,此时remove方法进行 hashCode
时得到的值不一致,所以成功写入该Set集合
情况2:通过 hashCode
计算属性值为 id=1001, name='AA'
的对象得到的索引位置,该位置上的没有储存任何的值(虽然修将p1的name修改为了 “CC” ,但是他的索引位置没变)所以成功写入。
情况3:通过 hashCode
得到的 new Person(1001,"AA")
与 p1 的值相同,但此时的 p1
对象的name为 “CC”,所以与p1进行 equals()
得到的结果为 false
,所以写入成功。
总结
通过本篇笔记的整理,再次巩固了对 Collection 接口下的 List、Set 的各项实现类,例如 ArrayList
、LinkedList
、HashSet
的使用方法及其原理有了进一步的认识。