提升编程效率的利器: 解析Google Guava库之集合篇Immutable（一）

<dependency>  
    <groupId>com.google.guava</groupId>  
    <artifactId>guava</artifactId>  
    <version>31.0.1-jre</version> <!-- 请检查是否有更新的版本 -->  
</dependency>

import com.google.common.collect.ImmutableList;  
import com.google.common.collect.ImmutableSet;  
import com.google.common.collect.ImmutableMap;  
  
public class GuavaImmutableCollectionsExample {  
  
    public static void main(String[] args) {  
        // 创建一个ImmutableList  
        ImmutableList<String> immutableList = ImmutableList.of("Apple", "Banana", "Cherry");  
        System.out.println("ImmutableList: " + immutableList);  
  
        // 尝试修改ImmutableList（这将导致编译时错误）  
        // immutableList.add("Date"); // 这行代码将无法编译  
  
        // 创建一个ImmutableSet  
        ImmutableSet<Integer> immutableSet = ImmutableSet.of(1, 2, 3, 4, 5);  
        System.out.println("ImmutableSet: " + immutableSet);  
  
        // 尝试修改ImmutableSet（这也将导致编译时错误）  
        // immutableSet.add(6); // 这行代码也无法编译  
  
        // 创建一个ImmutableMap  
        ImmutableMap<String, Integer> immutableMap = ImmutableMap.of("One", 1, "Two", 2, "Three", 3);  
        System.out.println("ImmutableMap: " + immutableMap);  
  
        // 尝试修改ImmutableMap（这同样会导致编译时错误）  
        // immutableMap.put("Four", 4); // 这行代码也无法编译  
  
        // 访问ImmutableMap中的元素  
        Integer value = immutableMap.get("Two");  
        System.out.println("Value associated with 'Two': " + value);  
    }  
}

import com.google.common.collect.ImmutableSortedSet;  
import com.google.common.collect.ImmutableSortedMap;  
import com.google.common.collect.Ordering;  
  
import java.util.Comparator;  
  
public class GuavaImmutableSortedCollectionsExample {  
  
    public static void main(String[] args) {  
        // 创建一个根据自然顺序排序的ImmutableSortedSet  
        ImmutableSortedSet<Integer> sortedSet = ImmutableSortedSet.copyOf(Ordering.natural(), 10, 5, 15, 20);  
        System.out.println("ImmutableSortedSet (natural order): " + sortedSet);  
  
        // 创建一个根据自定义比较器排序的ImmutableSortedSet  
        Comparator<String> stringComparator = Comparator.comparing(String::length);  
        ImmutableSortedSet<String> sortedSetCustomOrder = ImmutableSortedSet.copyOf(stringComparator, "apple", "banana", "kiwi", "pear");  
        System.out.println("ImmutableSortedSet (custom order): " + sortedSetCustomOrder);  
  
        // 创建一个根据自然顺序排序键的ImmutableSortedMap  
        ImmutableSortedMap<Integer, String> sortedMap = ImmutableSortedMap.of(5, "five", 1, "one", 3, "three");  
        // 注意：上面的of方法会根据键的自然顺序对条目进行排序，但这里我们传入的已经是排序好的键值对  
        System.out.println("ImmutableSortedMap (natural order): " + sortedMap);  
  
        // 创建一个根据自定义比较器排序键的ImmutableSortedMap  
        ImmutableSortedMap<String, Integer> sortedMapCustomOrder =  
                ImmutableSortedMap.orderedBy(stringComparator)  
                        .put("apple", 1)  
                        .put("banana", 2)  
                        .put("kiwi", 3)  
                        .put("pear", 4)  
                        .build();  
        System.out.println("ImmutableSortedMap (custom order): " + sortedMapCustomOrder);  
    }  
}

import com.google.common.collect.ImmutableMultiset;  
import com.google.common.collect.ImmutableMultimap;  
import com.google.common.collect.Multiset;  
import com.google.common.collect.Multimap;  
  
import java.util.Arrays;  
  
public class GuavaImmutableMultiCollectionsExample {  
  
    public static void main(String[] args) {  
        // 创建一个ImmutableMultiset  
        ImmutableMultiset<String> multiset = ImmutableMultiset.<String>builder()  
                .addAll(Arrays.asList("apple", "apple", "banana", "orange"))  
                .addCopies("banana", 2) // 添加额外的"banana"元素  
                .build();  
        System.out.println("ImmutableMultiset: " + multiset);  
  
        // 展示元素及其出现次数  
        for (Multiset.Entry<String> entry : multiset.entrySet()) {  
            System.out.println(entry.getElement() + ": " + entry.getCount());  
        }  
  
        // 创建一个ImmutableMultimap  
        ImmutableMultimap<String, Integer> multimap = ImmutableMultimap.<String, Integer>builder()  
                .putAll("fruits", Arrays.asList(1, 2, 3))  
                .putAll("veggies", Arrays.asList(4, 5))  
                .put("fruits", 6) // 添加额外的键值对到"fruits"  
                .build();  
        System.out.println("ImmutableMultimap: " + multimap);  
  
        // 展示键及其对应的值  
        for (String key : multimap.keySet()) {  
            System.out.println(key + " => " + multimap.get(key));  
        }  
    }  
}

ImmutableMultiset: [apple x 2, banana x 3, orange]  
apple: 2  
banana: 3  
orange: 1  
ImmutableMultimap: {fruits=[1, 2, 3, 6], veggies=[4, 5]}  
fruits => [1, 2, 3, 6]  
veggies => [4, 5]

import com.google.common.collect.ImmutableBiMap;  
import com.google.common.collect.ImmutableBiMap.Builder;  
  
public class ImmutableBiMapExample {  
  
    public static void main(String[] args) {  
        // 使用 Builder 创建 ImmutableBiMap  
        Builder<String, Integer> builder = ImmutableBiMap.builder();  
        builder.put("one", 1);  
        builder.put("two", 2);  
        builder.put("three", 3);  
        ImmutableBiMap<String, Integer> biMap = builder.build();  
  
        // 输出整个双向映射  
        System.out.println("ImmutableBiMap: " + biMap);  
  
        // 通过键获取值  
        Integer valueOne = biMap.get("one");  
        System.out.println("Value for 'one': " + valueOne);  
  
        // 通过值获取键（这是 BiMap 的特点）  
        String keyForValueTwo = biMap.inverse().get(2);  
        System.out.println("Key for value 2: " + keyForValueTwo);  
  
        // 尝试修改（注意：这会失败，因为 ImmutableBiMap 是不可变的）  
        // biMap.put("four", 4); // 这行代码会导致编译错误  
  
        // 尝试使用已存在的值作为键进行插入（也会失败，因为值也必须唯一）  
        // builder.put("four", 2); // 这同样会导致错误，即使你试图在 build() 之后再做  
    }  
}