Java学习——函数式编程

最新推荐文章于 2025-06-28 14:03:07 发布
原创 最新推荐文章于 2025-06-28 14:03:07 发布 · 3.2k 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #学习 #python

函数式编程

函数式编程指的是使用Lambda函数替代某些匿名内部类，从而让程序代码更简洁，可读性更好

1.Lambda表达式

1.1 定义

  • JDK 8开始新增的一种语法形式，它表示函数
  • 可以用于替代某些匿名内部类，从而让程序更简洁，可读性更好

Tips:Lambda表达式只能替代函数式接口的匿名内部类

（被重写方法的形参列表）->
{
	被重写方法的方法体代码
}
函数式接口：
  • 有且仅有一个抽象方法的接口
  • 注意：将来见到的大部分函数式接口，上面都可能会有一个@FunctionalInterface的注解，该注解用于约束当前接口必须是函数式接口
public class Lambdademo {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("狗吃骨头");
            }
        };
        a.eat();


        System.out.println("============================");
        Swim s1=new Swim() {
            @Override
            public void swim() {
                System.out.println("学生游泳贼快");
            }
        }

        Swim s2=()->{
            System.out.println("学生游泳贼快");
        }
    }

}
abstract class Animal{
    abstract void eat();
}

//函数式接口:有且仅有一个抽象方法的接口
@FunctionalInterface//声明函数式接口的注解
interface Swim{
    void swim();
}

分析这段代码：

Animal由于只是抽象类不是接口，所以不能使用Lambda表达式替代

而Swim是接口，且只有一个抽象方法所以能被Lambda表达式替代

**为什么这个Lambda能替代？**因为能推断出上下文，Swim s2能推断出是一个接口，后面的方法体代码能代码能推断出只有一个抽象方法，所以能推断出原来的代码如s1。

1.2 实例

1.2.1 用comparator接口的匿名内部函数类实现对数组进行排序

在匿名内部类中使用comparator接口的匿名内部函数类实现对数组进行排序代码中可以看到编译器用灰色标记Comparator提示可以进行Lambda表达式进行简化，进入该方法的声明，该方法有声明函数式接口的注解，说明该匿名内部类可以使用Lambda表达式进行化简

import com.fqw.anonymousclass.Student;

import java.util.Arrays;
import java.util.Comparator;

public class Lambdademo1 {
    public static void main(String[] args) {
        Student[] students=new Student[6];
        students[0]=new Student("张三", 18, 1.75);
        students[1]=new Student("李四", 23, 1.80);
        students[2]=new Student("王五", 20, 1.65);
        students[3]=new Student("赵六", 17, 1.70);
        students[4]=new Student("钱七", 22, 1.65);
        students[5]=new Student("孙八", 16, 1.75);
        //输出排序前的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }


        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2)
            {
                return o1.getAge()-o2.getAge();//升序

            }
        });
        System.out.println("=======================================");
        //输出排序后的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }

    }
}

请添加图片描述
请添加图片描述

简化后的代码

import com.fqw.anonymousclass.Student;

import java.util.Arrays;
import java.util.Comparator;

public class Lambdademo1 {
    public static void main(String[] args) {
        Student[] students=new Student[6];
        students[0]=new Student("张三", 18, 1.75);
        students[1]=new Student("李四", 23, 1.80);
        students[2]=new Student("王五", 20, 1.65);
        students[3]=new Student("赵六", 17, 1.70);
        students[4]=new Student("钱七", 22, 1.65);
        students[5]=new Student("孙八", 16, 1.75);
        //输出排序前的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }


        Arrays.sort(students, (Student o1, Student o2)->{
                return o1.getAge()-o2.getAge();//升序

        });
        System.out.println("=======================================");
        //输出排序后的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }

    }
}
1.2.2 登录窗口登录
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Lambdademo2 {
    public static void main(String[] args) {
        //需求：创建一个登录窗口，登录窗口中包含一个登录按钮
        JFrame win = new JFrame("登录窗口");
        win.setSize(300, 200);
        win.setLocationRelativeTo(null);//居中显示
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //创建一个面板，把按钮添加到面板中
        JPanel panel = new JPanel();
        win.add(panel);

        //创建一个按钮
        JButton button = new JButton("登录");
        panel.add(button);

        //java要求必须给按钮添加一个点击事件监听器对象，这样就可以监听用户事件，做出反应
        button.addActionListener((ActionEvent e) -> {
                System.out.println("登录成功");
        });


        win.setVisible(true);


    }
}

