java8终于懂了

java8有哪些新特性：

1. lamdad表达式
2. 函数式接口
3. 方法引用构造器引用
4. StreamAPI
5. 接口中的默认方法与静态方法
6. 新时间日期API
7. 其它特性

感受java8的优点：

提示：为什么学习lamdad表达式？能帮我们解决什么问题？值不值得学习？

public void test() {

        //之前的内部类
        Comparator<String> com = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {

                return Integer.compare(o1.length(), o2.length());
            }
        };

        System.out.println("如果是lamdad表达式的写法----------------------------------------------");

        Comparator<String> com2= (o1,o2)-> Integer.compare(o1.length(), o2.length());
    }

提示：找出符合条件的用户(年龄大于30. 薪资大于5000的， id 大于3)

 List<User> users = Arrays.asList(
            new User(1,"张三",15,2000.00),
            new User(2,"李四",20,3000.00),
            new User(3,"王五",30,5900.00),
            new User(4,"赵六",35,6600.00),
            new User(5,"田七",45,7700.00));

    //获取年龄小于35的用户？
    public List<User> filteByAge(List<User> users) {
        List<User> temp = new ArrayList<>();
        for(User user : users){
            if(user.getAge()>35) {
                temp.add(user);
            }
        }
        return temp;
    }
    //获取工资大于5000的用户？
    public List<User> filteBySalary(List<User> users) {
        List<User> temp = new ArrayList<>();
        for(User user : users){
            if(user.getSalary()>35) {
                temp.add(user);
            }
        }
        return temp;
    }
    //获取id大于2的数据
    //...
    //优化方式1，策略设计模式
    public List<User> filterByPredicate(List<User> users, MyPredicate<User> predicate) {
        List<User> temp = new ArrayList<>();
        for(User user : users){
            if(predicate.judge(user)) {
                temp.add(user);
            }
        }
        return temp;
    }

    public void test1() {
        List<User> users = filterByPredicate(this.users, new MyPredicateByAge());
    }


    //优化方式2，匿名内部类
    public void test2() {
        List<User> users = filterByPredicate(this.users, new MyPredicate<User>() {
            @Override
            public boolean judge(User user) {
                return user.getAge()>35;
            }
        });
    }

    //优化方式3 lamdad表达式
    public void test3() {
        List<User> users = filterByPredicate(this.users, user->user.getAge()>35);
    }

    //优化方式4
    public void test4() {
        List<User> users = users.stream().filter(user->user.getAge()>35).collect(Collectors.toList());
    }

1. 通过写不同的方法
2. 通过策略模式写不同的类
3. 通过策略模式写匿名内部类
4. 通过策略模式lamdad表达式
5. 通过Stream API （现成的方法）
   提示：通过java8的新特性lamdad表达式和streamapi变得很简单

---

lamdad表达式：

提示：lamdad表达式无非就是简化代码

Comparator<String> com2= (o1,o2)-> Integer.compare(o1.length(), o2.length());

定义： lamdad表达式：左侧 ->右侧

• 左侧定义参数列表
• 右侧具体实现
• lamdad表达式需要函数式接口支持

---

函数式接口：

提示：接口中只有一个抽象方法的接口，称为函数式接口，可以使用@FunctionalInterface注解，来说明该接口是函数式接口，当然java8的接口做了升级，可以允许有静态方法和默认方法，来增强接口

例如：

@FunctionalInterface
public interface MathOperation {
    float operator(int a, int b);
}

四种内置函数式接口

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);


@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

方法引用：

提示：其实质就是对lamdad表达式的简化,方法体只是一个方法的调用
使用前提：若lamdad体实现的功能，已经有方法提供了实现，可以使用方法引用

1. 对象的引用：：实例方法名

PrintStream ps =  System.out;
Consumer<String> con = x-> ps.println(x);
Consumer<String> co2 = x-> ps::println;

2. 类名：：静态方法名

Comparator<Integer> com1= (o1,o2)-> Integer.compare(o1,o2);

Comparator<Integer> com2= Integer::compare;

3. 类名：：实例方法名

BiPredicate<String, String> bp = (x,y)->x.equals(y);
BiPredicate<String, String> b2 = String::equals;

提示：方法引用注意：1：方法引用的方法参数列表与返回类型必须与函数式接口中抽象方法的参数列表与返回类型必须一致。2返回类型相同的情况下，函数接口中的抽象方法的参数列表的第一个参数是方法引用方法的调用者，第二个参数（或无参），是方法引用方法的参数时，可以使用类名：实例方法名

构造器引用：

提示：跟引用类似 类名：：new

Supplier<User> user = ()-> new User();
Supplier<User> use2 = User::new;