java8 stream API学习测试用例

package com.lin.fund;

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.IntSummaryStatistics;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoubleFunction;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.junit.Before;
import org.junit.Test;

/**
 * Unit test for simple App.
 */
public class AppTest {
	@Test
	public void test1() {
		System.out.println("------stream<runnable>---");
		Character[] arr = { 'A', 'B', 'C' };
		List<Runnable> list = new ArrayList<Runnable>();
		for (Character c : arr) {
			list.add(() -> {
				System.out.println(c);
			});
		}
		// for(int i=0;i<arr.length;i++){
		// final Character c = arr[i];
		// list.add(()->{System.out.println(c);});
		// }
		sleep(1000);
		System.out.println("-----------------");
		list.forEach((r) -> {
			r.run();
		});
	
	}
	Path path = null;
	@Before
	public void before(){
//		path = FileSystems.getDefault().getPath("E:","testdata.txt");
		
	}
	@Test
	public void test2() throws IOException, InterruptedException{
		System.out.println("------for ----");
		Path path = FileSystems.getDefault().getPath("E:","test.txt");
		
		List<String> contentList = Files.readAllLines(path);
		long t1 = System.nanoTime();
		long c1 = 0;
		for(Object obj:contentList){
			if(obj.toString().length()>-1){
				c1++;//=obj.toString().length();
			}
		}
		long t2 = System.nanoTime();
		System.out.println("normal:"+(t2-t1)/1000000.0+":"+c1);
		sleep(1000*1);
	}
	@Test
	public void test3() throws IOException{
		System.out.println("------stream ----");
		Path path = FileSystems.getDefault().getPath("E:","test.txt");
		
		List<String> contentList = Files.readAllLines(path);
		long t2 = System.nanoTime();
		Stream<String> stream = contentList.stream();
		long ts = System.nanoTime();
		long c2 = stream.filter(p->{System.out.println(Thread.currentThread().getName());return p.toString().length()>-1;}).count();
		long t3 = System.nanoTime();
		System.out.println("stream:"+(t3-t2)/1000000.0+":"+c2);
		System.out.println(" to stream:"+(ts-t2)/1000000.0);
		sleep(1000*1);
	}
	@Test
	public void test4() throws IOException{
		System.out.println("------parallelStream ----");
		Path path = FileSystems.getDefault().getPath("E:","test.txt");
		
		List<String> contentList = Files.readAllLines(path);
		long t3 = System.nanoTime();
		Stream<String> stream = contentList.parallelStream();
		long ts = System.nanoTime();
		long c3 = stream.filter(p->{System.out.println(Thread.currentThread().getName());return p.toString().length()>-1;}).count();
		long t4 = System.nanoTime();
		System.out.println("parallel stream:"+(t4-t3)/1000000.0+":"+c3);
		System.out.println(" to parallel stream:"+(ts-t3)/1000000.0);
		sleep(1000*1);
	}
	static void sleep(long millionsTime){
		try {Thread.sleep(millionsTime);} catch (InterruptedException e) {}
	}
	@Test
	public void test5(){
		System.out.println("------stream generate skip,limit----");
//		Builder<String> builder = Stream.builder();
//		Stream<String> stream = builder.build();
//		System.out.println(stream);
//		stream.close();
		Stream<Double> streamStr = Stream.generate(()->{double r = Math.random();System.out.println("generator:"+r);return r;}).skip(10).limit(100);
//		streamStr.forEach(d->System.out.println(d));
		long count = streamStr.filter(p->{if(p.doubleValue()*10>5){System.out.println(p.doubleValue());return true;}else{System.err.println(p.doubleValue());return false;}}).count();
		System.out.println(count);
		streamStr.close();
	}
	@Test
	public void test6(){
		System.out.println("map、flat 测试");
		Path path = FileSystems.getDefault().getPath("E:", "test.txt");
//		List<String> contentList = Files.readAllLines(path);
		try(Stream<String> stream = Files.lines(path)){
//			stream.map(String::length).forEach(str->{System.out.println(str);});
			Stream<Character> charStream = stream.flatMap(m -> {
				List<Character> list = new ArrayList<Character>();
				for(int i=0;i<m.length();i++){
					list.add(m.charAt(i));
				}
				return list.stream();
			});
			System.out.println(charStream.count());
//			.forEach(c -> {
//				System.out.println(c);
//			});
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	@Test
	public void test7(){
		System.out.println("stream peek test");
		Stream<String> stream = Stream.of("abcdefg".split(""));
		Stream<String> newStream = stream.peek(str->{ System.out.println("do print:"+str);});
		newStream.forEach(str->{System.out.println(str);});
	}
	@Test
	public void test8(){
		System.out.println("stable stream");
		List<String> data = Arrays.asList("a","b","c","d","a","b","c","d");
		Stream<String> stream = data.stream();
		Stream<String> distinctStream = stream.distinct();
		distinctStream.forEach(str->System.out.println(str));
		
	}
	@Test
	public void test9(){
		System.out.println("aggregate function stream");
		Stream<String> stream = Arrays.asList("a","aeedc","abcdefg","dsgsdc","hef","rdsfsabfd","fvasfvsdf","zdds").stream();
		Optional<String> option = stream.max(String::compareToIgnoreCase);
		System.out.println(option.get());
		Stream<String> s = Arrays.asList("a","aeedc","abcdefg","hef","rdsfsabfd","fvasfvsdf","zdds").stream();
		Optional<String> over5LengthStr = s.parallel().filter(p-> p.length()>=1).findAny();
		System.out.println(over5LengthStr.get());
		Stream<String> mStream = Arrays.asList("a","aeedc","abcdefg","hef","rdsfsabfd","fvasfvsdf","zdds").stream();
		boolean match = mStream.parallel().allMatch(p-> p.length()>=5);
		System.out.println(match);
		
		Path path = FileSystems.getDefault().getPath("E:", "test.txt");
		try (Stream<String> dataStream = Files.lines(path)) {
			Iterator<String> iter = dataStream.iterator();
			long t1 = System.nanoTime();
			boolean anyOver100 = false;
			while(iter.hasNext()){
				if(iter.next().length()>100){
					anyOver100 = true;
					break;
				}
			}
			long t2 = System.nanoTime();
			System.out.println(anyOver100+"_for_"+(t2-t1)/1000_000.0);
		} catch (Exception e) {
			e.printStackTrace();
		}
		try (Stream<String> dataStream = Files.lines(path)) {
			long t3 = System.nanoTime();
			boolean anyOver100 = dataStream.anyMatch(p->p.length()>100);
			long t4 = System.nanoTime();
			System.out.println(anyOver100+"_stream_"+(t4-t3)/1000_000.0);
		}catch (Exception e) {
			e.printStackTrace();
		}
		try (Stream<String> dataStream = Files.lines(path).parallel()) {
			long t3 = System.nanoTime();
			boolean anyOver100 = dataStream.anyMatch(p->p.length()>100);
			long t4 = System.nanoTime();
			System.out.println(anyOver100+"_parallel stream_"+(t4-t3)/1000_000.0);
		}catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	@Test
	public void test10(){
		System.out.println("------optional map、elseget、ifpresent--------");
		Stream<String> stream = Arrays.asList("a","点3几点wk0ofikkdw","aeedc","abcdefg","hef","rdsfsabfd","fvasfvsdf","zdds").stream();
		Optional<String> optional = stream.parallel().filter(p->p.length()>10).findAny();
		String elseGetRsult = optional.orElseGet(()->"no data is suit");
		System.out.println("elseget result:"+elseGetRsult);
		optional.ifPresent(str->System.out.println(str));
		
		
		Optional<Boolean> booPtional =  optional.map(str->str.length()<100);
		booPtional.ifPresent(s->System.out.println(s));
	}
	@Test
	public void test11(){
		System.out.println("-------Optional of-----");
		String str = StringUtils.trimToNull("11");
		Optional<String> optional = Optional.ofNullable(str);
		optional.ifPresent(p->System.out.println(p));
		
	}
	@Test
	public void test12(){
		System.out.println("-----Optional flatMap-------");
		Optional<String> optional = Arrays.asList(new Users("Jack"),new Users("Lucy"),new Users("Jim"),new Users("David")).stream().findFirst().flatMap(Users::getUser);
		optional.ifPresent(str->System.out.println(str));
		
	}
	@Test
	public void test13(){
		System.out.println("--------- stream reduce---------");
		Path path = FileSystems.getDefault().getPath("E:", "test.txt");
		try (Stream<String> dataStream = Files.lines(path)) {
			int strSumLenth = dataStream.reduce(0, (sum, str)->sum+str.length(),(sum1,sum2)->sum1+sum2);
			System.out.println(strSumLenth);
		}catch (Exception e) {
			// TODO: handle exception
		}
		Stream<Integer> intStream = Arrays.asList(1,2,3,4,5,6,7,8,9,10).stream();
		int sum = intStream.reduce(0, (x,y)->x+y);
		System.out.println(sum);
		Arrays.asList(1,2,3,4,5,6,7,8,9,10).stream().reduce((x,y)->x+y).ifPresent(s->System.out.println(s));
		
		
	}
	@Test
	public void test14(){
		System.out.println("-------stream collect sum,count,average,total,max,min-------");
		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
		Stream<Integer> s1 = list.stream();
		List<Integer> result = s1.collect(Collectors.toList());
		result.forEach(i->System.out.println(i));
		Stream<Integer> s2 = list.stream();
		TreeSet<Integer> treeSet = s2.collect(Collectors.toCollection(TreeSet::new));
		treeSet.forEach(c->System.out.println("treeset:"+c));
		IntSummaryStatistics summary = list.stream().collect(Collectors.summarizingInt((x)->x));
		System.out.println(summary.getSum());
		System.out.println(summary.getAverage());
		System.out.println(summary.getCount());
		System.out.println(summary.getMax());
		System.out.println(summary.getMin());
	}
	@Test
	public void test15(){
		System.out.println("-------stream to map--------");
		Stream<Users> stream = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(4,"Lucy")).stream();
		Map<Integer, Users> idName = stream.collect(Collectors.toMap(Users::getId, Function.identity()));
		System.out.println(idName);
		Stream<Users> stream2 = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(2,"Lucy")).stream();
		Map<Integer, String> umap = stream2.collect(Collectors
				.toMap(Users::getId, Users::getName,
						(existingId, newId) -> existingId));
		System.out.println(umap);
		Stream<Users> stream3 = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(2,"Lucy")).stream();
		Map<Integer, Set<String>> u2map = stream3.collect(Collectors
				.toConcurrentMap(Users::getId, u->Collections.singleton(u.getName()),
						(existingName, newName) -> {
							//throw new IllegalStateException();
							Set<String> set = new HashSet<>(existingName);
							set.addAll(newName);
							return set;
						},ConcurrentHashMap::new));
		System.out.println(u2map);
	}
	@Test
	public void test16(){
		System.out.println("--------------stream groupingby partitioningby-----------------");
		Stream<Users> stream = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(2,"Lucy")).stream();
		Map<Integer, List<Users>> umap = stream.collect(Collectors.groupingBy(Users::getId));
		System.out.println(umap);
		Map<Boolean, List<Users>> bmap = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(2,"Lucy")).stream().collect(Collectors.partitioningBy(u->u.getId()>2));
		System.out.println(bmap);
		Map<Integer, Long> bmap2 = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(2,"Lucy")).stream().collect(Collectors.groupingBy(Users::getId,Collectors.counting()));
		System.out.println(bmap2);
		
		Stream<Users> stream3 = Arrays.asList(new Users(1,"Jack"),new Users(2,"Lily"),new Users(3,"Tom"),new Users(2,"Lucy")).stream();
		Map<Integer, Set<String>> u2map = stream3.collect(Collectors.groupingBy(Users::getId,Collectors.mapping(Users::getName, Collectors.toSet())));
		System.out.println(u2map);
	}
	@Test
	public void test17(){
		System.out.println("-------------base data type test------------");
		IntStream intstream = IntStream.of(1,2,3,4,5,6,7,8,9);
		int[] array = new int[]{1,2,3,4,5,6,7,8,9};
		IntStream intstream2 = Arrays.stream(array, 0, array.length);
		intstream.forEach(x->System.out.println(x));
		intstream2.forEach(x->System.out.println(x));
		IntStream.range(0, 10).boxed().forEach(x->System.out.println("0,10 range"+x));
		IntStream.range(0, 10).max().ifPresent(x->System.out.println(x));
		IntStream.range(0, 10).min().ifPresent(x->System.out.println(x));
		IntStream.range(0, 10).boxed().mapToInt(x->x).average().ifPresent(x->System.out.println(x));
		new Random().ints(5).forEach(x->System.out.println("random->"+x));
	}
	@Test
	public void test18(){
		System.out.println("------parallel stream test----------");
		String[] arr = new String[]{"ddsdas","cdascascasd","dsaerwrtyrt","nrtwaefa","frtevbn","erwtbasd","tbwa","wegerb","aevgv"};
		AtomicInteger[] count = new AtomicInteger[100];
		Stream.of(arr).parallel().forEach(str->{AtomicInteger c = count[str.length()];if(c==null){c = new AtomicInteger();}c.incrementAndGet();count[str.length()]=c;});
		System.out.println("parallel test result:"+Arrays.asList(count));
		
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		list.add(6);
		Stream<Integer> stream = list.stream();
		list.add(7);
		stream.forEachOrdered(i->System.out.println(i));
	}
	@Test
	public void test19(){
		System.out.println("------functional interface---------");
//		Supplier<T> 返回T类型的值
//		Consumer<T> 接收处理T类型的数值
//		BiConsumer<T, U> 与Consumer类似
//		Predicate<T> 对T进行返回Boolean操作
//		ToIntFunction<T> 将给定值T计算为int
//		ToDoubleFunction<T>
//		ToLongFunction<T>
//		IntFunction<R> 将int计算为R类型
//		DoubleFunction<R>
//		LongFunction<R>
//		Function<T, R> 将给定T计算为R
//		BiFunction<T, U, R> 将给定T U计算为R
//		UnaryOperator<T> 将给定值进行操作后返回 以下为实例
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		list.replaceAll(x->x*x);
		System.out.println(list);
//		BinaryOperator<T> 对给定的两个值操作后返回，以下为实例
		int sum = list.stream().reduce(0,(x,y)->x+y);
		System.out.println(sum);
		
	}
}
class Users {
	private Integer id;
	private String name;
	public Users(Integer id){
		this.id = id;
	}
	public Users(String name){
		this.name = name;
	}
	public Users(Integer id,String name){
		this.id = id;
		this.name = name;
	}
	public Optional<String> getUser(){
		return Optional.ofNullable(this.name);
	}
	public Integer getId(){
		return this.id;
	}
	public String getName(){
		return this.name;
	}
	@Override
	public String toString() {
		return ReflectionToStringBuilder.toString(this);
	}
}