Stream(一)

import java.time.LocalDate;
import java.util.Objects;

public class Employee {
	private String name;
	private Double salary;
	private Integer age;
	private LocalDate hireDay;
	
	public Employee() {
		super();
	}

	public Employee(String name,Double salary,Integer age, LocalDate hireDay) {
		super();
		this.name=name;
		this.salary = salary;
		this.age=age;
		this.hireDay = hireDay;
	}
        //省略get set hashCode equals toString方法
        ··············
}

 

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.Stream;

import org.junit.Test;
import pojo.Employee;

public class StreamIntermediateTest {
	Employee[] e= {
		new Employee("张三",500.0,25,LocalDate.of(1995, 03, 07)),
		new Employee("李四",400.0,20,LocalDate.of(1999, 01, 13)),
		new Employee("王五",700.0,23,LocalDate.of(1997, 11, 27)),
		new Employee("赵六",900.0,26,LocalDate.of(1994, 07, 06)),
		new Employee("阿七",400.0,22,LocalDate.of(1998, 10, 19)),
		new Employee("阿七",400.0,22,LocalDate.of(1998, 10, 19))
	};
	@Test
	public void createStream() {
		//of(T...t)方法传入元素可以获得一个有限长度的流
		Stream<Integer> of = Stream.of(1,2,3,4,5);
		
		//generate(supplier<T> s)方法可以获得一个无限长度的流
		Stream<Random> generate = Stream.generate(()->new Random());
		
		//iterate(final T seed, final UnaryOperator<T> f)方法也可以获取一个无限长度的流，
		//seed指定元素的种子  f的方法对给指定的元素种子迭代而产生无限连续有序Stream
		//可以认为是：把1作为参数传给了f的apply()方法无限循环+1
		Stream<Integer> iterate = Stream.iterate(1,(x)->x+1);
		
		//empty()方法返回一个空的Stream，不包含任何元素项。
		Stream<Object> empty = Stream.empty();
		
		//使用集合中的stream()方法可以获取一个流
		//parallelStream()方法可以获取一个并行流
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		Stream<Integer> stream = list.stream();
		Stream<Integer> parallelStream = list.parallelStream();
	}
	
