Lambda和Stream流

发布时间：2024年01月19日

Lambda和Stream流

1 jdk8 新特性

Lambda和Stream流
hashmap 数组、链表、红黑树
JVM 元空间代替了永久代

一 lambda表达式

1 函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

@FunctionalInterface可以放在接口上面，定义一个函数式接口

# 语法糖
备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

2 语法格式

(o1,o2) -> Integer.compare(o1,o2);

->是Lambda操作符或箭头操作符
->左边是Lambda形参列表（其实就是接口中的抽象方法的形参列表）
->右边是lambda体（Lambda 表达式要执行的功能/重写的接口的方法）

3 代码演示

定义六个接口

public interface ILambdaInterface {
}
//无参无返回值
interface NoReturnNoParam{
   void m1();
}
//一个参数无返回值
interface  NoReturnOneParam{
    void m1(int a);
}
//多个参数无返回值
interface NoReturnParam{
    void m1(int a,int b);
}
//无参有返回值
interface ReturnNoParam{
    int m1();
}
//一个参数有返回值
interface ReturnOneParam{
    int m1(int a);
}
//多个参数有返回值
interface ReturnParam{
    int m1(int a ,int b);
}

用lambda表达式实现

public class LambdaTest {
    public static void main(String[] args) {
        //无参无返回值
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println(1);
        };
        noReturnNoParam.m1();
        //一个参数无返回值
        NoReturnOneParam noReturnOneParam=(int a) -> {
            System.out.println(a);
        };
        noReturnOneParam.m1(5);
        //多个参数无返回值
        NoReturnParam noReturnParam =(int a ,int b) ->{
            System.out.println(a+b);
        } ;
        noReturnParam.m1(5,10);
        //无参有返回值
        ReturnNoParam returnNoParam =() -> {
            System.out.println(100);
            return 100;
        };
        System.out.println(returnNoParam.m1());
        //一个参数有返回值
        ReturnOneParam returnOneParam = (int a) ->{
            return a;
        };
        System.out.println(returnOneParam.m1(10));
        //多个参数有返回值
        ReturnParam returnParam= (int a, int b)-> {
            return a+b;
        };
        System.out.println(returnParam.m1(10, 90));
    }
}

4 简化lambda表达式

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

简化后：

public class LambdaTest01 {
    public static void main(String[] args) {
        //lambda表达式简化
        NoReturnParam noReturnParam =(int a ,int b) ->{
            System.out.println(a+b);
        } ;
        noReturnParam.m1(5,95);
        
        
        //不需要声明参数类型，编译器可以统一识别参数值。
        NoReturnParam noReturnParam1 =( a , b) ->{
            System.out.println(a+b);
        } ;
        noReturnParam1.m1(5,95);
        System.out.println("=====================================");
        NoReturnOneParam noReturnOneParam=(int a) -> {
            System.out.println(a);
        };
        noReturnOneParam.m1(5);
        
        
        //一个参数无需定义圆括号，但多个参数需要定义圆括号。
        NoReturnOneParam noReturnOneParam1= a ->{
            System.out.println(a);
        };
        noReturnOneParam1.m1(666);
        System.out.println("=======================================");
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println(1);
        };
        noReturnNoParam.m1();
        
        
        //如果主体包含了一个语句，就不需要使用大括号。
        NoReturnNoParam noReturnNoParam1 = ()->System.out.println("lambda");
        noReturnNoParam1.m1();
        ReturnOneParam returnOneParam = (int a) ->{
            return a;
        };
        System.out.println(returnOneParam.m1(10));
        
        
        //如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
        ReturnOneParam returnOneParam1 = a -> a;
        System.out.println(returnOneParam1.m1(10));
    }
}

5 变量作用域

访问局部变量要注意如下 3 点：

可以直接在 Lambda 表达式中访问外层的局部变量；
在 Lambda 表达式当中被引用的变量的值不可以被更改；（本质上因为lambda用的是内部类）
在 Lambda 表达式当中不允许声明一个与局部变量同名的参数(包括参数的名称也不能一样)

# 补充内部类应用的变量为什么是常量

因为局部内部类是相当于拷贝一份局部变量的值，如果局部变量的值可以随便的改变，那么可能会造成结果的不一致性，所以局部变量必须定义成常量。

