Java 8 新特性：Java 类库的新特性之 Stream类（二）

List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
    System.out.println(“sum is:”
      + nums.stream().filter(num -> num != null)
        .distinct().mapToInt(num -> num * 2)
        .peek(System.out::println).skip(2).limit(4).sum() );

        List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
        List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null)
        .collect(() -> new ArrayList<Integer>(),
                (list, item) -> list.add(item),
                (list1, list2) -> list1.addAll(list2));

    List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
    List<Integer> numsWithoutNull = nums.stream().filter(num -> num != null)
      .collect(Collectors.toList());

/**
    *这个函数有两个参数，第一个参数是上次函数执行的返回值（也称为中间结果），第二个参数是stream中的元素，这个函数把这两个值相加，得到的和会被赋值给下次执行这个函数的第一个参数。Note：**第一次执行的时候第一个参数的值是Stream的第一个元素，第二个参数是Stream的第二个元素。
    *这个方法返回值类型是Optional，这是Java8防止出现NPE的一种可行方法。
    */
    List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
    System.out.println("ints sum is:"
      + ints.stream().reduce((sum, item) -> sum + item).get());

    /**
    *不同的是：它允许用户提供一个循环计算的初始值，如果Stream为空，就直接返回该值。
    *而且这个方法不会返回Optional，因为其不会出现null值。
    */
    List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
    System.out.println("sum is:" 
      + ints.stream().reduce(0, (sum, item) -> sum + item));

    List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
    System.out.println("sum is:" + ints.stream().count());

public class MyStreams  {
    private enum Status {
        OPEN, CLOSED
    };
    /**
     * Task类有一个分数的概念（或者说是伪复杂度），其次是还有一个值可以为OPEN或CLOSED的状态.
     */
    private static final class Task {
        private final Status status;
        private final Integer points;
        Task( final Status status, final Integer points ) {
            this.status = status;
            this.points = points;
        }
        public Integer getPoints() {
            return points;
        }
        public Status getStatus() {
            return status;
        }
        @Override
        public String toString() {
            return String.format( "[%s, %d]", status, points );
        }
    }
}
/**
 * Stream API极大简化了集合框架的处理
 */
public class StreamDemo {
    public static void main(String[] args) {
        final Collection< Task > tasks = Arrays.asList(
                new Task( Status.OPEN, 5 ),
                new Task( Status.OPEN, 13 ),
                new Task( Status.CLOSED, 8 )
        );
        //1.获取tasks中状态为OPEN的总数和
        getOpenTotalPoint();
        //2.计算所有状态的总和
        getTotalPoints();
        //3.根据状态分组
        getListByStatus();
        //4.计算整个集合中每个task分数（或权重）的平均值
        //5.从文本文件中逐行读取数据这样典型的I/O操作也很适合用Stream API来处理。
        final Path path = new File( filename ).toPath();
        try( Stream< String > lines = Files.lines( path, StandardCharsets.UTF_8 ) ) {
            //对一个stream对象调用onClose方法会返回一个在原有功能基础上新增了关闭功能的stream对象，
            //当对stream对象调用close()方法时，与关闭相关的处理器就会执行。
            lines.onClose( () -> System.out.println("Done!") ).forEach( System.out::println );
        }
    }
    /**
     1.获取tasks中状态为OPEN的总数和
     思路：
     第一，task集合被转换化为其相应的stream表示。然后，filter操作过滤掉状态为CLOSED的task。
     下一步，mapToInt操作通过Task::getPoints这种方式调用每个task实例的getPoints方法把Task的stream转化为Integer的stream。
     最后，用sum函数把所有的分数加起来，得到最终的结果。
     */
    public static void getOpenTotalPoint(){
        final long totalPointsOfOpenTasks = tasks
                .stream()
                .filter( task -> task.getStatus() == Status.OPEN )
                .mapToInt( Task::getPoints )
                .sum();
        System.out.println( "OPEN--Total points: " + totalPointsOfOpenTasks );//输出结果：OPEN--Total points:18
    }
    /**
     *  stream另一个有价值的地方是能够原生支持并行处理。
     *  2.计算所有状态的总和
     */
    public static void getTotalPoints(){
        //这个示例和第一个示例很相似，但这个例子的不同之处在于这个程序是并行运行的，
        //其次使用reduce方法来算最终的结果。
        final double totalPoints = tasks
                .stream()
                .parallel()
                .map( task -> task.getPoints() ) // 或 map( Task::getPoints ) 
                .reduce( 0, Integer::sum );
        System.out.println( "Total points (all tasks): " + totalPoints );//输出结果：Total points (all tasks): 26.0
    }
    /**
     按照某种准则来对集合中的元素进行分组。
     3.根据状态分组
     */
    public static void getListByStatus(){
        final Map< Status, List< Task > > map = tasks
                .stream()
                .collect( Collectors.groupingBy( Task::getStatus ) );
        System.out.println( map );//输出结果：{CLOSED=[[CLOSED, 8]], OPEN=[[OPEN, 5], [OPEN, 13]]}
    }
    /**
     4.计算整个集合中每个task分数（或权重）的平均值
     */
    public static void getPercentage(){
        final Collection< String > result = tasks
                .stream()                                        // Stream< String >
                .mapToInt( Task::getPoints )                     // IntStream
                .asLongStream()                                  // LongStream
                .mapToDouble( points -> points / totalPoints )   // DoubleStream
                .boxed()                                         // Stream< Double >
                .mapToLong( weigth -> ( long )( weigth * 100 ) ) // LongStream
                .mapToObj( percentage -> percentage + "%" )      // Stream< String> 
                .collect( Collectors.toList() );                 // List< String > 
        System.out.println( result );//输出结果：[19%, 50%, 30%]
    }
}

