Lambda表达式

最新推荐文章于 2022-04-26 16:07:56 发布

哦?

最新推荐文章于 2022-04-26 16:07:56 发布

阅读量271

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_44241861/article/details/108348672

版权

Java基础专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章目录

Lambda的简写
方法引用与构造引用

Lambda表达式，是匿名内部类的一种简写形式。
Lambda表达式的语法特点
1.Lambda表达式 引入了一个箭头符号 ->
2.箭头符号 -> 把Lambda表达式分成左右两部分
3.左边：写这个接口中的抽象方法的形参列表。
4.右边：你对这个接口中的抽象方法的具体的重写逻辑

定义一个接口如下：

package demo8;

public interface MyInterface {
    public abstract void show();
}

测试类如下：

package demo8;

public class Mytest {
    public static void main(String[] args) {
        new MyInterface() {
            @Override
            public void show() {
                System.out.println("show");
            }
        };

        //lambda形式：
        MyInterface MyInterface = () -> {
            System.out.println("show");
        };
    }
}

Lambda的简写

接口如下：

package demo9;

public interface MyInterface {
    public int   test(String name,int age);
}

测试类如下：

package demo9;

public class Mytest {
    public static void main(String[] args) {
        //lambda形式：
        //第一步简写
        MyInterface myInterface = (String name,int age) -> {
            return 10;
        };

        //第二步简写 形参的数据类型也可以省略不写
        MyInterface myInterface1=(name,age)->{return 10;};

        //第三次简写：如果你对接口中的抽象方法的具体实现逻辑，只有一行代码，可以省略return关键字和{}
        MyInterface myInterface2=(name,age)->10;
    }
}

函数式函数式接口：接口中只有一个抽象方法

一个函数式接口如下：

package demo10;
//可以检测这个接口是不是个函数式接口
@FunctionalInterface
public interface MyInterface {
    public abstract int show(int a);
}

测试类如下：

package demo10;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.function.Consumer;

public class Mytest {
    public static void main(String[] args) {
        //当接口中只有一个抽象方法，才能使用Lambda表达式来简写。
        //Lambda表达式之支持函数式接口：接口中只有一个抽象方法
        // @FunctionalInterface 这个注解可以检测这个接口是不是个函数式接口
       MyInterface myInterface=a-> a+100;


        Integer[] arr={20,30,2,3};
        //此处的比较器可以使用Lambda作为参数传递
        Arrays.sort(arr,(a,b)->a-b);
        System.out.println(arr);

        Consumer<Integer> consumer=integer -> System.out.println(integer);
    }
}

Lambda表达式，是匿名内部类的一种简写形式。
Lambda表达式的语法特点
1.Lambda表达式引入了一个箭头符号 ->
2.箭头符号 -> 把Lambda表达式分成左右两部分
3.左边：写这个接口中的抽象方法的形参列表。
4.右边：你对这个接口中的抽象方法的具体的重写逻辑
定义一个接口如下：

package demo8;

public interface MyInterface {
public abstract void show();
}

测试类如下：

package demo8;

public class Mytest {
public static void main(String[] args) {
new MyInterface() {
@Override
public void show() {
System.out.println(“show”);
}
};

    //lambda形式：
    MyInterface MyInterface = () -> {
        System.out.println("show");
    };
}

}
Lambda的简写
接口如下：

package demo9;

public interface MyInterface {
public int test(String name,int age);
}
测试类如下：

package demo9;

public class Mytest {
public static void main(String[] args) {
//lambda形式：
//第一步简写
MyInterface myInterface = (String name,int age) -> {
return 10;
};

    //第二步简写 形参的数据类型也可以省略不写
    MyInterface myInterface1=(name,age)->{return 10;};

    //第三次简写：如果你对接口中的抽象方法的具体实现逻辑，只有一行代码，可以省略return关键字和{}
    MyInterface myInterface2=(name,age)->10;
}

}
函数式函数式接口：接口中只有一个抽象方法

一个函数式接口如下：

package demo10;
//可以检测这个接口是不是个函数式接口
@FunctionalInterface
public interface MyInterface {
public abstract int show(int a);
}
测试类如下：

package demo10;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.function.Consumer;

public class Mytest {
public static void main(String[] args) {
//当接口中只有一个抽象方法，才能使用Lambda表达式来简写。
//Lambda表达式之支持函数式接口：接口中只有一个抽象方法
// @FunctionalInterface 这个注解可以检测这个接口是不是个函数式接口
MyInterface myInterface=a-> a+100;

    Integer[] arr={20,30,2,3};
    //此处的比较器可以使用Lambda作为参数传递
    Arrays.sort(arr,(a,b)->a-b);
    System.out.println(arr);

    Consumer<Integer> consumer=integer -> System.out.println(integer);
}

}

Markdown 1487 字数 124 行数当前行 1, 当前列 0 HTML 1420 字数 74 段落

方法引用与构造引用

你要看你对接口中这个抽象方法的重写逻辑
Consumer接口中这个抽象方法 accept(String s) 返回值是void 参数只有一个参数
我们对这个accept(String s)这个方法的重写逻辑 System.out.println(s);
对象.println(s) 这个println(s)方法的返回值是void 方法的参数也是一个，正好跟我们重写的accept(String s)
的返回值类型和参数列表能对应上，那么我就可以使用方法引用，来简写。

public class test {
    public static void main(String[] args) {
        Consumer<String> consumer = new Consumer<>() {
            @Override
            public void accept(String s) {
                //一个对象 调用的返回为void的只需要一个String类型参数的方法，与accept方法需求一致，可以使用方法引用简化。
                PrintStream out = System.out;
                out.println(s);
            }
        };

        //简化一：
        Consumer<String> consumer1 =s->System.out.println(s);
        //方法引用  对象::方法
        Consumer<String> consumer2 =System.out::println;

        System.out.println("=============================");

        BinaryOperator<Double> binaryOperator = new BinaryOperator<>() {
            @Override
            public Double apply(Double aDouble, Double aDouble2) {
                double max = Math.max(aDouble, aDouble2);
                return max;
            }
        };

        //简化一：
        BinaryOperator<Double> binaryOperator2 =(a,b)->Math.max(a,b);
        //方法引用
        BinaryOperator<Double> binaryOperator3 =Math::max;

        System.out.println("=======================");
        Supplier<Double> supplier = new Supplier<>() {
            @Override //get()方法 没有参数、返回Double类型
            public Double get() {
                Random random = new Random();
                double v = random.nextDouble();
                return v;

            }
        };

        //简化一
        Supplier<Double> supplier1 = ()->new Random().nextDouble();
        //构造引用
        Supplier<Double> supplier2 =new Random()::nextDouble;
        System.out.println("===================================");

        Predicate<String> stringPredicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                boolean b = new String("abc").startsWith(s);
                return b;
            }
        };
        //简化一：
        Predicate<String> stringPredicate1 =(s)-> new String("abc").startsWith(s);

        //构造引用
        Predicate<String> stringPredicate2 =new String("abc")::startsWith;

        System.out.println("==================================");
        //传入的两个参数，一个作为了调用者，一个作为了传入者，也可以使用方法引用进行简写。
        Comparator<String> comparator = new Comparator<>() {
            @Override
            public int compare(String o1, String o2) {
                //传入的两个参数，一个作为了调用者，一个作为了传入者，也可以使用方法引用进行简写。
                int i = o1.compareTo(o2);
                return i;
            }
        };

        //简化一：
        Comparator<String> comparator1 = (a,b)->a.compareTo(b);
        //方法引用
        Comparator<String> comparator2 = String::compareTo;

    }
}