创建不可变集合：list.of()

package cn.zhage.collectionstudy.map;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Iterator;
import java.util.List;

@SpringBootTest
public class mapDemo {
    //创建不可变集合

    @Test
    public void test1()
    {

//简单理解：不想让别人修改集合中内容
//比如在某些场合一些数据不允许修改，代码层面不可修改

        List<Integer> list = List.of(1, 2, 3);
        List<String> name = List.of("付永闯");//创建不可变集合
        //一旦创建成功，不可修改，只能进行查询
        System.out.println(list.get(0));
        System.out.println(name);
        Iterator<Integer> iterator = list.iterator();
        //迭代器
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
        //增强for循环
        for (Integer i : list) {
            System.out.println(i);
        }
           //普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
//如果我们要修改元素，这是不允许的，比如我们删除集合list中的元素
        list.remove(0);


    }





}

修改操作也是不允许的

同样的还有set集合，和list一样，set集合没索引，要想查询只能遍历

Map.of()也是不可变集合

java默认会认为前两个元素是一个键值对，以此类推

map.keySet（）会得到集合中所有的键

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        
        Set<String> keys = map.keySet();
        System.out.println(keys); // 输出 [a, b, c]
    }
}

注意：这里是得到的每一个键

2. 遍历所有值（values()）

如果只需要值，可通过 values() 直接获取值的集合：

// 遍历值（不关心键）
for (Integer value : map.values()) {
    System.out.println("值：" + value);
}

3. 遍历键值对（entrySet()，推荐）

通过 entrySet() 获取键值对（Map.Entry）的集合，同时获取键和值，效率比先遍历键再查值更高：

// 遍历键值对（推荐，效率高）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println("键：" + key + "，值：" + value);
}

java9特性：

场景 2：先存数据到可变 Map，再转不可变（如果需要）

如果需要先动态存数据，最后转不可变，可以这样：

// 1. 先用可变 Map 存数据（比如 HashMap）
Map<String, String> mutableMap = new HashMap<>();
mutableMap.put("赵六", "北京");
mutableMap.put("孙七", "深圳");
// ... 放 10 个以上数据

// 2. 转成不可变 Map（Java 9+ 支持）
Map<String, String> immutableMap = Map.copyOf(mutableMap);

// 注意：不可变 Map 不支持 put，以下代码会报错！
// immutableMap.put("新键", "新值"); // 抛 UnsupportedOperationException

在 Java 中，Map.copyOf(...) 方法会返回一个不可变的 Map 集合。

该方法接收一个现有的 Map 作为参数，返回一个包含相同键值对的新 Map，但这个新 Map 具有以下特性：

• 不可修改：不支持 put、remove 等修改操作，调用这些方法会抛出 UnsupportedOperationException
• 只读性：只能进行查询操作（如 get、containsKey 等）
• 值不可变：如果原 Map 中的值是可变对象，虽然可以修改对象本身的状态，但无法替换整个键值对

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 创建一个可变的 HashMap
        Map<String, Integer> mutableMap = new HashMap<>();
        mutableMap.put("a", 1);
        mutableMap.put("b", 2);
        
        // 转换为不可变 Map
        Map<String, Integer> immutableMap = Map.copyOf(mutableMap);
        
        // 尝试修改会抛出异常
        try {
            immutableMap.put("c", 3); // 不支持添加新元素
        } catch (UnsupportedOperationException e) {
            System.out.println("无法添加元素：" + e.getMessage());
        }
        
        try {
            immutableMap.remove("a"); // 不支持删除元素
        } catch (UnsupportedOperationException e) {
            System.out.println("无法删除元素：" + e.getMessage());
        }
    }
}