Java—— 可变参数、集合工具类、集合嵌套、不可变集合

可变参数

说明

可变参数本质上就是一个数组

作用：在形参中接收多个数据

格式：数据类型...参数名称

举例:int...a

注意事项：

形参列表中可变参数只能有一个

可变参数必须放在形参列表的最后面

案例演示

定义一个方法，计算n个数相加后的结果

java 复制代码

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

        int sum1 = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(sum1);//55

        int sum2 = getSum(1, 2, 3, 4, 5);
        System.out.println(sum2);//15
    }

    //定义一个方法，计算n个数相加后的结果
    public static int getSum(int... nums) {
        int sum = 0;
        for (int n : nums) {
            sum = sum + n;
        }
        return sum;
    }
}

集合工具类Collections

Collections常用的API

|-----------------------------------------------------------------------|-------------------|
| 方法名称 | 说明 |
| public static <T> boolean addA11 (Collection<T> c, T... elements) | 批量添加元素 |
| public static void shuffle(List<?> list) | 打乱List集合元素的顺序 |
| public static <T> void sort(List<T> list) | 排序 |
| public static <T> void sort(List<T> list, Comparator<T> c) | 根据指定的规则进行排序 |
| public static <T> int binarySearch (List<T> list, T key) | 以二分查找法查找元素 |
| public static<T> void copy(List<T> dest,List<T> src) | 拷贝集合中的元素 |
| public static <T> int fill (List<T> list, T obj) | 使用指定的元素填充集合 |
| public static <T> void max/min(Collection<T> coll) | 根据默认的自然排序获取最大/小值 |
| public static <T> void swap(List<?> list,int i, int j) | 交换集合中指定位置的元素 |

代码演示

java 复制代码

import java.util.ArrayList;
import java.util.Collections;

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

        ArrayList<String> list = new ArrayList<>();

        Collections.addAll(list, "aaa", "bb", "ccc", "d", "ee", "f", "ggggg", "h");
        System.out.println(list);
        //[aaa, bb, ccc, d, ee, f, ggggg, h]

        Collections.shuffle(list);
        System.out.println(list);
        //[ee, aaa, ccc, ggggg, d, bb, h, f]

        Collections.sort(list);
        System.out.println(list);
        //[aaa, bb, ccc, d, ee, f, ggggg, h]

        Collections.sort(list, (o1, o2) -> o1.length() - o2.length());
        System.out.println(list);
        //[d, f, h, bb, ee, aaa, ccc, ggggg]

        int index = Collections.binarySearch(list, "bb");
        System.out.println(index);
        //3

        String max = Collections.max(list);
        System.out.println(max);
        //h

        String min = Collections.min(list);
        System.out.println(min);
        //aaa

        Collections.swap(list, 0, 1);
        System.out.println(list);
        //[f, d, h, bb, ee, aaa, ccc, ggggg]

        Collections.fill(list, "o");
        System.out.println(list);
        //[o, o, o, o, o, o, o, o]

        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2, "1", "2", "3", "4", "5", "6", "7", "8");
        Collections.copy(list2, list);
        System.out.println(list2);
        //[o, o, o, o, o, o, o, o]

    }
}

集合嵌套

定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。

添加完毕后，遍历结果格式如下:

江苏省=南京市，扬州市，苏州市，无锡市，常州市

湖北省=武汉市，孝感市，十堰市，宜昌市，鄂州市

河北省=石家庄市，唐山市，邢台市，保定市，张家口市

java 复制代码

import java.util.*;

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

        //定义集合存入城市
        ArrayList<String> city1 = new ArrayList<>();
        Collections.addAll(city1, "南京市", "扬州市", "苏州市", "无锡市", "常州市");

        ArrayList<String> city2 = new ArrayList<>();
        Collections.addAll(city2, "武汉市", "孝感市", "十堰市", "宜昌市", "鄂州市");

        ArrayList<String> city3 = new ArrayList<>();
        Collections.addAll(city3, "石家庄市", "唐山市", "邢台市", "保定市", "张家口市");

        //定义双列集合，键为省，值为城市集合
        //集合的嵌套也要有泛型的嵌套
        //第一个范式为String类型，第二个泛型为ArrayList类型，而ArrayList的泛型是String
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        hm.put("江苏省", city1);
        hm.put("湖北省", city2);
        hm.put("河北省", city3);

        //遍历打印输出
        Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
            //定义StringJoiner将值集合的元素拼接为字符串
            StringJoiner sj = new StringJoiner("，", "", "");
            for (String city : value) {
                sj.add(city);
            }
            System.out.println(key + " = " + sj);
        }
        //江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
        //湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
        //河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市

    }
}

