javaSE：Lambda表达式；前端ES6箭头函数

目录

1、Lambda表达式概念

1.1、Lambda举例：

2、前端ES6箭头函数

1、Lambda表达式概念

/*
面向对象思想：做一件事情，找一个能解决这个事情的对象，来完成这个事情
函数式编程思想：只要能获取到结果就可以，谁去做的，怎么做的不关心。重视结果
JDK1.8之后允许使用Lambda表达式	可以把Lambda看做匿名内部类的语法糖，但实质还是不一样的，Lambda内存中少加载一个class文件，效率更高
Lambda表达式格式：a、一些参数
				b、一个箭头
				c、一段代码
				（参数列表） -> {一些重写方法的代码}
			解释：（）接口中抽象方法的参数列表，有就写，没有就空着，多个用逗号隔开
				-> 把参数传递给方法体
				{} 重写接口的方法体
	注意：1、Lambda必须具有接口，且要求接口有且只有一个【无论是Runnable，Comparator接口还是自定义接口】
		2、必须有上下文推断，也就是方法参数或局部变量类型必须是Lambda对应的接口类型。
	只有一个抽象方法的接口称为函数式接口


 */

1.1、Lambda举例：

 //例题
 public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"新线程创建了");
    }
}
public class lianxi_01 {
    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        Thread t=new Thread(r);
        t.start();
        //可以使用匿名内部类简化代码
        Runnable r1=new RunnableImpl(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        };
        new Thread(r1).start();
        //继续简化
        new Thread(new RunnableImpl(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        }).start();
    }
}
/*例题中，仍然有很多冗余代码；
编程思想转换：只关心结果：
    System.out.println(Thread.currentThread().getName()+"新线程创建了");
* Lambda表达式实现多线程创建:
*() -> sout("新线程创建了")
	前面的（）代表run（）方法的参数无，中间箭头代表将前面的参数传给后面的代码；后面的输出语句即业务逻辑代码
*  */
public class Demou_01 {
    public static void main(String[] args) {
        new Thread(() -> {
			System.out.println(Thread.currentThread().getName()+"新线程创建了"
		)};
        ).start();
    }
}
==
//Lambda无参无返回值练习
public interface Cook {
    //定义无参数无返回值的方法
    public abstract void makeFood();
}
public class DemoCook {
    public static void main(String[] args) {
        //调用invokeCook方法，参数是Cook接口，传递Cook接口的匿名内部类对象
        invokeCook(new Cook(){
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });
        //使用Lambda表达式
        invokeCook(()->{
            System.out.println("吃饭了");
        });
    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}
//Lambda有参有返回值练习
import java.util.Arrays;
import java.util.Comparator;

/*
* 需求：使用数组存储多个Person对象，对数组的Person对象使用Arrays的sort方法通过年龄升序排序
*
*  */
public class Demo01Arrays {
    public static void main(String[] args) {
        Person[] arr={//对象数组
          new Person("柳岩",18),
          new Person("禾苗",22),
          new Person("古力娜扎",20)
        };
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        //Lambda进行简化
        Arrays.sort(arr,(Person o1,Person o2)->{
            return o1.getAge()-o2.getAge();
        });
		
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}
//Lambda有参有返回值练习
/*
需求 给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值，
使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

 */
public interface Calculator {
    public abstract int calc(int a,int b);
}
public class Demou_01 {
    public static void main(String[] args) {
    //调用invokeCalc方法，方法参数是一个接口，可以调用匿名内部类[省去创建实现类]
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        //Lambda化简
        invokeCalc(120,130,(int a,int b)->{
            return a+b;
        });
    }
    //定义一个方法 参数传递两个int类型的整数，参数传递Calculator接口
    // 方法内部调用calc计算两个整数的和
    public static void invokeCalc(int a,int b,Calculator c){
        int sum=c.calc(a,b);
        System.out.println(sum);
    }
}
/* 使用Lambda作为参数
	练习1：创建线程
*/
public class Demo01Runnable {
    //定义一个方法startThread，方法参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        new Thread(run).start();
    }

    public static void main(String[] args) {
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"--> 线程启动");
            }
        });
        //因为Runnable接口是一个函数式接口，可以使用Lambda
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"--》 线程执行");
        });
        //优化
        startThread(()->
            System.out.println(Thread.currentThread().getName()+"--》 线程执行")
        );
    }
}
/*使用Lambda作为返回值 
	练习2：比较器
	java.util.Arrays
*	static <T> void sort(T[] a, Comparator<? super T> c) 	根据指定比较器产生的顺序对指定对象数组进行排序。
* */
import java.util.Arrays;
import java.util.Comparator;

public class Demo01Comparator {
    //定义一个方法，返回值为函数式接口Comparator
    public static Comparator<String> getComparator(){
        //优化前
        /*return new Comparable<String>() {
            @Override
            public int compareTo(String o1,String o2) {
                //降序排序
                return o2.length()-o1.length();
            }
        }*/
        //优化后
        /*return (String o1,String o2)->{
            //降序排序
            return o2.length()-o1.length();
        };*/
        return (o1, o2)->
            //降序排序
                o2.length()-o1.length();
    }

    public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr={"aaa","b","cccc","dd"};
        //打印排序前的数组
        System.out.println(Arrays.toString(arr));//[aaa, b, cccc, dd]
        //打印排序后数组
        Arrays.sort(arr,getComparator());
        System.out.println(Arrays.toString(arr));//[cccc, aaa, dd, b]
    }
}

2、前端ES6箭头函数

箭头函数半桶水，参考一下别人的帖子​​​​​​​