java8新特性 (Lambda表达式)

1:lambda表达式入门

提供的接口有四种：

->Function<T,R>接受一个参数T，返回一个参数R

->Consumer<T>接受一个参数T，无返回值

->Supplier<T>不接受参数，返回一个参数T

->Predicate<T>接受一个参数T，返回boolean值

代码如下：

        /***
         *  ---------------初级入门---------------
         */
        // 01:Function<T,R>函数接口:接受一个参数T，返回一个参数R
        Function<Integer,Integer> function = p -> p * 10;
        System.out.println(function.apply(2));

        // 02:Consumer<T>函数接口:接受一个参数T,没有返回
        Consumer<String> consumer = p -> System.out.println(p);
        consumer.accept("你好啊，我是lambda表达式");

        // 03:Predicate<T>函数接口:接受一个参数T，返回一个boolean值
        Predicate<Integer> predicate = (a) -> a > 10;
        System.out.println(predicate.test(1));

        // 04:Supplier<T>函数接口:不接受参数，返回一个参数T
        Supplier<Integer> supplier = () -> 100;
        System.out.println(supplier.get());

运行结果：

当然，你还可以自定义函数接口

1：自定义的函数接口需要用@FunctionalInterface注解

扫描二维码关注公众号，回复： 4385039 查看本文章

2：然后自定义一个抽象方法

例：自定义了一个函数接口MyLambda <T,E,R>接受两个参数T,E,返回一个参数R

自定义的函数接口：

@FunctionalInterface
public interface MyLambda<T,E,R> {

    // 自定义一个函数接口，接受两个参数T,E，返回参数R
    R num(T t,E e);
}

代码：

        // 05:自定义函数接口:需要自定义一个接口，用上@FunctionalInterface注解
        MyLambda<Integer,Integer,Integer> myLambda = (a,b) -> a + b;
        System.out.println(myLambda.num(1,2));

运行结果：

以上，就是Lambda的简单入门。Lambda的表达式不用我多说了(箭头左边是参数，箭头右边是方法体)

结合集合一起用：

在网上复制了一个字符数组，让我们来看看怎么用Lambda表达式循环变量字符数组，然后在和增强for比一下效率

代码如下：

        String[] players = {"Rafael Nadal", "Novak Djokovic",
                "Stanislas Wawrinka", "David Ferrer",
                "Roger Federer", "Andy Murray",
                "Tomas Berdych", "Juan Martin Del Potro",
                "Richard Gasquet", "John Isner"};

        long currtenTime = System.currentTimeMillis();
        // 01:给这个数组排序
        Arrays.sort(players,(p1,p2) -> p1.compareTo(p2));

//        Arrays.asList(players).forEach((p) -> System.out.println(p));
        for(String s : players){
            System.out.println(s);
        }
        long oldTime = System.currentTimeMillis();
        System.out.println("相差时间:" + (oldTime - currtenTime));

查看结果：

这是使用增强for的遍历

这是使用lambda表达式的遍历

发现效率差不多，就问你们lambda表达式骚不骚，三行增强for的代码变成了一句代码。爽不爽！匿名内部类的自定义排序也在使用lambda表达式的情况下，变成了一句代码，感觉如何？

打上注释的是lambda表达式

lambda也可以用来代替匿名内部类

代码如下：

        // 定义一个字符数组
        String[] players = {"Rafael Nadal", "Novak Djokovic",
                "Stanislas Wawrinka", "David Ferrer",
                "Roger Federer", "Andy Murray",
                "Tomas Berdych", "Juan Martin Del Potro",
                "Richard Gasquet", "John Isner"};

        // 01:给这个数组排序,然后遍历输出(根据字符串的大小)
        Arrays.sort(players,(p1,p2) -> p1.compareTo(p2));
        Arrays.asList(players).forEach((p) -> System.out.println(p));
        System.out.println("-------------------------");

        // 02:根据字符串的长度排序\
        Arrays.sort(players,(p1,p2) -> p1.length() - p2.length());
        Arrays.asList(players).forEach((p) -> System.out.println(p));
        System.out.println("-------------------------");

        // 03:根据字符串最后一个字符
        Arrays.sort(players,(p1,p2) -> p1.charAt(p1.length() - 1) - p2.charAt(p2.length() - 1));
        Arrays.asList(players).forEach((p) -> System.out.println(p));

是不是感觉简单明了，还略带有点骚气。（唯一就是有点不好，可读性不是很好）

