Java【集合】_java集合方法，零基础入门到精通，收藏这篇就够了

目录

一、集合的概述

二、Java集合的类框架

三、集合方法

addAll()方法

removeAll()方法

containsAll()方法

retainAll()方法

toArray()方法

四、集合类型

Iterator（迭代器）

迭代器接口定义的常用方法

引入Iterator 类

获取一个迭代器

循环集合元素

删除元素

Collection集合

List集合

ArrayList类

LinkedList类

Vector集合

Stack类

Queue集合

Set集合

HashSet类

TreeSet类

Map集合

HashMap类

TreeMap类

Properties类

---

一、集合的概述

集合建立在数组基础上，主要位于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[] 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 类型。如果要存储其他类型，而 只能为引用数据类型，这时就需要使用到基本类型的包装类。

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

Java开发的就业市场正在经历结构性调整，竞争日益激烈

传统纯业务开发岗位（如仅完成增删改查业务的后端工程师）的需求，特别是入门级岗位，正显著萎缩。随着企业技术需求升级，市场对Java人才的要求已从通用技能转向了更深入的领域经验（如云原生、微服务）或前沿的AI集成能力。这也导致岗位竞争加剧，在一、二线城市，求职者不仅面临技术内卷，还需应对学历与项目经验的高门槛。

大模型为核心的AI领域正展现出前所未有的就业热度与人才红利

2025年，AI相关新发岗位数量同比激增543%，单月增幅最高超过11倍，大模型算法工程师位居热门岗位前列。行业顶尖人才的供需严重失衡，议价能力极强，跳槽薪资涨幅可达30%-50%。值得注意的是，市场并非单纯青睐算法研究员，而是急需能将大模型能力落地于复杂业务系统的工程人才。这使得具备企业级架构思维和复杂系统整合经验的Java工程师，在向“Java+大模型”复合人才转型时拥有独特优势，成为企业竞相争夺的对象，其薪资天花板也远高于传统Java岗位。

说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。

结果GPT、DeepSeek火了之后，整条线上的人都开始有点慌了，大家都在想：“我是不是要学大模型，不然这饭碗还能保多久？”

先给出最直接的答案：一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。

即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！

如何学习AGI大模型？

作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版CSDN大礼包：《AGI大模型学习资源包》免费分享**

一、2025最新大模型学习路线

一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。

我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。

L1级别:AI大模型时代的华丽登场

L1阶段：我们会去了解大模型的基础知识，以及大模型在各个行业的应用和分析；学习理解大模型的核心原理，关键技术，以及大模型应用场景；通过理论原理结合多个项目实战，从提示工程基础到提示工程进阶，掌握Prompt提示工程。

L2级别：AI大模型RAG应用开发工程

L2阶段是我们的AI大模型RAG应用开发工程，我们会去学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。

L3级别：大模型Agent应用架构进阶实践

L3阶段：大模型Agent应用架构进阶实现，我们会去学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造我们自己的Agent智能体；同时还可以学习到包括Coze、Dify在内的可视化工具的使用。

L4级别：大模型微调与私有化部署

L4阶段：大模型的微调和私有化部署，我们会更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调；并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。

整个大模型学习路线L1主要是对大模型的理论基础、生态以及提示词他的一个学习掌握；而L3 L4更多的是通过项目实战来掌握大模型的应用开发，针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。

二、大模型经典PDF书籍

书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。（书籍含电子版PDF）

三、大模型视频教程

对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的大模型视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。

四、大模型项目实战

学以致用 ，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。

五、大模型面试题

面试不仅是技术的较量，更需要充分的准备。

在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版CSDN大礼包：《AGI大模型学习资源包》免费分享