• Java#31（不可变集合，Stream流和方法引用）

    目录

    一.创建不可变集合: 不可以被修改的集合

    1.List接口创建不可变集合

    2.Set接口创建不可变集合

    3.Map接口创建不可变集合

    二.Stream流

    1.如何获取Stream流?

    2.Stream流的中间方法

    3.Stream流终结方法

    三.方法引用

    1.引用静态方法

    2.引用成员方法

    3.引用结构方法

    4.使用类名引用成员方法

    5.引用数组的构造方法

    一.创建不可变集合: 不可以被修改的集合

    作用: 不让别人修改集合中的内容

    1.List接口创建不可变集合

    格式: List.of(数据); 

    可以进行查询和遍历但是不能修改内容

    代码示范:

    1. package Demo;
    2.  
    3. import java.util.List;
    4. import java.util.Locale;
    5. import java.util.function.Consumer;
    6.  
    7. public class Test1 {
    8.     public static void main(String[] args) {
    9.         List list = List.of("张三", "李四", "王五");
    10.         System.out.println(list.get(0));
    11.         System.out.println(list.get(1));
    12.         System.out.println(list.get(2));
    13.         System.out.println("-----------------------");
    14.         //遍历
    15.         for (String s : list) {
    16.             System.out.println(s);
    17.         }
    18.         System.out.println("------------------------");
    19.         list.forEach(s-> System.out.println(s));
    20.  
    21.         list.add("maliu");
    22.     }
    23. }

     (未对集合内容进行更改)

     (想修改集合内容就会报错)

    2.Set接口创建不可变集合

    格式: Set.of(数据);

    可以进行查询和遍历但是不能修改内容(元素不能出现重复)

    3.Map接口创建不可变集合

    可以进行查询和遍历但是不能修改内容(元素不能出现重复)

    格式: Map.of(数据); (键值对数量最多是10个)

             Map.copyOf(Map集合); (没有键值对数量限制, 在JDK10开始出现)

    (Map.of()添加10个键值对,没有报错) 

     (Map.of()添加11个键值对,直接报错) 

    Map.copyOf(Map集合); 的代码示范:

    1. import java.util.HashMap;
    2. import java.util.Map;
    3. import java.util.function.BiConsumer;
    4.  
    5. public class Test3 {
    6.     public static void main(String[] args) {
    7.         Map map1 = new HashMap();
    8.         map1.put("1","a");
    9.         map1.put("2","a");
    10.         map1.put("3","a");
    11.         map1.put("4","a");
    12.         map1.put("5","a");
    13.         map1.put("6","a");
    14.         map1.put("7","a");
    15.         map1.put("8","a");
    16.         map1.put("9","a");
    17.         map1.put("10","a");
    18.         map1.put("11","a");
    19.         map1.put("12","a");
    20.  
    21.         Map map2 = Map.copyOf(map1);
    22.         map2.forEach((s, s2)-> System.out.println(s+"="+s2));
    23.         //map2.put("13","a");
    24.  
    25.     }
    26. }

    结果展示: 

    二.Stream流

    作用: 结合了lambda表达式,简化集合,数组的操作

    步骤:

    (1)先得到一条Stream流,并把数据放上去

    (2)利用Stream流中的API进行各种操作(过滤,转换(中间方法: 方法调用后还可以调用其他方法), 统计, 打印(终结方法: 最后一步, 调用完毕之后, 不能调用其他方法))

    1.如何获取Stream流?

    获取方式                                        方法名                                                       说明
    单列集合                       default Stream stream0                      Collection中的默认方法
    双列集合                                            无                                          无法直接使用stream流
    数组              public static Stream stream(T[ ] array)  Arrays工具类中的静态方法
    一堆零散数据      public static Stream of(T... values)       stream接口中的静态方法

    单列集合获取Stream流代码示范:

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3.  
    4. public class StreamDemo1 {
    5.     public static void main(String[] args) {
    6.         ArrayList arr = new ArrayList<>();
    7.         Collections.addAll(arr,"b","c","a");
    8.         arr.stream().forEach(s -> System.out.println(s));//遍历集合
    9.     }
    10. }

    结果展示:

     双列集合获取Stream流代码示范:

    1. import java.util.HashMap;
    2.  
    3. public class StreamDemo2 {
    4.     public static void main(String[] args) {
    5.         HashMap map = new HashMap<>();
    6.         map.put("a",1);
    7.         map.put("b",2);
    8.         map.put("c",3);
    9.         //第一种方式
    10.         map.keySet().forEach(s -> System.out.println(s));
    11.         System.out.println("---------------------------");
    12.         //第二种方式
    13.         map.entrySet().forEach(a-> System.out.println(a));
    14.     }
    15. }

    结果展示:

    数组获取Stream流代码示范:

    1. import java.util.Arrays;
    2.  
    3. public class StreamDemo3 {
    4.     public static void main(String[] args) {
    5.         int[] arr = {1,2,3,4,5,6,7};
    6.         Arrays.stream(arr).forEach(i-> System.out.println(i));
    7.     }
    8. }

    结果展示:

     一堆零散数据获取Stream流代码示范:

    1. import java.util.stream.Stream;
    2.  
    3. public class StreamDemo4 {
    4.     public static void main(String[] args) {
    5.         Stream.of(1,2,3,4,5).forEach(i-> System.out.print(i+" "));
    6.         System.out.println();
    7.         System.out.println("-----------------");
    8.         Stream.of("a","b","c").forEach(s-> System.out.print(s+" "));
    9.  
    10.         String[] s = {"a","b","c","d"};
    11.         Stream.of(s).forEach(a-> System.out.print(a+" "));
    12.         System.out.println();
    13.         int[] arr1 = {1,2,3,4,5,6};
    14.         Stream.of(arr1).forEach(i-> System.out.print(i+" "));
    15.     }
    16. }

    结果展示:

    注意: Stream.of()   ()中添加元素是类型要相同, 添加数组时只能添加引用数据类型,如果添加基本数据类型打印的是地址

    2.Stream流的中间方法

                         名称                                                                       说明
    Stream filter(Predicate predicate)                过滤
    Stream limit(long maxSize)                                       获取前几个元素
    Stream skip(long n)                                                   跳过前几个元素
    Stream distinct()                                    元素去重，依赖(hashCode和equals方法)
    static Stream concat(Stream a, Stream b)    合并a和b两个流为一个流

    Stream map(Function mapper)                    转换流中的数据类型
    注意1:中间方法，返回新的Stream流，原来的Stream流只能使用一次，所以没有必要创建一个新的变量来存储, 建议使用链式编程

    注意2:修改Stream流中的数据，不会影响原来集合或者数组中的数据

    代码示范:

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.function.Function;
    4. import java.util.function.Predicate;
    5. import java.util.stream.Stream;
    6.  
    7. public class StreamDemo5 {
    8.     public static void main(String[] args) {
    9.         ArrayList list = new ArrayList<>();
    10.         Collections.addAll(list,"小明","小红","小李飞刀","小张","刘备","马超","黄忠");
    11.         //1.filter
    12.         list.stream().
    13.                 /*filter(new Predicate() {
    14.             @Override
    15.             public boolean test(String s) {
    16.                 return s.startsWith("小");
    17.             }
    18.         })*/
    19.                   filter(s-> s.startsWith("小"))//true表示留下, false表示舍弃
    20.                 .forEach(s-> System.out.println(s));
    21.         System.out.println("======================");
    22.         //2.limit
    23.         list.stream()
    24.                 .limit(3)
    25.                 .forEach(s-> System.out.println(s));
    26.         System.out.println("======================");
    27.         //3.skip
    28.         list.stream()
    29.                 .skip(2)
    30.                 .forEach(s -> System.out.println(s));
    31.         System.out.println("======================");
    32.         //4.distinct
    33.         ArrayList list2 = new ArrayList<>();
    34.         Collections.addAll(list2,"李华","王五");
    35.         Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s));
    36.         System.out.println("======================");
    37.         //5.map
    38.         ArrayList list3 = new ArrayList<>();
    39.         Collections.addAll(list3,"小华-12","小五-13","马六-14");
    40.                                 //第一个是原本的数据类型,
    41.                                 //第二个要转化成的数据类型
    42.         list3.stream()
    43. /*                .map(new Function() {
    44.             @Override
    45.             public Integer apply(String s) {
    46.                 String[] str = s.split("-");
    47.                 String ageString = str[1];
    48.                 int age = Integer.parseInt(ageString);
    49.                 return age;
    50.             }
    51.         })*/
    52.                 .map(s->Integer.parseInt(s.split("-")[1]))
    53.                 .forEach(s-> System.out.println(s));
    54.  
    55.     }
    56. }

    3.Stream流终结方法

              名称                                                    说明
    void forEach(Consumer action)                遍历
    long count()                                                 统计
    toArray()                                       收集流中的数据，放到数组中
    collect(Collector collector)         收集流中的数据，放到集合中

    前三个方法的代码示范: 

    1. import java.util.ArrayList;
    2. import java.util.Arrays;
    3. import java.util.Collections;
    4. import java.util.function.IntFunction;
    5.  
    6. public class Test1 {
    7.     public static void main(String[] args) {
    8.         ArrayList list = new ArrayList<>();
    9.         Collections.addAll(list,"asd","zxc","qwe");
    10.         //1.forEach(Consumer action)
    11.         list.stream().forEach(s -> System.out.println(s));
    12.         //2.count()
    13.         long count1 = list.stream().count();
    14.         System.out.println(count1);
    15.         //3.toArray()
    16.                                         //转化成什么类型的数组
    17.         String[] str = list.stream().toArray(new IntFunction() {
    18.             @Override
    19.             public String[] apply(int value) {
    20.                 return new String[value];
    21.             }
    22.         });
    23.         System.out.println(Arrays.toString(str));
    24.         //简化写法
    25.         String[] str1 = list.stream().toArray(value -> new String[value]);
    26.         System.out.println(Arrays.toString(str));
    27.     }
    28. }

    结果展示: 

    三.方法引用

    1.引用方法必须是函数式接口

    2.被引用的方法必须已经存在

    3.被引用方法的形参和返回值需要和抽象方法保持一致

    4.被引用的方法的功能要满足当前需求

    5. :: 是方法引用符

    代码示范:

    1. import java.util.ArrayList;
    2. import java.util.Arrays;
    3. import java.util.Comparator;
    4.  
    5. public class Test1 {
    6.     public static void main(String[] args) {
    7.         Integer[] arr = {1,4,7,2,6,3,5};
    8.         //将数组从大到小排序
    9.         //1.匿名内部类
    10.        /* Arrays.sort(arr, new Comparator() {
    11.             @Override
    12.             public int compare(Integer o1, Integer o2) {
    13.                 return o2-o1;
    14.             }
    15.         });*/
    16.         //2.lambda表达式
    17.         /*Arrays.sort(arr,(o1, o2)-> o2-o1);*/
    18.         //3.方法引用
    19.         //::方法引用符
    20.         Arrays.sort(arr,Test1::subtraction);
    21.  
    22.         System.out.println(Arrays.toString(arr));
    23.     }
    24.     public static int subtraction(int num1,int num2){
    25.         return num2-num1;
    26.     }
    27. }

    结果展示:

     1.引用静态方法

    格式: 类名::静态方法

    例如: Integer::parseInt

    代码示范: 

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.function.Function;
    4.  
    5. public class Test2 {
    6.     public static void main(String[] args) {
    7.         ArrayList list = new ArrayList<>();
    8.         Collections.addAll(list,"1","2","3","4","5");
    9.         /*list.stream().map(new Function() {
    10.             @Override
    11.             public Integer apply(String s) {
    12.                 Integer i = Integer.parseInt(s);
    13.                 return i;
    14.             }
    15.         }).forEach(s-> System.out.println(s));*/
    16.  
    17.         list.stream()
    18.                 .map(Integer::parseInt)
    19.                 .forEach(s-> System.out.println(s));
    20.     }
    21. }

    结果展示: 

    2.引用成员方法

    格式:  对象::成员方法

    (1)其他类: 其他类对象::方法名

    (2)本类: this::方法名  (引用处不能是静态方法)

    (3)父类: super::方法名 (引用处不能是静态方法)

    代码示范: 第一个是类的代码,第二个是测试代码

    1. public class Demo1 {
    2.     public static boolean stringJudge(String s){
    3.         return s.startsWith("小")&&s.length()==2;
    4.     }
    5.  
    6. }
    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.function.Predicate;
    4.  
    5. public class Test3 {
    6.     public static void main(String[] args) {
    7.         ArrayList list = new ArrayList<>();
    8.         Collections.addAll(list,"小明","小红","小张","小李飞刀","张三","李四");
    9.         //普通
    10.         list.stream().filter(new Predicate() {
    11.             @Override
    12.             public boolean test(String s) {
    13.                 return s.startsWith("小")&&s.length()==2;
    14.             }
    15.         }).forEach(s-> System.out.println(s));
    16.         System.out.println("=========================");
    17.         //简化
    18.         list.stream()
    19.                 .filter(s->s.startsWith("小")&&s.length()==2)
    20.                 .forEach(s-> System.out.println(s));
    21.         System.out.println("=========================");
    22.         //方法引用
    23.         list.stream()
    24.                 .filter(Demo1::stringJudge)
    25.                 .forEach(s-> System.out.println(s));
    26.     }
    27. }

    结果展示: 

    3.引用结构方法

    格式: 类名::new

    例如: Student::new

    代码示范: 第一个是Student类的代码,第二个是测试类的代码

    1. public class Student {
    2.     private String name;
    3.     private int age;
    4.  
    5.     public Student() {
    6.     }
    7.     //str是stream流中的数据
    8.     public Student(String str) {
    9.         String[] arr = str.split(",");
    10.         this.name = arr[0];
    11.         this.age = Integer.parseInt(arr[1]);
    12.     }
    13.  
    14.     public Student(String name, int aeg) {
    15.         this.name = name;
    16.         this.age = aeg;
    17.     }
    18.  
    19.     /**
    20.      * 获取
    21.      * @return name
    22.      */
    23.     public String getName() {
    24.         return name;
    25.     }
    26.  
    27.     /**
    28.      * 设置
    29.      * @param name
    30.      */
    31.     public void setName(String name) {
    32.         this.name = name;
    33.     }
    34.  
    35.     /**
    36.      * 获取
    37.      * @return aeg
    38.      */
    39.     public int getAge() {
    40.         return age;
    41.     }
    42.  
    43.     /**
    44.      * 设置
    45.      * @param age
    46.      */
    47.     public void setAge(int age) {
    48.         this.age = age;
    49.     }
    50.  
    51.     public String toString() {
    52.         return "Student{name = " + name + ", aeg = " + age + "}";
    53.     }
    54. }
    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.List;
    4. import java.util.function.Function;
    5. import java.util.stream.Collectors;
    6.  
    7. public class Test4 {
    8.     public static void main(String[] args) {
    9.         ArrayList list = new ArrayList<>();
    10.         Collections.addAll(list,"小明,18","小红,19","小张,20","小李飞刀,21","张三,22","李四,23");
    11.         //封装成Student对象并收集到List集合中
    12.         //普通方法
    13.         List newList = list.stream().map(new Function() {
    14.             @Override
    15.             public Student apply(String s) {
    16.                 String[] arr = s.split(",");
    17.                 String name = arr[0];
    18.                 int age = Integer.parseInt(arr[1]);
    19.                 return new Student(name, age);
    20.             }
    21.         }).collect(Collectors.toList());
    22.         System.out.println(newList);
    23.         System.out.println("==========================");
    24.         //引用构造方法
    25.         List newList2 = list.stream()
    26.                 .map(Student::new)
    27.                 .collect(Collectors.toList());
    28.         System.out.println(newList2);
    29.     }
    30. }

    结果展示: 

     4.使用类名引用成员方法

    格式: 类名::成员方法

    例如: String::substring

    注意: 被引用的方法形参是跟抽象方法第二个参数后面的保持一致

    代码示范: 

    1. import java.util.ArrayList;
    2. import java.util.Collections;
    3. import java.util.function.Function;
    4.  
    5. public class Test5 {
    6.     public static void main(String[] args) {
    7.         ArrayList list = new ArrayList<>();
    8.         Collections.addAll(list,"aaa","bbb","ccc");
    9.         //把数据变成大写然后遍历
    10.         //普通
    11.         list.stream().map(new Function() {
    12.             @Override
    13.             public String apply(String s) {
    14.                 return s.toUpperCase();
    15.             }
    16.         }).forEach(s-> System.out.println(s));
    17.         System.out.println("==========================");
    18.         //引用方法
    19.         list.stream()
    20.                 .map(String::toUpperCase)
    21.                 .forEach(s-> System.out.println(s));
    22.         
    23.     }
    24. }

    结果展示: 

    5.引用数组的构造方法

    格式: 数据类型[ ]::new

    例如: Integer::new

    注意: 数组的类型,需要跟流中数组的类型保持一致

    代码示范: 

    1. import java.util.ArrayList;
    2. import java.util.Arrays;
    3. import java.util.Collections;
    4. import java.util.function.IntFunction;
    5.  
    6. public class Test6 {
    7.     public static void main(String[] args) {
    8.         ArrayList list = new ArrayList<>();
    9.         Collections.addAll(list,1,2,3,4,5,6);
    10.         //普通写法
    11.         Integer[] arr1 = list.stream().toArray(new IntFunction() {
    12.             @Override
    13.             public Integer[] apply(int value) {
    14.                 return new Integer[value];
    15.             }
    16.         });
    17.         //引用方法
    18.         Integer[] arr2 = list.stream().toArray(Integer[]::new);
    19.         System.out.println(Arrays.toString(arr1));
    20.         System.out.println("===================");
    21.         System.out.println(Arrays.toString(arr2));
    22.     }
    23. }

    结果示范: 

  • 相关阅读:
    修改密码复杂度
    C/C++---------------LeetCode第1394.找出数组中的幸运数
    【MySql】深入了解 MySQL 中的 INNER JOIN 和 OUTER JOIN
    三位球形模型应用
    Blazor前后端框架Known-V1.2.16
    进公司第一天 git流程
    网络规划与设计＞应用架构建模
    【Webpack】webpack5 模块联邦（Module Federation）
    【Java 进阶篇】Java Cookie共享：让数据穿越不同应用的时空隧道
    单板基础元器件之——电感
  • 原文地址：https://blog.csdn.net/guaiwu_/article/details/128137933