一、集合的概述
集合建立在数组基础上，主要位于java.util包中，用来存储Java类对象，并且可以实现各种数据结构。
- 集合大小可以改变，可以存放不同数据类型数据。
- 集合不能存放基本类型数据，只能存放引用数据类型数据。
- 集合不仅可以方便地存放数据，而且提供了添加、读取和删除数据等实用方法。
- 集合中只能存放对象，JVM会自动将基本类型与相应的包装类型转换（装箱：基本类型→对象；拆箱：对象→基本类型）。
二、Java集合的类框架
所有的集合框架都包含如下内容：
- 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象。
- Collection是单列集合的根接口，存储的元素符合某种规律。
- Map是双列集合的根接口，用于存储具有键、值映射关系的元素，每一个元素都包含一个键-值对 。
- 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
- 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序，这些算法实现了多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
三、集合方法
addAll()方法
用来将指定集合种所有的对象添加到该集合中，如果对象集合进行了泛化，则要求指定集合中所有对象都符合泛化类型，否则编译时会抛出异常。
方法签名
boolean addAll(Collection<? extends E> c)
- 参数：另一个集合
c，其中的所有元素将被添加到调用该方法的集合中。 - 返回值：如果该集合因为调用而发生了变化（即至少添加了一个元素），则返回
true；否则返回false。
import java.util.ArrayList;
import java.util.Collection;
public class Test{
public static void main(String[] args){
String a = "A";
String b = "B";
String c = "C";
//创建一个 ArrayList 用于存储字符串
Collection<String> list = new ArrayList<String>();
list.add(a);
list.add(b);
//使用 Object 类型以便添加不同类型的元素
Collection<Object> list2 = new ArrayList<Object>();
//使用 addAll() 将 list 的元素添加到 list2
list2.addAll(list);
//list2.add(list);也可以
list2.add(c);
//使用迭代器：通过iterator()方法序列化集合中所有的对象
Iterator<Object> it = list2.iterator();
while(it.hasNext()){
//获取下一个元素
Object ojb = it.next(); //对实例进行了泛化，不需要强制类型转换
System.out.println("使用迭代器打印："+ojb);
}
}
}注意：Collection不能实例化，而ArrayList类是Collection的间接实现类，可以通过ArrayList类实例化。
removeAll()方法
用来从集合中移除同时包含在指定集合中的对象，与retainAll()方法相反。
方法签名
boolean removeAll(Collection<?> c)
- 参数：
c是要从调用该方法的集合中移除的元素的集合。?表示可以接受任何类型的集合。 - 返回值：如果调用该方法后集合的内容发生了变化（即至少移除了一个元素），则返回
true；如果没有元素被移除，则返回false。
import java.util.ArrayList;
import java.util.Collection;
public class RemoveAllExample {
public static void main(String[] args) {
// 创建第一个集合
Collection<String> collection1 = new ArrayList<>();
collection1.add("A");
collection1.add("B");
collection1.add("C");
// 创建第二个集合
Collection<String> collection2 = new ArrayList<>();
collection2.add("B");
collection2.add("C");
// 使用 removeAll() 从 collection1 中移除 collection2 的元素
boolean modified = collection1.removeAll(collection2);
// 打印结果
System.out.println("集合1修改后: " + collection1);
System.out.println("集合是否被修改: " + modified);
}
}
//输出结果：
//集合1修改后: [A]
//集合是否被修改: truecontainsAll()方法
用来查看集合是否存在指定集合中的所有元素对象。
方法签名
boolean containsAll(Collection<?> c)
- 参数：
c是要检查的集合，?表示可以接受任何类型的集合。 - 返回值：如果调用的集合包含参数集合中的所有元素，则返回
true；否则返回false。
import java.util.ArrayList;
import java.util.Collection;
public class ContainsAllExample {
public static void main(String[] args) {
// 创建第一个集合
Collection<String> collection1 = new ArrayList<>();
collection1.add("A");
collection1.add("B");
collection1.add("C");
// 创建第二个集合
Collection<String> collection2 = new ArrayList<>();
collection2.add("B");
collection2.add("C");
// 使用 containsAll() 检查 collection1 是否包含 collection2 的所有元素
boolean contains = collection1.containsAll(collection2);
// 打印结果
System.out.println("集合1包含集合2的所有元素: " + contains);
}
}
//输出结果：
//集合1包含集合2的所有元素: trueretainAll()方法
仅保留集合中同时包含在指定集合中的元素，其他全部移除。
方法签名
boolean retainAll(Collection<?> c)
- 参数：
c是与调用该方法的集合进行比较的集合。只有在c中存在的元素将被保留。 - 返回值：如果调用的集合因调用该方法而发生变化（即至少移除了一个元素），则返回
true；如果集合没有变化，则返回false。
import java.util.ArrayList;
import java.util.Collection;
public class RetainAllExample {
public static void main(String[] args) {
// 创建第一个集合
Collection<String> collection1 = new ArrayList<>();
collection1.add("A");
collection1.add("B");
collection1.add("C");
// 创建第二个集合
Collection<String> collection2 = new ArrayList<>();
collection2.add("B");
collection2.add("C");
collection2.add("D");
// 使用 retainAll() 保留 collection1 中与 collection2 相同的元素
boolean modified = collection1.retainAll(collection2);
// 打印结果
System.out.println("集合1修改后: " + collection1);
System.out.println("集合是否被修改: " + modified);
}
}
//输出结果：
//集合1修改后: [B, C]
//集合是否被修改: truetoArray()方法
用来获得一个包含所有对象的指定类型的数组，将集合转换为数组的方法。
方法签名
//无参数
Object[] toArray()
- 返回值：返回一个包含集合中所有元素的数组，数组的类型为
Object[]。
import java.util.ArrayList;
import java.util.Collection;
public class ToArrayExample {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
collection.add("A");
collection.add("B");
collection.add("C");
// 使用无参数版本的 toArray()
Object[] array = collection.toArray();
// 打印结果
for (Object element : array) {
System.out.println(element);
}
}
}//带参数
<T> T[] toArray(T[] a)
- 参数：
a是一个用于指定返回数组的类型的数组实例，如果传入的数组能够容纳集合中的所有元素，则返回该数组；否则，将创建一个新的数组并返回。 - 返回值：带参数版本返回
T[]，其中T是参数数组的类型。
import java.util.ArrayList;
import java.util.Collection;
public class ToArrayExample {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
collection.add("A");
collection.add("B");
collection.add("C");
// 使用带参数版本的 toArray()
String[] array = collection.toArray(new String[0]);
// 打印结果
for (String element : array) {
System.out.println(element);
}
}
}四、集合类型
Iterator（迭代器）
Java Iterator（迭代器）不是一个集合，是一种用于遍历集合的接口，可用于迭代 ArrayList 和 HashSet 等集合。它提供了一种统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。
迭代器接口定义的常用方法
- next()：返回迭代器的下一个元素，并将迭代器的指针移到下一个位置。
- hasNext()：用于判断集合中是否还有下一个元素可以访问。
- remove()：从集合中删除迭代器最后访问的元素（可选操作）。
引入Iterator 类
import java.util.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();
// 输出集合中的第一个元素：Google
System.out.println(it.next());
}
}循环集合元素
让迭代器 it 逐个返回集合中所有元素最简单的方法是使用 while 循环：
while(it.hasNext()) {
System.out.println(it.next());
}
// 引入 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删除元素
// 引入 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]注意：Java 迭代器是一种单向遍历机制，只能从前往后遍历集合中的元素。在使用迭代器遍历集合时，不能直接修改集合中的元素，否则，可能会导致 ConcurrentModificationException 异常；为了避免这个问题而是需要使用迭代器的 remove() 方法来删除当前元素。通过使用迭代器，可以逐个访问集合中的元素，而不需要使用传统的 for 循环或索引。这种方式更加简洁和灵活，适用于各种类型的集合。
Collection集合
Collection 是最基本的集合接口，无法实例化；一个 Collection 代表一组 Object，Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。Collection 接口存储一组不唯一，无序的对象。
List集合
List集合为列表类型，以线性方式存储对象，List接口元素有序可重复。List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
ArrayList类
对象被存储在ArrayList对象中，其容量会自带增加，也可以通过ensureCapacity()来人工增加容量。该类实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
适合用处
- 频繁访问列表中的某一个元素。
- 只需要在列表末尾进行添加和删除元素操作。
引入ArrayList 类
import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>(); // 初始化添加元素
public class RunoobTest {
public static void main(String[] args) {
ArrayList<String> sites = new ArrayList<String>();
//使用 add() 方法添加元素到 ArrayList
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);
}
}访问元素
System.out.println(sites.get(1)); // 访问第二个元素修改元素
set(int index, E element) 方法的第一个参数是索引（index），表示要替换的元素的位置，第二个参数是新元素（element），表示要设置的新值。
sites.set(2, "Wiki"); // 修改第三个元素的值删除元素
sites.remove(3); // 删除第四个元素计算大小
System.out.println(sites.size());迭代数组列表
for (int i = 0; i < sites.size(); i++) {
System.out.println(sites.get(i));
}for (String i : sites) {
System.out.println(i);
}其他基本类型引用
ArrayList 中的元素实际上是对象，在以上实例中，数组列表元素都是字符串 String 类型。如果要存储其他类型，而 <E> 只能为引用数据类型，这时就需要使用到基本类型的包装类。
此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。
ArrayList<Integer> list1 = new ArrayList<>(); // 存放整数元素
ArrayList<Character> list2 = new ArrayList<>(); // 存放字符元素示例
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(10);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(25);
for (int i : myNumbers) {
System.out.println(i);
}
}
}ArrayList 排序
import java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
public class RunoobTest {
public static void main(String[] args) {
ArrayList<String> sites = new ArrayList<String>();
sites.add("Taobao");
sites.add("Wiki");
sites.add("Runoob");
sites.add("Weibo");
sites.add("Google");
Collections.sort(sites); // 字母排序
for (String i : sites) {
System.out.println(i);
}
}
}
//执行输出结果为：
//Google
//Runoob
//Taobao
//Weibo
//Wikiimport java.util.ArrayList;
import java.util.Collections; // 引入 Collections 类
public class RunoobTest {
public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);
Collections.sort(myNumbers); // 数字排序
for (int i : myNumbers) {
System.out.println(i);
}
}
}
//执行输出结果为：
//8
//12
//15
//20
//33
//34ArrayList 常用方法（更多请看：ArrayList）
| 方法 | 描述 |
|---|---|
| add() | 将元素插入到指定位置的 arraylist 中 |
| addAll() | 添加集合中的所有元素到 arraylist 中 |
| clear() | 删除 arraylist 中的所有元素 |
| clone() | 复制一份 arraylist |
| contains() | 判断元素是否在 arraylist |
| get() | 通过索引值获取 arraylist 中的元素 |
| indexOf() | 返回 arraylist 中元素的索引值 |
| removeAll() | 删除存在于指定集合中的 arraylist 里的所有元素 |
| remove() | 删除 arraylist 里的单个元素 |
| size() | 返回 arraylist 里元素数量 |
| isEmpty() | 判断 arraylist 是否为空 |
| subList() | 截取部分 arraylist 的元素 |
| set() | 替换 arraylist 中指定索引的元素 |
| sort() | 对 arraylist 元素进行排序 |
| toArray() | 将 arraylist 转换为数组 |
| toString() | 将 arraylist 转换为字符串 |
| ensureCapacity() | 设置指定容量大小的 arraylist |
| lastIndexOf() | 返回指定元素在 arraylist 中最后一次出现的位置 |
| retainAll() | 保留 arraylist 中在指定集合中也存在的那些元素 |
| containsAll() | 查看 arraylist 是否包含指定集合中的所有元素 |
| trimToSize() | 将 arraylist 中的容量调整为数组中的元素个数 |
| removeRange() | 删除 arraylist 中指定索引之间存在的元素 |
| replaceAll() | 将给定的操作内容替换掉数组中每一个元素 |
| removeIf() | 删除所有满足特定条件的 arraylist 元素 |
| forEach() | 遍历 arraylist 中每一个元素并执行特定操作 |
LinkedList类
该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，即在创建List时候构造一个同步的List。
适合用处
- 需要通过循环迭代来访问列表中的某些元素。
- 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
引入LinkedList类
// 引入 LinkedList 类
import java.util.LinkedList;
//LinkedList<E> list = new LinkedList<E>(); // 普通创建方法
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表创建简单链表
// 引入 LinkedList 类
import java.util.LinkedList;
public class RunoobTest {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.addFirst("Wiki"); // 使用 addFirst() 在头部添加元素
sites.addLast("Wiki"); // 使用 addLast() 在尾部添加元素
System.out.println(sites);
}
}
//输出结果：[Wiki, Google, Runoob, Taobao, Weibo, Wiki]移除元素
sites.removeFirst(); // 使用 removeFirst() 移除头部元素
sites.removeLast(); // 使用 removeLast() 移除尾部元素获取元素
System.out.println(sites.getFirst()); // 使用 getFirst() 获取头部元素
System.out.println(sites.getLast()); // 使用 getLast() 获取尾部元素迭代元素
for (int size = sites.size(), i = 0; i < size; i++) {
System.out.println(sites.get(i));
}for (String i : sites) {
System.out.println(i);
}LinkedList类常用方法（其他请见：LinkedList）
| 方法 | 描述 |
|---|---|
| public boolean add(E e) | 链表末尾添加元素，返回是否成功，成功为 true，失败为 false。 |
| public void add(int index, E element) | 向指定位置插入元素。 |
| public boolean addAll(Collection c) | 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。 |
| public boolean addAll(int index, Collection c) | 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。 |
| public void addFirst(E e) | 元素添加到头部。 |
| public void addLast(E e) | 元素添加到尾部。 |
| public boolean offer(E e) | 向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。 |
| public boolean offerFirst(E e) | 头部插入元素，返回是否成功，成功为 true，失败为 false。 |
| public boolean offerLast(E e) | 尾部插入元素，返回是否成功，成功为 true，失败为 false。 |
| public void clear() | 清空链表。 |
| public E removeFirst() | 删除并返回第一个元素。 |
| public E removeLast() | 删除并返回最后一个元素。 |
| public boolean remove(Object o) | 删除某一元素，返回是否成功，成功为 true，失败为 false。 |
| public E remove(int index) | 删除指定位置的元素。 |
| public E poll() | 删除并返回第一个元素。 |
| public E remove() | 删除并返回第一个元素。 |
| public boolean contains(Object o) | 判断是否含有某一元素。 |
| public E get(int index) | 返回指定位置的元素。 |
| public E getFirst() | 返回第一个元素。 |
| public E getLast() | 返回最后一个元素。 |
| public int indexOf(Object o) | 查找指定元素从前往后第一次出现的索引。 |
| public int lastIndexOf(Object o) | 查找指定元素最后一次出现的索引。 |
| public E peek() | 返回第一个元素。 |
| public E element() | 返回第一个元素。 |
| public E peekFirst() | 返回头部元素。 |
| public E peekLast() | 返回尾部元素。 |
| public E set(int index, E element) | 设置指定位置的元素。 |
| public Object clone() | 克隆该列表。 |
| public Iterator descendingIterator() | 返回倒序迭代器。 |
| public int size() | 返回链表元素个数。 |
| public ListIterator listIterator(int index) | 返回从指定位置开始到末尾的迭代器。 |
| public Object[] toArray() | 返回一个由链表元素组成的数组。 |
| public T[] toArray(T[] a) | 返回一个由链表元素转换类型而成的数组。 |
Vector集合
Vector实现动态数组，与ArrayList相似，但Vector是同步的。
Stack类
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。该类不是同步的，因此在多线程环境下需要自行实现同步。
适合用处
- 需要实现回溯功能（如浏览器历史记录）。
- 需要进行深度优先搜索（DFS）等算法。
import java.util.Stack; // 引入 Stack 类
public class StackTest {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
stack.push("Google");
stack.push("Runoob");
stack.push("Taobao");
System.out.println(stack); // 输出结果：[Google, Runoob, Taobao]
// 移除元素
stack.pop(); // 移除顶部元素
System.out.println(stack); // 输出结果：[Google, Runoob]
// 获取元素
System.out.println(stack.peek()); // 获取顶部元素，输出：Runoob
// 迭代元素
for (String item : stack) {
System.out.println(item);
}
}
}Queue集合
Queue接口表示队列，向末尾添加元素，从队头删除元素，允许有重复元素，LinkedList类不仅实现了List接口，还实现了Queue接口。
示例：
Queue<String> queue = new LinkedList<String>();
//从末尾进入队列
queue.add("Tom");
queue.add("Mike");
queue.add("Linda");
//从队头出
System.out.println(queue.remove()); //打印Tom
System.out.println(queue.remove()); //打印Mike
System.out.println(queue.remove()); //打印LindaSet集合
Set接口元素无序不可重复，与 Collection 完全一样的接口。Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。
HashSet类
HashSet 允许有 null 值，
引入HashSet语法
import java.util.HashSet;创建一个 HashSet 对象示例
HashSet<String> sites = new HashSet<String>();添加元素
// 引入 HashSet 类
import java.util.HashSet;
public class RunoobTest {
public static void main(String[] args) {
HashSet<String> sites = new HashSet<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");
sites.add("Runoob"); // 重复的元素不会被添加
System.out.println(sites);
}
}判断元素是否存在
System.out.println(sites.contains("Taobao"));删除元素
sites.remove("Taobao"); // 删除指定元素，删除成功返回 true，否则为 false
sites.clear(); // 删除所有元素计算大小
System.out.println(sites.size()); //打印集合大小迭代 HashSet
for (String i : sites) {
System.out.println(i);
}TreeSet类
TreeSet类实现了Set接口，基于红黑树的实现，元素是有序的。允许null元素（最多一个）。
适合用处
- 需要自动排序的集合。
- 需要快速查找、不允许重复的元素集合。
import java.util.TreeSet; // 引入 TreeSet 类
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("Google");
treeSet.add("Runoob");
treeSet.add("Taobao");
System.out.println(treeSet); // 输出结果：[Google, Runoob, Taobao]
// 移除元素
treeSet.remove("Runoob");
System.out.println(treeSet); // 输出结果：[Google, Taobao]
// 获取元素
System.out.println(treeSet.first()); // 获取第一个元素，输出：Google
System.out.println(treeSet.last()); // 获取最后一个元素，输出：Taobao
// 迭代元素
for (String item : treeSet) {
System.out.println(item);
}
}
}Map集合
Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
HashMap类
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，对象按升序排序。它实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。HashMap 的 key 与 value 类型可以相同也可以不同。
引入HashMap类语法
import java.util.HashMap;创建 HashMap 对象
HashMap<Integer, String> Sites = new HashMap<Integer, String>();添加元素
// 引入 HashMap 类
import java.util.HashMap;
public class RunoobTest {
public static void main(String[] args) {
// 创建 HashMap 对象 Sites
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
// 使用 put() 方法添加键值对
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
System.out.println(Sites);
}
}访问元素
System.out.println(Sites.get(3)); // 使用 get(key) 方法来获取 key 对应的 value删除元素
Sites.remove(4); // 使用 remove(key) 方法来删除 key 对应的键值对(key-value)
Sites.clear(); // 删除所有键值对计算大小
System.out.println(Sites.size());迭代 HashMap
// 输出 key 和 value
for (Integer i : Sites.keySet()) {
System.out.println("key: " + i + " value: " + Sites.get(i));
}
// 返回所有 value 值
for(String value: Sites.values()) {
// 输出每一个value
System.out.print(value + ", ");
}HashMap 常用方法
| 方法 | 描述 |
|---|---|
| clear() | 删除 hashMap 中的所有键/值对 |
| clone() | 复制一份 hashMap |
| isEmpty() | 判断 hashMap 是否为空 |
| size() | 计算 hashMap 中键/值对的数量 |
| put() | 将键/值对添加到 hashMap 中 |
| putAll() | 将所有键/值对添加到 hashMap 中 |
| putIfAbsent() | 如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。 |
| remove() | 删除 hashMap 中指定键 key 的映射关系 |
| containsKey() | 检查 hashMap 中是否存在指定的 key 对应的映射关系。 |
| containsValue() | 检查 hashMap 中是否存在指定的 value 对应的映射关系。 |
| replace() | 替换 hashMap 中是指定的 key 对应的 value。 |
| replaceAll() | 将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。 |
| get() | 获取指定 key 对应对 value |
| getOrDefault() | 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值 |
| forEach() | 对 hashMap 中的每个映射执行指定的操作。 |
| entrySet() | 返回 hashMap 中所有映射项的集合集合视图。 |
| keySet() | 返回 hashMap 中所有 key 组成的集合视图。 |
| values() | 返回 hashMap 中存在的所有 value 值。 |
| merge() | 添加键值对到 hashMap 中 |
| compute() | 对 hashMap 中指定 key 的值进行重新计算 |
| computeIfAbsent() | 对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中 |
| computeIfPresent() | 对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。 |
TreeMap类
继承了AbstractMap，实现了Map接口，基于红黑树的实现，键是有序的，对象按升序排序。允许null 键（最多一个）。
适合用处
- 需要键值对自动排序的映射。
- 需要快速查找和插入的键值对集合。
import java.util.TreeMap; // 引入 TreeMap 类
public class TreeMapTest {
public static void main(String[] args) {
TreeMap<String, String> treeMap = new TreeMap<>();
treeMap.put("Google", "搜索引擎");
treeMap.put("Runoob", "学习网站");
treeMap.put("Taobao", "购物网站");
System.out.println(treeMap); // 输出结果：{Google=搜索引擎, Runoob=学习网站, Taobao=购物网站}
// 移除元素
treeMap.remove("Runoob");
System.out.println(treeMap); // 输出结果：{Google=搜索引擎, Taobao=购物网站}
// 获取元素
System.out.println(treeMap.get("Google")); // 获取键为 Google 的值，输出：搜索引擎
// 迭代元素
for (String key : treeMap.keySet()) {
System.out.println(key + ": " + treeMap.get(key));
}
}
}Properties类
是Hashtable的一个子类，它用来保持值的列表，其中键和值都是String。
import java.util.Properties;
import java.util.Set;
import java.util.Iterator;
public class Test{
public static void main(String[] args){
// 创建 Properties 对象
Properties capitals = new Properties();
Set states;
String str;
// 添加元素
capitals.put("中国", "北京");
capitals.put("俄罗斯", "莫斯科");
capitals.put("日本", "东京");
capitals.put("法国", "巴黎");
capitals.put("英国", "伦敦");
// 获取映射中包含的项的集合
states = capitals.keySet();
// 遍历国家和首都的映射
Iterator itr = states.iterator();
while(itr.hasNext()){
str = (String) itr.next();
System.out.println("国家："+str+"，首都："+capitals.getProperty(str)+".");
}
System.out.println();
str = capitals.getProperty("美国", "没有发现");
System.out.println("美国的首都："+str+".");
}
}
