java1.8新特性（一）

一直在更新java 版本，原来也没有关注java版本的变化 引入的一些新的api  引起注意的还是  关于一些并发包的使用，那时候才对每个版本的特性 去了解了一下，虽然 不一定都用上了，但是不管学习什么语言，花点时间学习新的api还是很有必要的，在工作中 还用一些 1.8的新特性，但是 始终 是 不明白。总是有问题，特意花些时间 去重点学习一下，如果其中 有什么说的不对，请一定要提出来！

用户 对象 User：

package com.java;

public class User {
    String name;
    int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }

}

需求1：从所有的用户中 找出 age大于15的用户

package com.java;

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

public class Test {

    public static List<User> users = new ArrayList<>();
    static {

        User user = new User("张三", 15);

        users.add(user);
        User user1 = new User("李四", 26);
        users.add(user1);

    }

    public List<User> findAgeGreater15(List<User> users, int age) {
        List<User> tempUser = new ArrayList<>();
        for (User user : users) {
            if (user != null) {
                if (user.getAge() > age) {
                    tempUser.add(user);
                }
            }
        }
        return tempUser;
    }

    public static void main(String[] args) {
        Test test = new Test();
        List<User> findAgeGreater15 = test.findAgeGreater15(users, 15);
        for (User user : findAgeGreater15) {
            System.out.println(user);
        }
    }

要实现 上面的需求其实有很多种方法,讲一个基本的方法 和  使用 java1.8 Lambda 方法 实现该需求：

首先：java1.8  提供了 函数式编程（概念可百度）需要 提供一个接口：（不包括 defulet方法 和 static方法）

package com.java;

@FunctionalInterface
public interface UserInterface {
    boolean filter(int age);

}

    public List<User> findAgeGreater15(List<User> users, UserInterface userInterface) {
        List<User> tempUser = new ArrayList<>();
        for (User user : users) {
            if (user != null) {
                if (userInterface.filter(user.getAge())) {
                    tempUser.add(user);
                }
            }
        }
        return tempUser;
    }

    public static void main(String[] args) {
        Test test = new Test();
        List<User> findAgeGreater15 = test.findAgeGreater15(users, (int a) -> {
            return a > 15;
        });
        for (User user : findAgeGreater15) {
            System.out.println(user);
        }
    }

关于  test.findAgeGreater15(users, (int a) -> {return a > 15;}); 调用 findAgeGreater15 方法的时候  参数类型（有两个 一个 List<User> 一个 UserInterface ）：
  我这是这样理解的， 调用该方法的时候  将 (int a) -> {return a > 15;} 这个函数 当成一个 UserInterface的参数类型 传入该方法中，在 findAgeGreater15  方法体中

 if (userInterface.filter(user.getAge())) {
                    tempUser.add(user);
               }

.filter（user.getAge()） 执行的方法 就是 判断 user.getAge() 是否 大于 15   user.getAge()类似于 变量a 只要 满足 user.getAge() >15 则返回true。

关于Lamabda 表达式规则:（参数） ->(分割参数和表达式)   表达式

关于 参数的写法：参数可以可以没有 (和定义的接口 参数列表有关系)

1. 没有则可以写成：List<User> findAgeGreater15 = test.findAgeGreater15(users, () -> System.out.println("执行完成"));
2. 一个参数可以写成  List<User> findAgeGreater15 = test.findAgeGreater15(users, (int a) -> System.out.println("执行完成"));或者List<User> findAgeGreater15 = test.findAgeGreater15(users, ( a) -> System.out.println("执行完成"));
   当只有一个参数的时候 可以不说明类型，该类型是可导类型
3. 多个类型的时候  List<User> findAgeGreater15 = test.findAgeGreater15(users, (int a，int b) -> System.out.println("执行完成"))

关于表达式的写法：主要就是 有无返回值（和定义的接口 参数返回值有关系）：

1. 有返回值的写法：必须要有大括号 和分号

   test.findAgeGreater15(users, (int a) -> {
               return a > 15;
           });

2. 没有返回值的时候:

   test.findAgeGreater15(users, (int a) ->
            System.out.println("没有返回值")
          );

个人感觉 在使用Lambda的时候 比较困难的是 不知道 什么时候该用Lambda 或者 怎么用，这个需要实际中靠自己去 衡量，比如上面解决 age>15的这个需求 ，其实 常规操作 比使用Lambda 更快  使用 Lambda 还要去创建 接口 对 语法 不熟悉 还 要慢慢写。所以 虽然新特性。但是解决的时候 还是得看需求，别整复杂了，在写两个可能比较常用的Lambda表达式用处：

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("一般写法");
            }
        }).start();
        new Thread(() -> System.out.println("Lambda写法")).start();
        ;
    }

对一个集合从大到小进行排序：

public static void main(String[] args) {
        List<Integer> list = Arrays.asList(15, -1, 2, 9, 12);
        list.sort((Integer a, Integer b) -> b.compareTo(a));
        for (Integer integer : list) {
            System.out.println(integer);
        }

}

原文地址：https://www.cnblogs.com/920913cheng/p/10209675.html