1.3 省略规则(进一步简化Lambda表达式的写法)

  • 参数类型全部可以省略不写
  • 如果只有一个参数，参数类型省略的同时“()”也可以省略，但多个参数不能省略“()”
  • 如果Lambda表达式只有一行代码，大括号可以不写，同时要省略分号”;”，如果这行代码是return语句，也必须去掉return

根据简化规则简化后的代码：

import com.fqw.anonymousclass.Student;

import java.util.Arrays;
import java.util.Comparator;

public class Lambdademo1 {
    public static void main(String[] args) {
        Student[] students=new Student[6];
        students[0]=new Student("张三", 18, 1.75);
        students[1]=new Student("李四", 23, 1.80);
        students[2]=new Student("王五", 20, 1.65);
        students[3]=new Student("赵六", 17, 1.70);
        students[4]=new Student("钱七", 22, 1.65);
        students[5]=new Student("孙八", 16, 1.75);
        //输出排序前的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }


        Arrays.sort(students, ( o1,  o2) -> o1.getAge()-o2.getAge());
        System.out.println("=======================================");
        //输出排序后的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }

    }
}

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Lambdademo2 {
    public static void main(String[] args) {
        //需求：创建一个登录窗口，登录窗口中包含一个登录按钮
        JFrame win = new JFrame("登录窗口");
        win.setSize(300, 200);
        win.setLocationRelativeTo(null);//居中显示
        win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //创建一个面板，把按钮添加到面板中
        JPanel panel = new JPanel();
        win.add(panel);

        //创建一个按钮
        JButton button = new JButton("登录");
        panel.add(button);

        //java要求必须给按钮添加一个点击事件监听器对象，这样就可以监听用户事件，做出反应
        button.addActionListener(e -> System.out.println("登录成功"));


        win.setVisible(true);


    }
}

2.方法引用（了解）

2.1 静态方法引用

类名::静态方法

使用场景：如果某个Lambda表达式里只调用一个静态方法，并且“->”前后参数的形式一致，就可以使用静态方法

1.首先，在类中定义一个静态的方法，如学生类中定义一个比较年龄的静态类

package com.fqw.method1reference;

public class Student {
    //姓名、年龄、身高
    private String name;
    private int age;
    private double height;
    public Student() {}
    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public static int compareAge(Student s1, Student s2){
        return s1.getAge() - s2.getAge();
    }
}

2.接着，使用静态方法引用

package com.fqw.method1reference;

import java.util.Arrays;

public class Demo1{
    public static void main(String[] args) {
        Student[] students=new Student[6];
        students[0]=new Student("张三", 18, 1.75);
        students[1]=new Student("李四", 23, 1.80);
        students[2]=new Student("王五", 20, 1.65);
        students[3]=new Student("赵六", 17, 1.70);
        students[4]=new Student("钱七", 22, 1.65);
        students[5]=new Student("孙八", 16, 1.75);
        //输出排序前的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }
        //Arrays.sort(students, ( o1,  o2) -> o1.getAge()-o2.getAge);
        //Arrays.sort(students, ( o1,  o2) -> Student.compareAge(o1,o2));
        //静态方法引用 类名::静态方法
        Arrays.sort(students, Student::compareAge);
        System.out.println("=======================================");
        //输出排序后的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }
    }

}

2.2 实例方法引用

对象名::实例方法

使用场景：如果某个Lambda表达式里只是通过对象名称调用一个实例方法，并且“->”前后参数的形式一致，就可以使用实例方法

package com.fqw.method1reference;

public class Student {
    //姓名、年龄、身高
    private String name;
    private int age;
    private double height;
    public Student() {}
    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }


    

    public int compareByHeight(Student o1,Student o2){
        return Double.compare(o1.getHeight(), o2.getHeight());
    }
}

package com.fqw.method1reference;

