JDK8-Stream总结【精简】

lambda表达式是stream的基础，初学者建议先学习lambda表达式: JDK8-lambda表达式。 及其JDK8-Optional类

1 Stream流特点

• 1.stream不存储数据
• 2.stream不改变源数据
• 3.stream的延迟执行特性

通常我们在数组或集合的基础上创建stream，stream不会专门存储数据，对stream的操作也不会影响到创建它的数组和集合,对于stream的聚合、消费或收集操作只能进行一次，再次操作会报错，如下代码：

public static void main(String[] args) {
    Stream<String> stream = Stream.generate(()->"user").limit(5);
    stream.forEach(System.out::println);
}

2 创建Stream

1）通过数组创建 – Arrays.stream()或者Stream.of()

    //1.通过Arrays.stream
    //1.1基本类型
    int[] arr = new int[]{1,2,34,5};
    IntStream intStream = Arrays.stream(arr);
    //1.2引用类型
    Student[] studentArr = new Student[]{new Student("s1",29),new Student("s2",27)};
    Stream<Student> studentStream = Arrays.stream(studentArr);
    //2.通过Stream.of
    Stream<Integer> stream1 = Stream.of(1,2,34,5,65);
    //注意生成的是int[]的流
    Stream<int[]> stream2 = Stream.of(arr,arr);
    stream2.forEach(System.out::println);

2）通过集合创建流 – list.stream()或者list.parallelStream()

    List<String> strs = Arrays.asList("11212","dfd","2323","dfhgf");
    Stream<String> stream  = strs.stream();  //创建普通流
    Stream<String> stream1 = strs.parallelStream(); //创建并行流

3）创建空的流 – Stream.empty(

	Stream<Integer> stream  = Stream.empty(); 	//创建一个空的stream

4）创建无限流 – tream.generate(lambda表达式生成数据)

    //创建无限流，通过limit提取指定大小
    Stream.generate(()->"number"+new Random().nextInt()).limit(100).forEach(System.out::println);
    Stream.generate(()->new Student("name",10)).limit(20).forEach(System.out::println);

5）创建规律的无限流 Stream.iterate(lamvda表达式生成规律数据)

	// 产生规律的数据
    Stream.iterate(0,x->x+1).limit(10).forEach(System.out::println);
    Stream.iterate(0, UnaryOperator.identity()).limit(10).forEach(System.out::println);

3 对流的操作

1）最常使用

1 map – 转换流，将一种类型的流转换为另外一种流

	// map把一种类型的流转换为另外一种类型的流,将String数组中字母转换为大写
	String[] arr = new String[]{"yes", "YES", "no", "NO"};
	Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);

2 filter – 过滤流，过滤流中的元素

	Integer[] arr = new Integer[]{1,2,3,4,5,6,7,8,9,10};
	Arrays.stream(arr).filter(x->x>3&&x<8).forEach(System.out::println);

3 flapMap – 拆解流，将流中每一个元素拆解成一个流

    String[] arr1 = {"a", "b", "c", "d"};...
    List<String> collect = Stream.of(arr1, arr2).flatMap(Arrays::stream).collect(Collectors.toList());
    Stream.of(arr1, arr2).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);

4 sorted – 对流进行排序

String[] arr1 = {"abc","a","bc","abcd"};
Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
 
/**
 * 倒序。reversed(),java8泛型推导的问题，所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
 * Comparator.reverseOrder():也是用于翻转顺序，用于比较对象（Stream里面的类型必须是可比较的）
 * Comparator. naturalOrder()：返回一个自然排序比较器，用于比较对象（Stream里面的类型必须是可比较的）
 */
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
 
// thenComparing,先按照首字母排序,之后按照String的长度排序
public void testSorted3_(){
    Arrays.stream(arr1).sorted(Comparator.comparing(this::com1).thenComparing(String::length)).forEach(System.out::println);
}
public char com1(String x){
    return x.charAt(0);
}

2）提取流和组合流

public void init(){
    arr1 = new String[]{"a","b","c","d"};....
}

1 limit – 限制从流中获得前n个数据

    Stream.iterate(1,x->x+2).limit(10).forEach(System.out::println);

2 skip – 跳过前n个数据

    Stream.iterate(1,x->x+2).skip(1).limit(5).forEach(System.out::println);

3 concat – 合并流

 	// 可以把两个stream合并成一个stream（合并的stream类型必须相同）,只能两两合并
    Stream<String> stream1 = Stream.of(arr1);
    Stream<String> stream2 = Stream.of(arr2);
    Stream.concat(stream1,stream2).distinct().forEach(System.out::println);

3）聚合操作

@Before
public void init(){
    arr = new String[]{"b","ab","abc","abcd","abcde"};
}

1 max、min – 最大最小值

Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);
Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);

2 count – 计算数量

long count = Stream.of(arr).count();
System.out.println(count);

3 findFirst – 查找第一个

String str =  Stream.of(arr).parallel().filter(x->x.length()>3).findFirst().orElse("noghing");
System.out.println(str);

4 findAny – 找到所有匹配的元素

// findAny,找到所有匹配的元素,对并行流十分有效,只要在任何片段发现了第一个匹配元素就会结束整个运算
Optional<String> optional = Stream.of(arr).parallel().filter(x->x.length()>3).findAny();
optional.ifPresent(System.out::println);

5 anyMatch – 是否含有匹配元素

Boolean aBoolean = Stream.of(arr).anyMatch(x->x.startsWith("a"));
System.out.println(aBoolean);

4）收集结果

Student[] students;
@Before
public void init(){
    students = new Student[100];
    for (int i=0;i<30;i++){
        Student student = new Student("user",i);
        students[i] = student;
    }...
}

