函数式编程（Lambda表达式+方法引用）

已于 2023-06-14 09:33:22 修改
阅读量253 收藏 1
点赞数 1
文章标签： java servlet 开发语言
于 2023-06-13 22:23:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WQGuang/article/details/131186604
版权
本文详细介绍了函数式编程的基本思想及其在Java8中的体现，重点讲解了Lambda表达式的概念、语法、使用场景和优缺点，以及Lambda表达式的省略写法。此外，还探讨了内置的函数式接口，如Consumer、Supplier、Function和Predicate，以及如何通过方法引用来简化代码。文章通过实例展示了Lambda和方法引用在实际编程中的应用。
摘要由CSDN通过智能技术生成

目录

1.函数式编程思想

1.1.概念

1.2.优点

2.Lambda表达式

2.1.概述

2.2.Lambda的由来

2.3.Lambda表达式的语法

2.4.Lambda练习1

2.5.Lambda练习2

2.6.Lambda表达式的省略写法

2.7 Lambda表达式使用的前提

3. 内置函数式接口

3.1.内置函数式接口的由来

3.2. 消费型函数式接口Consumer

3.3. 供给型函数式接口---Supplier

3.4. 函数型函数式接口---Function,r>

3.5. 断言型函数式接口--Predicate

4. 方法引用

4.1.推荐用法

4.2. 基本格式

4.3.方法引用的由来

4.4.方法引用的类型

4.5.1.静态方法引用

4.5.2.实例方法引用

4.5.3.对象方法引用

5.方法引用总结

1.函数式编程思想

1.1.概念

面向对象思想需要关注用什么对象完成什么事情，而函数式编程思想就类似于数学中的函数。

它主要关注的是对数据进行了什么操作。

1.2.优点

  • 代码简洁，开发快速
  • 接近自然语言，易于理解
  • 易于“并发编程”

2.Lambda表达式

2.1.概述

Lambda是JDK8中一个语法。他可以对某些匿名内部类的写法进行简化。它是函数式编程思想的一个重要体现。让我们不用关注是什么对象。而是更关注我们对数据进行了什么操作。

2.2.Lambda的由来

public class Test01 {
    public static void main(String[] args) {
        //开启一个线程 该构造函数需要传递一个Runnable类型的接口参数
        Thread thread = new Thread(new My());
        thread.start(); //开启线程  执行run方法

        //匿名内部类
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过匿名内部类实现线程任务=====");
            }
        });
        thread1.start();//开启线程  执行匿名内部类的run方法
    }
}

class My implements Runnable {

    @Override
    public void run() {
        System.out.println("使用实现类完成线程任务=====");
    }
}

分析:

  1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
  2. 为了指定run方法体，不得不需要Runnable的实现类
  3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
  4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
  5. 而实际上，我们只在乎方法体中的代码.
  6. 我们可以使用Lambda表达式来完成上面的功能。

使用Lambda表达式来完成上面的功能：

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

        //Lambda表达式
        /*Runnable runnable = () -> {
            System.out.println("Lambda表达式完成线程任务");
        };
        Thread thread2 = new Thread(runnable);
        thread2.start(); //开启线程*/

        //Lambda表达式2
        Thread thread2 = new Thread(() -> {
            System.out.println("Lambda表达式完成线程任务");
        });
        thread2.start(); //开启线程
    }
}

class My implements Runnable {
    @Override
    public void run() {
        System.out.println("使用实现类完成线程任务=====");
    }
}

2.3.Lambda表达式的语法

Lambda省去了面向对象的条条框框，Lambda的标准格式由3个部分组成：

格式：( 参数列表 ) -> { 方法体 }

  • ():参数列表
  • ->:连接符 连接的是参数以及方法体。
  • {}: 方法体。

2.4.Lambda练习1

练习无参无返回值的Lambda表达式：

public class Test01 {
    public static void main(String[] args) {
        //主函数调用fun方法
        //第一种：匿名内部类方式
        User user1 = new User() {
            @Override
            public void show() {
                System.out.println("匿名内部类的show方法实现");
            }
        };
        fun(user1);

        //第二种：Lambda表达式方式 (接口必须为函数式接口)
        fun(() -> {
            System.out.println("Lambda表达式的show方法实现");
        });


    }

