Java:Lamda 表达式

例子01

package com.cnblogs.wanson;

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"\t:\t"+Thread.currentThread().getId() +
                "\t新的线程创建了");
        System.out.println("What I saw make me very sad");
    }
}

多线程演化过程

package com.cnblogs.wanson;

/**
 * 使用实现Runnable接口的方式实现多线程程序
 */
public class Driver {
    public static void main(String[] args) {
        //第一版 /原生版
//        创建Runnable接口的实现类对象
        RunnableImpl runnable = new RunnableImpl();
//        创建Thread类对象，构造方法中传递Runnable接口的实现类
        Thread thread = new Thread(runnable);
//        调用start方法开启新线程，执行run方法
        thread.start();

        // 进化第2版

//        简化代码，使用匿名内部类，实现多线程程序
        Runnable runnable1 = new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "\t:\t"+Thread.currentThread().getId() +
                        "\t新的线程创建了");
                System.out.println("there is no choice but to learn");
            }
        };

        new Thread(runnable1).start();


        // 进化第3版
        new Thread(
                new Runnable() {

                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + "\t:\t"+Thread.currentThread().getId() +
                                "\t新的线程创建了");
                        System.out.println("good good study,day day up");
                    }
                }
        ).start();

        // 进化第4版   使用lamda表达式，实现多线程

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t:\t"+Thread.currentThread().getId() +
                    "\t新的线程创建了");
            System.out.println("nothing is equal to knowledge");
        }
        ).start();
//        优化省略lamda
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "\t:\t"+Thread.currentThread().getId() +
                    "\t新的线程创建了")).start();

    }


}

例子02 排序

package com.cnblogs.wanson;

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

public class Driver {
    public static void main(String[] args) {
        String[] names = {"jim", "anna", "john", "wanson", "andrew"};
        for (String s : names) {
            System.out.print(s + "\t");
        }
//       进化第1版
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });
        System.out.println();
        for (String s : names) {
            System.out.print(s + "\t");
        }
//********************************************************
        //       进化第2版
        Arrays.sort(names, (String a, String b) -> {
            return b.compareTo(a);
        });
        System.out.println();
        for (String s : names) {
            System.out.print(s + "\t");
        }


//********************************************************
        //       进化第3版
        Arrays.sort(names, (String a, String b) -> b.compareTo(a));
        System.out.println();
        for (String s : names) {
            System.out.print(s + "\t");
        }


    }

}

lambda 玩法的套路

/**

• Lambda表达式的标准格式：
• 由三部分组成：
• a.一些参数
• b.一个箭头
• c.一段代码
• 格式：
• （参数列表）->{一些重写方法的代码};
• 解释说明格式：
• ()：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用超号分隔
• ->：传递的意思，把参数传递给方法体{}
• {}：重写接口的抽象方法的方法体
  */

例子03 做饭-吃饭 没有参数 没有返回值

package com.cnblogs.wanson;

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


package com.cnblogs.wanson;

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

/**
 * Lambda表达式的标准格式：
 * 由三部分组成：
 * a.一些参数
 * b.一个箭头
 * c.一段代码
 *
 *
 * 格式：
 * （参数列表）->{一些重写方法的代码};
 *
 * 解释说明格式：
 * ()：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用超号分隔
 *
 * ->：传递的意思，把参数传递给方法体{}
 *
 * {}：重写接口的抽象方法的方法体
 */

public class Driver {
    public static void main(String[] args) {
        // 演化第1代
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了，小猪们");
            }
        });

        // 演化第2代
        invokeCook(()->{
            System.out.println("吃饭了，小狗崽们");
        });
    }

//    定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }




}

例子04 有参返回值 身份证信息 按照年龄排序

package com.cnblogs.wanson;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}



package com.cnblogs.wanson;

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

/**
 * Lambda表达式的标准格式：
 * 由三部分组成：
 * a.一些参数
 * b.一个箭头
 * c.一段代码
 *
 *
 * 格式：
 * （参数列表）->{一些重写方法的代码};
 *
 * 解释说明格式：
 * ()：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用超号分隔
 *
 * ->：传递的意思，把参数传递给方法体{}
 *
 * {}：重写接口的抽象方法的方法体
 */

public class Driver {
    public static void main(String[] args) {
        Person[] person={
          new Person("wanson",16),
          new Person("jim",12),
          new Person("lily",18),
          new Person("andrew",10)
        };

        for (Person people : person) {
            System.out.println(people);
        }
        //年龄升序
        Arrays.sort(person, new Comparator<Person>() {
            @Override
            public int compare(Person x, Person y) {
                return x.getAge()-y.getAge();
            }
        });
        System.out.println();
        for (Person people : person) {
            System.out.println(people);
        }

        // 利用lambda 手段

        Arrays.sort(person, (Person x, Person y)-> {
                return x.getAge()-y.getAge();
        });

        System.out.println();
        for (Person people : person) {
            System.out.println(people);
        }



    }
}

例子05 两个数相加

package com.cnblogs.wanson;

public interface Calculator {
    public  abstract int compute(int x,int y);
}


package com.cnblogs.wanson;

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

/**
 * Lambda表达式的标准格式：
 * 由三部分组成：
 * a.一些参数
 * b.一个箭头
 * c.一段代码
 *
 *
 * 格式：
 * （参数列表）->{一些重写方法的代码};
 *
 * 解释说明格式：
 * ()：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用超号分隔
 *
 * ->：传递的意思，把参数传递给方法体{}
 *
 * {}：重写接口的抽象方法的方法体
 */

public class Driver {
    public static void main(String[] args) {
        invokeCompute(44, 55, new Calculator() {
            @Override
            public int compute(int x, int y) {
                return x+y;
            }
        });

        invokeCompute(30,45,(int x, int y)->{
            return x+y;
        });

    }

    private static void invokeCompute(int a,int b,Calculator calculator){
        System.out.println("两个数和结果为:\t"+calculator.compute(a,b));
    }
}

lambda 省略前提条件

/**
 * Lambda表达式：是可推导，可以省略
 * 凡是根据上下文推导出来的内容，都可以省略书写
 * 可以省略的内容：
 * 1.（参数列表）：括号中参数列表的数据类型，可以省略不写
 *
 * 2.（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
 *
 * 3.{一些代码}：如果{}中的代码只有一行，无论是否有返回值，都可以省略({}，return，分号)
 *          注意：要省略{}，return，分号 必须一起省略
 */

大结局 使用lambda 前提

* Lambda的语法非常简洁，完全没有面向对象复杂的约束。但是使用时有几个问题需要特别注意：

* 1.使用Lambda必须具有接口，且要求接口中 有且仅有一个抽象方法。

* 无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。

* 2.使用Lambda必须具有"上下文推断"。

* 也就是方法的参数或局部变量类型必须为Lambda对应的接口类塑，才能使用Lambda作为该接口的实例。

* 备注：有且仅有 一个抽象方法的 接口，称为函数式接口。