Java Stream

Stream的概述

/*
 * StreamAPI：
 * 	 StreamAPI是用来处理数据，处理集合等容器中的数据，处理操作有：查询、筛选、删除、过滤、统计、映射等。
 * 	 希望能够用类似于SQL语法的形式对Java内存中的数据进行处理。
 * 	
 *   SQL是对数据库中的数据进行处理。
 * 
 * 
 * Stream本身不负责存储数据，存储数据是用集合，数组等数据结构。
 * Stream只负责对数据进行处理、加工。
 * 
 * Stream的操作分为三步：
 * 1、创建Stream：告知Stream数据的来源是哪里？
 * 2、加工处理：这个过程可以很多步  0~n
 * 3、终结操作：收集结果
 *  一旦终结就不能再加工了，如果要加工需要重新创建Stream。
 *  
 *  Stream的特点：
 *  （1）Stream本身不负责存储数据，存储数据是用集合，数组等数据结构。
 *  （2）Stream是不可变，一旦修改，就会产生新的Stream对象。Stream不会修改数据源的数据。
 *  （3）Stream的操作是一个延迟操作。所有的操作都必须延迟到终结操作时，一起处理。
 *  
 */
public class Test06Stream {
	@Test
	public void test01(){
		ArrayList<Employee> list= new ArrayList<>();
		list.add(new Employee(1,"张三"));
		list.add(new Employee(1,"张三"));
		
		Stream<Employee> stream = list.stream();
		stream = stream.distinct();//处理，中间操作  
		long count = stream.count();//统计个数   终结操作
		System.out.println(count);
		System.out.println("over");
		System.out.println("--------------------");
		//重新遍历list
		for (Employee employee : list) {
			System.out.println(employee);
		}
		
	}
}
class Employee{
	private int id;
	private String name;
	public Employee(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public Employee() {
		super();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("比较....");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

Stream的创建

/*
 * Stream接口：
 * 实现类
 * IntStream
 * DoubleStream
 * LongStream
 * 
 * 一、创建Stream
 * 1、方式一：通过集合创建
 * 		集合对象.stream()
 * 2、方式二：通过数组工具类Arrays
 * 	   Arrays.stream(数组对象)
 * 3、方式三：Stream接口的静态方法of方法，产生一个有限流
 * 		Stream.of(...)
 * 4、方式四：Stream接口的静态方法
 * （1）generate方法，产生无限流
 * （2）Stream<T> iterate(T seed, UnaryOperator<T> f)  
 */
public class Test07StreamCreate {
	@Test
	public void test06(){
		/*
		 * Stream<T> iterate(T seed, UnaryOperator<T> f)  
		 * UnaryOperator接口，SAM接口，抽象方法：
		 * 
		 * UnaryOperator<T> extends Function<T,T>
		 * 		T apply(T t)
		 */
		Stream<Integer> stream = Stream.iterate(1, num -> num+=2);
//		stream = stream.limit(10);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test05(){
		Stream<Double> stream = Stream.generate(Math::random);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test04(){
		Stream<Integer> stream = Stream.of(1,2,3,4,5);
		stream.forEach(System.out::println);
	}
	
	@Test
	public void test03(){
		String[] arr = {"hello","world"};
		Stream<String> stream = Arrays.stream(arr);
	}
	
	@Test
	public void test02(){
		int[] arr = {1,2,3,4,5};
		IntStream stream = Arrays.stream(arr);
	}
	
	@Test
	public void test01(){
		List<Integer> list = Arrays.asList(1,2,3,4,5);
		
		//JDK1.8中，Collection系列集合增加了方法
		Stream<Integer> stream = list.stream();
	}
}

Stream的中间操作

/*
 * 二、中间的加工操作
 * （1）filter(Predicate p)：过滤
 * （2）distinct()：去重
 * （3）limit(long maxSize)：取有限的几个
 * （4）skip(long n)：跳过n个
 * （5）peek(Consumer action)  接收Lambda表达式，对流中的每个数据执行Lambda体操作
 * （6）sorted()：排序，按照自然排序
 *    sorted(Comparator com)：排序，按照定制排序
 *  （7）map(Function f)：接收Lambda表达式，对流中的每个数据，执行Lambda体操作，返回新的数据构成新的流
 *  （8）flatMap(Function f)
 *  
 *    map(Function<? super T,? extends R> mapper)   map操作流中的把T对象变成R对象，由R对象构成新的流
 *    flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 
 *    				 flatMap把流中的数据T对象压扁变成一个Stream，然后把一个个的Stream最后再合成一个大的Stream
 */
public class Test08StreamMiddle {
	
	@Test
	public void test12(){
		String[] arr = {"hello","world","java"};
		Stream<String> flatMap = Arrays.stream(arr)
			.flatMap(t -> Stream.of(t.split("|")));//Function<T,R>接口抽象方法 R apply(T t)  现在的R是一个Stream
		flatMap.forEach(System.out::println);
	}
	
	
	@Test
	public void test11(){
		String[] arr = {"hello","world","java"};
		
		Arrays.stream(arr)
		
			.map(t->t.toUpperCase())
			.forEach(System.out::println);
	}
	
	@Test
	public void test10(){
		Stream.of(1,2,3,4,5)
			.map(t -> t+=1)//Function<T,R>接口抽象方法 R apply(T t)
			.forEach(System.out::println);
	}
	
	@Test
	public void test09(){
		//希望能够找出前三个最大值，前三名最大的，不重复
		Stream.of(11,2,39,4,54,6,2,22,3,3,4,54,54)
			.distinct()
			.sorted((t1,t2) -> -Integer.compare(t1, t2))//Comparator接口  int compare(T t1, T t2)
			.limit(3)
			.forEach(System.out::println);
	}
	
	@Test
	public void test08(){
		long count = Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.distinct()
			.peek(System.out::println)  //Consumer接口的抽象方法  void accept(T t)
			.count();
		System.out.println("count="+count);
	}
	
	
	@Test
	public void test07(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.skip(5)
			.distinct()
			.filter(t -> t%3==0)
			.forEach(System.out::println);
	}

	@Test
	public void test06(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.skip(5)
			.forEach(System.out::println);
	}
	
	@Test
	public void test05(){
		Stream.of(1,2,2,3,3,4,4,5,2,3,4,5,6,7)
			.distinct()  //(1,2,3,4,5,6,7)
			.filter(t -> t%2!=0) //(1,3,5,7)
			.limit(3)
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test04(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.limit(3)
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test03(){
		Stream.of(1,2,3,4,5,6,2,2,3,3,4,4,5)
			.distinct()
			.forEach(System.out::println);
	}
	
	
	@Test
	public void test02(){
		Stream.of(1,2,3,4,5,6)
			.filter(t -> t%2==0)
			.forEach(System.out::println);
	}
	
	@Test
	public void test01(){
		//1、创建Stream
		Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
		
		//2、加工处理
		//过滤：filter(Predicate p)
		//把里面的偶数拿出来
		/*
		 * filter(Predicate p)
		 * Predicate是函数式接口，抽象方法：boolean test(T t)
		 */
		stream = stream.filter(t -> t%2==0);
		
		//3、终结操作：例如：遍历
		stream.forEach(System.out::println);
	}
}

Stream的终结操作

/*
 * 创建：一步
 * 中间：0~n步
 * 终结：一步
 * 
 * 三、终结操作
 * 1、void forEach(Consumer )：遍历流中的数据
 * 2、long count()：统计个数
 * 3、boolean allMatch(Predicate p)：是否全部满足xx条件
 *   boolean anyMatch(Predicate p)：是否有一个满足xx条件
 *   boolean noneMatch(Predicate  p)：是否全部都不满足xx条件
 * 4、  Optional<T> findFirst()：返回第一个
 *    Optional<T> findAny()：返回任意一个
 * 5、Optional<T> max(Comparator c)：找出最大的
 *   Optional<T> min(Comparator c)  ：找出最小的
 * 6、T reduce(T iden, BinaryOperator b) 通过反复的运算，留下最后一个结果
 *  Optional<U>  reduce(BinaryOperator b)
 * 7、R collect(Collector c)：把流中的数据最后都收集到一起
 *   Collector接口
 *   
 *   BiConsumer  抽象方法   void accept(R r,T t)
 */
public class Test09StreamEnding {
	
	@Test
	public void test14(){
		List<Integer> list = Stream.of(1,2,4,5,7,8)
				.filter(t -> t%2==0)
				.collect(Collectors.toList());
		
		System.out.println(list);
	}
	
	
	@Test
	public void test13(){
		Optional<Integer> reduce = Stream.of(1,2,4,5,7,8)
			 .reduce((t1,t2) -> t1>t2?t1:t2);//BinaryOperator接口   T apply(T t1, T t2)
		System.out.println(reduce);
	}
	
	@Test
	public void test12(){
		Integer reduce = Stream.of(1,2,4,5,7,8)
			 .reduce(0, (t1,t2) -> t1+t2);//BinaryOperator接口   T apply(T t1, T t2)
		System.out.println(reduce);
	}
	
	@Test
	public void test11(){
		Optional<Integer> max = Stream.of(1,2,4,5,7,8)
				.max((t1,t2) -> Integer.compare(t1, t2));
		System.out.println(max);
	}
	
	@Test
	public void test10(){
		Optional<Integer> opt = Stream.of(1,2,4,5,7,8)
				.filter(t -> t%3==0)
				.findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test09(){
		Optional<Integer> opt = Stream.of(1,2,3,4,5,7,9)
				.filter(t -> t%3==0)
				.findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test08(){
		Optional<Integer> opt = Stream.of(1,3,5,7,9).findFirst();
		System.out.println(opt);
	}
	
	@Test
	public void test04(){
		boolean result = Stream.of(1,3,5,7,9)
			.anyMatch(t -> t%2==0);
		System.out.println(result);
	}
	
	
	@Test
	public void test03(){
		boolean result = Stream.of(1,3,5,7,9)
			.allMatch(t -> t%2!=0);
		System.out.println(result);
	}
	
	@Test
	public void test02(){
		long count = Stream.of(1,2,3,4,5)
				.count();
		System.out.println("count = " + count);
	}
	
	
	@Test
	public void test01(){
		Stream.of(1,2,3,4,5)
				.forEach(System.out::println);
	}
}

Optional类

/*
 * Optional实际上是个容器，它是一个装一个对象的容器。这个对象可能是个空，可能是非空。
 * 数组和集合是装多个对象的容器。
 * 
 * 1、创建Optional对象的方法：
 * （1）Optional.of(xx);  			只能装非空对象
 * （2）Optional.ofNullable(x);		装可以是null的对象
 * （3）Optional<T> empty()          直接返回一个空箱子对象
 * 
 * 2、如何取出Optional容器中的对象
 * （1）get()  必须配合of(xx)使用，因为这里面的对象不能是null
 * （2）orElse(T other)   如果Optional容器中的对象是空的，用other代替
 * （3）orElseGet(Supplier<? extends T> other) 如果Optional容器中的对象是空的，用other这个供给型接口提供的对象代替
 * （4）orElseThrow(Supplier<? extends X> exceptionSupplier) 
 * 
 * 3、其他操作
 * Optional<T> filter(Predicate<? super T> predicate)  
 */
public class TestOptional {
	@Test
	public void test9(){
		String str = "hello";
		Optional<String> opt = Optional.ofNullable(str);
		Optional<String> opt2 = opt.filter(s->s.length()>5);
		System.out.println(opt2);
	}
	
	
	@Test
	public void test8(){
		String str = null;
		Optional<String> opt = Optional.ofNullable(str);
		String string = opt.orElseThrow(()->new RuntimeException("值不存在"));
		System.out.println(string);
	}
	
	
	@Test
	public void test7(){
		String str = null;
		Optional<String> opt = Optional.ofNullable(str);
		String string = opt.orElseGet(String::new);
		System.out.println(string);
	}
	
	@Test
	public void test6(){
		String str = "hello";
		Optional<String> opt = Optional.ofNullable(str);
		String string = opt.orElse("atguigu");
		System.out.println(string);
	}
	
	@Test
	public void test5(){
		String str = null;
		Optional<String> opt = Optional.ofNullable(str);
//		System.out.println(opt.get());//java.util.NoSuchElementException: No value present
	}
	
	@Test
	public void test4(){
		String str = "hello";
		Optional<String> opt = Optional.of(str);

		String string = opt.get();
		System.out.println(string);
	}
	
	
	@Test
	public void test3(){
		String str = null;
		Optional<String> opt = Optional.ofNullable(str);
		System.out.println(opt);
	}
	
	@Test
	public void test2(){
		String str = "hello";
		Optional<String> opt = Optional.of(str);
		System.out.println(opt);
	}
	
	
	@Test
	public void test1(){
		ArrayList<Student> list = new ArrayList<>();
		list.add(new Student("张三", 23));
		//...
		
		//取出流中第一个年龄大于30岁的学生
		Optional<Student> opt = list.stream()
			.filter(s -> s.getAge()>30)
			.findFirst();
	
		
		//打印该学生的年龄
		Student stu = opt.orElse(new Student());
		System.out.println("学生的年龄：" + stu.getAge());
	}
}
class Student{
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}