JDK1.8新特性学习(四)——Stream流

package test4;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.DoubleSummaryStatistics;
import java.util.List;import java.util.TooManyListenersException;
import java.util.function.Function;
import java.util.stream.Stream;

import com.oracle.jrockit.jfr.Producer;

import sun.net.www.content.text.plain;
import test.Product;

/**
 * jdk1.8 Stream流学习
 *
 */
public class StreamTest {
	
	/**
	 * 获取流的几种方式
	 */
	public static void test(){
		/*
		 * 数组——获取流 1
		 */
		String [] strList = {"1234","234","456"};
		Stream<String> stream = Arrays.stream(strList);
		/*
		 * 集合——获取流 2
		 */
		List<String> list = Arrays.asList("1234","234","456");
		Stream<String> stream2 = list.stream();
		/*
		 * 集合——获取流3
		 */
		Stream<String> stream3 = Stream.of("1234","234","456");
	}
	
	/**
	 * forEach() 使用该方法迭代流中的每个数据
	 */
	public static void test2(List<Product> list){
		/*
		 * JDK1.8前
		 */
		System.out.println("JDK1.8前");
		for (Product product : list) {
			System.out.println(product.toString());
		}
		
		/*
		 * java 8 lambda
		 */
		System.out.println("java 8 lambda");
		list.forEach(product->System.out.println(product));
		
		/*
		 * java 8 stream lambda
		 */
		System.out.println("java 8 stream lambda");
		list.stream().forEach(product->System.out.println(product));
	}
	
	/**
	 * sorted() 使用该方法排序数据
	 */
	public static void test3(List<Product> list){
		
		System.out.println("排序前");
		for (Product product : list) {
			System.out.println(product.toString());
		}
		System.out.println("排序后");
		
		System.out.println("JDK1.8前");
		Collections.sort(list, new Comparator<Product>(){
			@Override
			public int compare(Product o1, Product o2) {
				return o1.getPrice().compareTo(o2.getPrice());
			}
		});
		list.stream().forEach(product->System.out.println(product));
		
		System.out.println("JDK1.8 Stream 方法引用");
		list.stream().sorted(Comparator.comparing(Product::getPrice)).forEach(product->System.out.println(product));
	}
	
