简单了解JAVA8的新特性

package com.newflypig.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestJava {
    public static void main(String[] args) {
        // java8 的新特性，lambda表达式，类似于匿名内部类
        Thread testThread = new Thread(() -> {
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("aa");
            list.add("bb");
            list.add("cc");
            list.forEach(s -> {
                System.out.println(s);
                ;
            });

            list.stream().filter(s -> s.length() == 2).forEach(s -> {
                System.out.println(s);
            });
        });

        System.out.println("======================================");

        distinct("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9");

        testThread.run();
    }

    // 新特性，不定参数
    private static void distinct(String... numbers) {
        List<String> list = Arrays.asList(numbers);
        List<Integer> listInt = list.stream()
            .map(s -> Integer.parseInt(s))         // 将集合流中的元素一一映射为一个新的元素，并生成到新的输出流中
            .filter(a -> isPrime(a))             // 过滤，lambda表达式
            .distinct()                         // stream的高级方法，去除重复
            .collect(Collectors.toList());        // 将整理好的输出流收集到新的listInt集合中        
        /**
         * 你可能会觉得在这个例子里，List list被迭代了好多次，
         * map，filter，distinct都分别是一次循环，效率会不好。
         * 实际并非如此。这些返回另一个Stream的方法都是“lazy”的，而最后返回最终结果的collect方法则是“eager”的。
         * 在遇到eager方法之前，lazy的方法不会执行。
         * 
         * 当遇到eager方法时，前面的lazy方法才会被依次执行。
         * 而且是管道贯通式执行。这意味着每一个元素依次通过这些管道。
         * 例如有个元素“3”，首先它被map成整数型3；
         * 然后通过filter，发现是素数，被保留下来；又通过distinct，
         * 如果已经有一个3了，那么就直接丢弃，如果还没有则保留。这样，3个操作其实只经过了一次循环。
         * 
         * 除collect外其它的eager操作还有forEach，toArray，reduce等
         */
        
        
        listInt
            .stream()
            .forEach(i -> {                         // stream的forEach，类似于Collections.forEach
                System.out.println(i);
            });
        
        
        
        int sum=listInt
            .stream()
            .reduce((isum,item)->isum+item)
            .get();
        int min=listInt
            .stream()
            .reduce((a,b)->a<b?a:b)
            .get();
        int max=listInt
            .stream()
            .reduce((a,b)->a>b?a:b)
            .get();
        /**
         * reduce方法接受一个函数，这个函数有两个参数，
         * 第一个参数是上次函数执行的返回值（也称为中间结果），
         * 第二个参数是stream中的元素，这个函数把这两个值相加，
         * 得到的和会被赋值给下次执行这个函数的第一个参数。
         * 要注意的是：第一次执行的时候第一个参数的值是Stream的第一个元素， 第二个参数是Stream的第二个元素。
         * 这个方法返回值类型是Optional，这是Java8防止出现NPE(NULL POINT ELEMENT)的一种可行方法，
         * 这里就简单的认为是一个容器，其中可能会包含0个或者1个对象。
         */
        System.out.println(sum+"\t"+min+"\t"+max);
    }
    
    

    private static boolean isPrime(int a) {
        boolean flag = true;
        for (int i = 2; i <= a / 2; i++) {
            if (a % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }
}