526互联

JAVA~适合新手和复习~基础三（集合所有常用方法）

发布时间 2023-03-22 21:16:37作者: 这里那里

Java 集合框架

 

 

1 Set和List的区别
2 1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
3 
4 2. Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
5 
6 3. List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

ArrayList

 

 

 用法

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

示例

 1 import java.util.ArrayList;
 2 import java.util.Collections;  // 引入 Collections 类
 3 
 4 public class RunoobTest {
 5     public static void main(String[] args) {
 6         ArrayList<String> sites = new ArrayList<String>();
 7         sites.add("Taobao");
 8         sites.add("Wiki");
 9         sites.add("Runoob");
10         sites.add("Weibo");
11         sites.add("Google");
12         Collections.sort(sites);  // 字母排序
13         for (String i : sites) {
14             System.out.println(i);
15         }
16     }
17 }
18 
19 
20 //结果
21 /*
22 *Google
23 *Runoob
24 *Taobao
25 *Weibo
26 *Wiki
27 */

ArrayList 方法

add方法

上面已经看过了

addAll() 方法

addAll() 方法将给定集合中的所有元素添加到 arraylist 中。

arraylist.addAll(原集合开始下标,插入的集合)
 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5        
 6         // 创建一个动态数组
 7         ArrayList<Integer> primeNumbers = new ArrayList<>();
 8         // 往动态数组里添加元素
 9         primeNumbers.add(3);
10         primeNumbers.add(5);
11         System.out.println("Prime Numbers: " + primeNumbers);
12 
13         // 创建另外的一个动态数组
14         ArrayList<Integer> numbers = new ArrayList<>();
15         numbers.add(1);
16         numbers.add(2);
17 
18         // 把 primeNumbers 的所有元素添加到 numbers 的动态数组中
19         numbers.addAll(primeNumbers);
20         System.out.println("Numbers: " + numbers);
21     }
22 }
23 //执行以上程序输出结果为：
24 
25 //Prime Numbers: [3, 5]
26 //Numbers: [1, 2, 3, 5]

clear() 方法与 removeAll() 方法

clear() 和removeAll() 方法用于删除动态数组中的所有元素。但是clear() 比 removeAll() 更快，更高效。

示例

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        // 往动态数组里面添加元素
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        System.out.println("奇数 ArrayList: " + oddNumbers);

        // 删除所有元素
        oddNumbers.removeAll(oddNumbers);
        System.out.println("使用 removeAll() 方法后: " + oddNumbers);
    }
}
执行以上程序输出结果为:

奇数 ArrayList: [1, 3, 5]
使用 removeAll() 方法后: []

clone() 方法

clone() 方法用于拷贝一份动态数组，属于浅拷贝

 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5 
 6         // 创建一个数组
 7         ArrayList<String> sites = new ArrayList<>();
 8 
 9         sites.add("Google");
10         sites.add("Runoob");
11         sites.add("Taobao");
12         System.out.println("网站列表: " + sites);
13 
14 
15         // 对 sites 进行拷贝
16         ArrayList<String> cloneSites = (ArrayList<String>)sites.clone();
17         System.out.println("拷贝 ArrayList: " + cloneSites);
18     }
19 }
20 执行以上程序输出结果为：
21 
22 网站列表: [Google, Runoob, Taobao]
23 拷贝 ArrayList: [Google, Runoob, Taobao]

contains() 方法

contains() 方法用于判断元素是否在动态数组中。

 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5 
 6         // 创建一个数组
 7         ArrayList<String> sites = new ArrayList<>();
 8 
 9         sites.add("Google");
10         sites.add("Runoob");
11         sites.add("Taobao");
12         System.out.println("网站列表: " + sites);
13 
14 
15         // 检查 Runoob 是否在这个数组中
16         System.out.print("Runoob 是否存在于 arraylist: ");
17         System.out.println(sites.contains("Runoob"));
18 
19         // 检查 Weibo 是否在这个数组中
20         System.out.print("Weibo 是否存在于 arraylist: ");
21         System.out.println(sites.contains("Weibo"));
22     }
23 }
24 执行以上程序输出结果为：
25 
26 Runoob 是否存在于 arraylist: true
27 Weibo 是否存在于 arraylist: false