从生命周期上来看，内部类运行期间可能会使用局部变量的值的时间超过内部类的存在时间，若局部变量的值不是final类型，则会出现引用非法。（线程使用）

6.四大内置核心函数式接口

内置接口：Cousumer<T>、Supplier<T>、Function<T R>、Predicate<T>

Supplier<T> [s??pla??]

    /*
       Supplier<T>{ 供给型接口 Supplier, 无参数,返回一个 T 类型的返回值
           T get();
         }
     */
// Supplier  生产者
Supplier<Integer> supplier = () -> new Random().nextInt(100);
Integer integer = supplier.get();
System.out.println(integer);

Consumer<T>

     /*
        Consumer<T> {  消费性接口 Consumer, 接收一个 T 类型的参数,无返回值
            void accept(T t);
        }
    */

// Consumer 消费者
Consumer<Integer> consumer = (money) -> System.out.println("今晚潇洒花费" + money + "元");
consumer.accept(1000);

Function<T R>

    /* 
        Function<T R>{ 函数型接口 Function, 接收一个 T 类型的参数,返回一个 R 类型的返回值
               R apply(T t);
           }
     */
//Function 类型转换
Function<Dog, Integer> function = (dg) -> dg.getAge();
Integer i = function.apply(new Dog("旺财", 22));
System.out.println(i);

ArrayList<Dog> dogs = new ArrayList<>();
Collections.addAll(dogs, new Dog("a", 1), new Dog("b", 2), new Dog("c", 3), new Dog("d", 4));
Function<List<Dog>, HashMap<String, Integer>> function1 = (dd) -> {
    HashMap<String, Integer> map = new HashMap<>();
    for (Dog dog : dd) {
        map.put(dog.getName(), dog.getAge());
    }
    return map;
};
HashMap<String, Integer> apply = function1.apply(dogs);
System.out.println(apply);

Predicate<T>

	/*
    Predicate<T t>{ 断言型接口 Predicate, 接收一个 T 类型的参数,返回一个 boolean 类型的返回值
        boolean test(T t);
    }
    */

 // Predicate 预言
Predicate<String> predicate = (str) -> {
    char[] chars = str.toCharArray();
    for (char aChar : chars) {
        if (!Character.isDigit(aChar)) {
            return false;
        }
    }
    return true;
};
System.out.println(predicate.test("abc"));
System.out.println(predicate.test("123"));

7 方法引用

双冒号:: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

1 构造方法引用

格式：类名::new

注意需要调用构造器的参数列表要与函数式接口中抽象方法的参数列表一致，可以是一个参数，也可以是多个参数。

符合（方法参数）->new 对象（构造参数）这样的类型，就可以使用 对象::new ，如果是有参的构造，参数由方法参数决定。

# 前提条件
	1 抽象方法中，创建对象
	2 抽象方法的参数要和构造方法参数一致

public class Person {
    int id;
    String name;
    int age;

    public Person() {
    }
    public Person(String name){
        this.name=name;
    }

    public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    // set  get  toString
}

2 静态方法引用

格式：类名::静态方法名

本质上要求：接口中的方法调用了另一个类的静态方法。要求两个方法的参数要一致。

@FunctionalInterface
public interface InterA {

    Integer toInt(String s);
}

public class StaticB {
    public static Integer parse(String s){
        return Integer.valueOf(s);
    }
}

3 实例方法引用

格式：对象名::方法名

本质上要求：接口的方法调用了对象的方法。要求两个方法的参数要一致。

public interface InterB {

    String p(Integer x);
}

public class MyClass {
    public String parse(Integer i){
        return String.valueOf(i);
    }
}

4 对象方法引用

格式：类名::方法名

条件：在抽象方法中，参数作为实例方法调用者，就可以简化

@FunctionalInterface
public interface InterC {

    boolean empty(String s);

}

二 Stream流

1 流式思想

流式思想类似于工厂车间的“生产流水线”。当需要对元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。

2 Stream 概念

Stream 是JDK1.8 中处理集合的关键抽象概念，Lambda 和 Stream 是JDK1.8新增的函数式编程最有亮点的特性了，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream处理元素可以看成是一种流式处理。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

3 Stream创建

