lambda表达式教程

lambda表达式应用场景于任何有函数式接口的地方

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

函数式接口

Supplier	代表一个输出
Consumer	代表一个输入
BiConsumer	代表两个输入
Function	代表一个输入，代表一个输出（一般输入和输出是不同类型）
UnaryOperator	代表一个输入，代表一个输出（输入和输出是相同类型）
BiFunction	代表两个输入，代表一个输出（一般输入和输出是不同类型）
BinaryOperator	代表两个输入，代表一个输出（一般输入和输出是相同类型）

1、lambda表达式 demo1

package Io.com.lian.lambda.demo1;

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

        //内部类方式
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("lambda");
            }
        });
        thread.start();

        //lmbda方式
        new Thread(()->{
            System.out.println("lambda2");
        }).start();
    }
}

demo2

package Io.com.lian.lambda.demo1;

import java.util.*;

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

        List list = Arrays.asList("zhangsan", "lisi", "wangwu");

//        //内部类方式
//        Collections.sort(list, new Comparator() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        });

        //lambda方式
        Collections.sort(list,(o1,o2)->{return o1.length()-o2.length();});

        for (String s : list) {
            System.out.println(s);
        }

        //方法引用替代lambda
        Collections.sort(list, Comparator.comparingInt(String::length));
        for (String s : list) {
            System.out.println(s);
        }

    }
}

2、表达式案例

()->{}
()->{System.out.println(1)}
()->System.out.println(1)
()->{return 100;}
()->100
()->null
(int x)->(return x+1;)
(int x)->x+1
(x)->x+1
x->x+1

3、方法的引用自定义函数式接口

public class Person {

}

@FunctionalInterface
public interface PersonInterface {

    void insert(Person person);

}

实例演示

package Io.com.lian.lambda;

import java.io.Console;
import java.util.concurrent.Callable;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;


public class LambdaDemo {
    public static void main(String[] args) throws Exception {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("run1...");
            }
        };
        runnable.run();

        //lambda方式
        Runnable runnable2 = () -> {
            System.out.println("run2...");
        };
        runnable2.run();

        //当只有一条语句时可省略大括号
        Runnable runnable3 = () -> System.out.println("run3...");
        runnable3.run();

        //callable
        Callable callable4 = new Callable() {
            @Override
            public String call() throws Exception {
                return "run4...";
            }
        };
        System.out.println(callable4.call());

        //采用lambda
        //callable方法里没有参数
        //Callable callable5 = () -> "run5...";
        //带大括号就需要用return
        Callable callable5 = () -> {
            return "run5...";
        };
        System.out.println(callable5.call());

        //自定义函数式接口
        PersonInterface p = new PersonInterface() {
            @Override
            public void insert(Person person) {
                System.out.println("学生1");
            }
        };

        PersonInterface p2 = (person) -> System.out.println("学生1");
        PersonInterface p3 = (Person person) -> System.out.println("学生1");

        p.insert(new Person());
        p2.insert(new Person());
        p3.insert(new Person());

        
        Function f1 = new Function() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        System.out.println(f1.apply("abcdef"));

        Function f2 = s -> s.length();
        //Function f3 = s -> 1;  正确
        //Function f4 = s -> a;  错误

        System.out.println(f1.apply("abcdef"));
        System.out.println(f2.apply("abcd"));

        
        Supplier s = () -> 1;
        System.out.println(s.get());

        Supplier s2 = () -> {
            return "pi";
        };
        System.out.println(s2.get());


        
        Consumer c = (a) -> {
            System.out.println(a.length());
        };
        c.accept("abcd");

        Consumer c2 = (b) -> System.out.println(b);
        c2.accept("beijing");

        //---------------------调用新建方法-----------------------
        Runnable r1 = () -> {
            int i = get();
            System.out.println(i);
        };
        r1.run();

        //Runnable r2 = () -> exec(); 错误

        //自定义接口
        Lamdemo l = ()->get();
        l.get();

        //biFuction
        BiFunction bi = (a,b)->{
            return a.length() + b.length();
        };
        System.out.println(bi.apply("pi", "dan"));


    }

    //新建几个方法，lambda调用方法
    static int get() {
        return 1;
    }

    static String find() {
        return "find";
    }

    static void exec() {
        find();
    }

}

4、方法引用分类

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

传统方式

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

        //function
        Function f = (s)->s.length();
        System.out.println(f.apply("pidan"));

        //consumer
        Consumer c = (a)-> System.out.println(a);
        c.accept("dan");

    }
}

静态方法引用

package Io.com.lian.lambda;

