JDK1.8新特性之Lambda表达式学习

什么是Lambda?

Lambda是一个匿名函数,即一个没有函数名的函数(简化了匿名委托的使用,让你的代码更加简洁)

匿名委托就是匿名内部类

下面举两个例子:

 Thread thread = new Thread(new Runnable() {
            @Override  //这个就是一个匿名内部类
            public void run() {
                System.out.println("这是个Runable接口实例,用的是匿名内部类");
            }
        });
        thread.start();//使用了7行代码调用了这个内部类
        Thread thread2 = new Thread(()-> System.out.println("这是个Runable接口实例,用的是Lambda表达式"));
        thread2.start();
        //控制台结果:
        //这是个Runable接口实例,用的是匿名内部类
        //这是个Runable接口实例,用的是Lambda表达式
        //现在有一组set集合,添加字符串进行排序
        TreeSet treeSet = new TreeSet<>();//treeSet与普通set相比是根据首字母自动排序的
        treeSet.add("a");
        treeSet.add("dd");
        treeSet.add("ccc");
        treeSet.add("bbbb");
        System.out.println(treeSet);//输出结果为[a, bbbb, ccc, dd],此时是首字母排序

        //现在我们需要按照字符串长度进行排序
        TreeSet treeSet1 = new TreeSet<>(new Comparator() { //new Comparator为排序器
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(),o2.length());
            }
        });
        treeSet1.add("a");
        treeSet1.add("dd");
        treeSet1.add("ccc");
        treeSet1.add("bbbb");
        System.out.println(treeSet1);//输出结果为[a, dd, ccc, bbbb]

        //内部类又有很多,我们可以使用Lambda进行替换
        TreeSet treeSet2 = new TreeSet<>((a, b) -> Integer.compare(a.length(),b.length()));
        treeSet2.add("a");
        treeSet2.add("dd");
        treeSet2.add("ccc");
        treeSet2.add("bbbb");
        System.out.println(treeSet2);//输出结果仍然为[a, dd, ccc, bbbb]

 

我们发现Lambda表达式可以简化我们使用匿名内部类的使用,那么具体是如何使用呢?

package com.bruno_cheng.jdk;

import java.util.Comparator;

public class LambdaDemo2 {
    public static void main(String[] args) {
        //Lambda代码格式一:无参数,无返回值
        //()->System.out.println("规范一");
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是个匿名内部类");
            }
        };
        runnable = ()->System.out.println("这是个匿名内部类");


        //语法格式二:有一个参数,并且无返回值
        //(x) -> System.out.println("规范二");

        //语法格式三:若只有一个参数,小括号可以省略不写
        //x->System.out.println("规范三");

        //语法规范四:有两个以上的参数,有返回值,并且Lambda体中有多条语句
        Comparator comparator = new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                int i = Integer.compare(o1.length(),o2.length());
                System.out.println("规范四");
                return  i;
            }
        };
        comparator = (o1, o2) -> {
            int i = Integer.compare(o1.length(),o2.length());
            System.out.println("规范四");
            return  i;};

        //语法规范五:Lambda语句只有一个执行体,return和大括号可以不写:
        Comparator comparator2 = new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                return  Integer.compare(o1.length(),o2.length());
            }
        };
        comparator2 = (o1, o2) ->Integer.compare(o1.length(),o2.length());

        //语法规范六:lambda表达式的参数列表的数据类型可以不写
        // (JVM会通过上下文可以推断出数据类型,例如通过泛型就可以推断数据类型)
        //  Integer.compare(int a,int b);  -->>  Integer.compare(a,b);
    }
}

 

