本文为《Java 语言程序设计》第十版 章节笔记
20.1 引言
数据结构(data structure)是以某种形式将数据组织在一起的合集(collection)。数据结构不仅储存数据,还支持访问和处理数据的操作。
在面向对象思想里,一个数据结构也被认为是一个容器(container)或者容器对象(container object),它是一个能存储其他对象的对象,这里的其他对象称为数据或者元素。
定义一种数据结构从本质上讲就是定义一个类。数据结构类应该使用数据域存储数据,并提供方法支持查找、插入和删除等操作。
因此,创建一个数据结构就是创建这个类的一个实例。然后,可以使用这个实例上的方法了操作这个数据结构,例如,向该数据结构中插入一个元素,或者从这个数据结构中删除一个元素。
Java 中的数据结构通常统称称为 Java 合集框架(Java Collections Framework)
。
20.2 合集
Java 合集框架支持的两种类型的容器
- 一种是为了存储一个元素合集,简称为
合集(collection)
。 - 另一种是为了存储 键/值 对,称为
映射表(map)
。
映射表是一个使用一个键(key)快速搜索一个元素的高效数据结构。
Collection 接口为 线性表、集合、栈、向量、队列、优先队列定义了共同的操作。
合集的一些数据结构
- 线性表
List
:存储一个有序元素合集 - 集合
Set
:存储一组不重复的元素 - 栈
Stack
:存储采用后进先出方式处理的对象 - 队列
Queue
: 存储采用先进先出方式处理的对象 - 优先队列
Priority Queue
:存储按照优先级顺序处理的对象
在 Java 合集框架中定义的所有接口和类都分组在 java.util 包中。
合集框架的通用特性:
<interface>java.util.Collection<E>
+add(o: E): boolean
+addAll(c: Collection<? extends E>): boolean
+clear(): void
+contains(o: Object): boolean
+containsAll(c: Collection<?>): boolean
+equals(o: Object): boolean
+hashCode(): int
+isEmpty(): boolean
+remove(o: Object): boolean
+removeAll(c: Collection<?>): boolean
+retainAll(c: Collection<?>): boolean
+size(): int
+toArray(): Object[]
除开 java.tuil.PriorityQueue
没有实现 Cloneable 接口外,Java 合集框架中的其他具体类都实现了 java.lang.Cloneable
和 java.io.Serializable
接口。
20.3 迭代器
每种合集都是可迭代的(Iterable)(包括 map)。
<interface>java.lang.Iterable<E>
+iterator(): Iterator<E>
<interface>java.util.Iterator<E>
+hasNext(): boolean
+next(): E
+remove(): void
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class TestIterator {
public static void main(String[] args){
Collection<String> collection = new ArrayList<>();
collection.add("New York");
collection.add("Atlanta");
collection.add("Dallas");
collection.add("Madison");
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next().toUpperCase() + " ");
}
System.out.println("------------------------");
for (String element:collection) {
System.out.println(element.toUpperCase() + " ");
}
}
}
Collection 接口继承自 Iterable 接口。Iterable 接口中定义了 iterator 方法,该方法会返回一个迭代器。
20.4 线性表
List 接口继承自 Colletion 接口,定义了一个用于 顺序存储
元素的合集,其中元素 允许重复
。有两个具体类 ArrayList
、LinkedList
。
20.4.1 List 接口中的通用方法
List 接口增加了面向位置的操作,和一个能够双向遍历线性表的新线性表迭代器。
+add(index: int, element: Object): boolean
+addAll(index: int, c: Collection<? extends E>): boolean
+get(index: int): E
+indexOf(element: Object): int
+lastIndexOf(element: Object): int
+listIterator(): ListIterator<E>
+listIterator(startIndex: int): ListIterator<E>
+remove(index: int): E
+set(index: int, element: Object): Object
+subList(fromIndex: int, toIndex: int): List<E>
ListIterator 接口继承了 Iterator 接口,以增加对线性表的双向遍历能力。ListIterator 接口中的方法:(还不怎么理解这里的方法)
<interface>java.util.ListIterator<E>
+add(element: E): void
+hasPrevious(): boolean
+nextIndex(): int
+previous(): E
+previousIndex(): int
+set(element: E): void
20.4.2 数组线性表类 ArrayList 和 链表类 LinkedList
- ArrayList 用数组存储元素,这个数组是动态创建的。
- LinkedList 在一个链表(linked list)中存储元素。
一般只查询线性表里的元素,使用 ArryaList 实现,如果需要在起始位置插入或删除元素,使用 LinkedList 实现。
ArrayList 使用数组实现 List:
java.util.ArrayList<E>
+ArrayList()
+ArrayList(c: Collection<? extends E)
+ArrayList(initialCapacity: int)
+trimToSize(): void
LinkedList 提供从线性表两端插入、提取和删除的方法:
+LinkedList()
+LinkedList(c: Collection<? extends E)
+addFirst(element: E): void
+addLast(element: E): void
+getFirst(): E
+getLast(): E
+removeFirst(): E
+removeLast(): E
20.5 Comparator 接口
Comparator 可以用于比较没有实现 Comparable 的类的对象。
20.6 线性表和合集的静态方法
java.util.Collections
+sort(list: List): void
+sort(list: List, c: Comparator): void
+binarySearch(list: List, key: Object): int
+binarySearch(list: List, key: Object, c: Comparator): int
+reverse(list: List): void
+reverseOrder(): Comparator
+shuffle(list: List): void
+shuffle(list: List, rmd: Random): void
+copy(des: List, src: List): void
+nCopies(n: int, o: Object): List
+fill(list: List, o: Object): List
+max(c: Collection): Object
+max(c: Collection, c: Comparator): Object
+min(c: Collection): Object
+min(c: Collection, c: Comparator): Object
+disjoint(c1: Collection, c2: Collections): boolean
+frequency(c: Collection, o: Object): int
20.8 向量类和栈类
在 Java API 中,Vector 类是 AbstractList 的子类,Stack 类是 Vector 的子类。
Java 合集框架是在 Java 2 中引入的。Java 2 之前的版本也支持一些数据结构,其中就有向量类 Vector 与栈类 Stack。
除了包含用于访问和修饰向量的同步方法之外,Vector 类 与 ArrayList 是一样的。对于许多不需要同步的应用程序来说,使用 ArrayList 比使用 Vector 效率更高。
Vetor 类被广泛应用于 Java 的遗留代码中,因为在 Java 2 之前,它可以实现 Java 可变大小的数组。
java.util.Stack<E>
+Stack()
+empty(): boolean
+peek(): E
+pop(): E
+push(o: E): E
+search(o: Object): int
20.9 队列和优先队列
队列(queue)是一种先进先出的数据结构。元素被追加到末尾,然后从队列头删除。
在优先队列(priority queue)中,元素被赋予优先级。当访问元素时,拥有最高优先级的元素首先被删除。
20.9.1 Queue 接口
<interface>java.util.Queue
+offer(element: E): boolean
+poll(): E
+remove(): E
+peek(): E
+element(): E
20.9.2 双端队列 Deque 和链表 LinkedList
LinkedList 类实现了 Deque 接口,Deque 又继承自 Queue 接口。可使用 LinkedList 创建一个队列。
默认情况下,优先队列使用 Comparable 以元素的自然顺序进行排序。拥有最小数值的元素被赋予最高优先级,因此最先从队列中删除。如果有几个元素拥有相同的优先级,则任意选择一个。也可以使用构造方法 PriorityQueue(initialCapacity, comparator) 中的 Comparator 来指定一个顺序。
java.util.PriorityQueue<E>
+PriorityQueue()
+PriorityQueue(initialCapacity: int)
+PriorityQueue(c: Collection<? extends E>)
+PriorityQueue(initialCapacity: int, comparator: Comparator<? super E>)
END
欢迎来到这里!
我们正在构建一个小众社区,大家在这里相互信任,以平等 • 自由 • 奔放的价值观进行分享交流。最终,希望大家能够找到与自己志同道合的伙伴,共同成长。
注册 关于