import java.util.Arrays;

public class Demo2 {
    public static void main(String[] args) {
        Student[] students=new Student[6];
        students[0]=new Student("张三", 18, 1.75);
        students[1]=new Student("李四", 23, 1.80);
        students[2]=new Student("王五", 20, 1.65);
        students[3]=new Student("赵六", 17, 1.70);
        students[4]=new Student("钱七", 22, 1.65);
        students[5]=new Student("孙八", 16, 1.75);
        //输出排序前的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }


        //实例方法引用 对象名::静态方法
        Student t=new Student();
        //Arrays.sort(students, ( o1,  o2) -> t.compareByHeight(o1,o2));
        Arrays.sort(students, t::compareByHeight);
        System.out.println("=======================================");
        //输出排序后的学生数组
        for (int i=0;i<students.length;i++){
            Student student = students[i];
            System.out.println(student.getName()+","+ student.getAge()+","+ student.getHeight());
        }
    }
}

2.3 特定类型方法的引用

特定类的名称::方法

使用场景：如果某个Lambda表达式里只调用一个特定类型的实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用

场景：有一个字符串数组，里面有一些人的名字，都是英文名字，请按照名字的英文首字母排序,忽略首字母大小

import java.util.Arrays;
import java.util.Comparator;

public class Demo3 {
    public static void main(String[] args) {
        //有一个字符串数组，里面有一些人的名字，都是英文名字，请按照名字的英文首字母排序,忽略首字母大小
        String[] names=new String[]{"Tom","lisi","angela","zhaoliu","Mike","Jack","Bob","Andy","caocao","Rose"};
//        Arrays.sort(names, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.compareToIgnoreCase(o2);
//            }
//        });
        //Arrays.sort(names, (o1,o2)->o1.compareToIgnoreCase(o2));
        Arrays.sort(names, String::compareToIgnoreCase);

        System.out.println(Arrays.toString(names));
    }
}

2.4 构造器引用

类名::new

使用场景：如果某个Lambda表达式里只是创建对象，并且“->”前后参数的形式一致，就可以使用构造器引用

package com.fqw.method1reference;

public class Demo4 {
    public static void main(String[] args) {
//        CarFactory cf=new CarFactory() {
//            @Override
//            public Car getCar(String name){
//                return new Car(name);
//            }
//        };
//        CarFactory cf=name ->  new Car(name);

        CarFactory cf=Car:: new ;
        Car c1=cf.getCar("奥迪");
        System.out.println(c1.getName());

    }
}

interface CarFactory{
    Car getCar(String name);
}

class Car{
    private String name;

    public Car() {
    }