```
通过上面的规范实例我们可以看出使用Lambda可以有效的简化代码。

下面通过一个简答的练习感受下:


- 1.定义一个接口:接收两个参数(两个参数类型一样的泛型),返回int
- 2.定义一个person类,3个属性name,age,score

现在要求:
- 1.实现接口,比较两个的age大小;
- 2.实现接口,比较两个的score大小;
- 3.使用内置的compare接口对数组排序;

接口:

package com.bruno_cheng.jdk.com.bruno_cheng;

public interface TestInterface{
    //定义一个接口:接收两个参数(两个参数类型一样的泛型),返回int
    int method( T t1,T t2);
}

 person类:

package com.bruno_cheng.jdk.com.bruno_cheng;

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

    //getter &setter

    public void init(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

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


测试类:

package com.bruno_cheng.jdk.test;

import com.bruno_cheng.jdk.bruno_cheng.Person;
import com.bruno_cheng.jdk.bruno_cheng.TestInterface;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        List person = new ArrayList<>();
        person.add(new Person("张三",18,100));
        person.add(new Person("李四",19,90));
        person.add(new Person("王五",19,95));
        //- 1.实现接口,比较两个的age大小;
        //不使用Lambda
        TestInterface personTestInterface2 = new TestInterface() {
            @Override
            public int method(Person p1, Person p2) {
                return Integer.compare(p1.getAge(),p2.getAge());
            }
        };
        //使用Lambda后
        TestInterface personTestInterface = (p1,p2) ->Integer.compare(p1.getAge(),p2.getAge());
        //- 2.实现接口,比较两个的score大小;
        personTestInterface = (p1,p2) ->Integer.compare(p1.getScore(),p2.getScore());
        //此时我们可以发现,我们这里只需要该Lambda表达式右边的改动即可,不需想上面那样重复很多代码。
        //- 3.使用内置的compare接口对分数排序;


//        person.sort(new Comparator() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return Integer.compare(o1.getScore(),o2.getScore());
//            }
//        });
        System.out.println(person);
        //[Person{name='李四', age=19, score=90}, Person{name='王五', age=19, score=95}, Person{name='张三', age=18, score=100}]

        person.sort((Person o1, Person o2) ->Integer.compare(o1.getScore(),o2.getScore()));
        System.out.println(person);
    }
}


此时我们可以发现Lamda需要函数式接口:

什么是函数式接口?

函数式接口就是接口中只有一个抽象方法的的接口。可以使用注解@FunctionalInterface修饰可以检查是否是函数式接口

package com.bruno_cheng.jdk.bruno_cheng;
@FunctionalInterface  //检查是否是函数式接口
public interface TestInterface{
    //定义一个接口:接收两个参数(两个参数类型一样的泛型),返回int
    int method( T t1,T t2);
}

 

 JAVA内置的函数式接口

JDK1.8新特性之Lambda表达式学习_第1张图片

代码测试如下:

package com.bruno_cheng.jdk.test;

import com.bruno_cheng.jdk.bruno_cheng.Person;

import java.util.function.*;

/**
 * 测试java内置函数式接口
 */
public class Test2 {
    public static void main(String[] args) {
        //1.在内部类实现,传入参数,返回boolean类型(Predicate)
        //使用Predicate接口,,判断返回值类型判断某个person对象是否大于18岁
        Predicate predicate = (p)->p.getAge()>18;
        boolean b = predicate.test(new Person("张三",20,90));
        System.out.println(b);//true

        //2.在内部类实现,传入参数,没有返回值(Consumer)
        //使用Consumer接口,传入一个字符串,>>打印<<字符串长度.
        Consumer consumer = str -> System.out.println("\""+str+"\"的长度"+str.length());
        consumer.accept("早上好啊");//"早上好啊"的长度4

        //3.在内部类实现,传入参数,没有返回值(Function)
        //使用Consumer接口,传入一个字符串,>>返回<<字符串长度.
        Function function = s -> s.length();
        Integer integer = function.apply("中午好");
        System.out.println(integer);//3

        //4.在内部类实现,不传入参数,有返回值(Supplier)
        //使用Supplier接口,创建一个姓名等于张三,年龄18,分数80分的对象.
        Supplier supplier = ()->  new Person("张三", 18, 80);
        System.out.println(supplier.get()); //Person{name='张三', age=18, score=80}

        //5.在内部类实现,传入一个参数,返回一个参数(UnaryOperator)
        //使用UnaryOperator接口,传入一个字符串,返回全部转为大写的新字符串
        UnaryOperator unaryOperator = (str) ->str.toUpperCase();
        //UnaryOperator继承Function
        System.out.println(unaryOperator.apply("abcd"));//ABCD
    }

}


PS:这里就可以看出:函数式编程式对行为的封装。

 

你可能感兴趣的:(JAVA学习)