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

于 2022-12-03 17:12:10 发布
阅读量655 收藏 1
点赞数 1
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guaiwu_/article/details/128137933
版权

目录

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

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

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

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

二.Stream流

1.如何获取Stream流?

2.Stream流的中间方法

3.Stream流终结方法

三.方法引用

1.引用静态方法

2.引用成员方法

3.引用结构方法

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

5.引用数组的构造方法

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

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

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

格式: List.of(数据); 

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

代码示范:

package Demo;

import java.util.List;
import java.util.Locale;
import java.util.function.Consumer;

public class Test1 {
    public static void main(String[] args) {
        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("-----------------------");
        //遍历
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("------------------------");
        list.forEach(s-> System.out.println(s));

        list.add("maliu");
    }
}

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

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

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

格式: Set.of(数据);

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

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

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

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

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

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

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

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

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Test3 {
    public static void main(String[] args) {
        Map<String,String> map1 = new HashMap();
        map1.put("1","a");
        map1.put("2","a");
        map1.put("3","a");
        map1.put("4","a");
        map1.put("5","a");
        map1.put("6","a");
        map1.put("7","a");
        map1.put("8","a");
        map1.put("9","a");
        map1.put("10","a");
        map1.put("11","a");
        map1.put("12","a");

        Map<String,String> map2 = Map.copyOf(map1);
        map2.forEach((s, s2)-> System.out.println(s+"="+s2));
        //map2.put("13","a");

    }
}

结果展示: 

二.Stream流

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

步骤:

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

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

1.如何获取Stream流?

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

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

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

public class StreamDemo1 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        Collections.addAll(arr,"b","c","a");
        arr.stream().forEach(s -> System.out.println(s));//遍历集合
    }
}

结果展示:

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

import java.util.HashMap;

public class StreamDemo2 {
    public static void main(String[] args) {
        HashMap<String,Integer> map = new HashMap<>();
        map.put("a",1);
        map.put("b",2);
        map.put("c",3);
        //第一种方式
        map.keySet().forEach(s -> System.out.println(s));
        System.out.println("---------------------------");
        //第二种方式
        map.entrySet().forEach(a-> System.out.println(a));
    }
}

结果展示:

数组获取Stream流代码示范:

import java.util.Arrays;

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

结果展示:

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

import java.util.stream.Stream;

public class StreamDemo4 {
    public static void main(String[] args) {
        Stream.of(1,2,3,4,5).forEach(i-> System.out.print(i+" "));
        System.out.println();
        System.out.println("-----------------");
        Stream.of("a","b","c").forEach(s-> System.out.print(s+" "));

        String[] s = {"a","b","c","d"};
        Stream.of(s).forEach(a-> System.out.print(a+" "));
        System.out.println();
        int[] arr1 = {1,2,3,4,5,6};
        Stream.of(arr1).forEach(i-> System.out.print(i+" "));
    }
}

结果展示:

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

2.Stream流的中间方法

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

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

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

代码示范:

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"小明","小红","小李飞刀","小张","刘备","马超","黄忠");
        //1.filter
        list.stream().
                /*filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("小");
            }
        })*/
                  filter(s-> s.startsWith("小"))//true表示留下, false表示舍弃
                .forEach(s-> System.out.println(s));
        System.out.println("======================");
        //2.limit
        list.stream()
                .limit(3)
                .forEach(s-> System.out.println(s));
        System.out.println("======================");
        //3.skip
        list.stream()
                .skip(2)
                .forEach(s -> System.out.println(s));
        System.out.println("======================");
        //4.distinct
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"李华","王五");
        Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s));
        System.out.println("======================");
        //5.map
        ArrayList<String> list3 = new ArrayList<>();
        Collections.addAll(list3,"小华-12","小五-13","马六-14");
                                //第一个是原本的数据类型,
                                //第二个要转化成的数据类型
        list3.stream()
/*                .map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                String[] str = s.split("-");
                String ageString = str[1];
                int age = Integer.parseInt(ageString);
                return age;
            }
        })*/
                .map(s->Integer.parseInt(s.split("-")[1]))
                .forEach(s-> System.out.println(s));

    }
}