    //定义一个静态方法
    public static void fun(User user){
        user.show();
    }
}

//函数式接口（里面只有一个抽象方法）
@FunctionalInterface
interface User{
    public void show();
}

2.5.Lambda练习2

练习有参有返回值的Lambda表达式：

public class Test03 {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三",25));
        personList.add(new Person("李四",18));
        personList.add(new Person("王五",30));
        personList.add(new Person("马六",20));
        //对集合中的元素按照年龄从小到大排序     集合工具类：Collections
        System.out.println("没排序："+personList);
        //方法一：使用匿名内部类
        Comparator<Person> comparator = new Comparator<Person>() {
            @Override//如果是0表示相同  大于0表示o1大于o2
            public int compare(Person o1, Person o2) {//自带的参数
                return o1.getAge()-o2.getAge();
            }
        };
        Collections.sort(personList,comparator);
        System.out.println("从小到大排序后："+personList);

        //方法二：使用Lambda表达式  (就是对函数式接口中抽象方法的简写)
        Comparator<Person> comparator2 =(o1,o2) -> {
            return o1.getAge()- o2.getAge();
        };
        Collections.sort(personList,comparator2);
        System.out.println(personList);
        
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
class Person{
    private String name;
    private Integer age;
}

2.6.Lambda表达式的省略写法

 在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

  1. 小括号内的参数类型可以省略[ ]
  2. 如果小括号内有且仅有一个参数，则小括号可以省略
  3. 如果大括号内有且仅有一个语句，可以同时省略大括号 和 return 关键字及语句分号

案列1：

public class Test04 {
    public static void main(String[] args) {
        //未省略
       /* U01 u = (a) ->{
            System.out.println("heelo=="+a);
        };*/
        //省略后
        U01 u = a -> System.out.println("hello=="+a);
        fun(u);

        //U02 u2 = a -> {return a * 2;};   //未省略
        U02 u2 = a -> a * 2;   //省略后  Lambda默认把最后一条语句作为返回结果
        fun02(u2);

    }


    public static void fun(U01 u01) {
        u01.show(10);
    }

    public static void fun02(U02 u02) {
        int print = u02.print(20);
        System.out.println(print);
    }
}

interface U01 {
    public void show(int a);
}

interface U02 {
    public int print(int b);
}

案列2：

public class Test004 {
    public static void main(String[] args) {
        //Lambda表达式 （toUpperCase）
        fun((str) -> str.toUpperCase());
    }

    public static void fun(ABC abc) {
        String s = abc.toUpper("hello==");//使用Lambda表达式把字符串转为大写
        System.out.println(s);
    }

    interface ABC {
        public String toUpper(String str);
    }
}

2.7 Lambda表达式使用的前提

 Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

  1. 方法的参数或局部变量类型必须为接口才能使用Lambda
  2. 接口中有且仅有一个抽象方法(@FunctionalInterface)

3. 内置函数式接口

要想使用lambda表达式它的前提就是必须是函数式接口

3.1.内置函数式接口的由来

案列：

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

        /*Operation o = (int[] arr) -> {
            int sum = 0;
            for (int s:arr){
                sum += s ;
            }
            return sum;
        };
        fun(o);*/
 
        //简写
        fun(arr -> {
            int sum = 0;
            for (int s:arr){
                sum += s ;
            }
            return sum;
        });
    }

    public static void fun(Operation operation){
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int s = operation.getSum(arr);
        System.out.println("数组和为："+s);
    }
}

@FunctionalInterface
interface Operation{
    public int getSum(int[] arr);
}

分析：

我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口. 大多数无需自己再定义函数式接口，而可以直接使用jdk内置的函数式接口。分成以下四类：

函数式接口参数类型返回类型说明
Consumer<T> 消费型接口Tvoidvoid accept(T t);对类型为T的对象应用操作
Supplier<T> 供给型接口无TT get();返回类型为T的对象
Function<T,R>函数型接口TR

