JavaSE-11-Lambda表达式和Stream流

╰+哭是因爲堅強的太久メ 2023-10-06 10:51 21阅读 0赞

**Table of Contents**

Lambda表达式和Stream流

1：Lambda表达式

1.1 什么是lambda表达式

1.2：Lambda表达式的用法

1.3：Lambda表达式总结：

2：函数式接口

2.1：如果使用lambda表达式来创建一个函数式接口实例，那这个lambda表达式的入参和返回必须符合这个函数式接口中唯一的抽象方法的定义

2.2：方法引用

3：Stream用法

3.1：stream的特性

3.2：创建Stream

3.2.1：通过数组创建

3.2.2：通过集合创建

3.:2.3：创建空的流

3.2.4：创建无限流

3.2.5：创建规则的无限流

3.3：对Stream的操作

3.3.1：map：转换流，将一种类型的流转换为另外一种流

3.3.2：filter：过滤流，过滤流中的元素

3.3.3：flapMap：拆解流，将流中每一个元素拆解成一个流

3.3.4：sorted：对流进行排序

--------------------

# Lambda表达式和Stream流 #

# 1：Lambda表达式 #

## 1.1 什么是lambda表达式 ##

ambda表达式有两个特点：一是匿名函数，二是可传递。

匿名函数的应用场景是：

通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用Lambda表达式。lambda表达式所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。

可传递使用场景是：

就是将Lambda表达式传递给其他的函数，它当做参数，Lambda作为一种更紧凑的代码风格，使Java的语言表达能力得到提升。

## 1.2：Lambda表达式的用法 ##

Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为"->"，该操作符被称为Lambda操作符或箭头操作符，它将Lambda分为两个部分：

左侧：指定了Lambda表达式所需要的所有参数

右侧：指定了Lambda体，即Lambda表达式所要执行的功能。

**常见的语法格式：**

语法格式一：无参，无返回值，Lambda体只需要一条语句。

() -> System.out.println("Hello Lambda!");

语法格式二：Lambda需要一个参数

Consumer<String> con = (x) -> System.out.println(x);

语法格式三：Lambda只需要一个参数时，参数的小括号可以省略

Consumer<String> con = x -> System.out.println(x);

语法格式四：Lambda需要两个参数，并且有返回值

Comparator<Integer> com = (x, y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);
        };

语法格式五：当Lambda体只有一条语句时，return与大括号可以省略

Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

语法格式六：数据类型可以省略，因为可由编译器推断得出，称为类型推断

BinaryOperator<Long> operator = (Long x, Long y) -> {
        System.out.println("实现函数接口方法");
        return x + y;
    };

## 1.3：Lambda表达式总结： ##

把一段代码变成：一些参数，一个箭头，一段代码；

# 2：函数式接口 #

如果一个接口中，有且只有一个抽象的方法（Object类中的方法不包括在内），那这个接口就可以被看做是函数式接口。例如Runnable接口就是一个函数式接口：可用@FunctionalInterface注解进行函数式接口的验证

@FunctionalInterface
    　　public interface Runnable {
    　　　　public abstract void run();
    　　}

## 2.1：如果使用lambda表达式来创建一个函数式接口实例，那这个lambda表达式的入参和返回必须符合这个函数式接口中唯一的抽象方法的定义 ##

list.forEach(item -> System.out.println(item));

## 2.2：方法引用 ##

如果Lambda表达式需要做的事情，在另一个类中已经实现了，那么就可以直接拿过来用；

1：类名：：方法名（通过方法引用）

list.forEach(System.out::println);

2：引用静态方法 --- 类型：：方法名

3：引用某个对象的实例方法---对象：：方法名

4：引用类型对象的实例方法---类名：：方法名

5：引用构造方法---类名：：new

list.forEach(Test1::new);
    Test1(Integer i){
    　　System.out.println(i);
    }

java8提供了一系列常见的函数式接口，最常用的如下几个：

Function：提供任意一种类型的参数，返回另外一个任意类型返回值。 R apply(T t);

Consumer：提供任意一种类型的参数，返回空值。 void accept(T t);

Supplier：参数为空，得到任意一种类型的返回值。T get();

Predicate：提供任意一种类型的参数，返回boolean返回值。boolean test(T t);

# 3：Stream用法 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70][]

## 3.1：stream的特性 ##

stream主要具有如下三点特性，在之后我们会对照着详细说明