# Stream创建
	- 可以通过Collection系列集合提供的stream()或者paralleStream()来创建
	- 通过Arrays中的静态方法stream()获取数组流
	- 通过Stream中的静态方法of()
	- 创建无限流 iterate(),generate()

可以通过Coolection系列集合提供的stream()或者paralleStream()来创建

List<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c");
Stream<String> stream1 = list.stream();
Stream<String> stream2 = list.parallelStream();

通过Arrays中的静态方法stream()获取数组流

Integer[] array = {1, 2, 3, 4, 5,};
Stream stream = Arrays.stream(array);

通过Stream中的静态方法of()

Stream<Integer> stream = Stream.of(1, 2, 3, 4);

创建无限流，流中的元素无限多个，所以要配合limit使用。 generate(), iterate()

List<Integer> collect1 = Stream.generate(() -> new Random().nextInt(100)).limit(20).collect(Collectors.toList());

List<Integer> collect2 = Stream.iterate(1, s -> s * 2).limit(10).collect(Collectors.toList());

当创建流的时候，数组类型是基本数据类型的时候，需要用到boxed()，把流中的数据变成引用数据类型（装箱）
```
double[] array = {1, 2, 3, 4, 5};
DoubleStream stream = Arrays.stream(array);
Stream<Double> boxed = stream.boxed();
```

4 Stream流的中间操作

# Stream流的中间操作，所谓中间操作的意思是，stream经过中间操作以后，变成的还是stream。
	- filter---从stream流中过滤某些元素
	- limit--- 截断流，使其元素不超过指定数量
	- skip---  跳过元素
	- distinct---筛选，去除重复元素
	- sort---  流中的数据排序
	- map---   映射

filter

filter需要的参数是Predicate，也就是判断。predicate方法test的参数就是Stream流中的数据类型。

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 18),
                new Person(3, "老李", 22),
                new Person(3, "老黑", 12));
        Stream<Person> stream = list.stream();
        Stream<Person> stream1 = stream.filter(new Predicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getAge()>=20;
            }
        });
        Stream<Person> stream2 = stream.filter(person -> person.getAge() >= 20);
        stream2.forEach(System.out::println);

注意：以上代码想要执行，需要注释掉stream1的代码，因为stream1已经修改过了stream

limit

limit是从流中的数据获取前几个，0表示没有，1表示获取第一个，不能是负数，否则抛出异常，经常和无限流配合使用。

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 18),
                new Person(3, "老李", 22),
                new Person(3, "老黑", 12));
        Stream<Person> stream = list.stream();
        stream.limit(2).forEach(System.out::println);

Stream.generate(()->new Random().nextInt(100)).limit(10).forEach(System.out::println);

skip

跳过元素，参数long类型，表示跳过的个数

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 18),
                new Person(3, "老李", 22),
                new Person(3, "老黑", 12));
        Stream<Person> stream = list.stream();
        stream.skip(2).forEach(System.out::println);

distinct

去除流中重复数据，如果数据是引用数据类型，需要重写equals和hashCode

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 18),
                new Person(2, "老张", 18),
                new Person(3, "老李", 22),
                new Person(3, "老李", 22),
                new Person(3, "老黑", 12));
        Stream<Person> stream = list.stream();
        stream.distinct().forEach(System.out::println);

sort

指定流中数据的排序规则，参数是Comparator

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 15),
                new Person(3, "老毛", 22),
                new Person(4, "老朱", 24),
                new Person(5, "老狗", 7),
                new Person(6, "老夏", 83));
        Stream<Person> stream = list.stream();
        Stream<Person> stream1 = stream.sorted((o1, o2) -> o1.getAge() - o2.getAge());
        stream1.forEach(System.out::println);

map

映射，将流中集合的数据类型转化成另一种数据类型，map的参数是Function

  ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 15),
                new Person(3, "老毛", 22),
                new Person(4, "老朱", 24),
                new Person(5, "老狗", 7),
                new Person(6, "老夏", 83));
        Stream<Person> stream = list.stream();
        Stream<String> stream1 = stream.map(p -> p.getName());
        stream1.forEach(System.out::println);

5 Stream流的终端操作

查找与匹配

allMatch--检查是否匹配所有元素
anyMatch--检查是否至少匹配一个元素
noneMatch--检查是否没有匹配所有元素
findFirst--返回第一个元素
findAny--返回当前流中的任意元素
count--返回流中元素的总个数
max--返回流中最大值
min--返回流中最小值

