Java8的学习使用

一：lambda表达式的使用。

 

1：只有在需要函数式接口的时候才可以传递Lambda

函数式接口就是只定义一个抽象方法的接口。

package com.company;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class FilteringApples {
    // 定义一个苹果类
    public static class Apple{
        private int weight = 0;
        private String color = "";

        //空参构造器
        public Apple(){
        }
        //一个参数的构造器
        public Apple(int weight) {
            this.weight = weight;
        }
        //两个参数的构造器
        public Apple(int weight, String color){
            this.weight = weight;
            this.color = color;
        }
        
        
        public Integer getWeight() {
            return weight;
        }

        public void setWeight(Integer weight) {
            this.weight = weight;
        }

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public String toString() {
            return "Apple{" +
                    "color='" + color + '\'' +
                    ", weight=" + weight +
                    '}';
        }
    }
    //测试
    public static void main(String ... args) {

        int portNumber = 1337;
        Runnable runnable = () -> System.out.println(portNumber);
        System.out.println("runable:"+runnable.toString());
        //利用空参构造器
        Supplier<Apple> supplier = Apple::new;
        Apple apple = supplier.get();
        //一个参数的构造器
        Function<Integer, Apple> function = Apple::new;
        Apple apply = function.apply(100);
        //两个参数的构造函数
        BiFunction<Integer, String, Apple> aNew = Apple::new;
        Apple green = aNew.apply(90, "green");
        System.out.println(green);

        List<Apple> inventory = Arrays.asList(new Apple(80,"green"),
                new Apple(155, "green"),
                new Apple(120, "red"));

        // [Apple{color='green', weight=80}, Apple{color='green', weight=155}]
        //查询为绿色的苹果
        List<Apple> greenApples = filterApples(inventory, FilteringApples::isGreenApple);
        System.out.println(greenApples);

        // [Apple{color='green', weight=155}]
        // 查询重量超过150的苹果
        List<Apple> heavyApples = filterApples(inventory, FilteringApples::isHeavyApple);
        System.out.println(heavyApples);

        // [Apple{color='green', weight=80}, Apple{color='green', weight=155}]
        // Java8 Lambda表达式  查询颜色为绿色的苹果。
        List<Apple> greenApples2 = filterApples(inventory, (Apple a) -> "green".equals(a.getColor()));
        System.out.println(greenApples2);

        // [Apple{color='green', weight=155}]
        // Java8 Lambda表达式  查询重量超过150的苹果
        List<Apple> heavyApples2 = filterApples(inventory, (Apple a) -> a.getWeight() > 150);
        System.out.println(heavyApples2);

        // [Apple{color='green', weight=155}]
        //查询苹果重量大于150，颜色也为绿色的。
        List<Apple> weirdApples = filterApples(inventory, (Apple a) -> a.getWeight() >150 &&
                "green".equals(a.getColor()));
        System.out.println(weirdApples);
    }

    //以前的需求写法：查询集合中为 green的苹果
    public static List<Apple> filterGreenApples(List<Apple> inventory){
        List<Apple> result = new ArrayList<>();
        for (Apple apple: inventory){
            if ("green".equals(apple.getColor())) {
                result.add(apple);
            }
        }
        return result;
    }
    //以前的需求写法：查询重量超过150g的苹果
    public static List<Apple> filterHeavyApples(List<Apple> inventory){
        List<Apple> result = new ArrayList<>();
        for (Apple apple: inventory){
            if (apple.getWeight() > 150) {
                result.add(apple);
            }
        }
        return result;
    }

    //对上面的进行代码修改。上面的需求代码基本一样。把重复使用的给优化一下。
    public static boolean isGreenApple(Apple apple) {
        return "green".equals(apple.getColor());
    }

    public static boolean isHeavyApple(Apple apple) {
        return apple.getWeight() > 150;
    }
    //Predicate 这里使用了策略模式。定义一族算法，把它们封装起来（称为“策略”），然后在运行时选择一个算法
    public static List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> p){
        List<Apple> result = new ArrayList<>();
        for(Apple apple : inventory){
            if(p.test(apple)){
                result.add(apple);
            }
        }
        return result;
    }

}