个人中心
gpt4 book ai didi

Java8新特性:lambda表达式总结

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java8新特性:lambda表达式总结由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、Lambda 表达式的基础语法

Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符箭头操作符将 Lambda 表达式拆分成两部分:

  • 左侧：Lambda 表达式的参数列表
  • 右侧：Lambda 表达式中所需执行的功能，即 Lambda 体

语法格式一：无参数，无返回值 。

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

语法格式二：有一个参数，并且无返回值 。

?
1
(x) -> System.out.println(x)

语法格式三：若只有一个参数，小括号可以省略不写 。

?
1
x -> System.out.println(x)

语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句 。

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

语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写 。

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

语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断” 。

?
1
(Integer x, Integer y) -> Integer.compare(x, y);

 2、函数式接口

Lambda 表达式需要“函数式接口”的支持 。

 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰用来检查是否是函数式接口.

 Java8 内置的四大核心函数式接口 。

?
1
2
3
4
5
6
7
8
9
10
11
Consumer<T> : 消费型接口
        void accept(T t);
 
Supplier<T> : 供给型接口
        T get();
 
Function<T, R> : 函数型接口
        R apply(T t);
 
Predicate<T> : 断言型接口
        boolean test(T t);

3、内置的四大核心函数式接口用法实例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package com.lyz.java8;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
 
import org.junit.Test;
 
/*
  * @author liuyazhuang
  * @version 1.0.0
  * @date 2018/8/19 15:02
  * @description Java8 内置的四大核心函数式接口
  *
  * Consumer<T> : 消费型接口
  *      void accept(T t);
  *
  * Supplier<T> : 供给型接口
  *      T get();
  *
  * Function<T, R> : 函数型接口
  *      R apply(T t);
  *
  * Predicate<T> : 断言型接口
  *      boolean test(T t);
  *
  */
public class TestLambda {
    
     //Predicate<T> 断言型接口：
     @Test
     public void test4(){
         List<String> list = Arrays.asList( "Hello" , "world" , "Lambda" , "www" , "ok" );
         List<String> strList = filterStr(list, (s) -> s.length() > 3 );
        
         for (String str : strList) {
             System.out.println(str);
         }
     }
    
     //需求：将满足条件的字符串，放入集合中
     public List<String> filterStr(List<String> list, Predicate<String> pre){
         List<String> strList = new ArrayList<>();
        
         for (String str : list) {
             if (pre.test(str)){
                 strList.add(str);
             }
         }
        
         return strList;
     }
    
     //Function<T, R> 函数型接口：
     @Test
     public void test3(){
         String newStr = strHandler( "\t\t\t  我叫刘亚壮 " , (str) -> str.trim());
         System.out.println(newStr);
        
         String subStr = strHandler( "我叫刘亚壮" , (str) -> str.substring( 2 , 5 ));
         System.out.println(subStr);
     }
    
     //需求：用于处理字符串
     public String strHandler(String str, Function<String, String> fun){
         return fun.apply(str);
     }
    
     //Supplier<T> 供给型接口 :
     @Test
     public void test2(){
         List<Integer> numList = getNumList( 10 , () -> ( int )(Math.random() * 100 ));
        
         for (Integer num : numList) {
             System.out.println(num);
         }
     }
    
     //需求：产生指定个数的整数，并放入集合中
     public List<Integer> getNumList( int num, Supplier<Integer> sup){
         List<Integer> list = new ArrayList<>();
        
         for ( int i = 0 ; i < num; i++) {
             Integer n = sup.get();
             list.add(n);
         }
        
         return list;
     }
    
     //Consumer<T> 消费型接口 :
     @Test
     public void test1(){
         happy( 10000 , (m) -> System.out.println( "每次消费：" + m + "元" ));
     }
    
     public void happy( double money, Consumer<Double> con){
         con.accept(money);
     }
}

到此这篇关于Java8新特性:lambda表达式总结的文章就介绍到这了,更多相关Java lambda表达式内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://blog.csdn.net/l1028386804/article/details/81837489 。

最后此篇关于Java8新特性:lambda表达式总结的文章就讲到这里了,如果你想了解更多关于Java8新特性:lambda表达式总结的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： 不看后悔!揭秘游戏服务器开发
文章推荐： SEO三大要素助你优化关键字
文章推荐： Python django中如何使用restful框架
文章推荐： 网站制作seo规范
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com