Java 函数式编程 &Lambda表达式

悠悠 2021-11-22 08:34 425阅读 0赞

## 什么是函数式编程？ ##

类似于数学的函数，只在乎结果，不在乎形式  
**函数式编程的核心是：**  
关注做什么，而不是怎么做  
JDK 1.8 有个一个新的用法，就是lanmbda表达式

## 为什么需要函数式编程？ ##

面向对象编程在乎对象，实现一个功能，首先找到一个对象，然后用这个对象的方法去解决问题，这样会产生很多的冗余代码，但是，有的时候，我们真的需要这个对象吗？不是的，有的时候，我们只是需要对象的方法，但是受限于 语法，我们不得不创建一个对象。所以通过函数式编程，可以解决这个问题。

## 函数式接口 ##

函数式接口，就是只有一个抽象方法的接口

@FunctionalInterface
    public interface MyFunction {
        public abstract void m1();
    }

@FunctionalInterface 是注解，可以没有如果没有，并不影响 编译，但是有时却不能完全确保是函数式接口，如果加上这个注解，如果不是函数式接口，就会编译错误。

## 接口 ##

接口中可以定义变量，但是定义的变量实际上就是常量因为必须有，public static final 进行修饰同时必须要赋一个初值，名字要是大写的

public static final int NUM_OF_MY = 10;

JDK 8 新增的方法：可以在接口中添加默认方法，来解决接口升级问题，这样原来实现这个接口的方法也不会出错(在接口中增加了新的方法之后)，默认方法会被实现这个接口的类继承

public default void method5(){
            
        }

## Lambda表达式 ##

案例（一）  
CookerClass类

public class CookeClass{
        public static void main(String[] args) {
            //原来的使用方法
            invokeCook(new Cook() {
                @Override
                public void makeFood() {
                    System.out.println("eat the breakfast");
                }
            });
            //lambda表达式的使用方法
            invokeCook(()->{
                System.out.println("eat the breakfast 2 ");
            });
            //对其进一步优化
            invokeCook(()-> System.out.println("eat the breakfast 2"));
        }
        public static void invokeCook(Cook cook){
            cook.makeFood();
        }
    }

Cook接口

public interface Cook {
        public abstract  void makeFood();
    }

Lambda表达式可以进行省略：

*  1） 参数列表：括号中参数列表的数据类型
 *  2）参数列表中的参数只有一个，那么参数类型和（）都可以省略
 *  3）如果\{\} 函数体中的代码只有一行，无论是否有返回值，都可以省略 \{\}，return 和分号
 *  注意 3） 中的必须一起省略才可以

案例（二）

public class Lambda_shenglue {
        public static void main(String[] args) {
            //最初的线程创建
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            }).start();
    
            //使用Lambda表达式之后
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
            }).start();
    
            //对其进行进一步的优化
            new Thread(()-> System.out.println(Thread.currentThread().getName())).start();
        }
    }

案例（三）  
MyCalculator类

public class MyCalculator {
        public static void main(String[] args) {
            //原来的书写方式
            invokeCalc(10, 10, new Calculator() {
                @Override
                public int calc(int a, int b) {
                    return a+b;
                }
            });
            //lambda表达式的方式
            invokeCalc(100,100,(int a,int b)->{
                return a+b;
            });
            //对其进一步优化
            invokeCalc(100,100,(a,b)->a+b);
        }
        public static void invokeCalc(int a,int b, Calculator c){
            int sum = c.calc(a,b);
            System.out.println(sum);
        }
    }

Calculator接口

public interface Calculator {
        public abstract int calc(int a,int b);
    }

案例（四）  
Person类

public class Person {
        private String name;
        private int age;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        @Override
        public String  toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

SortPerson类

import java.util.Arrays;
    import java.util.Comparator;
    public class SortPerson {
        public static void main(String[] args) {
            Person[] arr= {
                new Person("haha",12),
                new Person("hdgs",15),
                new Person("hjef",20),
            };
            //原来的书写方式
            Arrays.sort(arr, new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return o1.getAge()-o2.getAge();
                }
            });
            for(Person p : arr){
                System.out.println(p    );
            }
            //Lambda表达式
            Arrays.sort(arr,(Person o1,Person o2)->{
                return o1.getAge()-o2.getAge();
            });
            for(Person p :arr){
                System.out.println("er:"+p);
            }
            //对其进一步优化
            Arrays.sort(arr,(o1,o2)->o1.getAge()-o2.getAge());
            for(Person p : arr){
                System.out.println("san:"+p);
            }
        }
    }