get() 方法

get() 方法通过索引值获取动态数组中的元素。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 获取在索引值为1处的元素
        String element = sites.get(1);
        System.out.println("索引值为 1 的元素为: " + element);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao]
索引值为 1 的元素为: Runoob

indexOf() 方法

indexOf() 方法返回动态数组中元素的索引值。

 1 获取动态数组元素的索引：
 2 
 3 实例
 4 import java.util.ArrayList;
 5 
 6 class Main {
 7     public static void main(String[] args){
 8 
 9         // 创建一个数组
10         ArrayList<String> sites = new ArrayList<>();
11 
12         sites.add("Google");
13         sites.add("Runoob");
14         sites.add("Taobao");
15         System.out.println("网站列表: " + sites);
16 
17 
18         // 查找位置索引值为 Runoob 的元素
19         int position1 = sites.indexOf("Runoob");
20         System.out.println("Runoob 的索引位置: " + position1);
21 
22         // 查找位置索引值为 Weibo 的元素
23         int position2 = sites.indexOf("Weibo");
24         System.out.println("Weibo 的索引位置: " + position2);
25     }
26 }
27 执行以上程序输出结果为：
28 
29 Runoob 的索引位置: 1
30 Weibo 的索引位置: -1

remove() 方法

remove() 方法用于删除动态数组里的单个元素。

 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5 
 6         // 创建一个数组
 7         ArrayList<String> sites = new ArrayList<>();
 8 
 9         sites.add("Google");
10         sites.add("Runoob");
11         sites.add("Taobao");
12         System.out.println("网站列表: " + sites);
13 
14 
15         // 删除元素 Taobao
16         boolean result = sites.remove("Taobao");
17         System.out.println("Taoabo 是否被删除? " + result);
18         System.out.println("使用 remove() 后: " + sites);
19 
20     }
21 }
22 执行以上程序输出结果为：
23 
24 网站列表: [Google, Runoob, Taobao]
25 Taoabo 是否被删除? true
26 使用 remove() 后: [Google, Runoob]

size() 方法

size() 方法用于返回动态数组中元素的数量。(和数组、字符窜的lenght类似)

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 得到数组中的元素个数
        int size = sites.size();
        System.out.println("动态数组长度: " + size);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao]
动态数组长度: 3

 isEmpty() 

isEmpty() 方法用于判断动态数组是否为空。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        // 检查数组中是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("sites 是否为空? " + result);

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 检查该数组是否为空
        result = sites.isEmpty();  // false
        System.out.println("sites 是否为空? " + result);
    }
}
执行以上程序输出结果为：

sites 是否为空? true
网站列表: [Google, Runoob, Taobao]
sites 是否为空? false

subList() 方法

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Wiki");
        System.out.println("网站列表: " + sites);

        // 元素位置为1到3
        System.out.println("SubList: " + sites.subList(1, 3));
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao, Wiki]
SubList: [Runoob, Taobao]

 

 

set() 方法

 set() 方法用于替换动态数组中指定索引的元素。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

            // 索引 2 的元素被替换
        String element = sites.set(2, "Wiki");
        System.out.println("替换后: " + sites);
        System.out.println("被替换的元素: " + element);
    }
}
执行以上程序输出结果为：

替换后: [Google, Runoob, Wiki]
被替换的元素: Taobao

sort() 方法

sort() 方法根据指定的顺序对动态数组中的元素进行排序。

import java.util.ArrayList;
import java.util.Comparator;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        System.out.println("不排序: " + sites);

        // 元素进行升序排列
        sites.sort(Comparator.naturalOrder());
        System.out.println("排序后: " + sites);
    }
}
执行以上程序输出结果为：

网站列表: [Runoob, Google, Wiki, Taobao]
不排序: [Runoob, Google, Wiki, Taobao]
排序后: [Google, Runoob, Taobao, Wiki]

toArray() 方法

toArray() 方法将 Arraylist 对象转换为数组。

