Stream流的三类方法

获取Stream流：创建一条流水线，并把数据放到流水线上准备进行操作
中间方法：流水线上的操作。一次操作完毕之后，还可以继续进行其他操作。
终结方法：一个Stream流只能有一个终结方法，流水线上的最后一个操作

1.获取Stream流

stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。

集合获取stream流的方式

名称	说明
default Stream<E> stream()	获取当前集合对象的Stream流
public static <T> Stream<T> stream(T[] array)	获取当前数组的stream流
public static<T> Stream<T> of(T...values)	获取当前数组/可变数据的Stream流

import java.util.*;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
       //集合
        List<String> list = new ArrayList<>();
        Stream<String> s = list.stream();
        //Map
        Map<String,Integer> maps =new HashMap<>();
        Stream<String> keyStream =maps.keySet().stream();
        Stream<Integer> valueStream =maps.values().stream();
        Stream<Map.Entry<String,Integer>> keyandvalueStream=maps.entrySet().stream();
        //数组
        String[] names = {"A","B"};
        Stream<String> nameStream = Arrays.stream(names);
        Stream<String> nameStream2 = Stream.of(names);
    }
}

2.中间方法

stream流的常用API(中间操作方法)

中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程在stream流中无法直接修改集合、数组中的数据

名称	说明
Stream<T> filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤
Stream<T> limit(long maxSize)	获取前几个元素
Stream<T>skip(long n)	跳过前几个元素
Stream<T> distinct()	去除流中重复的元素。依赖(hashCode和equals方法)
static <T> Stream<T> concat(Stream a，Stream b)	合井a和b两个流为一个流

中间方调用完成后返回新的Stream流可以继续使用，支持链式编程在stream流中无法直接修改集合、数组中的数据 

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张一一");
        list.add("张二");
        list.add("张三三");
        list.add("张三三");
        list.add("李思思");
        list.add("刘武");
        list.add("张六");
        list.add("张琪琪");
        System.out.println("-------------------------**filter-------------------------------");
        //------------------------------------------------------
        //Stream<T> filter(Predicate<? super T> predicate);
        //
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张");
//            }
//
//        });
        //*-------------
//        list.stream().filter(s -> s.startsWith("张")).forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//
//            }
//        });
        //--------------
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        //----------------------------------------------------

        long size = list.stream().filter(s -> s.length() ==3).count();
        System.out.println(size);
        System.out.println("------------------------**limit--------------------------------");
        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));
        //.forEach(s -> System.out.println(s))
        //lamada 两个变量（s）一样，两个参数相同，方法引用
        // println() 功能已经定义好了
        // 使用 System.out 中的 println() 功能
        //list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);
        System.out.println("-------------------------**skip-------------------------------");
        list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);
        System.out.println("------------------------**distinct--------------------------------");
        list.stream().distinct().forEach(s -> System.out.println(s));
        System.out.println("------------------------**Map--------------------------------");
        //*Map 加工方法 第一个参数（原材料） -> 第二个参数（加工后的结果）
        //给集合元素前加”一班的“
//        list.stream().map(new Function<String, Object>() {
//            public String apply(String s){
//                return "一班的" + s;
//            }
//        });
        list.stream().map(s -> "一班的" +s).forEach(s1 -> System.out.println(s1));

        //将名称加工成学生对象
        //新建Student类
        list.stream().map(s -> new Student(s)).forEach(s -> System.out.println(s) );
        //list.stream().map(Student::new).forEach(System.out::println); //构造器引用 方法引用
        System.out.println("------------------------**concat--------------------------------");
        Stream<String> s1 =list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 =Stream.of("老张","小张");
        //public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b
        Stream<String> s3 =Stream.concat(s1,s2); //不同类型的流合并用Objects接
        s3.forEach(s -> System.out.println(s));
    }
}

public class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

3.终结方法

stream流的常见终结操作方法

名称	说明
void forEach(Consumer action)	对此流的每个元素执行遍历操作
long count()	返回此流中的元素数

注意:终结操作方法，调用完成后流就无法继续使用了，原因是不会返回stream了

注意

使用 Java 流（Stream）时，有一些关键点需要注意，以确保正确和高效地使用流。以下是一些关键点：

1. 流的“惰性求值”：

   • 惰性求值意味着中间操作不会立即执行，而是等到遇到终端操作时才会触发。
   • 这种特性允许构建复杂的流水线，只有在需要结果时才进行计算。
   • 中间操作的惰性求值使得可以有效地处理大型数据集，只计算所需的部分数据。

2. 流的“只能消费一次”：

   • 一旦流执行了终端操作，它就不能再被使用。尝试在同一个流上执行多个终端操作会导致异常。（IllegalStateException: stream has already been operated upon or closed ）
   • 为了执行多次操作，应该创建新的流，或者在每次终端操作前重新创建流。

3. 避免修改源数据：

   • 流操作通常基于不可变原则，即中间操作返回一个新的流而不修改原有集合的状态。
   • 这有助于避免在多线程环境下的竞态条件，也使得代码更易读和维护。

4. 使用合适的操作：

   • 选择合适的流操作以满足需求。例如，使用 filter 进行条件过滤，使用 map 进行转换，使用 reduce 进行汇总等。
   • 了解每种操作的含义和适用场景，以确保选择最合适的操作。

5. 并行流的注意事项：

   • 并行流允许多线程同时处理流的元素，提高性能。
   • 在处理并行流时，需要注意线程安全性，确保并行执行不会导致不一致的结果。
   • 对于某些操作，串行流可能比并行流更有效率，具体取决于数据集的大小和性质。

6. null 安全：

   • 流操作中要注意处理可能包含 null 值的情况，以避免空指针异常。
   • 可以使用 filter 过滤掉 null 值，或者使用 Objects.requireNonNull 进行校验。

7. 有状态和无状态的操作：

   • 无状态操作（如 filter 和 map）不依赖于流中的其他元素，其结果仅取决于每个元素本身。
   • 有状态操作（如 distinct 和 sorted）可能依赖于其他元素，其结果可能会受到整个流的状态影响。

8. 避免无限流陷阱：

   • 无限流是可能的，但要确保在对无限流执行终端操作之前，有一种方式来限制流的大小，否则可能导致无限循环。
   • 可以使用 limit 或者在某些情况下使用短路操作（如 findFirst）来处理无限流。

9. 使用适当的数据结构：

   • 流的性能可能受到底层数据结构的影响，例如 ArrayList 比 LinkedList 更适合进行随机访问。
   • 在选择数据结构时，考虑流操作的具体需求，以最大程度地提高性能。

这些关键点是确保在使用 Java 流时能够充分利用其潜力并避免常见陷阱的关键要素。理解这些概念并在编写代码时考虑到它们，有助于更好地应用流式编程