int[] array = {1, 3, 5, 7, 8, 10, 12, 15};
Stream<Integer> stream = Arrays.stream(array).boxed();

System.out.println(stream.allMatch(num -> num % 2 == 0));
System.out.println(stream.anyMatch(num -> num % 2 == 0));
System.out.println(stream.noneMatch(num -> num % 2 == 0));

Optional<Integer> optional1 = stream.filter(num -> num > 5).findFirst();
System.out.println(optional1.get());

Optional<Integer> optional2 = stream.filter(num -> num > 5).findAny();
System.out.println(optional2.get());

long count = stream.count();
System.out.println(count);

Optional<Integer> max = stream.max((o1, o2) -> o1 - o2);
System.out.println(max.get());


Optional<Integer> min = stream.min((o1, o2) -> o1 - o2);
System.out.println(min.get());

归约(reduce)

元素累加，一般用作加法计算

int[] array = {1, 3, 5, 7, 8, 10, 12, 15};
Stream<Integer> stream = Arrays.stream(array).boxed();

Optional<Integer> reduce = stream.reduce((x1, x2) -> x1 + x2);
Integer sum = reduce.get();
System.out.println(sum);

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

Collections.addAll(list,
                   new Person(1, "老李", 20),
                   new Person(2, "老张", 15),
                   new Person(3, "老毛", 22),
                   new Person(4, "老朱", 24),
                   new Person(5, "老狗", 7),
                   new Person(6, "老夏", 83));
Stream<Person> stream = list.stream();
Optional<Person> reduce1 = stream.reduce(new BinaryOperator<Person>() {
    @Override
    public Person apply(Person person1, Person person2) {
        person1.setAge(person1.getAge() + person2.getAge());
        return person1;
    }
});
Optional<Person> reduce2 = stream.reduce((p1, p2) -> {
    p1.setAge(p1.getAge() + p2.getAge());
    return p1;
});

收集(collect)

就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。

返回list集合

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 20),
                new Person(2, "老张", 15),
                new Person(3, "老毛", 22),
                new Person(4, "老朱", 24),
                new Person(5, "老狗", 7),
                new Person(6, "老夏", 83));
        Stream<Person> stream = list.stream();
        List<String> personList1 = stream.map(Person::getName).collect(Collectors.toList());
        ArrayList<String> personList2 = stream.map(Person::getName).collect(Collectors.toCollection(ArrayList::new));

返回set集合

 Set<String> personSet1 = stream.map(Person::getName).collect(Collectors.toSet());
        HashSet<String> personSet2 = stream.map(Person::getName).collect(Collectors.toCollection(HashSet::new));

返回map集合

 Map<String, Integer> collect = stream.collect(Collectors.toMap(Person::getName, Person::getAge));
System.out.println(collect);

分组 groupingBy

 ArrayList<Person> list = new ArrayList<>();
        Collections.addAll(list,
                new Person(1, "老李", 10),
                new Person(2, "老张", 10),
                new Person(3, "老毛", 10),
                new Person(4, "老朱", 20),
                new Person(5, "老狗", 20),
                new Person(6, "老夏", 20));
        Stream<Person> stream = list.stream();
        Map<Integer, List<Person>> collect = stream.collect(Collectors.groupingBy(Person::getAge));
        System.out.println(collect);

6 Optional

是jdk8中的一个新特性

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

常用方法：

isPresent() ，返回容器中是否有值，有值 true
optional.get() 从容器中获取值，如果没有值，会抛出异常
ifPresent(消费一个数据) 如果容器中有数据，我们该怎么处理这个数据
orElse(值) 是前两个方法的组合，如果容器中有数据，就返回容器中的数据，没有的话，使用括号中的值

int[] array = {1, 3, 5, 7, 8, 10, 12, 15};
Stream<Integer> stream = Arrays.stream(array).boxed();

Optional<Integer> optional = stream.filter(num -> num > 100).findAny();


if(optional.isPresent()){
    System.out.println(optional.get());
}
optional.ifPresent(System.out::print);
Integer integer = optional.orElse(-1);

文章来源:https://blog.csdn.net/weixin_65700815/article/details/135701399
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！