	/**
	 * 
	 * filter()：使用该方法过滤
	 */
	public static void test4(List<Product> list){
		/*
		 *输出商品价格大于1000的商品 
		 */
		System.out.println("过滤前");
		list.forEach(product->System.out.println(product));
		System.out.println("过滤后");
		
		/*
		 * JDK1.8前
		 */
		System.out.println("JDK1.8前");
		for (Product product2 : list) {
			if (product2.getPrice() > 1000) {
				System.out.println(product2);
			}
		}
		
		System.out.println("JDK1.8后");
		list.stream().filter((Product p)->p.getPrice()>1000).forEach(b->System.out.println(b));
	}
	
	
	/**
	 * 
	 * limit()：使用该方法截断
	 */
	public static void test5(List<Product> list){
		/*
		 *从前两个开始截断，只输出前两个
		 */
		System.out.println("截断前");
		list.forEach(product->System.out.println(product));
		System.out.println("截断后");
		
		/*
		 * JDK1.8前
		 */
		System.out.println("JDK1.8前");
		for (int i = 0; i < 2; i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("JDK1.8后");
		list.stream().limit(2).forEach(b->System.out.println(b));
	}
	
	
	/**
	 * 
	 * skip()：与limit互斥，使用该方法跳过元素
	 * skip的位置开始于1
	 */
	public static void test6(List<Product> list){
		/*
		 *跳过前2个元素,从第3个输出
		 */
		System.out.println("原集合输出");
		list.forEach(product->System.out.println(product));
		System.out.println("跳过元素后");
		
		/*
		 * JDK1.8前
		 */
		System.out.println("JDK1.8前");
		for (int i = 0; i < list.size(); i++) {
			if(i >= 2){
				System.out.println(list.get(i));
			}
		}
		
		System.out.println("JDK1.8后");
		list.stream().skip(2).forEach(b->System.out.println(b));
	}
	
	
	/**
	 * 
	 * distinct()：使用该方法去重，注意：必须重写对应泛型的hashCode()和equals()方法
	 */
	public static void test7(List<Product> list){
		/*
		 *跳过前2个元素,从第3个输出
		 */
		System.out.println("原集合输出");
		list.forEach(product->System.out.println(product));
		System.out.println("去重后");
		
		/*
		 * JDK1.8前,会报错
		 */
		System.out.println("JDK1.8前");
		int size = list.size();
		for (int i = 0; i < size; i++) {
			for (int j = list.size() - 1; j > i; j--) {
				if (list.get(i).getProductName().equals(list.get(j).getProductName()) && 
					list.get(i).getColor().equals(list.get(j).getColor()) &&
					list.get(i).getPrice().equals(list.get(j).getPrice())){
					list.remove(i);  //此处报错java.lang.UnsupportedOperationException
					size--;
					
				}
			}
		}
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println("JDK1.8后");
		list.stream().distinct().forEach(b->System.out.println(b));
	}
	
	
	/**
	 * 
	 * 去重+取价格大于200从小到大+取前2
	 */
	public static void test8(List<Product> list){
		list.stream().distinct().filter(p->p.getPrice() >200)
					 .sorted(Comparator.comparing(Product::getPrice)).limit(2).forEach(b->System.out.println(b));
	}
	
	/**
	 * 
	 * max，min，sum，avg，count 
	 */
	public static void test9(List<Product> list){
		DoubleSummaryStatistics summaryStatistics = list.stream().mapToDouble(product -> product.getPrice()).summaryStatistics();
		System.out.println("总和"+summaryStatistics.getSum());
		System.out.println("平均"+summaryStatistics.getAverage());
		System.out.println("最大"+summaryStatistics.getMax());
		System.out.println("最小"+summaryStatistics.getMin());
		System.out.println("数量"+summaryStatistics.getCount());
	}
	
	/**
	 * 
	 * map()：接收一个方法作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
	 */
	public static void test10(List<Product> list){
		/**
		 * 只输出所有商品的价格
		 */
		List<Double> list2 = list.stream().map(p -> p.getPrice()).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
		list2.forEach(p->System.out.print(p+","));
		
		/**
		 * 商品颜色全部转成大写
		 */
		List<String> list3 = list.stream().map(s -> s.getColor().toUpperCase()).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
		list3.forEach(p->System.out.println(p));
	}
	
	
	/**
	 * 
	 * 将原来的stream中的所有元素都展开组成一个新的stream
	 */
	public static void test11(List<Product> list){
		//创建一个装有两个泛型为Integer的集合
		Stream<List<Integer>> stream = Stream.of(Arrays.asList(1,3,5),Arrays.asList(2,4));
		//将两个合为一个
		Stream<Integer> flatMap = stream.flatMap((Function<List<Integer>, Stream<Integer>>)integers->integers.stream());
		ArrayList<Integer> collect = flatMap.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
		System.out.println("新Stream的大小"+collect.size());
		System.out.println("合并后");
		collect.forEach(p->System.out.println(p));
	}
	
	/**
	 *使用该方法获取第一个元素 
	 */
	public static void test12(List<Product> list){
		Product product = list.stream().findFirst().get();
		System.out.println(product);
	}
	
	
	public static void main(String[] args) {
		List<Product> list = Arrays.asList(
				new Product("雨伞","pink",56.0),
				new Product("短裤","blue",100.0),
				new Product("手表","Silver",1000.0),
				new Product("手表","Silver",1000.0),
				new Product("笔记本","white",10000.0),
				new Product("洗衣机","white",2000.0),
				new Product("电饼铛","white",200.0));
		//test2(list);
		//test3(list);
		//test4(list);
		//test5(list);
		//test6(list);
		//test7(list);
		//test8(list);
		//test9(list);
		//test10(list);
		//test11(list);
		test12(list);
	}
}