Java集合
# 集合
# 集合的概述
# 简介
集合同样用于存放一组数据,我们将学习什么是集合、集合的应用场景 ,在应用场景部分我们将对比 Java 数组与集合的区别,还将系统介绍 Java 集合的架构,也将结合实例来讲解集合的实际应用。
什么是集合?
在计算机科学中,集合是一组可变数量的数据项(也可能为 0 个)的组合,这些数据可能共享某些特征,需要以某种操作方式一起进行操作。
Java 中集合主要分为 java.util.Collection
和 java.util.Map
两大接口。
下图描绘了 Java 集合的框架 (opens new window):
# Collection
java.util.Collection
接口的实现可用于存储 Java
对象。例如,所有学生可以视为一个 Collection
。
Collection
又可以分为三个子接口,分别是:
List
:序列,必须按照顺序保存元素,因此它是有序的,允许重复;Queue
:队列,按照排队规则来确定对象产生的顺序,有序,允许重复;Set
:集,不能重复。
# Map
java.util.Map
接口的实现可用于表示 “键”(key)和 “值”(value)对象之间的映射
。一个映射表示一组 “键” 对象,其中每一个 “键” 对象都映射到一个 “值” 对象。因此可以通过键来查找值。例如,慕课网的每一个学生都有他自己的账户积分,这个关联关系可以用 Map
来表示。
# 集合的应用场景
# 数组 (opens new window)与集合
在介绍集合的应用场景之前,我们先来看看数组和集合的对比。
我们知道数组和集合都用于存放一组数据,但数组的容量是固定大小的,而集合的容量是动态可变的;对于可存放的数据类型,数组既可以存放基本数据类型又可以存放引用数据类型,而集合只能存放引用数据类型,基本数据类型需要转换为对应的包装类才能存放到集合当中。
# 集合应用场景
无法预测存储数据的数量
:由于数组容量是固定大小,因此使用集合存储动态数量的数据更为合适;同时存储具有一对一关系的数据
:例如存储学生的积分,为了方便检索对应学生的积分,可使用 Map 将学生的 uid 和对应的积分进行一对一关联;数据去重
:使用数组实现需要遍历,效率低,而 Set 集合本身就具有不能重复的特性;需要数据的增删
:使用数组实现增删操作需要遍历、移动数组中元素,如果操作频繁会导致效率降低。
# Iterator(迭代器)
# 迭代器的概述
Java Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法,可用于迭代 ArrayList (opens new window) 和 HashSet (opens new window) 等集合。
Iterator 是 Java 迭代器最简单的实现,ListIterator 是 Collection API 中的接口, 它扩展了 Iterator 接口。
迭代器 it 的两个基本操作是 next 、hasNext 和 remove。
调用 it.next()
会返回迭代器的下一个元素,并且更新迭代器的状态。
调用 it.hasNext()
用于检测集合中是否还有元素。
调用 it.remove()
将迭代器返回的元素删除。
Iterator 类位于 java.util 包中,使用前需要引入它,语法格式如下:
import java.util.Iterator; // 引入 Iterator 类
# 获取一个迭代器
集合想获取一个迭代器可以使用 iterator() 方法:
// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;
public class RunoobTest {
public static void main(String[] args) {
// 创建集合
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
// 获取迭代器
Iterator<String> it = sites.iterator();
// 输出集合中的第一个元素
System.out.println(it.next());
}
}
执行以上代码,输出结果如下:
Google
# 循环集合元素
让迭代器 it 逐个返回集合中所有元素最简单的方法是使用 while 循环:
while(it.hasNext()) {
System.out.println(it.next());
}
以下输出集合 sites 中的所有元素:
// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;
public class RunoobTest {
public static void main(String[] args) {
// 创建集合
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
// 获取迭代器
Iterator<String> it = sites.iterator();
// 输出集合中的所有元素
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
执行以上代码,输出结果如下:
Google
Runoob
Taobao
Zhihu
# 删除元素
要删除集合中的元素可以使用 remove() 方法。
以下实例我们删除集合中小于 10 的元素:
// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;
public class RunoobTest {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(12);
numbers.add(8);
numbers.add(2);
numbers.add(23);
Iterator<Integer> it = numbers.iterator();
while(it.hasNext()) {
Integer i = it.next();
if(i < 10) {
it.remove(); // 删除小于 10 的元素
}
}
System.out.println(numbers);
}
}
执行以上代码,输出结果如下:
[12, 23]
# List 集合
# 概念和特性
List
是元素有序并且可以重复的集合,称之为序列。序列可以精确地控制每个元素的插入位置或删除某个位置的元素。通过前面的学习,我们知道 List
是 Collection
的一个子接口,它有两个主要实现类,分别为 ArrayList
(动态数组)和 LinkedList
(链表)。
# ArrayList 实现类
ArrayList 可以理解为动态数组,它的容量可以动态增长。当添加元素时,如果发现容量已满,会自动扩容为原始大小的 1.5 倍。
构造方法
ArrayList()
:构造一个初始容量为 10 的空列表;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);
# 常用成员方法
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)
:如果此列表包含指定的元素,则返回 true,否则返回 false;int size()
:返回该列表中元素的数量;Object[] toArray()
:以正确的顺序(从第一个元素到最后一个元素)返回一个包含此列表中所有元素的数组。
# 实例
# 新增元素
代码中,首先实例化了一个 ArrayList
对象,然后使用 for 循环语句循环 5 次,每次都向 arrayList
对象中追加变量 i
,并打印列表内容,运行结果清晰的展示了每次新增元素的过程。
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
的父类AbstractCollection
重写了toString()
方法,因此直接打印列表,可以直观地展示出列表中的元素。
# 删除元素
请查看如下实例:
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]
。
# 查询元素
可使用 get()
方法来获取列表中元素,实例如下:
我们在使用 for
循环遍历列表的时候,让限定条件为 i < arrayList.size();
,size()
方法可获取该列表中元素的数量。
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
# 自定义类的常用操作
请查看如下实例:
为了方便演示,我们定义了一个静态内部类 ImoocStudent
,它有两个属性 nickname
和 position
,定义了属性的 getter
和 setter
,并重写了 toString()
方法。在 main()
方法中,我们实现了自定义类在 ArrayList
中的增删改查。
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设计师
# LinkedList 实现类
LinkedList
是一个以双向链表实现的 List
。和 ArrayList
一样,也按照索引位置排序,但它的元素是双向连接的,因此顺序访问的效率非常高,而随机访问的效率比较低
。
构造方法
LinkedList()
:构造一个空列表;LinkedList(Collection<? extends E> c)
:构造一个包含指定集合元素的列表,其顺序由集合的迭代器返回。
常用成员方法
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)
:如果此列表包含指定的元素,则返回 true,否则返回 false;int size()
:返回该列表中元素的数量;Object[] toArray()
:以正确的顺序(从第一个元素到最后一个元素)返回一个包含此列表中所有元素的数组。
# 可变参数
- 可变参数用在形参中可以接收多个数据
- 可变参数的格式:
数据类型...参数名称
可变参数的作用:
- 传输参数非常的灵活,方便。可以不传输参数,可以传输1个或者多个,也可以传输一个数组。
可变参数在方法内部本质上就是一个数组
可变参数的注意事项:
- 一个形参列表中可变 参数只能有一个
- 可变参数必须放在形参列表的最后面
基础语法:
public static void sum(int...num){
System.out.println(num.length);
System.out.println(Arrays.toString(num));
}
# Set 集合
# 概念和特性
Set
是元素无序并且不可以重复的集合,我们称之为集。Set
是 Collection
的一个子接口,它的主要实现类有:HashSet
、TreeSet
、LinkedHashSet
、EnumSet
等,下面我们将详细介绍最常用的 HashSet 实现类。
# HashSet 实现类
HashSet
类依赖于哈希表(实际上是 HashMap
实例,下面将会介绍)。HashSet
中的元素是无序的、散列的。
# 构造方法
HashSet()
:构造一个新的空集;默认的初始容量为 16(最常用),负载系数为 0.75;HashSet(int initialCapacity)
:构造一个新的空集; 具有指定的初始容量,负载系数为 0.75;HashSet(int initialCapacity, float loadFactor)
:构造一个新的空集; 支持的 HashMap 实例具有指定的初始容量和指定的负载系数;HashSet(Collection<? extends E> c)
:构造一个新集合,其中包含指定集合中的元素。
# 常用成员方法
HashSet
的常用成员方法如下:
boolean add(E e)
:如果指定的元素尚不存在,则将其添加到该集合中;boolean contains(Object o)
:如果此集合包含指定的元素,则返回 true,否则返回 false;boolean isEmpty()
:如果此集合不包含任何元素,则返回 true,否则返回 false;Iterator<E> iterator()
:返回此集合中元素的迭代器;boolean remove(Object o)
:从该集合中删除指定的元素(如果存在);int size()
:返回此集合中的元素数量。
# 实例
# 新增元素
可使用 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中的内容为:[TypeScript, Java, PHP, Python]
在实例中,我们先后向 hashSet
中添加了两次 Python
元素,由于集的元素不可重复特性,因此集中只允许出现一个 Python
元素。我们还观察到,打印结果的元素顺序和我们添加的顺序是不同的,这验证了集的无序特性。
注意: 由于
HashSet
的父类AbstractCollection
重写了toString()
方法,因此直接打印集,可以直观地展示出集中的元素。
# 删除元素
可使用 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]
# 查询元素
我们知道了 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
# Map 集合
# 概念和特性
我们已经知道 Map
是以键值对(key-value)
的形式存储的对象之间的映射,key-value
是以 java.util.Map.Entry
类型的对象实例存在。
可以使用键来查找值,一个映射中不能包含重复的键,但值是可以重复的。每个键最多只能映射到一个值。
# HashMap 实现类
HashMap
是 java.util.Map
接口最常用的一个实现类,前面所学的 HashSet
底层就是通过 HashMap
来实现的,HashMap
允许使用 null 键和 null 值。
# 构造方法
HashMap()
:构造一个新的空映射;默认的初始容量为 16(最常用),负载系数为 0.75;HashMap(int initialCapacity)
:构造一个新的空映射; 具有指定的初始容量,负载系数为 0.75;HashMap(int initialCapacity, float loadFactor)
:构造一个新的空映射; 支持的HashMap
实例具有指定的初始容量和指定的负载系数;HashSet(Map<? extends K, ? extends V> m)
:构造一个新映射,其中包含指定映射相同。
# 常用API
lMap是双列集合的祖宗接口,它的功能是全部双列集合都可以继承使用的。
方法名称 | 说明 |
---|---|
V put(K key,V value) | 添加元素 |
V remove(Object key) | 根据键删除键值对元素 |
void clear() | 移除所有的键值对元素 |
boolean containsKey(Object key) | 判断集合是否包含指定的键 |
boolean containsValue(Object value) | 判断集合是否包含指定的值 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中键值对的个数 |
Map集合的遍历-键找值
- 先获取Map集合的全部键的Set集合。
- 遍历键的Set集合,然后通过键提取对应值。
方法名称 | 说明 |
---|---|
Set<K> keySet() | 获取所有键的集合 |
V get(Object key) | 根据键获取值 |
Map集合的遍历-键值对
- 先把Map集合转换成Set集合,Set集合中每个元素都是键值对实体类型了。
- 遍历Set集合,然后提取键以及提取值。
方法名称 | 说明 |
---|---|
Set<Map.Entry<K,V>> entrySet() | 获取所有键值对对象的集合 |
K getKey() | 获得键 |
V getValue() | 获取值 |
# 实例
# HashMap
下面我们使用 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 键对应的值为:英语
# forEach
Map集合的遍历方式三:Lambda
l得益于JDK 8开始的新技术Lambda表达式,提供了一种更简单、更直接的遍历集合的方式。
Map结合Lambda遍历的API
方法名称 | 说明 |
---|---|
default void forEach(BiConsumer<? super K, ? super V> action) | 结合lambda遍历Map集合 |
示例如下:
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
public class MapDemo3 {
public static void main(String[] args) {
Map<String,Integer> maps = new HashMap<>();
maps.put("娃娃",10);
maps.put("IphoneX",910);
maps.put("生活用品",100);
maps.put("华为",103);
maps.put("手表",100);
Set<Map.Entry<String, Integer>> stringIntegerEntry = maps.entrySet();
for (Map.Entry<String, Integer> entry : stringIntegerEntry){
String key = entry.getKey();
int value = entry.getValue();
System.out.println(key + "======>" + value);
}
// maps.forEach(new BiConsumer<String, Integer>() {
// @Override
// public void accept(String s, Integer integer) {
// System.out.println(s+integer);
// }
// });
maps.forEach((k,v) -> {
System.out.println(k + "=====>" + v);
});
}
}
运行结果:
IphoneX======>910
手表======>100
生活用品======>100
华为======>103
娃娃======>10
IphoneX=====>910
手表=====>100
生活用品=====>100
华为=====>103
娃娃=====>10
# Map集合案例
需求
某个班级80名学生,现在需要组成秋游活动,班长提供了四个景点依次是(A、B、C、D),每个学生只能选择一个景点,请统计出最终哪个景点想去的人数最多。
分析
- 将80个学生选择的数据拿到程序中去。
- 定义Map集合用于存储最终统计的结果。
- 遍历80个学生选择的数据,看Map集合中是否存在,不存在存入“数据=1“,存在则其对应值
package com.d5_map;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class MapTest1 {
public static void main(String[] args) {
String[] selects = {"A","B","C","D"};
StringBuilder sb = new StringBuilder();
Random r = new Random();
for (int i = 0; i < 80; i++) {
sb.append(selects[r.nextInt(selects.length)]);
}
System.out.println(sb);
Map<Character,Integer> infos = new HashMap<>();
// 遍历80个学生选择的数据
for (int i = 0; i < sb.length(); i++) {
// 提取当前选择的景点字符
char ch = sb.charAt(i);
// 判断Map集合中是否存在这个健
if(infos.containsKey(ch)){
// 让其值加1
infos.put(ch,infos.get(ch) + 1);
}else {
// 说明此景点还是第一次被选中
infos.put(ch,1);
}
}
System.out.println(infos);
}
}
运行结果:
AADABCBCBDDADCCBBABBADDCAAADABDBCBDCDDBDBBACCAACCCCCACCDAACABCDBADDDACBBCABCCCDD
{A=20, B=18, C=23, D=19}