Java8使用list.stream操作元素的基本方法

jdk8引入Stream流的概念 流中包含 源、中间过程、终止操作，当流声明源和中间过程时代码并不会执行，只有执行终止操作时才会执行

	public static void main(String[] args) {

		//jdk8引入Stream流的概念 流中包含 源、中间过程、终止操作，当流声明源和中间过程时代码并不会执行，只有执行终止操作时才会执行
		//新建一个stream
		Stream stream1 = Stream.of("hello","world","hello world");
		
		String[] arr = new String[] {"hello","world","hello world"};
		Stream stream2 = Stream.of(arr);
		
		Stream steam3 = Arrays.stream(arr);
		
		//list转流
		List<String> list = Arrays.asList(arr);
		Stream steam4 = list.stream();
		
		//list中流的使用
		//map(映射) 接收Function<T>为参数 输入一个参数返回一个结果
		list.stream().map(str -> str.toUpperCase()).forEach(str -> System.out.println(str)); //HELLO /r/n WORLD /r/n HELLO WORLD
		
		//distinct 去重
		list = Arrays.asList("a","b","c","c","d");
		list.stream().distinct().forEach(str -> System.out.println(str)); // a b c d
		
		//count 获取流中元素个数
		System.out.println(list.stream().count());  //5
		
		//flatMap 合并集合中包含的集合元素 使之成为一个包含只元素的集合
		List<String> list1 = Arrays.asList("a","b","c","d");
		List<String> list2 = Arrays.asList("e","f","g","h");
		//list3 为装入list1/list2的集合
		List<List<String>> list3 = Arrays.asList(list1,list2);
		list3.stream().flatMap(strList -> strList.stream()).forEach(str -> System.out.println(str)); //a b c d e f g h
		
		//使用收集器Collectors.joining()完成对集合中字符串的合并
		List<String> list4 = Arrays.asList("hello","world");
		System.out.println(list4.stream().collect(Collectors.joining()));    //helloworld
		System.out.println(list4.stream().collect(Collectors.joining(" ")));  //hello world
		System.out.println(list4.stream().collect(Collectors.joining("-")));  //hello-world
		
		System.out.println("--------------------------list元素计算----------------------------");
		//list元素计算
		List<Integer> listInt = Arrays.asList(1,2,3,4,5,6,7,8,9);
		//计算集合中所有元素按条件计算和的值 0代表起始值为0 
		//1*2 + 2*2 + 3*2 + 4*2 + 5*2 + 6*2 + 7*2 + 8*2 + 9*2
		int sum = listInt.stream().map(i -> i*2).reduce(0, (i1,i2) -> Integer.sum(i1, i2));
		System.out.println(sum); //90
		//使用方法引用写法
		listInt.stream().map(i -> i*2).reduce(0, Integer::sum);

		//filter传入条件如果取真则继续
		//计算集合中大于5元素的个数
		System.out.println(listInt.stream().filter(i -> i>5).count());   //4
		
		//IntStream为Stream对操作int类型的特定类 减少int类型拆装箱的损耗
		//iterate迭代输入一个种子参数 之后按照传入方法去持续生成元素
		//1.以1为种子参数 不断使用i=i+2函数去生成元素 2.取前6个生成的元素 3.过滤元素大于2 4.将符合条件元素乘以2 5.去除前两个元素 6.保留前两个元素
		IntStream iterate = IntStream.iterate(1, i -> i + 2).limit(6).filter(i -> (i > 2)).map(i -> i * 2).skip(2).limit(2);
		//IntSummaryStatistics为流中元素计算后值的一个对象，其中包含了最大值，最小值，平均数等基本信息
		IntSummaryStatistics iss = iterate.summaryStatistics();
		System.out.println(iss.getMax());  //18
		System.out.println(iss.getMin());  //14
		System.out.println(iss.getCount());  //2
		
		//元素排序
		listInt = Arrays.asList(5,2,8,4,9,3,7,1,6);
		listInt.stream().sorted(Comparator.comparingInt(i -> i)).forEach(System.out::println); // 1 2 3 4 5 6 7 8 9
		//reversed反转排序 使用reversed后可能导致比较的参数不能正确感知上下文类型
		listInt.stream().sorted(Comparator.comparingInt((Integer i) -> i).reversed()).forEach(System.out::println); // 9 8 7 6 5 4 3 2 1
		//等价于
		listInt.stream().sorted((i1,i2) -> i1<i2?-1:1).forEach(System.out::println); // 1 2 3 4 5 6 7 8 9

	}

注意流中经过中间过程的处理计算并不会改用原对象中的信息，需要指定Collector收集器才能保存处理后的信息

	public static void main(String[] args) {
		List<String> list1 = Arrays.asList("a","b","c","d");
		List<String> list2 = list1.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());
		//指定一种收集器可以是list也可以是set的实现类
		List<String> list3 = list1.stream().map(s -> s.toUpperCase()).collect(Collectors.toCollection(ArrayList::new));
		//list1中的元素并没有被修改
		list1.stream().forEach(System.out::println); //a b c d
		//必须使用收集器去存放流处理过的元素
		list2.stream().forEach(System.out::println); //A B C D
		list3.stream().forEach(System.out::println); //A B C D
	}