Java—— 可变参数、集合工具类、集合嵌套、不可变集合
可变参数
说明
1. 可变参数本质上就是一个数组
2. 作用：在形参中接收多个数据
3. 格式：数据类型...参数名称
举例:int...a
4. 注意事项：
形参列表中可变参数只能有一个
可变参数必须放在形参列表的最后面
案例演示
定义一个方法，计算n个数相加后的结果
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);//55int 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) | 交换集合中指定 位置的元素 |
代码演示
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);//3String max = Collections.max(list);System.out.println(max);//hString min = Collections.min(list);System.out.println(min);//aaaCollections.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，但是市会有多个。
添加完毕后，遍历结果格式如下:
江苏省=南京市，扬州市，苏州市，无锡市，常州市
湖北省=武汉市，孝感市，十堰市，宜昌市，鄂州市
河北省=石家庄市，唐山市，邢台市，保定市，张家口市
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的泛型是StringHashMap<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) | |
| static <K, V> Map<K, V> copyOf(Map<> map) |
不可变List
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
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
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);}
}