若希望某个数据是不可修改的，就可以考虑使用不可变集合，以提高安全性；（JKD9之后才有）
List不可变集合：
public static void main(String[] args) {/*创建不可变的List集合"张三", "李四", "王五", "赵六"*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作List<String> list = List.of("张三", "李四", "王五", "赵六");System.out.println(list.get(0));System.out.println(list.get(1));System.out.println(list.get(2));System.out.println(list.get(3));System.out.println("---------------------------");
//遍历for (String s : list) {System.out.println(s);}System.out.println("---------------------------");Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("---------------------------");for (int i = 0; i < list.size(); i++) {String s = list.get(i);System.out.println(s);}System.out.println("---------------------------");//list.remove("李四");//list.add("aaa");list.set(0,"aaa");}Set不可变集合：
public static void main(String[] args) {/*创建不可变的Set集合"张三", "李四", "王五", "赵六"细节：当我们要获取一个不可变的Set集合时，里面的参数一定要保证唯一性*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");for (String s : set) {System.out.println(s);}System.out.println("-----------------------");Iterator<String> it = set.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("-----------------------");//set.remove("王五");}Map不可变集合：
public static void main(String[] args) {/*创建Map的不可变集合细节1：键是不能重复的细节2：Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对细节3：如果我们要传递多个键值对对象，数量大于10个，在Map接口中还有一个方法*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作Map<String, String> map = Map.of("张三", "南京", "张三", "北京", "王五", "上海","赵六", "广州", "孙七", "深圳", "周八", "杭州","吴九", "宁波", "郑十", "苏州", "刘一", "无锡","陈二", "嘉兴");Set<String> keys = map.keySet();for (String key : keys) {String value = map.get(key);System.out.println(key + "=" + value);}System.out.println("--------------------------");Set<Map.Entry<String, String>> entries = map.entrySet();for (Map.Entry<String, String> entry : entries) {String key = entry.getKey();String value = entry.getValue();System.out.println(key + "=" + value);}System.out.println("--------------------------");}Map大于10个时候：
public static void main(String[] args) {/*创建Map的不可变集合,键值对的数量超过10个*///1.创建一个普通的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("aaa", "111");//2.利用上面的数据来获取一个不可变的集合
/*//获取到所有的键值对对象（Entry对象）Set<Map.Entry<String, String>> entries = hm.entrySet();//把entries变成一个数组，这里的0没有意义，假如不知道entries的长度，就可以写0，toArray方法会自动帮我们判断Map.Entry[] arr1 = new Map.Entry[0];//toArray方法在底层会比较集合的长度跟数组的长度两者的大小//如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组//如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用Map.Entry[] arr2 = entries.toArray(arr1);//不可变的map集合//可变参数可以直接传递对应类型数组Map map = Map.ofEntries(arr2);map.put("bbb","222");*///Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));//JDK10之后直接用copOf方法即可：不可变集合拷贝后还是不可变；但是可变集合拷贝后就转化为不可变了Map<String, String> map = Map.copyOf(hm);map.put("bbb","222");}Stream流
熟悉Envi的应该知道工作流这个东西，Stream流就类似于工作流，但是省去了中间产物；从输入，到操作最后再到输出，很像工厂流水线，在这个过程中你可以任意对数据操作，直到输出，通常和Lambda表达式结合，是链式编程的体现；
要想使用Stream流，首先得获取输入：
public static void main(String[] args) {//Collection体系的集合可以使用默认方法stream()生成流List<String> list = new ArrayList<String>();Stream<String> listStream = list.stream();Set<String> set = new HashSet<String>();Stream<String> setStream = set.stream();//Map体系的集合间接的生成流Map<String,Integer> map = new HashMap<String, Integer>();Stream<String> keyStream = map.keySet().stream();Stream<Integer> valueStream = map.values().stream();Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();//数组可以通过Arrays中的静态方法stream生成流String[] strArray = {"hello","world","java"};Stream<String> strArrayStream = Arrays.stream(strArray);//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流//注意，基本数据类型数组不建议使用这个方法，因为它会把一个数组当做一个对象，而不是可变类型参数Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");Stream<Integer> intStream = Stream.of(10, 20, 30);}中间处理步骤方法：
| 方法名 | 说明 |
|---|---|
| Stream filter(Predicate predicate) | 用于对流中的数据进行过滤（对原数据无影响） |
| Stream limit(long maxSize) | 返回此流中的元素组成的流，截取前指定参数个数的数据 |
| Stream skip(long n) | 跳过指定参数个数的数据，返回由该流的剩余元素组成的流 |
| static Stream concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
| Stream distinct() | 数据去重，自定义类需要重写hashCode方法 |
演示，要求：
- 创建一个集合，存储多个字符串元素
- 把集合中所有以"张"开头的元素存储到一个新的集合
- 把"张"开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合
public static void main(String[] args) {//集合的批量添加ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));//Stream流list1.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(s-> System.out.println(s));}map方法：
ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"aaa-111","bbb-12");//map方法用于返回用所给表达式处理之后的结果list.stream().map(s ->{String[] strings = s.split("-");return strings[1];}).forEach(s -> System.out.println(s));//111 12终结方法：
即执行完这些方法后流关闭，不能再执行别的操作了
| 方法名 | 说明 |
|---|---|
| void forEach(Consumer action) | 对此流的每个元素执行操作 |
| long count() | 返回此流中的元素数 |
| void toArray() | 收集流的数据，放到数组里 |
forEach和count演示：
public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("张三丰");list.add("张无忌");list.add("张翠山");list.add("王二麻子");list.add("张良");list.add("谢广坤");//method1(list);// long count()：返回此流中的元素数long count = list.stream().count();System.out.println(count);}private static void method1(ArrayList<String> list) {// void forEach(Consumer action)：对此流的每个元素执行操作// Consumer接口中的方法void accept(T t)：对给定的参数执行此操作//在forEach方法的底层,会循环获取到流中的每一个数据.//并循环调用accept方法,并把每一个数据传递给accept方法//s就依次表示了流中的每一个数据.//所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.list.stream().forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});System.out.println("====================");//lambda表达式的简化格式//是因为Consumer接口中,只有一个accept方法list.stream().forEach((String s)->{System.out.println(s);});System.out.println("====================");//lambda表达式还是可以进一步简化的.list.stream().forEach(s->System.out.println(s));}toArray其实是收集方法，类似还有：
| 方法名 | 说明 |
|---|---|
| public static Collector toList() | 把元素收集到List集合中 |
| public static Collector toSet() | 把元素收集到Set集合中 |
| public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
演示：
public static void main(String[] args) {ArrayList<Integer> list1 = new ArrayList<>();for (int i = 1; i <= 10; i++) {list1.add(i);}list1.add(10);list1.add(10);list1.add(10);list1.add(10);list1.add(10);//filter负责过滤数据的.//collect负责收集数据.//获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.//Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.List<Integer> list = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());System.out.println(list);Set<Integer> set = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());System.out.println(set);
}
}
/**
Stream流的收集方法 toMap方法演示
创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
*/
public class MyStream8 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("zhangsan,23");list.add("lisi,24");list.add("wangwu,25");Map<String, Integer> map = list.stream().filter(s -> {String[] split = s.split(",");int age = Integer.parseInt(split[1]);return age >= 24;}// collect方法只能获取到流中剩余的每一个数据.//在底层不能创建容器,也不能把数据添加到容器当中//Collectors.toMap 创建一个map集合并将数据添加到集合当中// s 依次表示流中的每一个数据//第一个lambda表达式就是如何获取到Map中的键//第二个lambda表达式就是如何获取Map中的值).collect(Collectors.toMap(s -> s.split(",")[0],s -> Integer.parseInt(s.split(",")[1]) ));System.out.println(map);}Stream流练习：
1.定义一个集合，添加1-10整数，要求只保留偶数，并将结果储存；
ArrayList<Integer> arrayList = new ArrayList<>();for (int i = 1; i <= 10; i++) {arrayList.add(i);}List<Integer> array = arrayList.stream().filter(integer -> integer % 2 == 0).collect(Collectors.toList());System.out.println(array.getClass());2.创建一个集合，要求前面是名字，后面是年龄，中间用逗号分开；对这些数据要求保留年龄大于等于24岁的人，并将结果添加到map当中，姓名为键，年龄为值；
ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"zhangsan,12","lisi,29","wangwu,26");Map<String, String> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24).collect(Collectors.toMap(s -> s.split(",")[0],s -> s.split(",")[1]));System.out.println(map);3.现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
- 男演员只要名字为3个字的前三人
- 女演员只要姓小的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
public class Actor {private String name;public Actor(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
} //添加演员 ArrayList<String> manList = new ArrayList<String>();manList.add("坤坤");manList.add("签签");manList.add("时间管理大师");manList.add("峰峰");manList.add("占春山");manList.add("翰翰");ArrayList<String> womanList = new ArrayList<String>();womanList.add("爽子");womanList.add("冰冰");womanList.add("sorry");womanList.add("高危职业");womanList.add("小a");womanList.add("小b"); Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);//女演员只要姓小的，并且不要第一个Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("小")).skip(1);//把过滤后的男演员姓名和女演员姓名合并到一起Stream<String> stream = Stream.concat(manStream, womanStream);// 将流中的数据封装成Actor对象之后打印stream.forEach(name -> {Actor actor = new Actor(name);System.out.println(actor);}); 
