java 8--Lambda表达式，Stream流

Wooo_e

于 2024-05-23 21:06:37 发布

阅读量1k

点赞数 13

文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/Wooo_e/article/details/139156840

版权

Lambda表达式

Lambda表达式的由来

Java是面向对象语言，除了部分简单数据类型，Java中的一切都是对象，即使数组也是一种对象。

在Java中定义的方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。

在Java8以前，若我们想要把某些功能传递给某个方法，总要去写内部类或匿名内部类。

简而言之，在Java里将普通的方法像参数一样传值并不简单，为此，Java8增加了一个语言级的新特性，名为Lambda表达式。

Lambda表达式简介

Lambda表达式是一个匿名函数，我们可以把lambda表达式理解为一段可以传递的代码（将代码段像数据一样传递）。

Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。

使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使java语言的表达式能力得到的提升。

Lambda表达式的结构

Lambda表达式可以具有零个，一个或多个参数。
可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。例如：(int a,int b)与(a,b)相同。
参数用小括号括起来，用逗号分隔。例如(a,b)或(int a,int b)或(String a,int b,float c)。
空括号用于表示一组空的参数。例如：()->42。
当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号。例如：a->returna*a
Lambda表达式的正文可以包含零条，一条或多条语句。
如果Lambda表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。
如果Lambda表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

import javax.swing.*;
import java.util.ArrayList;

public class lambda {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");

        //当排序时，需要定义排序规则
        //arrayList.sort(new StringComparator());
        arrayList.sort((a, b) -> {//用Lambda表达式实现
            return a.compareTo(b);
        });
        //匿名内部类， 为了减少类的创建
        //此处功能核心compareTo方法，但是java是面向对象的,方法是不能独立的存在的,必须将方法包装在对象中
        /* arrayList.sort(new Comparator<string>(){
              @Override
              public int compare(string ol, string o2){
              return o1.compareTo(o2);
            }
         });*/
        System.out.println(arrayList);

        //集合遍历
        arrayList.forEach((e)->{//用Lambda表达式实现
            System.out.println(e);
        });
    }
}

Stream流

什么是Stream流？

Stream是Java8的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。

此外与stream与lambada表达示结合后编码效率与大大提高，并且可读性更强。

要澄清的是java8中的stream 与 InputStream 和 OutputStream 是完全不同的概念。

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

元素列表：和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源：获取数据的源，比如集合。

数据处理操作：流更偏向于数据处理和计算，比如filter、map、find、sort等。

简单来说，我们通过一个集合的stream方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

Stream流操作

简单来说就是：

数据源=>中间操作=>终端操作=>结果

1、获取流，把集合/数组转为Stream对象

package De;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;

public class Demo1 {
    public static void main(String[] args) {
        //1、将集合转为流
        ArrayList<Integer> arrayList=new ArrayList<>();
                           arrayList.add(1);
                           arrayList.add(2);
                           arrayList.add(3);
                           arrayList.add(4);

        Stream<Integer> stream=arrayList.stream();//将集合转为流
        //2、将数组转为流
        Integer[] array=new Integer[]{1,2,3,4};
        Stream<Integer> stream1= Arrays.stream(array);//把数组转为流
        //3、调用Stream.of方法转为流
        Stream stream2=Stream.of(1,2,3,4,5);
    }
}

2、经过流操作

流的操作分为：
     中间操作: 流的各种数据处理
     终端操作: 把流转为最终结果(数组/集合/单值)

中间操作

filter：过滤流中的某些元素
sorted()：自然排序，流中元素需实现 Comparable 按口
distinct： 去除重复元素
limit(n)：获取 n 个元素
skip(n)：跳过n元素，配台limit(n)可实现分页
map:将对象中某个属性的值映射到一个新集合中


    public static void main(String[] args) {
        Integer[] array=new Integer[]{1,2,3,4};

         Arrays.stream(array)
                .skip(1)//跳过指定数量个元素
                .limit(2)//取出指定数量个元素
                .forEach((e) ->{
                    System.out.println(e);
                });
        System.out.println("------");
        Arrays.stream(array).filter((e)->{//过滤
            return e>0;
        }).sorted((o1, o2) -> {
            return o2-o1;
        }).distinct()//去重
        .forEach((e)->{
            System.out.println(e);
        });

    }

终端操作

把流转为最终结果(数组/集合/单值)

Min:返回流中元素最小值
Max:返回流中元素最大值
count:返回流中元素的总个数
Reduce:所有元素求和
anyMatch:按收一个 Predicate 函数，只要流中有一个元素满足条件则返true，否则返回 false
allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返true，否则返回 false
findFirst:返回流中第一个元素

package De;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        Integer[] array=new Integer[]{1,2,3,4,4,5,6};
        //Min:返回流中元素最小值
        Integer min=Arrays.stream(array)
                       .distinct().min((o1, o2) -> {
                           return o1-o2;
                }).get();
        System.out.println(min);
        //Max:返回流中元素最大值
        Integer max=Arrays.stream(array)
                .distinct().max((o1, o2) -> {
                    return o1-o2;
                }).get();
        System.out.println(max);
        //count:返回流中元素的总个数
        long count=Arrays.stream(array)
                .distinct().count();
        System.out.println(count);
        //Reduce:所有元素求和
        long sum=Arrays.stream(array)
                .distinct().reduce((o1, o2) -> {
                    return o1+o2;
                }).get();
        System.out.println(sum);
        //anyMatch:按收一个 Predicate 函数，只要流中有一个元素满足条件则返true，否则返回 false
        boolean result1=Arrays.stream(array)
                .distinct().anyMatch((e)->{
                    return e>4;
                });
        System.out.println(result1);
        // allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返true，否则返回 false
        boolean result=Arrays.stream(array)
                .distinct().allMatch((e)->{
                    return e>4;
                });
        System.out.println(result);
        //findFirst:返回流中第一个元素
        Integer res=Arrays.stream(array)
                .distinct().findFirst().get();
        System.out.println(res);

    }
}

如果对于一个对象而言，同样也适用。

public class Demo2 {
    public static void main(String[] args) {

        student s1=new student(101,"张三",20);
        student s2=new student(102,"李四",21);
        student s3=new student(103,"王五",22);
        student s4=new student(104,"老刘",20);
        student s5=new student(105,"杨一",24);
        ArrayList<student> students=new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        students.add(s5);

        //sorted()：自然排序，流中元素需实现 Comparable 按口
        List<student> students1=students.stream()
                                .sorted((s,y)->{
                                    return s.getNum()-y.getNum();
                                })
                                .collect(Collectors.toList());
        System.out.println(students1);
        //filter：过滤流中的某些元素
        List<student> students2=students.stream()
                                .filter((s)->{
                                    return s.getAge()>22;
                                })
                                .collect(Collectors.toList());
        System.out.println(students2);
        // map:将对象中某个属性的值映射到一个新集合中
        Object[] array1=students.stream()
                        .map(student::getNum)
                        .toArray();
        System.out.println(Arrays.toString(array1));
        //
        List list=students.stream()
                  .map(student::getNum)//)//将对象中某个属性的值映射到一个新集合中
                  .collect(Collectors.toList());
        System.out.println(list);
}
}

Wooo_e

关注

13
点赞
踩
23

收藏

觉得还不错? 一键收藏
1
评论
java 8--Lambda表达式，Stream流

Lambda表达式是一个匿名函数，我们可以把lambda表达式理解为一段可以传递的代码（将代码段像数据一样传递）。Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使java语言的表达式能力得到的提升。Stream是Java8的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。
复制链接

扫一扫