Java 集合
集合同样用于存放一组数据，我们将学习什么是集合、集合的应用场景 ，在应用场景部分我们将对比 Java 数组与集合的区别，还将系统介绍 Java 集合的架构，也将结合实例来讲解集合的实际应用。
1. 什么是集合
在计算机科学中，集合是一组可变数量的数据项（也可能为 0 个）的组合，这些数据可能共享某些特征，需要以某种操作方式一起进行操作。
Java 中集合主要分为
java.util.Collection
和
java.util.Map
两大接口。
下图描绘了 Java 集合的框架：
Tips： 图表最下方的 ArrayList、LinkedList、HashSet 以及 HashMap 都是常用实现类，本小节将介绍具体使用。
1.1 Collection
java.util.Collection
接口的实现可用于存储
Java
对象。例如，所有学生可以视为一个
Collection
。
Collection
又可以分为三个子接口，分别是：
-
List
-
Queue
-
Set
1.2 Map
java.util.Map
接口的实现可用于表示 “键”（key）和 “值”（value）对象之间的映射。一个映射表示一组 “键” 对象，其中每一个 “键” 对象都映射到一个 “值” 对象。因此可以通过键来查找值。例如，慕课网的每一个学生都有他自己的账户积分，这个关联关系可以用
Map
来表示。
2. 集合的应用场景
2.1 数组与集合
在介绍集合的应用场景之前，我们先来看看数组和集合的对比。
我们知道数组和集合都用于存放一组数据，但数组的容量是固定大小的，而集合的容量是动态可变的；对于可存放的数据类型，数组既可以存放基本数据类型又可以存放引用数据类型，而集合只能存放引用数据类型，基本数据类型需要转换为对应的包装类才能存放到集合当中。
2.2 集合应用场景
- 无法预测存储数据的数量：由于数组容量是固定大小，因此使用集合存储动态数量的数据更为合适；
- 同时存储具有一对一关系的数据：例如存储学生的积分，为了方便检索对应学生的积分，可使用 Map 将学生的 uid 和对应的积分进行一对一关联；
- 数据去重：使用数组实现需要遍历，效率低，而 Set 集合本身就具有不能重复的特性；
- 需要数据的增删：使用数组实现增删操作需要遍历、移动数组中元素，如果操作频繁会导致效率降低。
3. List 集合
3.1 概念和特性
List
是元素有序并且可以重复的集合，称之为序列。序列可以精确地控制每个元素的插入位置或删除某个位置的元素。通过前面的学习，我们知道
List
是
Collection
的一个子接口，它有两个主要实现类，分别为
ArrayList
（动态数组）和
LinkedList
（链表）。
3.2 ArrayList 实现类
ArrayList 可以理解为动态数组，它的容量可以动态增长。当添加元素时，如果发现容量已满，会自动扩容为原始大小的 1.5 倍。
3.2.1 构造方法
-
ArrayList()
-
ArrayList(int initialCapacity)
-
ArrayList(Collection<? extends E> c)
：构造一个包含指定集合元素的列表，其顺序由集合的迭代器返回。
在代码中，我们可以这样实例化
ArrayList
// 无参构造实例化，初始容量为10
List arrayList1 = new ArrayList();
// 实例化一个初始容量为20的空列表
List arrayList2 = new ArrayList(20);
// 实例化一个集合元素为 arrayList2 的列表（由于 arrayList2 为空列表，因此其实例化的对象也为空列表）
List arrayList3 = new ArrayList(arrayList2);
3.2.2 常用成员方法
-
void add(E e)
-
void add(int index, E element)
-
E remove(int index)
-
boolean remove(Object o)
-
void clear()
-
E set(int index, E element)
-
E get(int index)
-
boolean contains(Object o)
-
int size()
-
Object[] toArray()
3.3 实例
3.3.1 新增元素
请查看如下实例：
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo1 {
public static void main(String[] args) {
// 实例化一个空列表
List arrayList = new ArrayList();
for (int i = 0; i < 5; i ++) {
// 将元素 i 追加到列表的末尾
arrayList.add(i);
// 打印列表内容
System.out.println(arrayList);
}
}
}
运行结果：
[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]
代码中，首先实例化了一个
ArrayList
对象，然后使用 for 循环语句循环 5 次，每次都向
arrayList
对象中追加变量
i
，并打印列表内容，运行结果清晰的展示了每次新增元素的过程。
**Tips：**由于
ArrayList
的父类
AbstractCollection
重写了
toString()
方法，因此直接打印列表，可以直观地展示出列表中的元素。
3.3.2 泛型初识
**Tips：泛型（
Genericity
） 将在下次详细介绍，此处我们只简要介绍一下泛型以及其使用方法。如果你比较了解泛型，可直接跳过此知识点。
如果你使用 IDEA 编写如上代码，将会有下图所示的 3 处黄色警告：
既然
IDE
有了警告，我们就尝试来解决一下，将鼠标光标放置到警告处，会提示
“Unchecked call to ‘add (E)’ as a member of raw type ‘java.util.List’ ”
，这是
IDE
的泛型检查，可点击
Try to generify 'ArrayListDemo1.java'
按钮：
此时会出现一个
Generify
的弹窗，直接点击
Refactor
按钮：
代码变成了下图所示的样子，那 3 处警告被成功消除了：
我们观察到代码第 8 行的
List
类型后面多了一对尖括号
“<>”，<>
里面是 Java 的包装类型
Integer
，在
ArrayList
类型后面也多了一对尖括号，这里的
<>
中承载的就是 Java 的泛型的类型参数，它表示
arrayList
对象用于存放
Integer
类型的数据。这样的目的和好处这里不详细展开讨论，本小节我们只需知道这样做就可以消除
IDEA
的警告即可。
由于前面
List
已经指定了泛型的参数类型为
Integer
，后面的
ArrayList
就不需要再重复指定了。当然你也可以这样写（但是没必要）：
同理，如果你想向
arrayList
存放
String
类型的元素，只需将
<Integer>
改为
<String>
，我们再来看一个实例：
运行结果：
[Hello, World]
[Hello, Java, World]
代码中，首先实例化了一个
ArrayList
的对象，调用了两次
add(E e)
方法，依次向列表尾部插入了
Hello
和
World
元素，列表中元素为
[Hello, World]
，此时调用
add(int index, E element)
方法，将字符串元素 Java 插入到此列表中的索引为 1 的位置，因此列表中的元素为
[Hello, Java, World]
。
3.3.3 删除元素
请查看如下实例：
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo3 {
public static void main(String[] args) {
// 实例化一个空列表
List<String> arrayList = new ArrayList<>();
// 将字符串元素 Hello 追加到此列表的末尾
arrayList.add("Hello");
// 将字符串元素 World 追加到此列表的末尾
arrayList.add("World");
// 将字符串元素 Hello 追加到此列表的末尾
arrayList.add("Hello");
// 将字符串元素 Java 追加到此列表的末尾
arrayList.add("Java");
// 打印列表
System.out.println(arrayList);
// 删除此列表中索引位置为 3 的元素
arrayList.remove(3);
// 打印列表
System.out.println(arrayList);
// 删除此列表中第一次出现的 Hello 元素
arrayList.remove("Hello");
System.out.println(arrayList);
}
}
运行结果：
[Hello, World, Hello, Java]
[Hello, World, Hello]
[World, Hello]
代码中，我们首先添加了
4
个字符串元素，列表内容为
[Hello, World, Hello, Java]
，然后调用
remove(int index)
方法删除了索引位置为 3 的元素（即 Java），此时列表内容为
[Hello, World, Hello]
，再次调用
remove(Object o)
方法，删除了列表中第一次出现的
Hello
元素，此时列表内容为
[World, Hello]
。
3.3.4 修改元素
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo4 {
public static void main(String[] args) {
// 实例化一个空列表
List<String> arrayList = new ArrayList<>();
arrayList.add("Hello");
// 将字符串元素 World 追加到此列表的末尾
arrayList.add("World");
// 打印列表
System.out.println(arrayList);
// 用字符串元素 Hello 替换此列表中索引位置为 1 的元素
arrayList.set(1, "Java");
System.out.println(arrayList);
}
}
运行结果：
[Hello, World]
[Hello, Java]
3.3.5 查询元素
可使用
get()
方法来获取列表中元素，实例如下：
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo5 {
public static void main(String[] args) {
// 实例化一个空列表
List<String> arrayList = new ArrayList<String>();
arrayList.add("Hello");
arrayList.add("Immoc");
for (int i = 0; i < arrayList.size(); i ++) {
System.out.println("索引位置" + i + "的元素为" + arrayList.get(i));
}
}
}
运行结果：
索引位置0的元素为Hello
索引位置1的元素为Immoc
我们在使用
for
循环遍历列表的时候，让限定条件为
i < arrayList.size();
，
size()
方法可获取该列表中元素的数量。
3.2.7 自定义类的常用操作
请查看如下实例：
import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo6 {
static class ImoocStudent {
private String nickname;
private String position;
public ImoocStudent() {
}
public ImoocStudent(String nickname, String position) {
this.setNickname(nickname);
this.setPosition(position);
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getPosition() {
return position;
}
public void setPosition(String position) {
this.position = position;
}
@Override
public String toString() {
return "ImoocStudent{" +
"nickname='" + nickname + '\'' +
", position='" + position + '\'' +
'}';
}
}
public static void main(String[] args) {
// 实例化一个空列表
List<ImoocStudent> arrayList = new ArrayList<>();
// 实例化3个慕课网学生对象
ImoocStudent imoocStudent1 = new ImoocStudent("Colorful", "服务端工程师");
ImoocStudent imoocStudent2 = new ImoocStudent("Lillian", "客户端工程师");
ImoocStudent imoocStudent3 = new ImoocStudent("小慕", "架构师");
// 新增元素
arrayList.add(imoocStudent1);
arrayList.add(imoocStudent2);
arrayList.add(imoocStudent3);
System.out.println(arrayList);
// 删除元素
arrayList.remove(imoocStudent2);
System.out.println("删除 imoocStudent2 后：arrayList 内容为：" + arrayList);
arrayList.remove(1);
System.out.println("删除列表中索引位置为 1 的元素后，arrayList 内容为：" + arrayList);
// 实例化一个新的慕课网学生对象
ImoocStudent imoocStudent4 = new ImoocStudent("小李", "UI设计师");
// 修改元素
arrayList.set(0, imoocStudent4);
System.out.println("修改后：arrayList 内容为" + imoocStudent4);
// 查询元素，将 get() 方法得到的 Object 类型强制转换为 ImoocStudent 类型
ImoocStudent student = arrayList.get(0);
System.out.println("索引位置 0 的学生的昵称为：" + student.getNickname());
System.out.println("索引位置 0 的学生的职位为：" + student.getPosition());
}
}
运行结果：
[ImoocStudent{nickname='Colorful', position='服务端工程师'}, ImoocStudent{nickname='Lillian', position='客户端工程师'}, ImoocStudent{nickname='小慕', position='架构师'}]
删除 imoocStudent2 后：arrayList 内容为：[ImoocStudent{nickname='Colorful', position='服务端工程师'}, ImoocStudent{nickname='小慕', position='架构师'}]
删除列表中索引位置为 1 的元素后，arrayList 内容为：[ImoocStudent{nickname='Colorful', position='服务端工程师'}]
修改后：arrayList 内容为ImoocStudent{nickname='小李', position='UI设计师'}
索引位置 0 的学生的昵称为：小李
索引位置 0 的学生的职位为：UI设计师
为了方便演示，我们定义了一个静态内部类
ImoocStudent
，它有两个属性
nickname
和
position
，定义了属性的
getter
和
setter
，并重写了
toString()
方法。在
main()
方法中，我们实现了自定义类在
ArrayList
中的增删改查。
3.4 LinkedList 实现类
LinkedList
是一个以双向链表实现的
List
。和
ArrayList
一样，也按照索引位置排序，但它的元素是双向连接的，
因此顺序访问的效率非常高，而随机访问的效率比较低
。
3.4.1 构造方法
-
LinkedList()
-
LinkedList(Collection<? extends E> c)
3.4.2 常用成员方法
-
void add(E e)
-
void add(int index, E element)
-
void addFirst(E e)
-
vod addLast(E e)
-
E remove(int index)
-
boolean remove(Object o)
-
void clear()
-
E set(int index, E element)
-
E get(int index)
-
E getFirst()
-
E getLast()
-
boolean contains(Object o)
-
int size()
-
Object[] toArray()
4. Set 集合
4.1 概念和特性
Set
是元素无序并且不可以重复的集合，我们称之为集。
Set
是
Collection
的一个子接口，它的主要实现类有：
HashSet
、
TreeSet
、
LinkedHashSet
、
EnumSet
等，下面我们将详细介绍最常用的 HashSet 实现类。
4.2 HashSet 实现类
HashSet
类依赖于哈希表（实际上是
HashMap
实例，下面将会介绍）。
HashSet
中的元素是无序的、散列的。
4.2.1 构造方法
-
HashSet()
-
HashSet(int initialCapacity)
-
HashSet(int initialCapacity, float loadFactor)
-
HashSet(Collection<? extends E> c)
4.2.2 常用成员方法
HashSet
的常用成员方法如下：
-
boolean add(E e)
-
boolean contains(Object o)
-
boolean isEmpty()
-
Iterator<E> iterator()
-
boolean remove(Object o)
-
int size()
4.3 实例
4.3.1 新增元素
可使用
add()
方法向集中添加元素，实例如下：
import java.util.HashSet;
import java.util.Set;
public class HashSetDemo1 {
public static void main(String[] args) {
// 实例化一个新的空集
Set<String> hashSet = new HashSet<String>();
// 向 hashSet 集中依次添加元素：Python、Java、PHP、TypeScript、Python
hashSet.add("Python");
hashSet.add("Java");
hashSet.add("PHP");
hashSet.add("TypeScript");
hashSet.add("Python");
// 打印 hashSet 的内容
System.out.println("hashSet中的内容为：" + hashSet);
}
}
运行结果：
在实例中，我们先后向
hashSet
中添加了两次
Python
元素，由于集的元素不可重复特性，因此集中只允许出现一个
Python
元素。我们还观察到，打印结果的元素顺序和我们添加的顺序是不同的，这验证了集的无序特性。
Tips： 由于
HashSet
的父类
AbstractCollection
重写了
toString()
方法，因此直接打印集，可以直观地展示出集中的元素。
4.3.2 删除元素
可使用
remove()
方法删除集中元素，实例如下：
import java.util.HashSet;
import java.util.Set;
public class HashSetDemo2 {
public static void main(String[] args) {
// 实例化一个新的空集
Set<String> hashSet = new HashSet<>();
// 向 hashSet 集中依次添加元素：Python、Java
hashSet.add("Python");
hashSet.add("Java");
// 打印 hashSet 的内容
System.out.println(hashSet);
// 删除 hashSet 中的 Python 元素
hashSet.remove("Python");
// 打印 hashSet 的内容
System.out.println("删除 Python 元素后，hashSet中的内容为：" + hashSet);
}
}
运行结果：
[Java, Python]
删除 Python 元素后，hashSet中的内容为：[Java]
4.3.3 查询元素
我们知道了
ArrayList
通过
get
方法来查询元素，但
HashSet
没有提供类似的
get
方法来查询元素。
这里我们介绍一个迭代器（
Iterator
）接口，所有的 Collection 都实现了 Iterator 接口，它可以以统一的方式对各种集合元素进行遍历。我们来看下
Iterator
接口的常用方法：
-
hasNaxt()
-
next()
-
iterator()
实例如下：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo3 {
public static void main(String[] args) {
// 实例化一个新的空集
Set<String> hashSet = new HashSet<String>();
// 向 hashSet 集中依次添加元素：Python、Java、PHP
hashSet.add("Python");
hashSet.add("Java");
hashSet.add("PHP");
// 打印 hashSet 的内容
System.out.println(hashSet);
// 获取 hashSet 中元素的迭代器
Iterator<String> iterator = hashSet.iterator();
System.out.println("迭代器的遍历结果为：");
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
运行结果：
[Java, PHP, Python]
迭代器的遍历结果为：
Java
PHP
Python
4.3.4 自定义类的常用操作
请查看如下实例：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo4 {
/**
* 静态内部类：慕课网学生
*/
static class ImoocStudent {
private String nickname;
private String position;
public ImoocStudent() {
}
public ImoocStudent(String nickname, String position) {
this.setNickname(nickname);
this.setPosition(position);
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getPosition() {
return position;
}
public void setPosition(String position) {
this.position = position;
}
@Override
public String toString() {
return "ImoocStudent{" +
"nickname='" + nickname + '\'' +
", position='" + position + '\'' +
'}';
}
}
public static void main(String[] args) {
Set<ImoocStudent> hashSet = new HashSet<>();
// 实例化3个慕课网学生对象
ImoocStudent imoocStudent1 = new ImoocStudent("Colorful", "服务端工程师");
ImoocStudent imoocStudent2 = new ImoocStudent("Lillian", "客户端工程师");
ImoocStudent imoocStudent3 = new ImoocStudent("小慕", "架构师");
// 新增元素
hashSet.add(imoocStudent1);
hashSet.add(imoocStudent2);
hashSet.add(imoocStudent3);
// 使用Iterator遍历hashSet
Iterator<ImoocStudent> iterator = hashSet.iterator();
System.out.println("迭代器的遍历结果为：");
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
// 查找并删除
if (hashSet.contains(imoocStudent1.getNickname())) {
hashSet.remove(imoocStudent1);
}
System.out.println("删除nickname为Colorful的对象后，集合元素为：");
System.out.println(hashSet);
}
}
运行结果：
迭代器的遍历结果为：
ImoocStudent{nickname='Lillian', position='客户端工程师'}
ImoocStudent{nickname='Colorful', position='服务端工程师'}
ImoocStudent{nickname='小慕', position='架构师'}
删除nickname为Colorful的对象后，集合元素为：
[ImoocStudent{nickname='Lillian', position='客户端工程师'}, ImoocStudent{nickname='Colorful', position='服务端工程师'}, ImoocStudent{nickname='小慕', position='架构师'}]
为了方便演示，我们定义了一个静态内部类
ImoocStudent
，它有两个属性
nickname
和
position
，定义了属性的
getter
和
setter
，并重写了
toString()
方法。在
main()
方法中，我们实现了自定义类在
HashSet
中的增删改查，使用迭代器可以遍历元素。
5. Map 集合
5.1 概念和特性
我们已经知道
Map
是以键值对
（key-value）
的形式存储的对象之间的映射，
key-value
是以
java.util.Map.Entry
类型的对象实例存在。
可以使用键来查找值，一个映射中不能包含重复的键，但值是可以重复的。每个键最多只能映射到一个值。
5.2 HashMap 实现类
HashMap
是
java.util.Map
接口最常用的一个实现类，前面所学的
HashSet
底层就是通过
HashMap
来实现的，
HashMap
允许使用 null 键和 null 值。
5.2.1 构造方法
-
HashMap()
-
HashMap(int initialCapacity)
-
HashMap(int initialCapacity, float loadFactor)
HashMap
-
HashSet(Map<? extends K, ? extends V> m)
5.2.2 常用成员方法
-
void clear()
-
Set<Map, Entry<K, V>> entrySet
-
V get(Object key)
-
Set<K> keySet
-
V put(K key, V value)
-
V remove(Object key)
-
Collection<V> values
5.3 实例
下面我们使用
HashMap
来实现一个英汉字典的例子。
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class HashMapDemo1 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
// 添加数据
map.put("English", "英语");
map.put("Chinese", "汉语");
map.put("Java", "咖啡");
// 打印 map
System.out.println(map);
// 删除 key 为 Java 的数据
map.remove("Chinese");
System.out.println("删除键为Chinese的映射后，map内容为：");
// 打印 map
System.out.println(map);
// 修改元素：
map.put("Java", "一种编程语言");
System.out.println("修改键为Java的值后，Java=" + map.get("Java"));
// 遍历map
System.out.println("通过遍历entrySet方法得到 key-value 映射：");
Set<Entry<String, String>> entries = map.entrySet();
for (Entry<String, String> entry: entries) {
System.out.println(entry.getKey() + " - " + entry.getValue());
}
// 查找集合中键为 English 对应的值
Set<String> keySet = map.keySet();
for (String key: keySet) {
if (key.equals("English")) {
System.out.println("English 键对应的值为：" + map.get(key));
break;
}
}
}
}
运行结果：
{English=英语, Java=咖啡}
修改键为Java的值后，Java=一种编程语言
通过遍历entrySet方法得到 key-value 映射：
English - 英语
Java - 一种编程语言
English 键对应的值为：英语
实例中，
Map
的
key
是字符串类型，value 也是字符串类型。值得注意的是，我们在创建
HashMap
的时候，在
Map
类型的后面有一个
<String, String>
，分别表示映射中将要存放的
key
和
value
的类型都为
String
类型。在遍历映射的时候，我们调用了
entrySet
方法，它返回了此映射中包含的映射的集合。通过键查找值，我们可以调用
keySet
方法来获取映射中的键的集合，并且遍历这个集合即可找到对应键，通过键就可以获取值了。
6. 小结
Java 的集合，它们定义在
java.util
包中，Java 中的集合主要有
Collection
和
Map
两大接口。
List
集合是元素有序并且可以重复的集合；
Set
集合是元素无序并且不可以重复的集合；
Map
是以键值对（key-value）的形式存储的对象之间的映射，它们都支持泛型。我们分别介绍了 3 个接口常用的实现类的用法。同学们要多多进行编码练习。