import java.util.ArrayList;
import java.util.Comparator;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 创建一个新的 String 类型的数组
        // 数组长度和 ArrayList 长度一样
        String[] arr = new String[sites.size()];

        // 将ArrayList对象转换成数组
        sites.toArray(arr);

        // 输出所有数组的元素
        System.out.print("Array: ");
        for(String item:arr) {
            System.out.print(item+", ");
        }
    }
}
执行以上程序输出结果为：

网站列表: [Runoob, Google, Wiki, Taobao]
Array: Runoob, Google, Wiki, Taobao,

toString() 方法

toString() 方法将 Arraylist 对象转换为字符串

import java.util.ArrayList;
import java.util.Comparator;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 将ArrayList转换为String类型
        String list = sites.toString();
        System.out.println("String: " + list);
    }
}
执行以上程序输出结果为：

  
网站列表: [Runoob, Google, Wiki, Taobao]
String: [Runoob, Google, Wiki, Taobao]

ensureCapacity() 方法

ensureCapacity() 方法用于设置具有指定容量大小的动态数组。

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        // 设置 arraylist的容量大小
        sites.ensureCapacity(3);
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao]

lastIndexOf() 方法

lastIndexOf() 方法返回指定元素在动态数组中最后一次出现的位置

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Runoob");
        System.out.println("网站列表: " + sites);


        // 获取 Runoob 最后一次出现的位置
        int position1 = sites.lastIndexOf("Runoob");
        System.out.println("Runoob 最后出现的位置: " + position1);

        // Wiki 不在 arraylist 中
        // 返回 -1
        int position2 = sites.lastIndexOf("Wiki");
        System.out.println("Wiki 最后出现的位置: " + position2);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao, Runoob]
Runoob 最后出现的位置: 3
Wiki 最后出现的位置: -1

retainAll() 方法

retainAll() 方法用于保留 arraylist 中在指定集合中也存在的那些元素，也就是删除指定集合中不存在的那些元素

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList 1: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("Wiki");
        sites2.add("Runoob");
        sites2.add("Google");
        System.out.println("ArrayList 2: " + sites2);

        // 保留元素
        sites.retainAll(sites2);
        System.out.println("保留的元素: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList 1: [Google, Runoob, Taobao]
ArrayList 2: [Wiki, Runoob, Google]
保留的元素: [Google, Runoob]

containsAll() 方法

containsAll() 方法用于检测 arraylist 是否包含指定集合中的所有元素。。

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList 1: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("Runoob");
        sites2.add("Google");
        System.out.println("ArrayList 2: " + sites2);

        // 检查动态数组1是否包含动态数组2
        boolean result1 = sites.containsAll(sites2);
        System.out.println("ArrayList 1 包含了 ArrayList 2 的所有元素: " + result1);

        // 检查数组2是否包含数组1
        boolean result2 = sites2.containsAll(sites);
        System.out.println("ArrayList 2 包含了 ArrayList 1 的所有元素: " + result2);
    }
}
执行以上程序输出结果为：

ArrayList 1: [Google, Runoob, Taobao]
ArrayList 2: [Runoob, Google]
ArrayList 1 包含了 ArrayList 2 的所有元素: true
ArrayList 2 包含了 ArrayList 1 的所有元素: false

trimToSize() 方法

trimToSize() 方法用于将动态数组中的容量调整为数组中的元素个数。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 调整容量为3
        sites.trimToSize();
        System.out.println("ArrayList 大小: " + sites.size());
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao]
ArrayList 大小: 3

removeRange() 方法

removeRange() 方法用于删除指定索引之间存在的元素。

import java.util.*;