1 生成list、set、map

     // 生成List
    List<Student> list = Arrays.stream(students).collect(toList());
    list.forEach((x)-> System.out.println(x));
    // 生成Set
    Set<Student> set = Arrays.stream(students).collect(toSet());
    set.forEach((x)-> System.out.println(x));
    // 如果包含相同的key，则需要提供第三个参数，否则报错
    Map<String,Integer> map = Arrays.stream(students).collect(toMap(Student::getName,Student::getScore,(s,a)->s+a));
    map.forEach((x,y)-> System.out.println(x+"->"+y));

2 生成数组

    Student[] s = Arrays.stream(students).toArray(Student[]::new);
    for (int i=0;i<s.length;i++)
        System.out.println(s[i]);

3 指定生成的类型

    HashSet<Student> s = Arrays.stream(students).collect(toCollection(HashSet::new));
    s.forEach(System.out::println);

4 统计

    IntSummaryStatistics summaryStatistics = Arrays.stream(students).collect(Collectors.summarizingInt(Student::getScore));
    System.out.println("getAverage->"+summaryStatistics.getAverage());
    System.out.println("getMax->"+summaryStatistics.getMax());
    System.out.println("getMin->"+summaryStatistics.getMin());
    System.out.println("getCount->"+summaryStatistics.getCount());
    System.out.println("getSum->"+summaryStatistics.getSum());

5）分组和分片

分组和分片的意义是，将collect的结果集展示位Map<key,val>的形式：

Student[] students;
@Before
public void init(){
    students = new Student[100];
    for (int i=0;i<30;i++){
        Student student = new Student("user1",i);
        students[i] = student;
    }...
}

1 groupingBy – 分组

    Map<String,List<Student>> map = Arrays.stream(students).collect(groupingBy(Student::getName));
    map.forEach((x,y)-> System.out.println(x+"->"+y));

2 partitioningBy – 分成两组

 	// 如果只有两类，使用partitioningBy会比groupingBy更有效率
    Map<Boolean,List<Student>> map = Arrays.stream(students).collect(partitioningBy(x->x.getScore()>50));
    map.forEach((x,y)-> System.out.println(x+"->"+y));

3 downstream – 指定类型类分组

    Map<String,Set<Student>> map = Arrays.stream(students).collect(groupingBy(Student::getName,toSet()));
    map.forEach((x,y)-> System.out.println(x+"->"+y));

4 downstream --分组时进行聚合操作

    // counting
    Map<String,Long> map1 = Arrays.stream(students).collect(groupingBy(Student::getName,counting()));
    map1.forEach((x,y)-> System.out.println(x+"->"+y));
    // summingInt
    Map<String,Integer> map2 = Arrays.stream(students).collect(groupingBy(Student::getName,summingInt(Student::getScore)));
    map2.forEach((x,y)-> System.out.println(x+"->"+y));
    // maxBy
    Map<String,Optional<Student>> map3 = Arrays.stream(students).collect(groupingBy(Student::getName,maxBy(Comparator.comparing(Student::getScore))));
    map3.forEach((x,y)-> System.out.println(x+"->"+y));
    // mapping
    Map<String,Set<Integer>> map4 = Arrays.stream(students).collect(groupingBy(Student::getName,mapping(Student::getScore,toSet())));
    map4.forEach((x,y)-> System.out.println(x+"->"+y));

4 原始类型流

在数据量比较大的情况下，将基本数据类型（int,double…）包装成相应对象流的做法是低效的，因此，我们也可以直接将数据初始化为原始类型流，在原始类型流上的操作与对象流类似，我们只需要记住两点

• 1.原始类型流的初始化
• 2.原始类型流与流对象的转换

    // 原始类型流的初始化
    @Before
    public void testStream1(){
        doubleStream = DoubleStream.of(0.1,0.2,0.3,0.8);
        intStream = IntStream.of(1,3,5,7,9);
        IntStream stream1 = IntStream.rangeClosed(0,100);
        IntStream stream2 = IntStream.range(0,100);
    }
    // 包装流与原始类型流的转换
    @Test
    public void testStream2(){
        Stream<Double> stream = doubleStream.boxed();
        doubleStream = stream.mapToDouble(Double::new);
    }

5 并行流

可以将普通顺序执行的流转变为并行流，只需要调用顺序流的parallel() 方法即可，如Stream.iterate(1, x -> x + 1).limit(10).parallel()。
问答：

1 sorted()、distinct()等对并行流的影响？ sorted()、distinct()是元素相关方法，和整体的数据是有关系的,map，filter等方法和已经通过的元素是不相关的,
不需要知道流里面有哪些元素 ，并行执行和sorted会不会产生冲突呢？

结论：1.并行流和排序是不冲突的，2.一个流是否是有序的，对于一些api可能会提高执行效率，对于另一些api可能会降低执行效率

6 ‌‌stream和‌parallelStream的基本区别

Stream和parallelStream是‌Java 8中引入的两种流处理方式。Stream是顺序流，它在单个线程上执行，适用于数据量较小或不需要并行处理的情况。而parallelStream支持并行处理，可以充分利用多核处理器的优势，显著提高处理大量数据的性能。

‌性能差异‌

顺序流在单个线程上执行，因此在处理小量数据时通常比并行流更快。然而，当处理大量数据时，并行流可以充分利用多核处理器的优势，从而显著提高性能。需要注意的是，并行流在处理过程中可能会引入额外的开销，如线程创建、同步和合并结果等，因此在数据量较小的情况下，使用并行流可能并不会带来性能提升。

‌适用场景‌

顺序流适用于数据量较小或不需要并行处理的情况，例如在处理一些简单的数据转换或过滤操作时，使用顺序流通常更加简单和高效。而并行流则适用于需要处理大量数据，并且这些数据之间没有依赖关系的情况。