	// 中间操作（返回值是Stream）
	//filter(Predicate<? super T> predicate)  过滤出符合条件的元素
	@Test
	public void filterTest() {
		List<Employee> list = Arrays.asList(e);
		list.stream()
			.filter((e)->e.getName().equals("阿七"))
			.forEach(System.out::println);
	}
	输出：	
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]
	

	//limit(long maxSize)	获取流中的前几个元素
	@Test
	public void limitTest() {
		List<Employee> list = Arrays.asList(e);
		Stream<Employee> limit = list.stream().limit(3);
		limit.forEach(System.out::println);
	}
	输出：
	Employee [name=张三, salary=500.0, age=25, hireDay=1995-03-07]
	Employee [name=李四, salary=400.0, age=20, hireDay=1999-01-13]
	Employee [name=王五, salary=700.0, age=23, hireDay=1997-11-27]


	//skip(long n)  过滤掉前几个元素，获取剩下的元素
	@Test
	public void skipTest() {
		List<Employee> list = Arrays.asList(e);
		Stream<Employee> skip = list.stream().skip(3);
		skip.forEach(System.out::println);
	}
	输出：
	Employee [name=赵六, salary=900.0, age=26, hireDay=1994-07-06]
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]


	//sorted(Comparator<? super T> comparator) 将流进行排序，返回一个有序的新流（无参方法为基本类型排序）
	@Test
	public void sortedTest() {
		List<Employee> list = Arrays.asList(e);
		//这里根据年龄排序
		Stream<Employee> sorted = list.stream().sorted((x,y)->x.getAge().compareTo(y.getAge()));
		sorted.forEach(System.out::println);
	}
	输出：
	Employee [name=李四, salary=400.0, age=20, hireDay=1999-01-13]
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]
	Employee [name=王五, salary=700.0, age=23, hireDay=1997-11-27]
	Employee [name=张三, salary=500.0, age=25, hireDay=1995-03-07]
	Employee [name=赵六, salary=900.0, age=26, hireDay=1994-07-06]


	//distinct()   除去流中的重复元素    需要重写Employee类的 hashCode() equals()方法
	@Test
	public void distinctTest() {
		List<Employee> list = Arrays.asList(e);
		Stream<Employee> distinct = list.stream().distinct();
		distinct.forEach(System.out::println);
	}
	输出：
	Employee [name=张三, salary=500.0, age=25, hireDay=1995-03-07]
	Employee [name=李四, salary=400.0, age=20, hireDay=1999-01-13]
	Employee [name=王五, salary=700.0, age=23, hireDay=1997-11-27]
	Employee [name=赵六, salary=900.0, age=26, hireDay=1994-07-06]
	Employee [name=阿七, salary=400.0, age=22, hireDay=1998-10-19]


	/* concat(Stream a,Stream b)   Stream的静态方法 把两个流合并成一个新流
	 *  若两个输入的Stream都串行的，则新Stream也是串行的；
	 *  若输入的Stream中任何一个是并行的，则新的Stream也是并行的；
	 *  若关闭新的Stream时，原两个输入的Stream都将执行关闭处理。
	 */	
	@Test
	public void concatTest() {
		Stream<Integer> concat = Stream.concat(Stream.of(4,2,0), Stream.of(3,1));
		concat.forEach(System.out::println);
	}
	输出：
	4
	2
	0
	3
	1

	/* 
	 * peek(Consumer<? super T> action)  生成一个包含原Stream的所有元素的新Stream，
	 * 	同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都
	 * 	会执行给定的消费函数(原Stream也会跟着执行但不进行消费操作)，并且消费函数优先执行
	 */
	@Test
	public void peekTest() {
		List<Employee> list = Arrays.asList(e);
		Stream<Employee> peek = list.stream().peek((e)->System.out.println(e.getName()));
		peek.limit(1).forEach(System.out::println);
	}
	输出：
	张三
	Employee [name=张三, salary=500.0, age=25, hireDay=1995-03-07]


	/*
	 * map(Function<? super T, ? extends R> mapper)	将元素转化为其他形式或提取信息，
	 * 	传入Function对象调用的apply()方法会应用到每一个元素，
	 * 	并将其映射为一个新的元素。
	 */
	@Test
	public void mapTest() {
		String[] s= {"aaa","bbb","ccc"};
		List<String> list = Arrays.asList(s);
		Stream<String> map = list.stream().map(String::toUpperCase);
		map.forEach(System.out::println);
		System.out.println("=====================");
		Stream<Stream<Character>> map2 = list.stream().map(StreamIntermediateTest::toCharacter);
		map2.forEach((stream)->{
			stream.forEach(System.out::println);
		});
	}
	输出：
	AAA
	BBB
	CCC
	=====================
	a
	a
	a
	b
	b
	b
	c
	c
	c


	/* 
	 * flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) 
	 * 	传入Function对象调用的apply()方法会应用到每一个元素，并将其映射为一个新的元素。
	 * 	把所有的流连接为一个流
	 */
	@Test
	public void flatMapTest() {
		String[] s= {"aaa","bbb","ccc"};
		List<String> list = Arrays.asList(s);
		Stream<Character> flatMap = list.stream().flatMap(StreamIntermediateTest::toCharacter);
		flatMap.forEach(System.out::println);
	}
	输出：
	a
	a
	a
	b
	b
	b
	c
	c
	c

	public static Stream<Character> toCharacter(String s){
		ArrayList<Character> list = new ArrayList<Character>();
		for (Character character : s.toCharArray()) {
			list.add(character);
		}
		return list.stream();
	}
}