Java 8系列之Lamda的基本语法

Lamda的基本语法:

如果要理解Lamda表达式 ， 需要先理解匿名内部类

lamda的三种形式：
　　a. (参数) -> 单行语句
　　b. (参数) -> {单行语句}
　　c. (参数) -> 表达式

一、参数的引用

a. 第一种形式： (参数) -> 单行语句

interface IMessage{
    //a.单行语句：直接输出语句
    public void print(String str);
}

public class LamdaTest {

    public static void main(String[] args) {
        //以前的写法： 匿名内部类
//        fun(new IMessage() {
//            @Override
//            public void print() {
//                System.out.println("Hello");
//            }
//        });

        //Lamda表达式
        //a.单行语句：首先要定义此表达式里面需要接收的变量，单行语句直接输出
        fun((t) -> System.out.println(t));
    }

    public static void fun(IMessage message){
        message.print("Hello World");
    }

}

　

b. 第二种形式： (参数) -> {多行语句}

interface IMessage{
    //a.单行语句：直接输出语句
    public void print(String str);
}

public class LamdaTest {

    public static void main(String[] args) {
        //Lamda表达式
        //多行语句：
        fun((t) -> {
            t = t.toUpperCase(Locale.ROOT);
            System.out.println(t);
        });
    }

    public static void fun(IMessage message){
        message.print("Hello World");
    }
}

　　

c. 第三种形式： (参数) -> 表达式

interface IMessage{
    //a.单行语句：直接输出语句
    public int add(int x, int y);
}

public class LamdaTest {

    public static void main(String[] args) {
        //Lamda表达式
        fun((s1, s2) -> s1 + s2);
    }

    public static void fun(IMessage msg){
        System.out.println(msg.add(10, 20));
    }
}

如果现在只是一个表达式， 那么进行操作的返回， 还是不写return比较合适， 是多行的是才可以考虑写return

fun((s1, s2) -> {return s1 + s2;});

　　

二、方法的引用

方法引用在java8之中一共定义了四种形式：

 •  引用静态方法： 类名称 :: static 方法名称

 •  引用某个对象的方法： 实例化对象 :: 普通方法

 •  引用特定类型的方法：特定类 :: 普通方法

 •  引用构造方法：类名称 :: new

 

1. 引用静态方法

/**
 * 实现方法引用的接口
 * param: P -- 引用方法的参数类型
 * param: R -- 引用方法的返回类型
 */
interface IMessage<P, R>{
   public R zhuanhuan(P p);
}

public class LamdaTest {

    public static void main(String[] args) {
        //即：将String.valueOf()方法变为了IMessage接口里的zhuanhuan()方法
        IMessage<Integer, String> msg = String::valueOf;
        String str = msg.zhuanhuan(1000);
        System.out.println(str.replaceAll("0", "9"));

    }

}

　　普通方法

@FunctionalInterface   //此为函数式接口， 接口里面只能够定义一个方法
interface IDemo<P, R>{
    public R zhuanhuan(P p);
}

　　特定类的对象支持

@FunctionalInterface   //此为函数式接口， 接口里面只能够定义一个方法
interface IDemo<P>{
    public int compare(P p1, P p2);
}

public class LamdaMethodTest {

    public static void main(String[] args) {
        //即：将String.valueOf()方法变为了IMessage接口里的zhuanhuan()方法
        IDemo<String> msg = String::compareTo;
        System.out.println(msg.compare("A", "B"));
    }
}

　　引用构造方法：

@FunctionalInterface   //此为函数式接口， 接口里面只能够定义一个方法
interface IDemo<C>{
    public C creat(String t, double p);
}

class Book{
    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "title='" + title + '\'' +
                ", price=" + price +
                '}';
    }
}
public class LamdaMethodTest {

    public static void main(String[] args) {
        IDemo<Book> msg = Book::new; //引用构造方法
　　　　　//调用的虽然是create(), 但是这个方法引用的是Book类的构造
        Book book = msg.creat("Java开发", 20.2);
        System.out.println(book);
    }
}