lambda表达式整合集合一起使用:

Person类:

public class Person {

    private String firstName, lastName, job, gender;
    private int age;
    private double salary;

    public Person(String firstName, String lastName, String job,
                  String gender, int age, int salary)       {
        this.firstName = firstName;
        this.lastName = lastName;
        this.gender = gender;
        this.age = age;
        this.job = job;
        this.salary = salary;
    }

代码如下：

给每个人涨薪资20%，用lambda表达式：

        /**
         * 给每个人的薪资涨20%
         *   1:很容易的我们就想到了用Consumer函数接口来接受增长后的薪资（传入一个参数，没有返回值）
         *   2:获取到增长后的薪资后，forEach设置
         *   3:最后forEach获取
         */
        long currentTime = System.currentTimeMillis();

        Consumer<Person> consumer = p -> p.setSalary(p.getSalary() + (p.getSalary() / 100 * 20));
        javaProgrammers.forEach(consumer);
        javaProgrammers.forEach(p -> System.out.println(p.getFirstName() + "  " + p.getSalary()));

        long nowTime = System.currentTimeMillis();
        System.out.println("相差时间:" + (nowTime - currentTime));

运行结果：

1.8之前的用法：

        long currentTime = System.currentTimeMillis();

//        Consumer<Person> consumer = p -> p.setSalary(p.getSalary() + (p.getSalary() / 100 * 20));
//        javaProgrammers.forEach(consumer);
//        javaProgrammers.forEach(p -> System.out.println(p.getFirstName() + "  " + p.getSalary()));

        for(int i=0; i< javaProgrammers.size(); i++){
            Person person = javaProgrammers.get(i);
            person.setSalary(person.getSalary() + (person.getSalary() / 100 * 20));
            System.out.println(person.getFirstName() + "  " + person.getSalary());
        }

        long nowTime = System.currentTimeMillis();
        System.out.println("相差时间:" + (nowTime - currentTime));

运行结果：

配合Stream一起使用:

        /**
         * 获取所有的女人
         *     1:很容易的我们就想到了Predicate函数接口来获取所有的女程序员(传入一个参数，返回boolean值)
         */
        System.out.println("所有的女人：");
        Predicate<Person> female = p -> p.getGender().equals("female");
        javaProgrammers.stream().filter(female).forEach(p -> System.out.println(p.getFirstName() + "  " + p.getGender()));
        System.out.println();

        /**
         * 获取月薪超过1400的人
         * 1:很容易的我们就想到了Predicate函数接口来获取所有的女程序员(传入一个参数，返回boolean值)
         */
        System.out.println("所有月薪超过1400的人：");
        Predicate<Person> personPredicate = p -> (p.getSalary() > 1400);
        javaProgrammers.stream().filter(personPredicate).forEach(p -> System.out.println(p.getFirstName() + "  " + p.getSalary()));
        System.out.println();

        /**
         * 获取月薪超过1400的女人
         */
        System.out.println("月薪超过1400的女人：");
        javaProgrammers.stream().filter(female).filter(personPredicate).forEach(p -> System.out.println(p.getFirstName() + "  " + p.getSalary()));
        System.out.println();

        /**
         *  按着年龄来排序
         */
        System.out.println("按着年龄来排序 ");
        javaProgrammers.stream().sorted((p1,p2) -> (p1.getAge() - p2.getAge())).forEach(p -> System.out.println(p.getFirstName() + "  " +p.getAge()));
        System.out.println();

        /**
         * 获取年龄最小的三个人
         */
        System.out.println("获取年龄最小的三个人：");
        javaProgrammers.stream().sorted((p1,p2) -> p1.getAge() - p2.getAge()).limit(3L).forEach(p -> System.out.println(p.getFirstName() + "  " +p.getAge()));
        System.out.println();

        /**
         * 获取最高的薪资
         */
        System.out.println("获取最高的薪资：");
        Person person = javaProgrammers.stream().max((p1, p2) -> new Double(p1.getSalary()).intValue() - new Double(p2.getSalary()).intValue()).get();
        System.out.println(person.getFirstName() + "  " + person.getSalary());

运行结果：

运行结果不就截图完了；

由于实习期间接触的项目用的还是1.7，所以lambda表达式先学到了这吧到时候用到了再总结吧！

毕竟贪多嚼不透。

java8新特性 (Lambda表达式)

猜你喜欢