R apply(T t);对类型为T的对象应用操作，并返回类型

为R类型的对象

Predicate<T>断言型接口Tboolean

boolean test(T t);确定类型为T的对象是否满足条件，

并返回boolean类型

3.2. 消费型函数式接口Consumer

适合有参数，但是没有返回值的

根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中对传入的参数进行消费。

案列：

public class Test06 {
    public static void main(String[] args) {
        Consumer<Double> c = t ->{
            System.out.println("今天吃饭花费："+t+"元");
        };
        fun(c,200.0);
    }
    public static void fun(Consumer<Double> consumer , Double money){
        consumer.accept(money);
    }
}

3.3. 供给型函数式接口---Supplier

无参，需要返回值的接口类

根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中创建对象，把创建好的对象返回

案列：

public class Test07 {
    public static void main(String[] args) {
        Supplier<Integer> s = () -> new Random().nextInt(10); //Random：随机获取一为数
        fun(s);
    }

    public static void fun(Supplier<Integer> supplier) {
        Integer a = supplier.get();
        System.out.println("结果：" + a);
    }
}

3.4. 函数型函数式接口---Function<T,R>

T: 参数的泛型

R:返回值的泛型

根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中对传入的参数计算或转换，把结果返回

修改（3.1.内置函数式接口的由来）中的案列：

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

        /*Function<int[] , Integer> o = (int[] arr) -> {
            int sum = 0;
            for (int s:arr){
                sum += s ;
            }
            return sum;
        };
        fun(o);*/

        //简写
        fun(arr -> {
            int sum = 0;
            for (int s:arr){
                sum += s ;
            }
            return sum;
        });
    }

    public static void fun(Function<int[] , Integer> fun){
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int s = fun.apply(arr);
        System.out.println("数组和为："+s);
    }
}

修改分析：

不需要自己再定义函数式接口，直接用内置的 函数式接口就行了。因为方法有参有返回值

3.5. 断言型函数式接口--Predicate

T: 参数

boolean:返回值类型

根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中对传入的参数条件判断，返回判断结果

public class Test09 {
    public static void main(String[] args) {
        Predicate<String> p = t -> t.length()>3;
        fun(p,"cj"); //字符串长度小于3为false

    }
    public static void fun(Predicate<String> predicate , String name){
        boolean test = predicate.test(name);
        System.out.println("是否成年："+test);
    }
}

4. 方法引用

我们在使用lambda时，如果方法体中只有一个方法的调用的话（包括构造方法）,我们可以用方法引用进一步简化代码

4.1.推荐用法

  • 我们在使用lambda时不需要考虑什么时候用方法引用，用哪种方法引用，方法引用的格式是什么。
  • 我们只需要在写完lambda方法发现方法体只有一行代码，并且是方法的调用时使用快捷键尝试是否能够转换成方法引用即可。
  • 当我们方法引用使用的多了慢慢的也可以直接写出方法引用。

4.2. 基本格式

类名或者对象名 :: 方法名

4.3.方法引用的由来

public class Test10 {
    public static void main(String[] args) {
        Consumer<int[]> c = t -> {
            int sum = 0;
            for (int a : t) {
                sum += a;
            }
            System.out.println("数组的和是：" + sum);
        };
        fun(c);

    }

    public static void fun(Consumer<int[]> consumer) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        consumer.accept(arr);
    }

    //求和方法
    public static void sum(int[] arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        System.out.println("数组的和是：" + sum);
    }
}

分析：

如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引 用”过去就好了----方法引用  ::  可以办到

public class Test10 {
    public static void main(String[] args) {
        //Consumer<int[]> c=(t)->Test10.sum(t); 
        Consumer<int[]> c = Test10::sum; //方法引用  //静态方法引用
        fun(c);

    }

    public static void fun(Consumer<int[]> consumer) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        consumer.accept(arr);
    }

    //求和方法
    public static void sum(int[] arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        System.out.println("数组的和是：" + sum);
    }
}

