lambda 求和_最火的java8新特性：Lambda 表达式

亦凉 2023-10-05 18:41 4阅读 0赞

### **主要内容** ###

1. Lambda 表达式  
2. 函数式接口  
3. 方法引用与构造器引用  
4. Stream API  
5. 其他新特性

### **Java 8新特性简介** ###

速度更快  
代码更少(增加了新的语法 Lambda 表达式)  
强大的 Stream API  
便于并行  
最大化减少空指针异常 Optional

### **1、Lambda表达式** ###

Lambda 是一个匿名函数

在Java 语言中引入了一个新的语法元  
素和操作符。这个操作符为 “->” ， 该操作符被称  
为 Lambda 操作符或剪头操作符。它将 Lambda 分为  
两个部分：  
左侧：指定了 Lambda 表达式需要的所有参数  
右侧：指定了 Lambda 体，即 Lambda 表达式要执行  
的功能。

### **2、Lambda 表达式语法** ###

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

Runnable r1 = () → System.out.println("hello world");

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

Consumerfun = (args) → System.out.println(args);

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

Consumerfun = args → System.out.println(args);

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

BinaryOperator<Long> bo = (x, y) → {
         System.out.println("hello world");reurn x + y;}

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

BinaryOperator<Long> bo = (x, y) → x + y;

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

BinaryOperator<Long> bo = (Longx, Long y) → {
         System.out.println("hello world");reurn x + y;}

类型推断：  
上述 Lambda 表达式中的参数类型都是由编译器推断  
得出的。Lambda 表达式中无需指定类型，程序依然可  
以编译，这是因为 javac 根据程序的上下文，在后台  
推断出了参数的类型。Lambda 表达式的类型依赖于上  
下文环境，是由编译器推断出来的。这就是所谓的  
“类型推断”

### **2、函数式接口** ###

(1) 只包含一个抽象方法的接口，称为函数式接口。  
(2) 你可以通过 Lambda 表达式来创建该接口的对象。(若 Lambda  
表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方  
法上进行声明)。  
(3) 我们可以在任意函数式接口上使用 @FunctionalInterface 注解，  
这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包  
含一条声明，说明这个接口是一个函数式接口。

#### **自定义函数式接口** ####

@FounctionalInterfacepublic interface MyNumber {
         public double getValue();}@FounctionalInterfacepublic interface MyNumber<T> {
         public T getValue(T t);}

####    作为参数传递 Lambda 表达式 ####

ListenableFuture<Integer> speechTechniqueMacdFuture = executorService.submit( () -> 1+1);

### **3、Java 内置四大核心函数式接口** ###

<table> 
 <thead> 
  <tr> 
   <th><p>函数式接</p></th> 
   <th><p>参数类型</p></th> 
   <th><p>返回类型</p></th> 
   <th><p>用途</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><p>Consumer<br>消费型接口</p></td> 
   <td>T</td> 
   <td>void</td> 
   <td>对类型为T的对象应用操<br>作，包含方法：<br>void accept(T t)</td> 
  </tr> 
  <tr> 
   <td>Supplier供给型</td> 
   <td>无&nbsp;</td> 
   <td>T&nbsp;</td> 
   <td><p>返回类型为T的对象，包<br>含方法：T get();</p></td> 
  </tr> 
  <tr> 
   <td>Function函数型</td> 
   <td>T&nbsp;</td> 
   <td>R</td> 
   <td>对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)</td> 
  </tr> 
  <tr> 
   <td>Predicate断定型</td> 
   <td>T</td> 
   <td>boolea</td> 
   <td>确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法boolean test(T t)</td> 
  </tr> 
 </tbody> 
</table>

### **4、方法引用与构造器引用** ###

方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来

对象::实例方法

类::静态方法

类::实例

Functionin = Integer[]::new;.stream().sorted(Comparator.comparingLong(ConditionAllVO::getStockTotalCount).reversed()).collect(Collectors.toList()))

### **5、强大的 Stream API** ###

是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列“集合讲的是数据，流讲的是计算

注意：

(1)Stream 自己不会存储元素。

(2)Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

(3)Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

Lists.newArrayList().stream() : 返回一个顺序流Lists.newArrayList().parallelStream() : 返回一个并行流Arrays.stream(new Integer[1]).count();Stream stream = Stream.of(Lists.newArrayList());

####  ####

#### **Stream 的中间操作** ####

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，

