java 不可变类数据类型 java 不可变map

转载

蓝梦之翼 2023-07-18 07:16:45

文章标签 java 不可变类数据类型 java System iphone 文章分类 Java 后端开发

Map集合体系

Map集合体系特点

Map集合实现类特点

Map集合常用API

Map集合的遍历方式

Map集合的遍历方式一：键找值

Map集合的遍历方式二：键值对

Map集合的遍历方式三：Lambda

不可变集合

Map集合也被称为“键值对集合”，其每个元素的格式：key=value(键值对元素)

键无序、不重复，值可以重复

Map集合体系

java 不可变类数据类型 java 不可变map_java

Map集合体系特点

Map集合的键是无序、不重复、无索引，值可以重复
Map集合后面重复的键对应的值会覆盖前面重复键的值
Map集合的键值对都可以为null

Map集合实现类特点

HashMap:元素按照键是无序、不重复、索引，值不做要求（与Map体系一致）
LinkedHashMap:元素按照键是有序、不重复、无索引，值不做要求
TreeMap：元素按照建是排序、不重复、无索引的，值不做要求

【例】

package com.test.d5_map;

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

public class MapDemo1 {
    public static void main(String[] args) {
        // 1、创建一个Map集合对象，一行经典代码
        // Map<String, Integer> maps = new HashMap<>(); //输出：{null=null, Java=10, Go=3, Python=10}
        Map<String, Integer> maps = new LinkedHashMap<>(); //输出：{Go=3, Java=10, Python=10, null=null}
        maps.put("Go", 3);
        maps.put("Java", 1);
        maps.put("Python", 10);
        maps.put("Java", 10); // 覆盖前面的数据
        maps.put(null, null);
        System.out.println(maps);

    }
}

Map集合常用API

java 不可变类数据类型 java 不可变map_iphone_02

【例】

package com.test.d6_map_api;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {
    public static void main(String[] args) {
        // 1.添加元素: 无序，不重复，无索引。
        Map<String , Integer> maps = new HashMap<>();
        maps.put("iphone13",3);
        maps.put("iphone13 Pro",5);
        maps.put("iphone13",2);//  Map集合后面重复的键对应的元素会覆盖前面重复的整个元素！
        maps.put("Nova 9",6);
        maps.put("Nova 8",2);
        maps.put("ProGo HERO10",1);
        maps.put("OSMO pocket",1);
        System.out.println(maps); // {ProGo HERO10=1, OSMO pocket=1, Nova 9=6, Nova 8=2, iphone13=2, iphone13 Pro=5}

        // 2.清空集合
//        maps.clear();
//        System.out.println(maps);

        // 3.判断集合是否为空，为空返回true
        System.out.println(maps.isEmpty()); // false

        // 4.根据键获取对应值:public V get(Object key)
        Integer keyvalue = maps.get("OSMO pocket");
        System.out.println(keyvalue); // 1
        System.out.println(maps.get("iphone13 Pro")); // 5
        System.out.println(maps.get("iphone13 mini")); // null

        // 5.根据键删除整个元素(删除键会返回键的值)
        System.out.println(maps.remove("iphone13")); // 2
        System.out.println(maps); // {ProGo HERO10=1, OSMO pocket=1, Nova 9=6, Nova 8=2, iphone13 Pro=5}

        // 6.判断是否包含某个键 ，包含返回true 
        System.out.println(maps.containsKey("iphone13 Pro"));  // true
        System.out.println(maps.containsKey("iphone13"));  // false

        // 7.判断是否包含某个值。
        System.out.println(maps.containsValue(10));  // false
        System.out.println(maps.containsValue(5));  // true

        // 8.获取全部键的集合：public Set<K> keySet()
        Set<String> keys = maps.keySet();  // [ProGo HERO10, OSMO pocket, Nova 9, Nova 8, iphone13 Pro]
        System.out.println(keys);

        System.out.println("------------------------------");
        // 9.获取全部值的集合：Collection<V> values();
        Collection<Integer> values = maps.values(); 
        System.out.println(values); // [1, 1, 6, 2, 5]

        // 10.集合的大小
        System.out.println(maps.size()); // 5

        // 11.合并其他Map集合。(拓展)
        Map<String , Integer> map1 = new HashMap<>();
        map1.put("java1", 1);
        map1.put("java2", 100);
        Map<String , Integer> map2 = new HashMap<>();
        map2.put("java2", 1);
        map2.put("java3", 100);
        map1.putAll(map2); // 把集合map2的元素拷贝一份到map1中去
        System.out.println(map1); // {java3=100, java2=1, java1=1}
        System.out.println(map2); // {java3=100, java2=1}
    }
}