3.Stream流终结方法

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

前三个方法的代码示范: 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;

public class Test1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"asd","zxc","qwe");
        //1.forEach(Consumer action)
        list.stream().forEach(s -> System.out.println(s));
        //2.count()
        long count1 = list.stream().count();
        System.out.println(count1);
        //3.toArray()
                                        //转化成什么类型的数组
        String[] str = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(str));
        //简化写法
        String[] str1 = list.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(str));
    }
}

结果展示: 

三.方法引用

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

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

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

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

5. :: 是方法引用符

代码示范:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Test1 {
    public static void main(String[] args) {
        Integer[] arr = {1,4,7,2,6,3,5};
        //将数组从大到小排序
        //1.匿名内部类
       /* Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });*/
        //2.lambda表达式
        /*Arrays.sort(arr,(o1, o2)-> o2-o1);*/
        //3.方法引用
        //::方法引用符
        Arrays.sort(arr,Test1::subtraction);

        System.out.println(Arrays.toString(arr));
    }
    public static int subtraction(int num1,int num2){
        return num2-num1;
    }
}

结果展示:

 1.引用静态方法

格式: 类名::静态方法

例如: Integer::parseInt

代码示范: 

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5");
        /*list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                Integer i = Integer.parseInt(s);
                return i;
            }
        }).forEach(s-> System.out.println(s));*/

        list.stream()
                .map(Integer::parseInt)
                .forEach(s-> System.out.println(s));
    }
}

结果展示: 

2.引用成员方法

格式:  对象::成员方法

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

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

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

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

public class Demo1 {
    public static boolean stringJudge(String s){
        return s.startsWith("小")&&s.length()==2;
    }

}
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;

public class Test3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"小明","小红","小张","小李飞刀","张三","李四");
        //普通
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("小")&&s.length()==2;
            }
        }).forEach(s-> System.out.println(s));
        System.out.println("=========================");
        //简化
        list.stream()
                .filter(s->s.startsWith("小")&&s.length()==2)
                .forEach(s-> System.out.println(s));
        System.out.println("=========================");
        //方法引用
        list.stream()
                .filter(Demo1::stringJudge)
                .forEach(s-> System.out.println(s));
    }
}

结果展示: 

3.引用结构方法

格式: 类名::new

例如: Student::new

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

public class Student {
    private String name;
    private int age;

    public Student() {
    }
    //str是stream流中的数据
    public Student(String str) {
        String[] arr = str.split(",");
        this.name = arr[0];
        this.age = Integer.parseInt(arr[1]);
    }

    public Student(String name, int aeg) {
        this.name = name;
        this.age = aeg;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return aeg
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", aeg = " + age + "}";
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Test4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"小明,18","小红,19","小张,20","小李飞刀,21","张三,22","李四,23");
        //封装成Student对象并收集到List集合中
        //普通方法
        List<Student> newList = list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String[] arr = s.split(",");
                String name = arr[0];
                int age = Integer.parseInt(arr[1]);
                return new Student(name, age);
            }
        }).collect(Collectors.toList());
        System.out.println(newList);
        System.out.println("==========================");
        //引用构造方法
        List<Student> newList2 = list.stream()
                .map(Student::new)
                .collect(Collectors.toList());
        System.out.println(newList2);
    }
}

结果展示: 

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

格式: 类名::成员方法

例如: String::substring

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

代码示范: 

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Test5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc");
        //把数据变成大写然后遍历
        //普通
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s-> System.out.println(s));
        System.out.println("==========================");
        //引用方法
        list.stream()
                .map(String::toUpperCase)
                .forEach(s-> System.out.println(s));
        
    }
}

结果展示: 

5.引用数组的构造方法

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

例如: Integer::new

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

代码示范: 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;

public class Test6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6);
        //普通写法
        Integer[] arr1 = list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });
        //引用方法
        Integer[] arr2 = list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr1));
        System.out.println("===================");
        System.out.println(Arrays.toString(arr2));
    }
}

结果示范: 

guaiwu_
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值