否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

**筛选**

<table> 
 <thead> 
  <tr> 
   <th><p>方 法</p></th> 
   <th><p>描述</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><p>filter(Predicate p)</p></td> 
   <td><p>接收 Lambda ， 从流中排除某些元素。</p></td> 
  </tr> 
  <tr> 
   <td>distinct()</td> 
   <td>筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复</td> 
  </tr> 
  <tr> 
   <td>limit(long maxSize)</td> 
   <td>截断流，使其元素不超过给定数</td> 
  </tr> 
  <tr> 
   <td colspan="1">skip(long n)</td> 
   <td colspan="1">跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n)&nbsp;&nbsp;互补</td> 
  </tr> 
 </tbody> 
</table>

**映射**

<table> 
 <thead> 
  <tr> 
   <th><p>方 法</p></th> 
   <th><p>描述</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>map(Function f)</td> 
   <td>接收一个函数作为参数，该函数会被应用到每个素上，并将其映射成一个新的</td> 
  </tr> 
  <tr> 
   <td>mapToDouble(ToDoubleFunction f)</td> 
   <td><p>接收一个函数作为参数，该函数会被应用到每个元<br>素上，产生一个新的 DoubleStream。</p></td> 
  </tr> 
  <tr> 
   <td>mapToInt(ToIntFunction f)</td> 
   <td>接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream</td> 
  </tr> 
  <tr> 
   <td>mapToLong(ToLongFunction f)</td> 
   <td>接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream</td> 
  </tr> 
  <tr> 
   <td><p>flatMap(Function f)</p><p>flatMapToDouble(Function f)</p><p>flatMapToInt(Function f)</p><p>flatMapToLong(Function f)</p></td> 
   <td>接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流</td> 
  </tr> 
 </tbody> 
</table>

**排序**

<table> 
 <thead> 
  <tr> 
   <th><p>方 法</p></th> 
   <th><p>描述</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sorted()</td> 
   <td>产生一个新流，其中按自然顺序</td> 
  </tr> 
  <tr> 
   <td>sorted(Comparator comp)</td> 
   <td>产生一个新流，其中按比较器顺序</td> 
  </tr> 
 </tbody> 
</table>

**查找与匹配**

<table> 
 <thead> 
  <tr> 
   <th><p>方 法</p></th> 
   <th><p>描述</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>allMatch(Predicate p)</td> 
   <td>检查是否匹配所有元素</td> 
  </tr> 
  <tr> 
   <td>anyMatch(Predicate p)</td> 
   <td>检查是否至少匹配一个元素</td> 
  </tr> 
  <tr> 
   <td>noneMatch(Predicate p)</td> 
   <td>检查是否没有匹配所有元素</td> 
  </tr> 
  <tr> 
   <td>findFirst()</td> 
   <td>返回第一个元素</td> 
  </tr> 
  <tr> 
   <td>findAny()</td> 
   <td>返回当前流中的任意元素</td> 
  </tr> 
  <tr> 
   <td colspan="1">count()</td> 
   <td colspan="1">返回流中元素个数</td> 
  </tr> 
  <tr> 
   <td colspan="1">max(Comparator c)</td> 
   <td colspan="1">返回流中最大值</td> 
  </tr> 
  <tr> 
   <td colspan="1">min(Comparator c)</td> 
   <td colspan="1">返回流中最小值</td> 
  </tr> 
  <tr> 
   <td colspan="1">forEach(Consumer c)</td> 
   <td colspan="1">内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了</td> 
  </tr> 
 </tbody> 
</table>

**归约**

<table> 
 <thead> 
  <tr> 
   <th><p>方 法</p></th> 
   <th><p>描述</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><p>reduce(T iden, BinaryOperator b)</p></td> 
   <td>可以将流中元素反复结合起来，得到一个值。返回 T</td> 
  </tr> 
  <tr> 
   <td>reduce(BinaryOperator b)</td> 
   <td>可以将流中元素反复结合起来，得到一个值。返回 Optional</td> 
  </tr> 
 </tbody> 
</table>

**收集**

