java8新特性之 Lambda表达式（一）

在学习Lambad表达式前有必要学习一下匿名内部类的使用，因为可以将lambda理解为匿名内部类方式的一种升级

/**
 * 优化方式二
 * 匿名内部类
 *
 */
@Test
public void test1() {
    test02( userList, new FilterUser <Use>( ) {
        @Override
        public Boolean checkUser(Use o) {
            //想要过滤那个属性就在这里直接判断，不需要再去实现多个接口
            return o.getId()>5?true:false;
        }
    } );
}

以上就是匿名内部类方式，可以直接判断需要过滤的属性，对于java8之前这是最优的写法，但是在java8之后。上面的写法中其实有效代码只有一行。于是Lambda的写法产生了如下

/**
 * 优化方式三
 * Lambda表达式
 */
public void test2() {
    test02( userList,(u) -> u.getId()>5?true:false );
}

lambda基础语法：

package com.example.jedis.test.test2;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * ***GOOD LUCK****
 *
 * @Author : Wukn
 * @Date : 2018/6/28
 *
 * Lambda表达式基础语法
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class LambadDemo {

    /**
     * 首先Lambda表示其实是在匿名内部类中进行升级的其实就是匿名方法的实现，所以在->中，左侧和右侧就是参数和执行体
     * jaba8中引用新的操作符。成为箭头操作符->
     * 箭头操作符将Lambda表达式拆成两个部分
     * 左侧：Lambda 表达式的参数列表   就是方法的传入数据
     * 右侧：Lambda 表达式的功能体
     *
     *
     * 语法格式一：无参数，无返回值
     * () -> System.out.println("wwwwwww");
     *
     *  语法格式二：有一个参数，无返回值
     *  Consumer<String> consumer = o -> System.out.println(o);
     *
     *
     * 语法格式三：有一个参数，小括号可以不写
     * Consumer<String> consumer = o -> System.out.println(o);


       语法格式四：有两个参数，有返回值，Lambda有多条语句,用{}
           Comparator<Integer> con = (x,y) -> {
                System.out.println("Sss");
                return Integer.compare( x,y );
         };
     *
     * 语法格式五： Lambda有一条语句  大括号和return都可以不写
     *  Comparator<Integer> con = (x,y) -> Integer.compare( x,y );
     *
     */
    @Test
    public void test01() {
       Runnable r1 = new Runnable( ) {
           @Override
           public void run() {
               System.out.println("ss");
           }
       };
       r1.run();

       Runnable r2 = () -> System.out.println("dds");
       r2.run();

    }


    @Test
    public void test02() {
        Consumer<String> consumer = o -> System.out.println(o);
        consumer.accept( "sd" );
    }


    @Test
    public void test03() {
        Consumer<String> consumer = (o) -> System.out.println(o);
        consumer.accept( "sd" );
    }


    /**
     * 语法格式四：有两个参数，有返回值，Lambda有多条语句,要使用{},且要return返回
     *
     * 在有参数时，可以不用指定参数的类型，因为java虚拟机可以进行类型判断，通过上下文进行类型推断
     */
    @Test
    public void test04() {
        Comparator<Integer> con = (x,y) -> {
            System.out.println("Sss");
            return Integer.compare( x,y );
        };
    }


    /**
     * 语法格式五： Lambda有一条语句  大括号和return都可以不写
     */
    public void test05() {
        Comparator<Integer> con = (x,y) -> Integer.compare( x,y );
    }


    /**
     * 二
     *
     * Lambda表达式需要“函数式接口”的支持
     * 函数式接口： 接口中只有一个抽象方法的接口，可以使用注解@FunctionalInterface修改
     * 可以检查接口是否是函数式接口。
     */

实习内容：

1：建立一个接口

package com.example.jedis.test.test2;

/**
 * ***GOOD LUCK****
 *
 * @Author : Wukn
 * @Date : 2018/6/
 */
@FunctionalInterface
public interface SchoolServer<T>{

    public Integer filter(Integer t);
}

2：

实现一

@Test
public void test6() {
    Integer n = gtf( 100,(x) -> x+8 );

}


public Integer gtf(Integer i,SchoolServer schoolServer) {
    return schoolServer.filter( i );
}

实现二

@Test
public void test7() {
    //自定义实现语句
    SchoolServer schoolServer = (x) -> x+9;
    //执行
    Integer s = schoolServer.filter( 10 );
    System.out.println(s);


}

上面两种实现方式结果都一样。

总结：

1：Lambda 表达式其实就是匿名内部类的升级

2：Lambda需要函数式接口的支持。所谓函数式接口其实就是只有一个方法的接口

3：Lambda表达式新增的-> 箭头左边是是参数，右边是需要执行的语句，也就是接口方法的实现内容

a:左边参数如果没有参数，或者只有一个参数可以不用括号，右边执行体如果有多个需要{}

4：Lambda表达可以不需要指定属性类型，因为java8可以通过虚拟机进行上下文类型判断，

5：在java8之前。在匿名内部类使用局部变量是需要使用fianl修饰的变量，java8之后可以不用。因为底层已经增加。

java8新特性之 Lambda表达式（一）

猜你喜欢