class Main extends ArrayList<String> {
    public static void main(String[] args) {
        // 创建一个动态数组
        Main sites = new Main();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Wiki");
        sites.add("Weibo");

        System.out.println("ArrayList : " + sites);

            // 删除从索引值1到3的元素
            sites.removeRange(1, 3);
            System.out.println("删除后的 ArrayList: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao, Wiki, Weibo]
删除后的 ArrayList: [Google, Wiki, Weibo]

replaceAll() 方法

replaceAll() 方法用于将给定的操作内容替换掉数组中每一个元素。

import java.util.*;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 将所有元素更改为大写
        sites.replaceAll(e -> e.toUpperCase());
        System.out.println("更新后的 ArrayList: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao]
更新后的 ArrayList: [GOOGLE, RUNOOB, TAOBAO]

removeIf() 方法

removeIf() 方法用于删除所有满足特定条件的数组元素。

import java.util.*;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 删除名称中带有 Tao 的元素
        sites.removeIf(e -> e.contains("Tao"));;
        System.out.println("删除后的 ArrayList: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao]
删除后的 ArrayList: [Google, Runoob]

forEach() 方法

forEach() 方法用于遍历动态数组中每一个元素并执行特定操作。

import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<Integer> numbers = new ArrayList<>();

        // 往数组中添加元素
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("ArrayList: " + numbers);

        // 所有元素乘以 10
        System.out.print("更新 ArrayList: ");
       
        // 将 lambda 表达式传递给 forEach
        numbers.forEach((e) -> {
            e = e * 10;
            System.out.print(e + " ");
        });
    }
}
执行以上程序输出结果为：

ArrayList: [1, 2, 3, 4]
更新 ArrayList: 10 20 30 40

HashSet

 

 

 

1 HashSet 类位于 java.util 包中，使用前需要引入它，语法格式如下：
2 
3 import java.util.HashSet; // 引入 HashSet 类
4 以下实例我们创建一个 HashSet 对象 sites，用于保存字符串元素：
5 
6 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);
    }
}

判断元素是否存在

// 引入 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.contains("Taobao"));
    }
}
执行以上代码，输出结果如下：

true

删除元素

// 引入 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");     // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);
    }
}
执行以上代码，输出结果如下：

[Google, Runoob, Zhihu]

删除集合中所有元素可以使用 clear 方法：

// 引入 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");     // 重复的元素不会被添加
        sites.clear();  
        System.out.println(sites);
    }
}
执行以上代码，输出结果如下：

[]

计算大小

// 引入 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.size());  
    }
}
执行以上代码，输出结果如下：

4

迭代 HashSet

//可以使用 for-each 来迭代 HashSet 中的元素。

//实例
// 引入 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");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}
执行以上代码，输出结果如下：

Google
Runoob
Zhihu
Taobao

 

HashMap

 

 

 

HashMap 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashMap; // 引入 HashMap 类
以下实例我们创建一个 HashMap 对象 Sites， 整型（Integer）的 key 和字符串（String）类型的 value：

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

clear() 方法

clear() 方法用于删除指定 hashMap 中所有键/值对

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 从HashMap中删除所有映射
        sites.clear();
        System.out.println("使用 clear() 方法后: " + sites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
使用 clear() 方法后: {}

clone() 方法

clone() 方法用于复制一份 hashMap，属于浅拷贝。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 复制 sites
        HashMap<Integer, String> cloneSites = (HashMap<Integer, String>)sites.clone();
        System.out.println("Cloned HashMap: " + cloneSites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
Cloned HashMap: {1=Google, 2=Runoob, 3=Taobao}

isEmpty() 方法

isEmpty() 方法用于检查该 HashMap 是否为空。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        // 检查该 HashMap 是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("是否为空? " + result);

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        result = sites.isEmpty(); // false
        System.out.println("是否为空? " + result);
    }
}
执行以上程序输出结果为：

是否为空? true
HashMap: {1=Google, 2=Runoob, 3=Taobao}
是否为空? false

size() 方法

计算 hashMap 中键/值对的数量

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 获得该 HashMap 中键/值对映射的数量
        int size = sites.size();
        System.out.println("Size of HashMap: " + size);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
Size of HashMap: 3

put() 方法

put() 方法将指定的键/值对插入到 HashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}

putAll() 方法

putAll() 方法将指定所有的键/值对插入到 HashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);
        // 创建另一个 HashMap
        HashMap<Integer, String> sites2 = new HashMap<>();
        sites2.put(1, "Weibo");  // 已存在会被替换
        sites2.put(4, "Wiki");

        // 将所有的映射关系从 sites 添加到 sites2
        sites2.putAll(sites);
        System.out.println("sites2 HashMap: " + sites2);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
sites2 HashMap: {1=Google, 2=Runoob, 3=Taobao, 4=Wiki}

putIfAbsent() 方法