4.4.方法引用的类型

类型语法对应的Lambda表达式
静态方法引用类名::staticMethod(args)->类名.staticMethod(args)
实例方法引用inst::instMethod(args)->inst.instMethod(args)
对象方法引用类名::instMethod(inst,args)->inst.instMethod(args)
构建方法引用类名::new(args)->new 类名(args)

4.5.方法引用举例

4.5.1.静态方法引用

使用前提：如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的静态方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候我们就可以引用类的静态方法

public class Test11 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(); //从小到大排序
        list.add(2);
        list.add(8);
        list.add(4);
        list.add(1);

        //Comparator<Integer>comparator=(o1,o2)->o1-o2; //第一种排序方法
        //Comparator<Integer>comparator=(o1,o2)->Integer.compare(o1,o2);//第二种排序方法//Integer.compare排序
        Comparator<Integer> comparator = Integer::compareTo;//第三种排序方法  静态方法引用


        Collections.sort(list, comparator);
        System.out.println(list);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
class Person {
    private String name;
    private Integer age;
}

4.5.2.实例方法引用

使用前提： 如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了第一个参数的成员方法，并且我们把要重写的抽象方法中剩余的所有的参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用类的实例方法。

实例方法引用特点：( ) -> 对象.普通方法( )；

案例：

public class Test01 {
    public static void main(String[] args) {
        User u = new User("张三",20);

        //在这个lambda表达式中只有一条语句，而且该语句又是调用了某个方法
        //Supplier<String> s = ()->u.getName();
        //实例方法引用
        Supplier<String> s = u::getName;  //实例方法引用特点：( ) -> 对象.普通方法( )；
        fun(s);
    }
    
    public static void fun(Supplier<String> supplier){
        String s = supplier.get();
        System.out.println("结果为："+s);
    }
}

@Data
@AllArgsConstructor
class User{
    private String name;
    private Integer age;
}

4.5.3.对象方法引用

使用前提： 如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个对象的成员方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用对象的实例方法

案例1：

public class Test02 {
    public static void main(String[] args) {
        //对象方法引用： 类名::实例方法      (参数1,参数2)->参数1.实例方法(参数2)


        //Lambda表达式   函数式接口Function<T,R>
       /* Function<String,Integer> function = (str)->{
            return str.length();
        };*/

        //使用对象方法引用
        Function<String,Integer> function = String::length;

        Integer integer = function.apply("hello~~");  //获取字符串长度
        System.out.println(integer);

    }
}

案例2：

比较两个字符串内容是否一致

public class Test02 {
    public static void main(String[] args) {
        //对象方法引用： 类名::实例方法      (参数1,参数2)->参数1.实例方法(参数2)


        //案例2：比较两个字符串内容是否一致 T , U , R
        //R apply(T t, U u);
        /*BiFunction<String,String,Boolean> bi =(t,u)->{
            return t.equals(u);
        };*/
        BiFunction<String,String,Boolean> bi = String::equals;
        Boolean apply = bi.apply("hello", "hello");
        System.out.println(apply);
    }
}

4.5.4.构造方法引用

使用前提：如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的构造方法，并且我们把要重写的抽象方法中的所有的参数都按照顺序传入了这个构造方法中，这个时候我们就可以引用构造器。

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


        //构造方法引用 ： 类名::new  (参数)->new 类名(参数)
        // 供给型函数式接口---Supplier
        /*Supplier<People>supplier=()->{
            return new People();
        };*/
        Supplier<People> supplier = People::new;  //调无参构造
        People s = supplier.get();
        System.out.println(s);

        //函数型函数式接口---Function<T,R>
        //Function<String,People> function=(n)->new People(n);
        Function<String, People> function = People::new;      // 调有参构造
        People s2 = function.apply("张三");
        System.out.println(s2);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
class People {
    private String name;
}

5.方法引用总结

