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
}