    public Car(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
Java8新特性学习-函数式编程(Stream/Function/Optional/Consumer)
icarusliu的专栏
03-09 8万+
Java8新引入函数式编程方式，大大的提高了编码效率。本文将对涉及的对象等进行统一的学习及记录。 首先需要清楚一个概念：函数式接口；它指的是有且只有一个未实现的方法的接口，一般通过FunctionalInterface这个注解来表明某个接口是一个函数式接口。函数式接口是Java支持函数式编程的基础。 本文目录： 1 Java8函数式编程语法入门 2 Java函数式接口 2.1 Consu...
Java 函数式编程
09-12 772
/ 计算当前时间//调用get()方法，此时会调用对象的构造方法，即获得到真正对象!!!!
【Java函数式编程-58.2】深入理解Java中的Function函数式接口
weixin_39033358的博客
05-02 1036
是Java 8中引入的一个函数式接口，位于包中。// 默认方法省略...T：输入参数类型R：返回结果类型Function接口为Java带来了强大的函数组合和转换能力，使得代码更加简洁、灵活和可维护。通过熟练掌握Function及其相关接口，您可以编写出更具表现力的Java代码。记住，函数式编程不是要完全替代面向对象编程，而是为我们提供了另一种解决问题的工具和视角。在实际开发中，合理使用Function减少样板代码提高代码的可读性和可维护性实现更灵活的代码结构。
JavaSE——函数编程
最新发布
weixin_69032308的博客
06-28 138
Lambda是JDK8中的一个语法糖。他可以对某些匿名内部类的写法进行简化。让我们不用关注什么是对象，而是更关注我们对数据进行了什么操作。
Java基础(4)-Java8函数式编程
BoringError的博客
01-05 1938
文章目录一、Lambda表达式1.1、用Lambda表达式代替匿名内部类1.2、Lambda表达式的参数类型判断二、Stream API2.1、Stream API 和 Lambda Expression实现遍历的Demo2.2、Stream常用方法2.2.1、 of(T... values)2.2.2、filter(Predicate&amp;amp;amp;amp;amp;amp;amp;amp;lt;? super T&amp;amp;amp;amp;amp;amp;amp;amp;g
Java函数式编程
GM_115的博客
03-28 819
Java 8是Java语言发展史上的一个重要里程碑，它引入了函数式编程范式，极大地丰富了Java的表达能力。下面我将从核心概念到实际应用全面介绍Java 8的函数式编程特性。
一文带你入门 Java 函数式编程
Huangjiazhen711的博客
11-09 1076
本文从函数式编程思想、原则到 Java 对函数式编程的实现，给大家梳理了一遍，建议大家重点理解 Java 的函数式接口，为什么 Lambda 表达式对函数式接口的实现，以及 Java 内置提供的覆盖了大多数函数式编程应用场景的函数式接口。至此用 Java 编程那些绕不开的接口这个子系列的文章已经更新完毕，感兴趣的请持续关注，后面还有更多实用、精彩的内容。
Java如何支持函数式编程？
阿里云开发者
09-22 3735
简介：Java是面向对象的语言，无法直接调用一个函数。Java 8开始，引入了函数式编程接口与Lambda表达式，便于开发者写出更少更优雅的代码。什么是函数式编程？函数式编程的特点是什么？本文通过代码实例，从Stream类、Lambda表达式和函数接口这三个语法概念来分享Java对函数式编程的支持。背景在很长的一段时间里，Java一直是面向对象的语言，一切皆对象，如果想要调用一个函数，函数必须属于一个类或对象，然后在使用类或对象进行调用。但是在其它的编程语言中，如JS、C++，我们可以直接写一个函数，然后在
java8stream源码-java8:Java8——函数式编程
06-04
函数式编程 介绍 该存储库包含例如 Java 8 In Action 和 Java 8 Lambdas Pragmatic Functional Programming 一书中的源代码。 同时自己也做了一些扩展使用，修复了源码中的bug。 例如 Java 8 In Action 中的源代码...
java8函数式编程（csdn）————程序.pdf
12-01
Java 8 函数式编程 Java 8 函数式编程是指在 Java 8 中引入的一种新的编程范式，它强加了额外的约束，即所有数据必须是不可变的，设置一次，永不改变。函数式编程将值传递给函数，该函数然后生成新值但从不修改...
Java 中的函数式编程.zip
11-24
Functional Java 还可以作为学习函数式编程概念的平台，通过使用熟悉的语言来介绍这些概念。该库旨在用于生产应用程序，并使用 ScalaCheck 和 Functional Java 的 quickcheck 模块的基于自动化规范的测试技术进行了...
【Java】—— 函数式编程：Lambda表达式、方法引用
张修宇的博客
11-10 832
JDK 8开始新增的一种语法形式，可以替代匿名内部类对象，让程序更简洁。注意：只能替代函数式接口（有且仅有一个抽象方法的接口）的匿名内部类！！
Java开发『函数式编程』——函数式接口
成都汇智动力的博客
09-03 336
提到函数式编程我们首先需要了解的就是函数式接口，我们之前讲解的Lambda 表达式的主要服务对象就是函数式接口了。 所以这章我们就来认识下函数式接口： 函数式接口的定义 在java中函数式接口（Functional Interface）指的是只能有一个抽象方法但是可以有多个非抽象方法的接口。 函数式接口上一般会有@FunctionalInterface 修饰，但是不是必须的。 @FunctionalInterface 主要是为了更好的让编译器检查当前接口是否是函数式接口。 例如：线程的Runnable接
JAVA函数式编程
北风的博客
08-04 1580
函数式编程
Java 中的函数式编程
DevCampsite的博客
09-27 2079
Java 中的函数式编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值