不可变集合

说明

不可变集合：不可以被修改的集合

不可以修改长度

不可以修改内容

应用场景

如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。

或者当集合对象被不可信的库调用时，不可变形式是安全的。
简单理解：不想让别人修改集合中的内容

创建不可变集合的书写格式

在List、Set、Map接口中，都存在静态的of方法，可以获取一个不可变的集合。

|-------------------------------------------------------------|---------------------|
| 方法名称 | 说明 |
| static <E> List<E> of (E...elements) | 创建一个具有指定元素List集合对象 |
| static <E> Set<E> of (E...elements) | 创建一个具有指定元素Set集合对象 |
| static <K,V> Map<K,V> of (......) | 创建一个具有指定元素Map集合对象 |
| static <K, V> Map<K, V> ofEntries(Entry<>... entries) | 创建一个具有指定元素Map集合对象 |
| static <K, V> Map<K, V> copyOf(Map<> map) | 创建一个具有指定元素Map集合对象 |

不可变List

java 复制代码

import java.util.List;

public class Test1 {
    public static void main(String[] args) {
        List<String> list = List.of("aa", "bb", "cc", "dd");

        //可读
        for (String s:list){
            System.out.println(s);
        }
        //aa
        //bb
        //cc
        //dd

        //不可修改
        //list.add("ee");
        //报错UnsupportedOperationException
    }
}

不可变Set

java 复制代码

import java.util.Set;

public class Test2 {
    public static void main(String[] args) {
        Set<String> set = Set.of("aa", "bb", "cc", "dd");

        //可读
        for (String s : set) {
            System.out.println(s);
        }
        //dd
        //aa
        //bb
        //cc

        //不可修改
        //set.add("ee");
        //报错UnsupportedOperationException

        //Set类型的不可变集合不能有重复的元素
        //Set<String> set = Set.of("aa", "bb", "cc", "dd","aa");
        //报错IllegalArgumentException
    }
}

不可变Map

java 复制代码

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

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

        //默认两两一组，前面的是键，后面的是值
        //最多存入10对也就是20个元素，因为底层没有可变参数
        Map<String, String> map = Map.of("豹子头", "林冲", "黑旋风", "李逵");

        //可读
        map.forEach((key, value) -> System.out.println(key + " = " + value));
        //黑旋风 = 李逵
        //豹子头 = 林冲

        //不可修改
        //map.put("花和尚","鲁智深");
        //报错UnsupportedOperationException


        //存入的元素需要大于10对时需要使用Map.ofEntries()方法
        //先创建一个可变Map集合
        HashMap<String,String> hm = new HashMap<>();
        hm.put("玉麒麟", "卢俊义");
        hm.put("智多星", "吴用");
        hm.put("入云龙", "公孙胜");
        hm.put("大刀", "关胜");
        hm.put("豹子头", "林冲");
        hm.put("霹雳火", "秦明");
        hm.put("双鞭", "呼延灼");
        hm.put("小李广", "花荣");
        hm.put("小旋风", "柴进");
        hm.put("黑旋风", "李逵");
        hm.put("花和尚", "鲁智深");
        //将其转化为Entry对象
        Set<Map.Entry<String,String>> entries = hm.entrySet();
        //将Entry对象转化为Entry类型的数组（空参默认Object类型）
        Map.Entry[] arr = entries.toArray(new Map.Entry[0]);
        //调用方法传递数组，将数组中的元素存入不可变集合
        Map m1 = Map.ofEntries(arr);

        //Jdk10后可以使用Map.copyOf方法
        //方法底层就是上述步骤
        Map<String, String> m2 = Map.copyOf(hm);
        
    }
}