**　　　　**（1）stream不存储数据

（2）stream不改变源数据

（3）stream的延迟执行特性

通常我们在数组或集合的基础上创建stream，stream不会专门存储数据，对stream的操作也不会影响到创建它的数组和集合，对于stream的聚合、消费或收集操作只能进行一次，再次操作会报错，如下代码：

Stream<String> stream = Stream.generate(()->"user").limit(3);
        stream.forEach(System.out::println);
        stream.forEach(System.out::println);

输出结果：

<table> 
 <tbody> 
  <tr> 
   <td> <p><code>user</code></p> <p><code>user</code></p> <p><code>user</code></p> <p>&nbsp;</p> <p><code>java.lang.IllegalStateException: stream has already been operated upon or closed</code></p> </td> 
  </tr> 
 </tbody> 
</table>

程序在正常完成一次打印工作后报错。

public static void main(String[] args) {
            Integer[] arr = new Integer[]{1,2,3,4,5,6,7,8,9,10};
            List<Integer> list = new ArrayList<>();
            Arrays.stream(arr).filter(x->x>3&&x<8)
                    .forEach(x->list.add(x));//4,5,6,7这是找出大于3小于8的数
            System.out.println(""+list);
        }

## 3.2：创建Stream ##

### 3.2.1：通过数组创建 ###

public static void main(String[] args) {
            //基本类型
            int[] arr = new int[]{1,2,34,5};
            IntStream stream = Arrays.stream(arr);
            //引用类型
            Student[] studentArr = new Student[]{new Student("s1",29),new Student("s2",27)};
            Stream<Student> studentStream = Arrays.stream(studentArr);
            //通过Stream.of
            Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
            
        }

### 3.2.2：通过集合创建 ###

public static void main(String[] args) {
            List<String> strs = Arrays.asList("11212","dfd","2323","dfhgf");
            //创建普通流
            Stream<String> stream  = strs.stream();
            //创建并行流（即多个线程处理）
            Stream<String> stream1 = strs.parallelStream();
    
        }

### 3.:2.3：创建空的流 ###

public void testEmptyStream(){
        //创建一个空的stream
        Stream<Integer> stream  = Stream.empty();
    }

### 3.2.4：创建无限流 ###

public static void main(String[] args) {
            //generate:创建无限流
            Stream.generate(()->"number"+new Random().nextInt())
                    .limit(100).forEach(System.out::println);
    
        }

### 3.2.5：创建规则的无限流 ###

public static void main(String[] args) {
            //iterate:创建无限流
            //              初始值，生成函数的规则
            Stream.iterate(0,x->x+1)
                    .limit(10).forEach(System.out::println);
    
        }

## 3.3：对Stream的操作 ##

### 3.3.1：**map：转换流，将一种类型的流转换为另外一种流** ###

public static void main(String[] args) {
            /**
             * map把一种类型的流转换为另外一种类型的流
             * 将String数组中字母转换为大写
             */
            String[] arr = new String[]{"yes", "YES", "no", "NO"};
            Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);
    
        }

### **3.3.2：filter：过滤流，过滤流中的元素** ###

public static void main(String[] args) {
            Integer[] arr = new Integer[]{1,2,3,4,5,6,7,8,9,10};
            Arrays.stream(arr).filter(x->x>3&&x<8)
                    .forEach(System.out::println);//4,5,6,7这是找出大于3小于8的数
    
        }

### **3.3.3：flapMap：拆解流，将流中每一个元素拆解成一个流** ###

flatMap接收一个Function<T, R>函数接口：<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);即入参为集合类型，返回Stream类型。

public static void main(String[] args) {
            String[] arr1 = {"a", "b", "c", "d"};
            String[] arr2 = {"e", "f", "c", "d"};
            String[] arr3 = {"h", "j", "c", "d"};
            Stream.of(arr1, arr2, arr3)
                    .flatMap(Arrays::stream).forEach(System.out::println);
        }

### **3.3.4：sorted：对流进行排序** ###

/**
     * Comparator.comparing是一个键提取的功能
     * 以下两个语句表示相同意义
     */
    @Test
    public void testSorted1_(){
        /**
         * 按照字符长度排序
         */
        Arrays.stream(arr1).sorted((x,y)->{
            if (x.length()>y.length())
                return 1;
            else if (x.length()<y.length())
                return -1;
            else
                return 0;
        }).forEach(System.out::println);
    
        Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200610231905173.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70