class FibonacciSupplier implements Supplier<Long> {
    long a = 0;
    long b = 1;
    @Override
    public Long get() {
        long x = a + b;
        a = b;
        b = x;
        return a;
    }
}
public class FibonacciStream {
    public static void main(String[] args) {
        Stream<Long> fibonacci = Stream.generate(new FibonacciSupplier());
        fibonacci.limit(10).forEach(System.out::println);
    //如果想取得数列的前10项，用limit(10)，如果想取得数列的第20~30项,用skip()，
    //通过collect()方法把Stream变为List。该List存储的所有元素就已经是计算出的确定的元素了.
    List<Long> list = fibonacci.skip(20).limit(10).collect(Collectors.toList());
    }
}

/**
* 把π表示为一个无穷Stream
*/
class PiSupplier implements Supplier<Double> {
    double sum = 0.0;
    double current = 1.0;
    boolean sign = true;
    @Override
    public Double get() {
        sum += (sign ? 4 : -4) / this.current;
        this.current = this.current + 2.0;
        this.sign = ! this.sign;
        return sum;
    }
}
public class StreamDemo {
    public static void main(String[] args) {
    /*
    * 这个级数从100项开始可以把π的值精确到3.13~3.15之间
    */
    Stream<Double> piStream = Stream.generate(new PiSupplier());
    piStream.skip(100).limit(10).forEach(System.out::println);
    }
}

/**
* 用代码实现就是把一个流变成另一个流
*/
class EulerTransform implements Function<Double, Double> {
    double n1 = 0.0;
    double n2 = 0.0;
    double n3 = 0.0;
    @Override
    public Double apply(Double t) {
        n1 = n2;
        n2 = n3;
        n3 = t;
        if (n1 == 0.0) {
            return 0.0;
        }
        return calc();
    }
    double calc() {
        double d = n3 - n2;
        return n3 - d * d / (n1 - 2 * n2 + n3);
    }
}
public class StreamDemo {
    public static void main(String[] args) {
    /*
    * 可以在10项之内把π的值计算到3.141~3.142之间：
    */
    Stream<Double> piStream2 = Stream.generate(new PiSupplier());
      piStream2.map(new EulerTransform())
      .limit(10)
      .forEach(System.out::println);
    }
}

/*
      20项之内可以计算出极其精确的值
    */
    Stream<Double> piStream3 = Stream.generate(new PiSupplier());
    piStream3.map(new EulerTransform())
         .map(new EulerTransform())
         .map(new EulerTransform())
         .map(new EulerTransform())
         .map(new EulerTransform())
         .limit(20)
         .forEach(System.out::println);

//如何并行Stream来提升性能
class StreamDemo 
{
  public static void main(String[] args) 
  {
    //创建一个没有重复元素的大表
    int max =1000000;
    List<String> val=new ArrayList<>(max);
    for(int i=0;i<max;i++){
      UUID id=UUID.randomUUID();
      val.add(id.toString());
    }
    //算一下排序这个Stream要耗时多久
    //串行排序：
    getSequentialStreamTime();// 串行耗时: 899 ms
    //并行排序
    getParallelStreamTime();// 并行排序耗时: 472 ms
    //通过比较两段方法代码几乎是一样的，但是并行版的快了50%之多，
    //唯一需要做的改动就是将stream()改为parallelStream()。
  }
  public static void getSequentialStreamTime(){
    long t0 = System.nanoTime();
    long count = values.stream().sorted().count();
    System.out.println(count);
    long t1 = System.nanoTime();
    long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
    System.out.println(String.format("sequential sort took: %d ms", millis));
  }
  public static void getParallelStreamTime(){
    long t0 = System.nanoTime();
    long count = values.parallelStream().sorted().count();
    System.out.println(count);
    long t1 = System.nanoTime();     
    long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
    System.out.println(String.format("parallel sort took: %d ms", millis));     
  }
}

List<String> transactionIds = new ArrayList<>();
    for(Transaction t: transactions){
      transactionIds.add(t.getId()); //外部遍历
    }
    List<Integer> transactionIds = transactions.stream()
          .map(Transaction::getId) //内部遍历
          .collect(toList())
    }

/**
* 自然数集合的规则非常简单，每个元素都是前一个元素的值+1。
* 反复调用get()，将得到一个无穷数列，利用这个Supplier，可以创建一个无穷的Stream
*/
class NaturalSupplier implements Supplier<Long> {
    long num = 0;
    public Long get() {
        this.num = this.num + 1;
        return this.num;
    }
}

class StreamDemo
{
  public static void main(String[] args) {
    /**
    * 对这个Stream做任何map()、filter()等操作都是完全可以的，这说明Stream API对Stream进行转换并生成一个新的Stream并非实时计算，而是做了延迟计算。
    * 当然，对这个无穷的Stream不能直接调用forEach()，这样会无限打印下去。但是我们可以利用limit()变换，把这个无穷Stream变换为有限的Stream。
    */
    Stream<Long> natural = Stream.generate(new NaturalSupplier());
    natural.map((x) -> {
      return x * x;
    }).limit(10).forEach(System.out::println);
  }
}