putIfAbsent() 方法会先判断指定的键（key）是否存在，不存在则将键/值对插入到 HashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);
       

        // HashMap 不存在该key
        sites.putIfAbsent(4, "Weibo");

        // HashMap 中存在 Key
        sites.putIfAbsent(2, "Wiki");
        System.out.println("Updated Languages: " + sites);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Updated sites HashMap: {1=Google, 2=Runoob, 3=Taobao, 4=Weibo}

remove() 方法

remove() 方法用于删除hashMap 中指定键 key 对应的键值对(key-value)。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 删除key为2的映射关系
        String siteName = sites.remove(2);  // return Runoob
        System.out.println("返回值: " + siteName);
        System.out.println("删除后的 HashMap: " + sites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
返回值: Runoob
删除后的 HashMap: {1=Google, 3=Taobao}

containsKey() 方法

containsKey() 方法检查 hashMap 中是否存在指定的 key

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        //检查 key 为 1 是否存在
        if(sites.containsKey(1)) {
            System.out.println("key 为 1 存在于 sites 中");
        }

    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 为 1 存在于 sites 中

containsValue() 方法

containsValue() 方法检查 hashMap 中是否存在指定的 value 。

 1 import java.util.HashMap;
 2 
 3 class Main {
 4     public static void main(String[] args) {
 5         // 创建一个 HashMap
 6         HashMap<Integer, String> sites = new HashMap<>();
 7 
 8         // 往 HashMap 添加一些元素
 9         sites.put(1, "Google");
10         sites.put(2, "Runoob");
11         sites.put(3, "Taobao");
12         System.out.println("sites HashMap: " + sites);
13 
14         //检查映射中值value是否有Java
15         if(sites.containsValue("Runoob")) {
16             System.out.println("Runoob 存在于 sites 中");
17         }
18     }
19 }
20 执行以上程序输出结果为：
21 
22 sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
23 Runoob 存在于 sites 中

replace() 方法

replace() 方法替换 hashMap 中是指定的 key 对应的 value。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 替换key为2的映射
        String value = sites.replace(2, "Wiki");

        System.out.println("Replaced Value: " + value);
        System.out.println("Updated HashMap: " + sites);
    }
}
执行以上程序输出结果为：

Replaced Value: Runoob
Updated HashMap: {1=Google, 2=Wiki, 3=Taobao}

replaceAll() 方法

replaceAll() 方法将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 将所有的值更改为大写
        sites.replaceAll((key, value) -> value.toUpperCase());
        System.out.println("Updated HashMap: " + sites);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Updated HashMap: {1=GOOGLE, 2=RUNOOB, 3=TAOBAO}

get() 方法

get() 方法获取指定 key 对应对 value

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 得到 value
        String value = sites.get(1);
        System.out.println("key 1 对应的 value: " + value);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 1 对应的 value: Google

getOrDefault() 方法

getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // key 的映射存在于 HashMap 中
        // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value1 = sites.getOrDefault(1, "Not Found");
        System.out.println("Value for key 1:  " + value1);

        // key 的映射不存在于 HashMap 中
        // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value2 = sites.getOrDefault(4, "Not Found");
        System.out.println("Value for key 4: " + value2);
    }
}
执行以上程序输出结果为：

Value for key 1:  Google
Value for key 4: Not Found

forEach() 方法

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<String, Integer> prices = new HashMap<>();

        // 往 HashMap 中插入映射项
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("Normal Price: " + prices);

        System.out.print("Discounted Price: ");

        //通过 lambda 表达式使用 forEach()
        prices.forEach((key, value) -> {
            // value 价格减少百分之 10
            value = value - value * 10/100;
            System.out.print(key + "=" + value + " ");
        });
    }
}
执行以上程序输出结果为：

Normal Price: {Pant=150, Bag=300, Shoes=200}
Discounted Price: Pant=135 Bag=270 Shoes=180

entrySet() 方法

entrySet() 方法返回映射中包含的映射的 Set 视图。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 返回映射关系中 set view
        System.out.println("Set View: " + sites.entrySet());
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Set View: [1=Google, 2=Runoob, 3=Taobao]

 keySet() 方法

keySet() 方法返回映射中所有 key 组成的 Set 视图。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 返回所有 key 组成的 set 集合视图
        System.out.println("Keys: " + sites.keySet());
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Keys: [1, 2, 3]

