一、集合的概述

集合建立在数组基础上，主要位于java.util包中，用来存储Java类对象，并且可以实现各种数据结构。

• 集合大小可以改变，可以存放不同数据类型数据。
• 集合不能存放基本类型数据，只能存放引用数据类型数据。
• 集合不仅可以方便地存放数据，而且提供了添加、读取和删除数据等实用方法。
• 集合中只能存放对象，JVM会自动将基本类型与相应的包装类型转换（装箱：基本类型→对象；拆箱：对象→基本类型）。

---

二、Java集合的类框架

所有的集合框架都包含如下内容：

•  接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象。

1.  Collection是单列集合的根接口，存储的元素符合某种规律。
2. 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]
//集合是否被修改: true

containsAll()方法

用来查看集合是否存在指定集合中的所有元素对象。

方法签名

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的所有元素: true

retainAll()方法

仅保留集合中同时包含在指定集合中的元素，其他全部移除。

方法签名

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]
//集合是否被修改: true

toArray()方法

用来获得一个包含所有对象的指定类型的数组，将集合转换为数组的方法。

方法签名

//无参数

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
//Wiki

import 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
//34

ArrayList 常用方法（更多请看：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());  //打印Linda

Set集合

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+".");
  }
}