Java 8 stream try

因为工程有一个需求，什么需求？ 恩，就是须要将一个iterable 在多核状态下运行。如今已有的方案是，wrapper iterable，即对Iterable进行封装，将iterable 对象做为封装类的私有成员，而后为其写一个 Synchronized method 或者 Synchronized block，实现对next()函数的惟一访问权。这里推荐 Synchronized block，由于前者会带来Dos 问题（怎么会？在文章里有说明）

class A
{
   Iterable<T> iter;
    prive Object lock;public next()
    {
      T result;
      Synchronized(lock)
        
        {
               T= iter.hasnext()? iter.next(): null;
        }
            return T;
　　　}
}

上述代码中可能存在语法错误的，但大体意思表达到了，时间有限，后期补充。

可是，上述问题只是解决了多线程下iterable的线程安全。没有解决多核同时访问itreable 这个问题。用google搜了一下，不少都推荐使用 java 8 的stream的parallel。懵啊。。。好吧，开始学习stream是什么鬼东西。

首先，利用睡前一个小时的时间，中英文blogs同时出发，看了一下大概，明白了stream 的数据来源、中间转换和终止状态问题。大体明白了怎么回事。可是一直纠结，可不能够用本身定义的类型（class），可不可使用本身定义的函数，怎么使用? 睡前想了想，总结前面看mvn的经验——不能一直看网上的blog 介绍，由于不成系统，只能作到管中窥象，不能对其造成总体认知，得看官方manual或者教科书。放心的睡去。然而，清早起床发现，网上根本没有这类资料。好吧，从新看blogs，同时，根据本身的须要，开始编写一些简单的程序。上程序：

// stream_hello.java 
//package com.mkyong.java8;

import java.util.stream.Collectors;
import java.util.Arrays;
import java.util.Map;
import java.util.List;
import java.util.function.Function;
import java.util.Collection;

public class stream_hello
{
	private static final class Task
	{
		private final Integer points;

		Task(final Integer points)
		{
			this.points=points;
		}

		public Integer getPoints()
		{
			System.out.println("threadId="+Thread.currentThread().getId()+ "  "+points);
			return points;

		}
		public Integer println()
		{
			System.out.println();
			return points;
		}
		public String toString()
		{
			return String.format("[%d]",points);
		}
	}

	public static void main(String [] args)
	{
		System.out.println("single thread stream-List");
		List<String> items=Arrays.asList("apple","apple","banana","apple","orange","banana","papaya");
		Map<String, Long> result=items.stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));
		System.out.println(result);

		System.out.println();

		System.out.println("single thread stream-Task");
		final Collection<Task> tasks=Arrays.asList(
			new Task(5), new Task(4), new Task(5));

		final long totalPoint=tasks
		.stream()
		.filter(Task-> Task.getPoints() >4)
		.filter(Task->Task.println()>4)
		.mapToInt(Task::getPoints)
		.sum();

		System.out.println("Total points:"+totalPoint);
		System.out.println();

		System.out.println("Multi thread ");
		final Collection<Task> tasks2=Arrays.asList(
			new Task(5), new Task(4), new Task(5));

		final long totalPoint2=tasks2
		.stream()
		.parallel()
		.map(Task->Task.getPoints())
		.reduce(0,Integer::sum);

		System.out.println("Total points:"+totalPoint2);
		System.out.println();
	}
}

　　编译以下： javac stream_example.java   获得 stream_example.class

　　运行以下： java stream_example

运行结果：

single thread stream-List
{papaya=1, orange=1, banana=2, apple=3}

single thread stream-Task
threadId=1  5

threadId=1  5
threadId=1  4
threadId=1  5

threadId=1  5
Total points:10

Multi thread
threadId=10  5
threadId=9  5
threadId=1  4
Total points:14

　经过上述代码，有对string进行stream，对本身定义的类做为元素进行stream， 对本身定义的类做为元素进行多核stream。

　我当前的认知以下： 能够本身定义元素，定义元素的数据成员，定义元素的方法，该方法的返回结果能够做为filter,map等函数的参考标准。

　 filter、map等函数都是根据必定条件对stream进行转换。

　注意： stream parallel 的多核采用的是fork/join poll.  

　PS：鉴于一些知识，我想和你们分享。因此，之后有些blogs我会发表在随笔中。