11. Java集合
11.1 Java集合框架概述
1. 相关概述
引入集合的原因
一方面,面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。另一方面,使用Array存储对象方面具有一些弊端,而Java 集合就像一种容器,可以动态地把多个对象的引用放入容器中。
集合、数组都是对多个数据进行存储操作的结构,简称Java容器。(此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储)
数组在内存存储方面的特点:
- 数组初始化以后,长度就确定了
- 数组声明的类型,就决定了进行元素初始化时的类型
数组在存储数据方面的弊端:
- 数组初始化以后,长度就不可变了,不便于扩展
- 数组中提供的属性和方法少,不便于进行添加、删除、插入等操作,且效率不高。同时无法直接获取存储元素的个数
- 数组存储的数据是有序的、可以重复的,存储数据的特点单一
Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。
2. Java集合体系
Java 集合可分为 Collection 和 Map 两种体系
Collection接口:单列数据,定义了存取一组对象的方法的集合
-
List:元素有序、可重复的集合
- ArrayList、LinkedList、Vector…
-
Set:元素无序、不可重复的集合
- HashSet、LinkedHashSet、TreeSet…
Map接口:双列数据,保存具有映射关系“key-value对”的集合
- HashMap、LinkedHashMap、TreeMap、Hashtable、Properties…
11.2 Collection接口方法
1. Collection接口介绍
- Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。
- JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。
- 在 Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成 Object 类型处理;从 JDK 5.0 增加了泛型以后,Java 集合可以记住容器中对象的数据类型。
- 向Collection接口的实现类的对象中添加数据时,要求数据所在类要重写equals()。
2. Collection接口中的方法
-
添加
- boolean add(E e):将元素e添加到当前的集合中(E为泛型,可以看作是Object,下同)
- boolean addAll(Collection<? extends E> c):将c集合中的元素添加到当前的集合中
-
获取有效元素的个数
- int size():获取添加的元素的个数
-
清空集合
- void clear():清空集合元素
-
是否是空集合
- boolean isEmpty():判断当前集合是否为空
-
是否包含某个元素
- boolean contains(Object o):判断当前集合中是否包含o;在判断时会调用o对象所在类的equals(),即是通过元素的equals方法来判断是否是同一个对象
- boolean containsAll(Collection<?> c):判断形参c中的所有元素是否都存在于当前集合中,也是调用元素的equals方法来拿两个集合的元素挨个比较
-
删除
- boolean remove(Object o):从当前集合中移除o元素,通过元素的equals方法判断要删除的那个元素是否在集合中,只会删除找到的第一个元素
- boolean removeAll(Collection<?> c):从当前集合中移除c中所有的元素,即取差集
-
取两个集合的交集
- boolean retainAll(Collection<?> c):获取当前集合和c集合的交集,并把交集的结果存在当前集合中,不影响c
-
集合是否相等
- boolean equals(Object o):判断当前集合的所有元素是否与形参集合的所有元素相同(不同实现类的比较方式可能不同,例如ArrayList集合的存储顺序也要一样,两个集合才相等)
-
转成对象数组
-
Object[] toArray():将集合转为Object类型的数组
-
<T> T[] toArray(T[] a):将集合转为T类型的数组,并存放到a中,且还会将生成的数组返回
public class CollectionTest { public static void main(String[] args) { List<String> list = Arrays.asList("123", "456"); String[] str1 = new String[list.size()]; String[] str2 = list.toArray(str1); System.out.println(Arrays.toString(str1)); // 输出[123, 456] System.out.println(Arrays.toString(str2)); // 输出[123, 456] } }
补充:数组转集合:调用Arrays的asList方法
<T> List<T> asList(T… a):将可变形参a转为List集合(如果是基本数据类型的数组,则会认为是一个元素)
public class CollectionTest { public static void main(String[] args) { List<String> list1 = Arrays.asList("123", "456"); System.out.println(list1); // [123, 456] List<String> list2 = Arrays.asList(new String[]{"123", "456"}); System.out.println(list2); // [123, 456] List<Integer> list3 = Arrays.asList(123, 456); System.out.println(list3.size()); // 2 System.out.println(list3); // [123, 456] // ----------注意---------- List<int[]> list4 = Arrays.asList(new int[]{123, 456}); System.out.println(list4.size()); // 1 System.out.println(list4); // [[I@1b6d3586] List<Integer> list5 = Arrays.asList(new Integer[]{123, 456}); System.out.println(list5.size()); // 2 System.out.println(list5); // [123, 456] } }
-
-
获取集合对象的哈希值
- int hashCode():返回当前集合对象的哈希值
-
遍历
- Iterator<E> iterator():返回Iterator接口的实例,用于遍历集合元素
11.3 Iterator迭代器接口
1. 相关说明
- Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
- GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。迭代器模式,就是为容器而生。
- Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
- Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象,则必须有一个被迭代的集合。
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
2. Iterator接口的方法
-
boolean hasNext():判断集合中是否还存在下一个元素
-
E next():①将指针下移 ②将下移以后集合位置上的元素返回
在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常
-
void remove():移除集合中的当前元素(JDK1.8变成了默认方法)
- Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法
- 如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法, 再调用remove都会报IllegalStateException
3. 迭代器的原理
例子
public class IteratorTest {
public static void main(String[] args) {
Collection coll = Arrays.asList("123", "456");
// 获取迭代器对象
Iterator iterator = coll.iterator();
// 判断是否存在下一个元素
while (iterator.hasNext()) {
// 指针下移并将元素返回
Object next = iterator.next();
System.out.println(next);
}
}
}
原理
首先根据集合对象获取迭代器实例,获取的迭代器实例的默认游标在集合的第一个元素之前,然后通过hasNext()方法判断是否存在下一个元素,如果存在则通过next()方法先将游标向下移,然后返回当前指向的元素。
4. foreach——增强for循环
说明
- Java 5.0 提供了 foreach 循环迭代访问 Collection和数组。
- 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可以用来遍历数组。
格式
for (要遍历的元素类型 遍历后自定义元素名称 : 要遍历的结构名称) {
// 执行逻辑
}
例子
public class ForEachTest {
public static void main(String[] args) {
Collection coll = Arrays.asList("123", 456);
for (Object o : coll) {
System.out.println(o);
}
}
}
执行流程
首先coll取出一个元素赋值给o,然后输出o的内容,之后如果coll中还有元素,则再次取出赋值给o,直到coll中没有元素
5. 默认方法——foreach
JDK 1.8时Iterable接口提供了一个默认方法forEach,Collection接口继承了Iterable接口,因此其也具有该方法,能够直接遍历Collection集合
方法声明:
default void forEach(Consumer<? super T> action)
例子
public class ForEachTest {
public static void main(String[] args) {
Collection coll = Arrays.asList(123, 456, "aaa");
coll.forEach(System.out::println); // jdk8新特性lambda表达式
}
}
11.4 Collection子接口之一: List接口
1. List接口概述
- 鉴于Java中数组用来存储数据的局限性,通常使用List替代数组(可以将List理解为动态数组,能够根据变换长度)
- List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素
- JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector
- 向List中添加的数据,其所在的类一定要重写和equals(),以实现对象相等规则(remove() / contains()等方法需要)
2. List接口方法
List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法。
方法 | 说明 |
---|---|
void add(int index, E element) | 在index位置插入element元素 |
boolean addAll(int index, Collection<? extends E> c) | 从index位置开始将c中的所有元素添加进来 |
E get(int index); | 获取指定index位置的元素 |
int indexOf(Object o) | 返回o在集合中首次出现的位置,如果不存在,返回-1 |
int lastIndexOf(Object o) | 返回o在当前集合中末次出现的位置,如果不存在,返回-1 |
E remove(int index) | 移除指定index位置的元素,并返回此元素 |
E set(int index, E element) | 设置指定index位置的元素为element |
List<E> subList(int fromIndex, int toIndex) | 返回从fromIndex到toIndex位置的左闭右开区间的子集合 |
3. List实现类之一:ArrayList
相关说明
- ArrayList 是 List 接口的典型实现类、主要实现类
- 本质上,ArrayList是对象引用的一个”变长”数组
- ArrayList的JDK1.8之前与之后的实现有所区别
- jdk7中的ArrayList的对象的创建类似于单例的饿汉式,直接创建一个初始容量为10的数组
- jdk8中的ArrayList的对象的创建类似于单例的懒汉式,一开始创建一个长度为0的数组,当添加第一个元 素时再创建一个始容量为10的数组,延迟了数组的创建,节省内存
- Arrays.asList(…) 方法返回的 List 集合,既不是 ArrayList 实例,也不是 Vector 实例。Arrays.asList(…) 返回值是一个固定长度的 List 集合
- 在创建ArrayList对象时,最好使用带参构造器进行创建
- ArrayList是线程不安全的,效率高
- ArrayList底层使用Object[] elementData存储
- ArrayList可以存储null值
源码分析
jdk 7情况下
源码:
private transient Object[] elementData;
// 空参构造器
public ArrayList() {
this(10); // 调用自身的带参构造器
}
// 带参构造器
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0) // 判断初始容量是否合法
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
// 如果合法则创建一个长度为10的数组
this.elementData = new Object[initialCapacity];
}
// 添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 在添加元素前先判断数组的长度是否足够
elementData[size++] = e; // 进行元素添加
return true;
}
// 判断容量是足够,如果不够则扩容
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// 判断当前的元素需要的最小长度是否已经超过了创建的数组的长度
if (minCapacity - elementData.length > 0)
grow(minCapacity); // 如果超过了就进行扩容
}
// 扩容
private void grow(int minCapacity) {
// 获取当前创建的数组的长度
int oldCapacity = elementData.length;
// 将长度扩容为原理的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果扩容后的长度还不够则直接将目前所需的长度作为扩容的长度
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果目前容量超过设定值,则调用其他方法获取长度(实际直接拿最大的整型数作为容量)
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 复制元素到新数组,并赋值给当前数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
分析:
首先使用空参构造器创建一个ArrayList对象,则其底层会创建一个长度为10的Object[]数组elementData,而后调用add()方法,则会先判断容量是否足够,如果不够,则进行扩容,默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
ArrayList list = new ArrayList(); // 底层创建了长度是10的Object[]数组elementData
list.add(123); // elementData[0] = new Integer(123);
...
list.add(11); // 如果此次的添加导致底层elementData数组容量不够,则扩容。
jdk 8情况下
源码:
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private transient Object[] elementData;
// 空参构造器
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 在添加元素前先判断数组的长度是否足够
elementData[size++] = e; // 进行元素添加
return true;
}
// 判断容量是足够,如果不够则扩容(会先计算容量)
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断当前数组是否为初始化时的数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity); // 返回默认容量(10)和当前当前所需的容量的最大值
}
return minCapacity;
}
// 判断容量是足够,如果不够则扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 判断当前的元素需要的最小长度是否已经超过了创建的数组的长度
if (minCapacity - elementData.length > 0)
grow(minCapacity); // 如果超过了就进行扩容
}
// 扩容
private void grow(int minCapacity) {
// 获取当前创建的数组的长度
int oldCapacity = elementData.length;
// 将长度扩容为原理的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果扩容后的长度还不够则直接将目前所需的长度作为扩容的长度
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果目前容量超过设定值,则调用其他方法获取长度(实际直接拿最大的整型数作为容量)
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 复制元素到新数组,并赋值给当前数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
分析:
首先使用空参构造器创建一个ArrayList对象,则其底层会创建一个空的Object[]数组elementData,而后在第一次调用add()方法,则会先创建一个长度为10的数组,之后的扩容机制则和jdk7中相同
ArrayList list = new ArrayList(); // 底层Object[] elementData初始化为{}.并没有创建长度为10的数组
list.add(123); // 第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
...
// 后续的添加和扩容操作与jdk7相同
4. List实现类之二:LinkedList
相关说明
- 对于频繁的插入、删除操作,使用LinkedList效率比ArrayList高
- LinkedList底层使用双向链表存储
- LinkedList可以存储null值
新增方法
方法 | 说明 |
---|---|
void addFirst(E e) | 在此集合的开头插入指定的元素 |
void addLast(E e) | 将指定的元素追加到此集合的末尾,此方法相当于add() |
E getFirst() | 返回此集合中的第一个元素 |
E getLast() | 返回此集合中的最后一个元素 |
E removeFirst | 从此集合中删除并返回第一个元素 |
E removeLast() | 从此集合中删除并返回最后一个元素 |
源码分析
源码:
// 头节点
transient Node<E> first;
// 尾节点
transient Node<E> last;
// Node内部类
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;
}
}
// 添加元素方法
public boolean add(E e) {
linkLast(e); // 调用添加最后一个元素方法
return true;
}
// 向最后添加一个元素
void linkLast(E e) {
final Node<E> l = last; // 获取当前的最后一个元素
final Node<E> newNode = new Node<>(l, e, null); // 创建新节点
last = newNode; // 将新添加的节点作为尾节点
if (l == null) // 判断是否存在尾节点(即判断是否是第一个元素的添加)
first = newNode; // 将新节点作为头节点
else
l.next = newNode; // 让添加前的尾节点指向新节点
size++;
modCount++;
}
分析:
LinkedList:双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。Node除了保存数据,还定义了两个变量:
- prev变量记录前一个元素的位置
- next变量记录下一个元素的位置
首先创建一个LinkedList对象,之后添加元素,如果为第一次添加,则将该添加的元素作为头节点,也作为尾节点,如果不是第一次添加,则将当前添加的元素作为尾节点,并让之前的尾节点指向当前新添加的节点
LinkedList list = new LinkedList(); // 内部声明了Node类型的first和last属性,默认值为null
list.add(123); // 将123封装到Node中,创建了Node对象。
5. List 实现类之三:Vector
相关说明
- Vector是一个古老的集合,JDK1.0就有了
- Vector底层使用Object[] elementData存储
- Vector大多数操作与ArrayList 相同
- Vector是线程安全的,效率低
- Vector可以存储null值
- 在各种list中,最好把ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList;Vector总是比ArrayList慢,所以尽量避免使用
新增方法
方法 | 说明 |
---|---|
void addElement(E obj) | 将指定对象添加到此集合末尾 |
void insertElementAt(E obj, int index) | 将指定对象插入此集合中的指定索引处 |
void setElementAt(E obj, int index) | 将此集合指定索引处的对象设置为指定对象 |
boolean removeElement(Object obj) | 将指定元素从该集合中删除 |
void removeAllElements() | 从该集合中删除所有元素并将大小设置为零,此方法相当于clear() |
源码分析
protected int capacityIncrement;
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组。在扩容方面,基本与ArrayList相同,默认扩容为原来的数组长度的2倍。
6. ArrayList、LinkedList、Vector三者的异同
相同:三个类都是实现了List接口,存储数据的特点相同:存储有序的、可重复的数据
不同:
- ArrayList:作为List接口的主要实现类;是线程不安全的,效率高;底层使用Object[] elementData存储
- LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储
- Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储
其他说明
ArrayList和LinkedList的异同
二者都线程不安全,相对线程安全的Vector,执行效率高。此外,ArrayList是实现了基于动态数组的数据结构,而LinkedList是基于链表的数据结构。对于随机访问get和set,ArrayList优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。
ArrayList和Vector的区别
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。**Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。**Vector还有一个子类Stack。
7. List集合总结
常用方法
增: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循环 / 普通的循环
11.5 Collection子接口之二: Set接口
1. Set 接口概述
-
Set接口是Collection的子接口,set接口没有提供额外的方法
-
Set集合中存储的是无序的、不可重复的数据
说明:以HashSet为例
- 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的
- 不可重复性:保证添加的元素按照equals()判断时,不能返回true;即:相同的元素只能添加一个
-
Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个 Set 集合中,则添加操作失败
-
Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法
-
JDK API中Set接口的实现类常用的有:HashSet、LinkedHashSet和TreeSet
-
向Set(主要指:HashSet、LinkedHashSet)中添加的数据,其所在的类一定要重写hashCode()和equals(),以实现对象相等规则(HashSet和LinkedHashSet需要调用这两个方法进行数据的存储,使用TreeSet时不会调用这两个方法,而是使用的排序接口)
-
重写的hashCode()和equals()尽可能保持一致性:相等的对象必须具有相等的散列码
重写技巧:对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值
2. Set实现类之一:HashSet
相关说明
-
HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时都使用这个实现类。
-
HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。
-
HashSet 的特点:
- 不能保证元素的排列顺序
- HashSet 不是线程安全的
- 集合元素可以是 null
-
HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
-
HashSet底层:
-
jdk 7:数组+链表的结构;在创建对象时,会直接初始化一个长度为16的数组
-
jdk 8:数组+链表+红黑树;在创建对象时,和ArrayList类似,会初始化一个空数组
-
当如果数组的使用率超过0.75,就会扩大容量为原来的2倍
-
3. Set集合添加元素的过程:以HashSet为例
- 当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hash 值,然后根据 hash 值,通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置(即为索引位置)。(这个散列函数会与底层数组的长度相计算得到在数组中的下标,并且这种散列函数计算还尽可能保证能均匀存储元素,越是散列分布,该散列函数设计的越好)
- 判断数组此位置上是否已经有元素,如果此位置上没有其他元素,则元素添加成功(直接添加在数组中);如果此位置上有其他元素(或以链表形式存在的多个元素),则比较添加的元素与该位置上的所有元素的hash值
- 如果hash值都不相等,则元素添加成功(通过链表的方式继续链接);如果有hash值相等的元素,则会再继续调用equals方法,如果equals方法结果为false,则元素添加成功(通过链表的方式继续链接);如果为true,则元素添加失败
对于后面两种添加成功的情况而言:新添加的元素与已经存在指定索引位置上数据以链表的方式存储。
- jdk 7:新添加的元素放到数组中,指向原来的元素
- jdk 8:原来的元素在数组中,指向新添加的元素
4. 重写 hashCode() 方法和 equals() 方法的基本原则
hashCode()
- 在程序运行时,同一个对象多次调用 hashCode() 方法应该返回相同的值。
- 当两个对象的 equals() 方法比较返回 true 时,这两个对象的 hashCode() 方法的返回值也应相等。
- 对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。
equals()
- 当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候,总是要改写hashCode()。根据一个类的equals方法(改写后),两个截然不同的实例有可能在逻辑上是相等的,但是,根据Object.hashCode()方法,它们仅仅是两个对象。此时,违反了 “相等的对象必须具有相等的散列码” ,那么就需要重写equals()和hashCode()。
- 重写equals方法的时候一般都需要同时重写hashCode方法。通常参与计算hashCode的对象的属性也应该参与到equals()中进行计算。
例子
public class Person {
String name;
int age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
5. Set实现类之二:LinkedHashSet
相关说明
- LinkedHashSet 是 HashSet 的子类
- LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的
- LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能
- LinkedHashSet 不允许集合元素重复
- 遍历其内部数据时,可以按照添加的顺序遍历(不代表就不是无序的)
- 对于频繁的遍历操作,LinkedHashSet效率高于HashSet
- 集合元素可以是 null
LinkedHashSet底层结构
6. Set实现类之三:TreeSet
相关说明
- TreeSet是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。
- TreeSet底层使用红黑树结构存储数据
- TreeSet可以按照添加对象的指定属性,进行排序
- TreeSet两种排序方法:自然排序(添加元素的类实现Comparable接口)和定制排序(使用TreeSet的带参构造方法,传入Comparator接口的实现类)。默认情况下,TreeSet 采用自然排序
- 向TreeSet中添加的数据,要求是相同类的对象
- TreeSet比较两个对象是否相等不再是调用equals()方法,而是根据排序
- 自然排序中,比较两个对象是否相同的标准为:compareTo()返回0
- 定制排序中,比较两个对象是否相同的标准为:compare()返回0
新增方法
方法 | 说明 |
---|---|
Comparator<? super E> comparator() | 返回对此集合中的元素进行排序的比较器;如果此集合使用其元素的自然顺序,则返回 null |
E first() | 返回此集合中当前第一个(最小)元素 |
E last() | 返回此集合中当前最后一个(最大)元素 |
E lower(E e) | 返回此集合中严格小于给定元素的最大元素;如果不存在这样的元素,则返回 null |
E higher(E e) | 返回此集合中严格大于给定元素的最小元素;如果不存在这样的元素,则返回 null |
SortedSet<E> subSet(E fromElement, E toElement) | 返回此集合的部分视图,其元素从fromElement(包括)到 toElement(不包括) |
SortedSet<E> headSet(E toElement) | 返回此集合的部分视图,其元素严格小于 toElement |
SortedSet<E> tailSet(E fromElement)) | 返回此集合的部分视图,其元素大于等于 fromElement |
TreeSet底层结构
TreeSet底层采用红黑树的存储结构;TreeSet的特点是:有序,查询速度比List快
7. TreeSet中涉及的排序相关问题
自然排序
-
自然排序:TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列
-
如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable 接口
实现 Comparable 的类必须实现 compareTo(Object obj) 方法,两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小
-
Comparable 的典型实现:
- BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
- Character:按字符的unicode值来进行比较
- Boolean:true 对应的包装类实例大于 false 对应的包装类实例
- String:按字符串中字符的 unicode 值进行比较
- Date、Time:后边的时间、日期比前面的时间、日期大
-
向 TreeSet 中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较
-
因为只有相同类的两个实例才会比较大小,所以向 TreeSet 中添加的应该是同一个类的对象
-
对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值
-
当需要把一个对象放入 TreeSet 中,重写该对象对应的 equals() 方法时,应保证该方法与 compareTo(Object obj) 方法有一致的结果:如果两个对象通过 equals() 方法比较返回 true,则通过 compareTo(Object obj) 方法比较应返回 0
定制排序
- TreeSet的自然排序要求元素所属的类实现Comparable接口,如果元素所属的类没有实现Comparable接口,或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序,则考虑使用定制排序。定制排序,通过Comparator接口来实现。需要重写compare(T o1,T o2)方法
- 利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2
- 要实现定制排序,需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器
- 此时,仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常
- 使用定制排序判断两个元素相等的标准是:通过Comparator比较两个元素返回了0