import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class Demo2 {

    static String put() {
        System.out.println("put");
        return "put";
    }

    static void getSize(int size) {
        System.out.println(size);
    }

    static String upperCase(String str) {
        return str.toUpperCase();
    }

    static Integer sum(String a,String b){
        return a.length()+b.length();
    }

    public static void main(String[] args) {
        //传统调用方式
        //System.out.println(put());

        //put方法没有参数，只有返回值，可以用Supplier
        Supplier s = () -> put();
        System.out.println(s.get());

        //方法引用格式，类名::方法名，用方法引用替代lambda
        Supplier f = Demo2::put;
        System.out.println(f.get());

        //调用内部类，haha方法没参数有返回值，可以用Supplier
        //lambda方式
        Supplier b = () -> Fun.haha();
        System.out.println(b.get());

        //引用方法方式，替代lambda方式
        Supplier d = Fun::haha;
        System.out.println(d.get());

        Consumer c = (arg) -> getSize(arg);
        c.accept(2);

        Consumer cc = Demo2::getSize;
        cc.accept(22);

        //演示function，一个参数，一个返回值
        Function f1 = (str) -> upperCase(str);
        System.out.println(f1.apply("pipi"));

        //方法引用 替代 lambda
        Function f2 = Demo2::upperCase;
        System.out.println(f2.apply("dandan"));

        //biFunction
        BiFunction bi = (a, e) -> {
            return a.length() + e.length();
        };
        System.out.println(bi.apply("pi", "dan"));

        //方法引用 替代 lambda
        BiFunction bi2 = (a, e) -> a.length() + e.length();
        System.out.println(bi2.apply("da", "ai"));

        //方法引用 + 调用方法
        BiFunction bi3 = Demo2::sum;
        System.out.println(bi3.apply("ai", "y"));

    }
}

//内部类
class Fun {
    public static String haha() {
        return "haha";
    }
}

实例方法引用

package Io.com.lian.lambda;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class Demo3 {

    public String put(){
        return "put";
    }

    public void getSize(int size){
        System.out.println("size: "+size);
    }

    public String upperCase(String s){
        return s.toUpperCase();
    }

    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        System.out.println(demo3.put());

        //lambda
        Supplier s = ()->new Demo3().put();
        System.out.println(s.get());

        Supplier s2 = ()->{ return new Demo3().put();};
        System.out.println(s2.get());

        //方法引用
        Supplier s3 = new Demo3()::put;
        System.out.println(s3.get());

        //getSize方法只有一个参数，没有返回值，适合用Consumer
        Consumer c = (a)->new Demo3().getSize(a);
        c.accept(5);

        Consumer c2 = new Demo3()::getSize;
        c2.accept(3);

        //upperCase方法有 一个参数，一个返回值，适合用function
        Function f = (arg)->new Demo3().upperCase(arg);
        System.out.println(f.apply("pi"));

        Function f2 = new Demo3()::upperCase;
        System.out.println(f2.apply("dan"));

        Function f3 = (str)->str.toUpperCase();
        System.out.println(f3.apply("ai"));
        
    }
}

对象方法引用

package Io.com.lian.lambda;

import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;

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

        //lambda
        Consumer c = (too)->new Too().foo();
        c.accept(new Too());

        Consumer c2 = (Too too)->new Too2().foo();
        c2.accept(new Too());

        //方法引用
        Consumer c3 = Too::foo;
        c3.accept(new Too());

        //BiConsumer演示，代表两个输入
        BiConsumer bi = (too2, s) -> new Too2().show(s);
        bi.accept(new Too2(),"dan");

        BiConsumer bi2 = Too2::show;
        bi2.accept(new Too2(),"pi");

        BiFunction bi3 = (exec,s) -> new Exec().test(s);
        System.out.println(bi3.apply(new Exec(), "pi"));

        BiFunction bi4 = Exec::test;
        System.out.println(bi4.apply(new Exec(), "dan"));
        
    }
}

class Too{

    public Integer fun(String s){
        return 1;
    }

    public void foo(){
        System.out.println("foo");
    }

}

class Too2{

    public Integer fun(String s){
        return 1;
    }

    public void foo(){
        System.out.println("foo....2");
    }

    public void show(String str){
        System.out.println("show str: "+str);
    }

}

class Exec{
    public Integer test(String name){
        return 10;
    }
}

构造方法引用

package Io.com.lian.lambda;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

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

        //只要是对象，都可以用构造引用方法,supplier没有参数，只有返回值
        Supplier s3 = ArrayList::new;
        Supplier s4 = HashSet::new;
        Supplier s5 = Thread::new;
        Supplier s6 = String::new;

        //Consumer 有参数，没有返回值
        Consumer s = Amount::new;
        s.accept(1);
        Consumer s2 = (age) -> new Amount(age);
        s2.accept(2);

        //function
        Function f1 = (str)->new Amount(str);
        System.out.println(f1.apply("a"));

        //引用方法
        Function f2 = Amount::new;
        System.out.println(f2.apply("b"));

    }
}

class Amount{
    public Amount() {
    }

    public Amount(int age){
        System.out.println("age 无参");
    }

    public Amount(String name){
        System.out.println("name 有参");
    }
}

lambda表达式教程

Java相关栏目本月热门文章