values() 方法

values() 方法返回映射中所有 value 组成的 Set 视图。

 1 import java.util.HashMap;
 2 
 3 class Main {
 4     public static void main(String[] args) {
 5         // 创建一个 HashMap
 6         HashMap<Integer, String> sites = new HashMap<>();
 7 
 8         // 往 HashMap 添加一些元素
 9         sites.put(1, "Google");
10         sites.put(2, "Runoob");
11         sites.put(3, "Taobao");
12         System.out.println("sites HashMap: " + sites);
13 
14         // 返回所有value值组成的视图
15         System.out.println("Values: " + sites.values());
16 
17     }
18 }
19 执行以上程序输出结果为：
20 
21 sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
22 Values: [Google, Runoob, Taobao]

merge() 方法

merge() 方法会先判断指定的 key 是否存在，如果不存在，则添加键值对到 hashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
    //创建一个HashMap
    HashMap<String, Integer> prices = new HashMap<>();

    // 往 HashMap 插入映射
    prices.put("Shoes", 200);
    prices.put("Bag", 300);
    prices.put("Pant", 150);
    System.out.println("HashMap: " + prices);

    int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
    System.out.println("Price of Shirt: " + returnedValue);

    // 输出更新后的 HashMap
    System.out.println("Updated HashMap: " + prices);
    }
}
执行以上程序输出结果为：

HashMap: {Pant=150, Bag=300, Shoes=200}
Price of Shirt: 100
Updated HashMap: {Pant=150, Shirt=100, Bag=300, Shoes=200}

compute() 方法

compute() 方法对 hashMap 中指定 key 的值进行重新计算。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        //创建一个 HashMap
        HashMap<String, Integer> prices = new HashMap<>();

        // 往HashMap中添加映射项
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("HashMap: " + prices);

        // 重新计算鞋子打了10%折扣后的值
        int newPrice = prices.compute("Shoes", (key, value) -> value - value * 10/100);
        System.out.println("Discounted Price of Shoes: " + newPrice);

        // 输出更新后的HashMap
        System.out.println("Updated HashMap: " + prices);
    }
}
执行以上程序输出结果为：

HashMap: {Pant=150, Bag=300, Shoes=200}
Discounted Price of Shoes: 180
Updated HashMap: {Pant=150, Bag=300, Shoes=180

computeIfAbsent() 方法

computeIfAbsent() 方法对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hashMap 中。

 1 import java.util.HashMap;
 2 
 3 class Main {
 4     public static void main(String[] args) {
 5         // 创建一个 HashMap
 6         HashMap<String, Integer> prices = new HashMap<>();
 7 
 8         // 往HashMap中添加映射项
 9         prices.put("Shoes", 200);
10         prices.put("Bag", 300);
11         prices.put("Pant", 150);
12         System.out.println("HashMap: " + prices);
13 
14         // 计算 Shirt 的值
15         int shirtPrice = prices.computeIfAbsent("Shirt", key -> 280);
16         System.out.println("Price of Shirt: " + shirtPrice);
17 
18         // 输出更新后的HashMap
19         System.out.println("Updated HashMap: " + prices);
20     }
21 }
22 执行以上程序输出结果为：
23 
24 HashMap: {Pant=150, Bag=300, Shoes=200}
25 Price of Shirt: 280
26 Updated HashMap: {Pant=150, Shirt=280, Bag=300, Shoes=200}

 

computeIfPresent() 方法

computeIfPresent() 方法对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<String, Integer> prices = new HashMap<>();

        // 往HashMap中添加映射关系
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("HashMap: " + prices);

        // 重新计算鞋加上10%的增值税后的价值
        int shoesPrice = prices.computeIfPresent("Shoes", (key, value) -> value + value * 10/100);
        System.out.println("Price of Shoes after VAT: " + shoesPrice);

        // 输出更新后的HashMap
        System.out.println("Updated HashMap: " + prices);
    }
}
执行以上程序输出结果为：

HashMap: {Pant=150, Bag=300, Shoes=200}
Price of Shoes after VAT: 220
Updated HashMap: {Pant=150, Bag=300, Shoes=220}}