Java 8系列之Lamda的基本语法

Lamda的基本语法:

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

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

一、参数的引用

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

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. 第二种形式： (参数) -> {多行语句}

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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. 第三种形式： (参数) -> 表达式

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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

?

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

　　

二、方法的引用

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

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

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

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

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

 

1. 引用静态方法

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/**  * 实现方法引用的接口  * 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"));       }   }

　　普通方法

?

1 2 3 4

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

　　特定类的对象支持

?

1 2 3 4 5 6 7 8 9 10 11 12 13

@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"));     } }

　　引用构造方法：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

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