Day_28 Stream

一、Stream API

1.  代码实现
   1.  常见中间操作
      1.  概述：一个中间操作链,对数据进行处理,一个流可以有0~N个中间操作
          他们每一个都返回新的流,方便下一个进行操作
         但是只能有一个终止操作
      2. 常见中间操作：

         1. filter : 对元素进行过滤筛选,不合符的就不要了
         2. distinct : 去掉重复元素
         3. skip : 跳过多少元素
         4. limit : 取最大条数(前几条)
         5. map : 对集合中的元素进行遍历并操作
         6. sorted : 排序

      3. 常见异常
         1. Stream使用之后,必须生成新的流,不能使用原来的stream
            所以可以进行链式调用,因为中间操作返回值都是一个新的stream 
      4. 使用方式

         1. public static void main(String[] args) {
            		List<String> strings = Arrays.asList("a", "b", "c", "a");
            		Stream<String> stream = strings.stream();
            		// stream.filter(x -> false);
            		// Stream使用之后,必须生成新的流,不能使用原来的stream
            		// 所以可以进行链式调用,因为中间操作返回值都是一个新的stream
            		// stream.filter(x->false);
            		/**
            		 * filter : 对元素进行过滤筛选,不合符的就不要了
            		 */
            		// x->!x.equals("a") : 如果返回false,就不要该数据了,如果返回true,就要这个数据
            		// collect(Collectors.toList()) : 终止操作,把stream转换为集合
            		List<String> value = stream.filter(x -> !x.equals("a")).collect(
            				Collectors.toList());
            		System.out.println(value);
            
            		/**
            		 * skip : 跳过 本来是 abca 跳过两个 还剩下 ca
            		 */
            		stream = strings.stream();
            		value = stream.skip(2).collect(Collectors.toList());
            		System.out.println(value);
            		/**
            		 * map : 对集合中的元素进行遍历并操作
            		 */
            		List<Integer> list = Arrays.asList(1000, 1200, 1100, 900, 5500);
            		Stream<Integer> stream2 = list.stream();
            		// 涨薪百分之十
            		List<Integer> result = stream2.map(x -> x + x / 10).collect(
            				Collectors.toList());
            		System.out.println(result);
            
            		/**
            		 * distomct : 去除重复
            		 * 
            		 * 本来是 abca现在是[a, b, c]
            		 */
            		stream = strings.stream();
            		value = stream.distinct().collect(Collectors.toList());
            		System.out.println(value);
            		/**
            		 * limit : 前几条
            		 * 
            		 * 本来是abca 前两条是[a, b]
            		 */
            		stream = strings.stream();
            		value = stream.limit(2).collect(Collectors.toList());
            		System.out.println(value);
            		/**
            		 * sorted : 排序
            		 */
            		
            		stream2 = list.stream();
            		// [900, 1000, 1100, 1200, 5500] 默认升序
            		// result = stream2.sorted().collect(Collectors.toList());
            		
            		// 匿名内部类  更改为降序
            		// [5500, 1200, 1100, 1000, 900]
            		// result = stream2.sorted(new Comparator<Integer>() {
            		// @Override
            		// public int compare(Integer o1, Integer o2) {
            		// return o2-o1;
            		// }
            		// }).collect(Collectors.toList());
            		// lambda写法
            		result = stream2.sorted((x, y) -> y - x).collect(Collectors.toList());
            	
            		System.out.println(result);
            	}

   2. 常见的终止操作
      1.  概述：一旦执行终止操作,中间操作才会真正执行 并且 stream也就不能再被使用了
      2. 常见的终止操作：

         1. forEach : 遍历
         2. collect : 收集器
         3. min,max,count,agerage 计算相关
         4. anyMatch 匹配数据,比如是否包含

      3. 使用方式

         1. public class Stream_02 {
            	public static void main(String[] args) {
            		List<String> strings = Arrays.asList("a","b","c","a","c","a");
            		Stream<String> stream = strings.stream();
            		// forEach
            		stream.limit(2).forEach(x->System.out.println(x));
            		
            		stream = strings.stream();
            		// 获取条数,这种不如直接调用集合的size方法简单一些
            		long count = stream.count();
            		System.out.println(count);
            		// 所以 这样很难体现出count的优势,一般需要结合中间操作执行,优势更大
            		// 统计 有多少a
            		stream = strings.stream();
            		count = stream.filter(x->x.equals("a")).count();
            		System.out.println(count);
            		
            		// 获取最大值 max
            		List<Integer> integers = Arrays.asList(1,2,3,4,5);
            		Stream<Integer> stream2 = integers.stream();
            		Integer i1 = stream2.max((x,y)->x-y).get();
            		System.out.println(i1);
            		
            		// 匹配数据 anyMatch
            		stream2 = integers.stream();
            		boolean flag = stream2.anyMatch(x->x==5);
            		System.out.println(flag);
            		// 上面 这种 使用集合的contains也可以解决,但是也有contains解决不了的问题
            		System.out.println(integers.contains(5));
            		
            		// 比如 好多学生 判断是否有19岁的学生,使用contains的话,Student中就要覆写equals方法了
            		List<Student> students = new ArrayList<Student>();
            		students.add(new Student("张三1", 18));
            		students.add(new Student("张三2", 19));
            		students.add(new Student("张三3", 17));
            		students.add(new Student("张三4", 16));
            		
            		Stream<Student> stream3 = students.stream();
            		flag = stream3.anyMatch(u->u.age==19);
            		System.out.println(flag);
            	}
            }
            class Student{
            	String name;
            	int age;
            	public Student(String name, int age) {
            		super();
            		this.name = name;
            		this.age = age;
            	}
            	
            }

标签：Stream,stream,28,System,collect,stream2,println,Day,out
来源： https://blog.csdn.net/qq_26942049/article/details/121118656