Lambda表达式（三）

public class Test04 {
    public static void main(String[] args) {
        /*
         * Java8中，有一个新的类：Stream类型，它代表一个数据加工流
         * java.util.stream.Stream<T>接口
         *        static <T> Stream<T> generate(Supplier<T> s)
         *
         *  这个静态方法的形参：Supplier<T>供给型接口的类型,可以使用Lambda表达式赋值
         *  接口的静态方法通过“接口名.静态方法”调用
         *
         *  Supplier<T>接口
         *  （1）抽象方法       T get()
         *  （2）抽象方法如何实现
         *        例如：在抽象方法中实现，随机产生一个小数[0,1)，返回值类型double
         */
//    Stream<Double> stream = Stream.generate(() -> {return Math.random();});
        //优化
        Stream<Double> stream = Stream.generate(()->Math.random());

        /*
         * 再调用Stream<T>接口的void forEach(Consumer<? super T> action)输出数据
         * 这个方法形参是Consumer<T>消费型接口类型，SAM接口，也可以使用Lambda表达式赋值
         *
         * Consumer<T>消费型接口：
         * （1）抽象方法
         *        void accept(T t)
         * （2）如何实现抽象方法
         *        例如：打印流中的元素
         *
         */
//    stream.forEach((Double num) -> {System.out.println(num);});
        //优化
        stream.forEach(num -> System.out.println(num));
    }
}

 

public class Test05 {

    /*
     * JDK1.8时Map接口增加了一个方法：
     *       default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
     */
    //把原来售价低于5元的，修改为为5元，其他的不变
    /*
     * replaceAll(BiFunction<? super K,? super V,? extends V> function)
     *
     * replaceAll的形参是BiFunction<T,U,R>接口类型，SAM接口，可以使用Lambda表达式赋值
     *
     * BiFunction<T,U,R>接口：
     * （1）抽象方法
     *         R apply(T t, U u)
     * （2）如何实现抽象方法
     *         例如：把原来commodity对象的售价<5元的替换（覆盖）为薪5元
     *
     * 如果抽象方法有返回值，那么实现抽象方法时，需要return语句。
     * 这里看返回值类型是V类型，是commodity的类型
     */
    public static void main(String[] args) {
        HashMap<String,Commodity> commodityMap = new HashMap<>();
        commodityMap.put("苹果",new Commodity("苹果",5.0));
        commodityMap.put("香蕉",new Commodity("香蕉",3.0));
        commodityMap.put("雪梨",new Commodity("雪梨",2.0));
        commodityMap.put("石榴",new Commodity("石榴",4.0));

        commodityMap.forEach((key,fruitsMap)->{
            System.out.print("水果："+fruitsMap.getName());
            System.out.println("价格:"+fruitsMap.getPrice()+"元");
        });
        System.out.println("--------同一价格后--------");

//        commodityMap.replaceAll((String key,Commodity commodity)->{
//            if(commodity.getPrice()<5.0){
//                commodity.setPrice(5.0);
//            }
//            return  commodity;
//        });

        //优化
        commodityMap.replaceAll((key,commodity)->{
            if(commodity.getPrice()<5.0){
                commodity.setPrice(5.0);
            }
            return  commodity;
        });

        commodityMap.forEach((key,fruitsMap)->{
            System.out.print("水果："+fruitsMap.getName());
            System.out.println("价格:"+fruitsMap.getPrice()+"元");
        });
    }
}
class Commodity{
    private String name;
    private Double price;

    public Commodity(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

}