<table> 
 <thead> 
  <tr> 
   <th><p>方 法</p></th> 
   <th><p>描述</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>collect(Collector c)</td> 
   <td>将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th><p>方法</p></th> 
   <th><p>返回类型</p></th> 
   <th><p>作用</p></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>toList</td> 
   <td>List</td> 
   <td>把流中元素收集到List：list.stream().collect(Collectors.toList());</td> 
  </tr> 
  <tr> 
   <td>toSet</td> 
   <td>Set</td> 
   <td>把流中元素收集到Set：list.stream().collect(Collectors.toSet());</td> 
  </tr> 
  <tr> 
   <td><p>toCollection</p></td> 
   <td>Collection</td> 
   <td>把流中元素收集到创建的集合：list.stream().collect(Collectors.toCollection(ArrayList::new));</td> 
  </tr> 
  <tr> 
   <td>counting</td> 
   <td>Long</td> 
   <td><p>计算流中元素的个数：list.stream().collect(Collectors.counting());</p></td> 
  </tr> 
  <tr> 
   <td>summingInt</td> 
   <td>Integer</td> 
   <td>对流中元素的整数属性求和：list.stream().collect(Collectors.summingInt(类名::属性名));</td> 
  </tr> 
  <tr> 
   <td>averagingInt</td> 
   <td>Double</td> 
   <td>计算流中元素Integer属性的平均值：list.stream().collect(Collectors.averagingInt(类名::属性名));</td> 
  </tr> 
  <tr> 
   <td><p>summarizingInt</p><p>summarizingLong</p><p>summarizingDouble</p></td> 
   <td>IntSummaryStatistics</td> 
   <td><p>收集流中Integer属性的统计值：list.stream().collect(Collectors.summarizingInt(类名::属性名));</p><p>一次性得到元素个数、总和、均值、最大值、最小值</p></td> 
  </tr> 
  <tr> 
   <td colspan="1"><p>joining</p></td> 
   <td colspan="1">String</td> 
   <td colspan="1"><p>连接流中每个字符串：<br>list.stream().map(类名::属性名).collect(Collectors.joining());</p></td> 
  </tr> 
  <tr> 
   <td colspan="1"><p>maxBy</p></td> 
   <td colspan="1">Optional</td> 
   <td colspan="1">根据比较器选择最大值：<br>list.stream().collect(Collectors.maxBy(comparingInt(类名::属性名)));</td> 
  </tr> 
  <tr> 
   <td colspan="1">minBy</td> 
   <td colspan="1">Optional</td> 
   <td colspan="1">根据比较器选择最小值：list.stream().collect(Collectors.minBy(comparingInt(类名::属性名))</td> 
  </tr> 
  <tr> 
   <td colspan="1">reducing</td> 
   <td colspan="1">归约产生的类型</td> 
   <td colspan="1"><p>从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值</p><p>list.stream().collect(Collectors.reducing(0,&nbsp;类名::属性名, Integer::sum));</p></td> 
  </tr> 
  <tr> 
   <td colspan="1">collectingAndThen</td> 
   <td colspan="1">转换函数返回的类型</td> 
   <td colspan="1">包裹另一个收集器，对其结果转换函数：list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));</td> 
  </tr> 
  <tr> 
   <td colspan="1">groupingBy 根据</td> 
   <td colspan="1">Map</td> 
   <td colspan="1"><p>某属性值对流分组，属性为K，结果为V：</p><p>list.stream().collect(Collectors.groupingBy(&nbsp;类名::属性名));</p></td> 
  </tr> 
  <tr> 
   <td colspan="1">partitioningBy</td> 
   <td colspan="1">Map&gt;</td> 
   <td colspan="1">根据true或false进行分区：list.stream().collect(Collectors.partitioningBy(类名::属性名)</td> 
  </tr> 
 </tbody> 
</table>

### **6、并行流与串行流** ###

并行流就是把一个内容分成多个数据块，并用不同的线程分  
别处理每个数据块的流。  
Java 8 中将并行进行了优化，我们可以很容易的对数据进行并  
行操作。Stream API 可以声明性地通过 parallel() 与  
sequential() 在并行流与顺序流之间进行切换。

###  ###

### **7、Optional 类** ###

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，  
原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且  
可以避免空指针异常。  
常用方法：  
Optional.of(T t) : 创建一个 Optional 实例  
Optional.empty() : 创建一个空的 Optional 实例  
Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例  
isPresent() : 判断是否包含值  
orElse(T t) : 如果调用对象包含值，返回该值，否则返回t  
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值  
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()  
flatMap(Function mapper):与 map 类似，要求返回值必须是Optional

给个[在看]，是对IT老哥最大的支持