Map集合的遍历方式

方式一：键找值的方式遍历：先获取Map集合全部的键，再根据遍历键找值
方式二：键值对的方式遍历，把“键值对“看成一个整体，难度较大
方式三：JDK 1.8开始之后的新技术：Lambda表达式

Map集合的遍历方式一：键找值

先获取Map集合的全部键的Set集合 --> 遍历键的Set集合，然后通过键提取对应值

键找值涉及到的API
Set<K> keySet() -> 获取所有键的集合
V get(Object key) -> 根据键获取值

【例】键找值

package com.test.d7_map_traversal;

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

/**
    Map集合的遍历方式一：键找值
 */
public class MapDemo01 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        // 1.添加元素: 无序，不重复，无索引。
        maps.put("iphone13 Pro",5);
        maps.put("iphone13",2);
        maps.put("Nova 9",6);
        maps.put("Nova 8",2);
        maps.put("ProGo HERO10",1);
        maps.put("OSMO pocket",1);
        System.out.println(maps);

        // 1、键找值：第一步：先拿到集合的全部键。
        Set<String> keys = maps.keySet();
        // 2、第二步：遍历每个键，根据键提取值
        for (String key : keys) {
            int value = maps.get(key);
            System.out.println(key + " ===> " + value);
        }

    }
}

输出：

java 不可变类数据类型 java 不可变map_iphone_03

Map集合的遍历方式二：键值对

先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型了 -->
遍历Set集合，然后提取键以及提取值

键值对涉及到的API
Set<Map.Entry<K,V>> entrySet() -> 获取所有键值对对象的集合
K getKey() -> 获得键
V getValue() -> 获取值

【例】键值对

package com.test.d7_map_traversal;

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

/**
        “键值对”的方式遍历：
        1.把Map集合转换成一个Set集合:Set<Map.Entry<K, V>> entrySet();
        2.此时键值对元素的类型就确定了，类型是键值对实体类型：Map.Entry<K, V>
        3.接下来就可以用foreach遍历这个Set集合，类型用Map.Entry<K, V>
 */
public class MapDemo02 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("iphone13 Pro",5);
        maps.put("iphone13",2);
        maps.put("Nova 9",6);
        maps.put("Nova 8",2);
        maps.put("ProGo HERO10",1);
        maps.put("OSMO pocket",1);
        System.out.println(maps);

       // 1、把Map集合转换成Set集合
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        // 2、开始遍历
        for(Map.Entry<String, Integer> entry : entries){
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + " ===> " + value);
        }
    }
}

Map集合的遍历方式三：Lambda

Map结合Lambda遍历的API

default void forEach(BiConsumer<? super K, ? super V> action) -> 结合lambda遍历Map集合

【例】Lambda

package com.test.d7_map_traversal;

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

/**
       JDK 1.8开始之后的新技术：Lambda表达式。
 */
public class MapDemo03 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("iphone13 Pro",5);
        maps.put("iphone13",2);
        maps.put("Nova 9",6);
        maps.put("Nova 8",2);
        maps.put("ProGo HERO10",1);
        maps.put("OSMO pocket",1);
        System.out.println(maps);

        maps.forEach((k, v) -> {
                System.out.println(k + " ===> " + v);
        });

    }
}

不可变集合

不可变集合不能添加、删除或修改元素

static <E> List<E> of(E…elements) -> 创建一个具有指定元素的List集合对象
static <E> Set<E> of(E…elements) -> 创建一个具有指定元素的Set集合对象
static <K,V> Map<K,V> of(E…elements) -> 创建一个具有指定元素的Map集合对象

【例】

package com.test.d1_unchange_collection;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionDemo {
    public static void main(String[] args) {
        // 1、不可变的List集合
        List<Double> lists = List.of(233.3, 66.6, 88.6, 99.6);
        System.out.println(lists);

        // 2、不可变的Set集合
        Set<String> names = Set.of("青龙", "白虎", "玄武", "朱雀" );
        System.out.println(names);

        // 3、不可变的Map集合
        Map<String, Integer> maps = Map.of("早饭",3, "中饭", 15 , "晚饭", 10);
        System.out.println(maps);
    }
}

输出:

java 不可变类数据类型 java 不可变map_System_04