lambda表达式

/**
 * 
 * @author moss18
 *
 *         级联表达式和何里化 何里化:把多个参数的函数转换为只有一个参数的函数 何里化的目的:函数标准化
 *         高阶函数:就是返回函数的函数
 *
 */

public class CurryDemo {
    public static void main(String[] args) {
        //实现了  x+y 的级联表达式
        
        Function<Integer, Function<Integer,Integer>> fun = x -> y -> x + y;
        
        System.out.println(fun.apply(2).apply(3));
        
        Function<Integer, Function<Integer,Function<Integer,Integer>>> fun2 = x -> y -> z -> x + y +z;
        
        System.out.println(fun2.apply(2).apply(3).apply(4));
        
        int[] nums = {2,3,4};
        Function f = fun2;
        
        for (int i = 0; i < nums.length; i++) {
            if(f instanceof Function) {
                Object obj = f.apply(nums[i]);
                if(obj instanceof Function) {
                    f = (Function) obj;
                }else {
                    System.out.println("调用结束:结果为:" + obj);
                }
            }
        }
    
        
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Object target = new Runnable() {
            
            @Override
            public void run() {
                System.out.println("ok");
            }
        };
        new Thread((Runnable) target).start();
        Object target2 = (Runnable)()->System.out.println("ok");
        Runnable target3 = ()->System.out.println("ok");
        System.out.println(target2 == target3);//false
        new Thread((Runnable) target2).start();
        //返回指定对象实例
    }
}

/**
 * 变量引用
 * @author moss18
 *
 */
public class VarDemo {
    public static void main(String[] args) {
        final String list = "我们的时间";
        Consumer<String> consumer = s -> System.out.println(s + list);
        consumer.accept("1222");        
    }
}

Stream流编程

public class StreamDemo1 {
    public static void main(String[] args) {
        int[] nums = {1,2,3};
        //外部迭代
        int sum = 0;
        for(int i:nums) {
            sum += i;
        }
        System.out.println("结果" + sum);
        
        //使用stream 的内部迭代
        //map就是中间操作(返回stream的操作)
        //sum就是终止操作
//        int sum2 = IntStream.of(nums).map(i -> i*2 ).sum();
        int sum2 = IntStream.of(nums).map(StreamDemo1::doubleNum).sum();
        System.out.println("结果为"+ sum2);
        
        System.out.println("惰性求值就是终止没有调用的情况下,中间操作不会执行");
        
        IntStream.of(nums).map(StreamDemo1::doubleNum);
    }
    
    public static int  doubleNum(int i) {
        System.out.println("执行了乘以2");
        return i*2;
    }
}

/**
 * 流终止操作
 * @author moss18
 *
 */
public class StreamDemo4 {
    public static void main(String[] args) {
        String str = "my name Moss18";
//        /非短路操作
        //使用并行流
        str.chars().parallel().forEach(i -> System.out.print((char)i));
        System.out.println();
        //使用 forEachOrdered 保证顺序
        str.chars().parallel().forEachOrdered(i -> System.out.print((char)i));
        System.out.println();
        //收集到list
        List<String> list = Stream.of(str.split(" ")).collect(Collectors.toList());
        System.out.println(list);
        //Optional 选项的意思. 使用 reduce拼接字符串
        Optional<String> letters = Stream.of(str.split(" ")).reduce((s1,s2) -> s1 + "|" +s2);
        System.out.println(letters.orElse(""));
        //带初始化值的reduce
        String reduce = Stream.of(str.split(" ")).reduce("",(s1,s2) -> s1 + "|" +s2);
        System.out.println(reduce);
        //计算所有单词总长度
        Integer length = Stream.of(str.split(" ")).map(s->s.length()).reduce(0,(s1,s2) -> s1 + s2);
        System.out.println(length);
        //max使用 计算出那个单词最长
        Optional<String> max = Stream.of(str.split(" ")).max((s1,s2) -> s1.length() - s2.length());
        System.out.println(max.get());
//      短路操作
        //使用findFirst短路操作   -- 在使用流停止短路常用到的地方
        OptionalInt findFirst = new Random().ints().findFirst();
        System.out.println(findFirst.getAsInt());
        
        
    }
}

public class StreamDemo1 {
    public static void main(String[] args) {
        int[] nums = {1,2,3};
        //外部迭代
        int sum = 0;
        for(int i:nums) {
            sum += i;
        }
        System.out.println("结果" + sum);
        
        //使用stream 的内部迭代
        //map就是中间操作(返回stream的操作)
        //sum就是终止操作
//        int sum2 = IntStream.of(nums).map(i -> i*2 ).sum();
        int sum2 = IntStream.of(nums).map(StreamDemo1::doubleNum).sum();
        System.out.println("结果为"+ sum2);
        
        System.out.println("惰性求值就是终止没有调用的情况下,中间操作不会执行");
        
        IntStream.of(nums).map(StreamDemo1::doubleNum);
    }
    
    public static int  doubleNum(int i) {
        System.out.println("执行了乘以2");
        return i*2;
    }
}

标签: none

评论已关闭