类型语法对应的Lambda表达式
静态方法引用类名::静态方法lambda表达式时:(参数)->类名.静态方法(参数)
实例方法引用对象::实例方法lambda表达式时:(参数)->对象.实例方法(参数)
对象引用方法  类名::实例方法 lambda表达式时:(参数1,参数2...)->参数1.实例方法(参数2...)
构造方法引用类名::new    lambda表达式时:(参数)->new 类名(参数)
IT光
关注
Lambda 表达式和函数式编程
xinyi_java的博客
01-17 596
Lambda表达式是一种轻量级的匿名函数，它可以被看作是一种简洁的方式来表示单一方法的接口（Single Abstract Method，SAM）。Stream API是Java 8中引入的用于处理集合数据的函数式编程的工具。它允许你以声明性的方式处理数据集合，支持各种操作，如映射、过滤、归约等。Lambda表达式和函数式编程是Java 8引入的两个重要特性，为Java带来了更加灵活和简洁的编程方式。函数式接口是只包含一个抽象方法的接口。包，其中包含了一些常用的函数式接口，如。
Java 8 函数式编程：Lambda 表达式和方法引用
叉叉哥的BLOG
04-23 2371
背景 在很多其他语言中，函数是一等公民。例如 JavaScript 中，函数（Function）和字符串（String）、数字（Number）、对象（Object）等一样是一种数据类型。可以这样定义函数： var myFunction = function () { doSomething(); }; 也可以将函数作为参数： setTimeout(function() { do...
函数式编程----lambda演算
weixin_30846599的博客
11-14 428
一 概念 函数式编程（英语：Functional programming），又称泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免状态以及可变数据。函数编程语言最重要的基础是λ 演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）。代表语言haskell,erlang，lisp等 特点： ...
函数式编程 lambda表达式
最新发布
Mwt258的博客
09-07 468
Java函数式编程，让代码更加优雅
Java8新特性【函数式编程API、新时间日期处理API、Optional容器类】总结
欢迎来到编程小栈
12-03 1273
文章目录1、Lambda表达式1.1什么是Lambda表达式1.2从匿名类到 Lambda 的转换1.3Lambda表达式语法2、函数式接口2.1什么是函数式接口2.2自定义函数式接口2.3内置核心函数式接口2.4接口中常用的默认方法3、方法引用与构造器引用3.1 推荐用法3.2 基本格式3.3 语法详解(了解)3.3.1引用类的静态方法3.3.2 引用对象的实例方法3.3.4 引用类的实例方法3.3.5 构造器引用4、Stream API4.1什么是Stream4.2Stream操作的三个步骤4.2.1创
Lambda函数式编程
西魏陶渊明的博客
07-17 739
Java8所有的新特性基本基于函数式编程的思想，函数式编程给Java带来了注入了新鲜的活力。函数式编程其实并不是很难，小编在学习函数式编程时候刚开始一头雾水，最后仔细观察就发现了其中的小窍门，读了本篇文章如果还没有掌握，就算我输了。......
函数式编程--使用lambda表达式
weixin_34262482的博客
10-23 188
前面一篇博客我们已经说到了，lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口的实例。现在我们来写一段java的命令者模式来自己研究下lambda表达式的语法。 这里重复下命令者模式： 考虑这么一个情景，某个方法需要完成一个行为，但是这个行为的具体实现无法确定，必须等到执行该方法时才可以确定。举个例子，我有个方法需要遍历某个数组的数组元素，但是无法确定在遍历这个...
Lambda+函数式接口+表达式和方法引用+实践
02-26
Lambda+函数式接口+表达式和方法引用+实践 - 本资源是一个Lambda的实践，教你如何用Java的Lambda表达式和方法引用简化代码，实现函数式编程，包括使用函数式接口，Stream，Optional等。
黑马程序员Java函数式编程全套视频教程，Lambda表达式、Stream流、函数式编程一套全通关1
05-16
本套黑马程序员的Java函数式编程视频教程涵盖了Lambda表达式、Stream流以及函数式编程的核心概念，旨在帮助学习者全面掌握这一现代编程技术。 Lambda表达式是Java 8引入的关键特性，它允许我们以更简洁的方式定义...
用通俗易懂的大白话搞明白Java里的函数式编程和Lambda表达式
曹举的个人博客
01-22 4976
今天，用通俗易懂的大白话来搞明白Java里的函数式编程和Lambda表达式
Java Lambda表达式的方法引用和构造器引用实例分析
08-25
Java Lambda表达式是Java 8中引入的一种新的编程模型，它允许开发者使用函数式编程的方式来编写代码。Lambda表达式可以用来简化代码，提高代码的可读性和可维护性。在Java Lambda表达式中，有两种重要的引用：方法...
函数式编程——Lambda表达式
Fizzoa的博客
11-17 1120
函数式编程——Lambda表达式
Lambda表达式和函数式编程
诗和远方
03-19 888
一.函数式编程概念 (a,b) -> {xxx} 参数 -> 方法体 左侧一个参数时()可以省略，右侧就一句方法体时{}可以省略 二.JDK8引入的函数是编程接口类 要想学习函数式编程一定要知道jdk提供的四种类型的函数式编程接口 1.Function<T, R> 该类型的方法接收一个T类型的参数，返回一个R类型的结果 2.Consumer<T> 该类型方法接收一个T类型的参数，无返回值 3.Supplier<T> 该类型方法不接收任何参数，返回一个
Lambda表达式&Stream流-函数式编程-java8函数式编程(Lambda表达式，Optional，Stream流)从入门到精通-最通俗易懂
weixin_55772633的博客
11-07 477
函数式编程强调将程序分解成独立的、无状态的函数，避免使用可变的状态和共享的数据。Lambda可以对某些匿名内部类的写法进行简化，Lambda表达式只支持函数式接口。5. 引用透明：函数式编程中的函数调用可以被视为对表达式的求值，因此引用透明性是一个重要的特点，即可以替换函数调用的结果而不影响程序的行为。1. 纯函数：函数式编程中的函数是纯函数，即给定相同的输入，总是产生相同的输出，不会对外部状态产生任何影响。2. 不可变数据：函数式编程中的数据一旦创建就不会被修改，任何改变都是通过创建新的数据来实现。
lambda函数式编程实践--第一篇
dfBeautifulLive的博客
06-25 201
偶然跟着网上看了jdk一点源码，发现jdk8之后新加的功能都是用函数式编程，看着很高大上啊，然后就想着学习学习，等到我学习了，函数式编程发现真的很强大的，能简化的代码，用着方便，像集合这样的需要循环获取，那么使用lambda可能就是一行代码的事情，这样你的代码也比较高大上，废话不多说了，开始实践吧！ 1.先来学习一下Optional，是用于简化java对空值的判断处理，以防止出现各种空指针...
函数式编程与Lambda表达式
博客首页
12-06 1238
面向对象编程？NO:面向函数式编程YES,最全函数式编程与Lambda表达式讲解
函数式编程中的方法引用
编程牧马人
01-12 339
使用Lambda表达式，我们就可以不必编写FunctionalInterface接口的实现类，从而简化代码： Arrays.sort(array, (s1, s2) -> { return s1.compareTo(s2); }); 静态方法引用 实际上，除了Lambda表达式，我们还可以直接传入方法引用。例如： import java.util.Arrays; public class Main { public static void main(String[] args) {
函数式接口、函数式编程及方法引用
iconhot的博客
05-05 339
一. 函数式接口 1. 语法糖(Syntactic sugar) 编程中的某一种语法, 让我们使用起来格式简化了.(不能改变底层的逻辑) 已经见过的语法糖: 增强for, 泛型, 自动装拆箱. 是否有.class字节码文件生成 内部类生成的.class文件的名字: ​ 普通内部类: 外部类名$内部类名.class ​ 匿名内部类: 外部类名$1.class , 外部类名​$2.class ...
Java函数式编程入门：Lambda表达式的魅力
"Java函数式编程，Lambda表达式，函数式接口，编程范式，命令式编程，声明式编程，函数式编程好处" 在编程世界里，不同的编程范式提供了不同的思考和解决问题的方式。Java 8引入了Lambda表达式，为Java开发者带来了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值