lambda和Stream

电玩女神 2023-10-01 22:47 24阅读 0赞

## lambda ##

1.出现的原因：为了适应时代的潮流，只有语言不断的进步，才能不会被世界所淘汰，java1.8出现了lambda，Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段 可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。Lambda 表达式的本质只是一个“语法糖”,由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。

list.sort(new Comparator<User>() {
     @Override 
    public int compare(User o1, User o2) 
    { return o1.getId()-o2.getId(); } }

而使用lambda以后，我们可以这样写

list.sort((User o1, User o2)-> { return o1.getId()-o2.getId(); });

一行代码就可以结束，是不是比以前效率有所提高呢，这就是java语言的魅力之所在。

2.lambda表达式的结构：

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

注意：**（参数）->\{方法体\} 功能存在时只允许存在一个抽象方法。**

java是面向对象的语言，想方法传递参数不能是单个函数，sort需要一个比较的函数，只能创建一个对象，将方法包装在对象中传递，可以通过创建匿名内部类对象，将比较函数包装起来，java1.8之后再次简化语法，推出lambda语言。

3.lambda的特性：

*  lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。
 *  lambda函数有输入和输出：输入是传入到参数列表argument\_list的值，输出是根据表达expression计算得到的值。
 *  lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。

##  **Stream** ##

**1.什么是 Stream？**

*  遍历集合时高级迭代器
 *  是java1.8推出的新功能，与IO完全不同
 *  提供了对象数据集合进行操作的各种办法，声明

![07f971472a5d495cb088737b17570c24.png][]

**2.获取流：**

**使用 Collection 接口下的 stream()**

> List<String> list = new ArrayList<>(); 
> 
> Stream<String> stream = list.stream();

**使用 Arrays 中的 stream() 方法，将数组转成流**

> Integer\[\] nums = new Integer\[10\]; 
> 
> Stream<Integer> stream = Arrays.stream(nums);

**使** **用 Stream 中的静态方法：of()**

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

**使用 BufferedReader.lines() 方法，将每行内容转成流**

> BufferedReader reader=new BufferedReader(new FileReader("stream.txt")); 
> 
> Stream<String> lineStream = reader.lines();

**3.流操作**

流操作可以分为两类： **中间操作** 和 **终端操作** 。

> List<Apple> apples = applestore 
> 
> .stream() 获得流 
> 
> .filter(a -> a.getColor().equals("red")) 中间操作 
> 
> .collect(Collectors.toList()); 终端操作

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

<table style="width:500px;">  中间操作  
 <tbody> 
  <tr> 
   <td style="text-align:center;width:263px;">方法名</td> 
   <td style="text-align:center;width:235px;">作用</td> 
  </tr> 
  <tr> 
   <td style="width:263px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">filter（）</span> 
    </div> </td> 
   <td style="width:235px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">过滤流中的某些元素,</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:263px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">sorted()</span> 
    </div> </td> 
   <td style="width:235px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">自然排序，流中元素需实现 Comparable 接口</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:263px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">distinct（）</span> 
    </div> </td> 
   <td style="width:235px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">去除重复元素</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:263px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">limit(n)</span> 
    </div> </td> 
   <td style="width:235px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">获取 n 个元素</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:263px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">skip(n)</span> 
    </div> </td> 
   <td style="width:235px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">跳过 n 元素，配合 limit(n)可实现分页</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="width:263px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">map():</span> 
    </div> </td> 
   <td style="width:235px;"> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">将其映射成一个新的元素</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

<table style="width:500px;">  终端操作  
 <tbody> 
  <tr> 
   <td style="text-align:center;">方法名</td> 
   <td style="text-align:center;">作用</td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">forEach</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">遍历流中的元素</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">toArray</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">将流中的元素倒入一个数组</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">min</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">返回流中元素最小值</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">max</td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">返回流中元素最大值</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">count</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">:返回流中元素的总个数 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">reduce</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">所有元素求和</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">anyMatch</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">接收一个 Predicate 函数，只要流中有一个元素满足条件则返 </span> 
    </div> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">回 true，否则返回 false</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">allMatch</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">接收一个 Predicate 函数，当流中每个元素都符合条件时才返 </span> 
    </div> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">回 true，否则返回 false</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">findFirst</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">返回流中第一个元素</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">collect</span> 
    </div> </td> 
   <td> 
    <div style="text-align:center;"> 
     <span style="color:#303133;">将流中的元素倒入一个集合,Collection 或 Map</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
            Car car1 = new Car(001, "宝马1", "红色");
            Car car2 = new Car(002, "宝马2", "黑色");
            Car car3 = new Car(003, "宝马3", "白色");
            Car car4 = new Car(004, "宝马4", "蓝色");
            Car car5 = new Car(002, "宝马2", "黑色");
            Car[] cars = {car1, car2, car3, car4, car5};//创建一个Car数组
            Collection listcar=  Arrays.stream(cars)//转换为流
                    .distinct()//去重
                    .filter((e)->{return e.getColor().equals("红色");})//筛剔元素
                    .collect(Collectors.toList());//:将流中的元素倒入一个集合,Collection 或 Map
            System.out.println(listcar);//进行输出
    
    //        Integer [] a={1,5,9,6,3,2,4,7,8};
    //        Integer a1= Arrays.stream(a)
    //                .sorted((b,c)->{return b-c;})
    //                .reduce((c,b)->{return b+c;})//求和
    //                .get();
    //        System.out.println(a1);
    
    
    
    
    //        Integer [] a={1,5,9,6,3,2,4,7,8};
    //        Boolean a1= Arrays.stream(a)
    //                .sorted((b,c)->{return b-c;})
    //                .allMatch((e)->{return e<9;});//:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
    //        System.out.println(a1);
    
    //        Integer [] a={1,5,9,6,3,2,4,7,8};
    //       Boolean a1= Arrays.stream(a)
    //                .sorted((b,c)->{return b-c;})
    //                .anyMatch((e)->{return  e<9;});//接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
    //        System.out.println(a1);
    //
    
    
    //        Integer [] a={1,5,9,6,3,2,4,7,8};
    //        long a1= Arrays.stream(a)
    //                .sorted((b,c)->{return b-c;})
    //                .count();
    //        System.out.println(a1);
    
    //        Integer [] a={1,5,9,6,3,2,4,7,8};
    //       Object [] a1= Arrays.stream(a)
    //                .sorted((b,c)->{return b-c;})
    //                .toArray();
    //        System.out.println(Arrays.toString(a1));
    
    
    //        Integer [] a={1,5,9,6,3,2,4,7,8};
    //        Integer a1= Arrays.stream(a)
    //                .sorted((b,c)->{return b-c;})
    //                .max((c,b)->{return c-b;})
    //                .get();
    //        System.out.println(a1);
    
        }}

[07f971472a5d495cb088737b17570c24.png]: https://img-blog.csdnimg.cn/07f971472a5d495cb088737b17570c24.png