Java从入门到精通十七(Stream 流)-阿里云开发者社区

Stream 流引入说明

这是java8 引入的新的特性

和之前介绍的java IO 流多多少少有所区别。简单的说IO就是进行了基本的数据传输操作，Stream是对集合的数据进行过滤操作。主要就是对集合进行操作。IO涉及比较广，主要还是进行数据的传输。

相比较集合的话就是一般是配合使用的。集合是用来对数据进行一个存储，不会对数据进行其它形式的处理，主要就是存储。Stream是会对数据处理的，判断，过滤，计算都有。

一般在对集合中的数据进行处理的话，结合Stream可以非常方便进行操作。我们一般还是配合Lambda表达式的模式进行处理。代码比较简化优雅。

Stream 流的常用方法说明

1： filter（）

filter(Predicate<? super T> predicate)

返回由与此给定谓词匹配的此流的元素组成的流。

会返回判断条件为true的元素，这个方法会返回一个流

如下，我们先用filter 来返回判断结果为true的流，然后再调用collect中的方法让它返回集合。

ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("张敏");
        list.add("张无忌");
        List<String> list_ = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());

2：collect（）

至于collect方法，我们主要需要了解它的一些用法。

collect(Collector<? super T,A,R> collector)

1.Collectors.toList()：转换成List集合。/ Collectors.toSet()：转换成set集合。

List<String> list_de = list.stream().collect(Collectors.toList());

2:Collectors.toCollection(TreeSet::new)：转换成特定的set集合。

TreeSet<String> treeset = list.stream().collect(Collectors.toCollection(TreeSet::new));

3:Collectors.toMap(keyMapper, valueMapper, mergeFunction)：转换成map

这个方法包含三个重载方法

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
        BinaryOperator<U> mergeFunction);
toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,
        BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier);

keyMapper：Key 的映射函数

valueMapper：Value 的映射函数

mergeFunction：当 Key 冲突时，调用的合并方法

mapSupplier：Map 构造器，在需要返回特定的 Map 时使用

需要注意的是如果键出现重复或者值为空的时候可能出现异常.所以再转换map的时候可以对值得冲突首先做处理.

简单举例

先创建一个类,Student_clo

package Stream;
public class Student_clo<S, I extends Number, S1> {
    private String name;
    private Integer age;
    private String id;
    public Student_clo(S jgdabc, I i, S snka) {
        this.name = (String) jgdabc;
        this.age = (Integer) i;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
**测试类的使用**

package Stream;
import java.util.ArrayList;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;
public class Student_Collection {
    public static void main(String[] args) {
//        Student_clo student_clo = new Student_clo();
//        Student_clo student_1_clo = new Student_clo();
//        Student_clo student_2_clo = new Student_clo();
        ArrayList<Student_clo<String,Integer,String>> student = new ArrayList<>(3);
        student.add(new Student_clo<>("jgdabc",12,"snka"));
        student.add(new Student_clo<>("jgdb",13,"45"));
        student.add(new Student_clo<>("sjns",19,"asjsa"));
//        v1,v2 这边对可能出现的键冲突进行了处理，只是用一下方法
        student.stream().collect(Collectors.toMap(Student_clo::getAge, Student_clo::getName,(v1,v2)->v2));
    }
}

3：distinct()

3：distinct() 方法

这个方法得作用是比较简单的，就是用来去除重复的元素。操作对象也是为流对象。

4：sorted()/sorted（）

4: sorted()/sorted(T,T)->int)

方法的主要作用就是实现一个排序。如果流中的元素实现了Comparable接口，有自己的排序规则，就可以直接调用sorted（）方法，如果没有实现排序接口，那么需要调用sorted((T,T)->int )去实现排序接口。

定义一个基本类

package Stream;
public class Student_clo<S, I extends Number, S1> {
    private String name;
    private Integer age;
    private String id;
    public Student_clo(S jgdabc, I i, S snka) {
        this.name = (String) jgdabc;
        this.age = (Integer) i;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}

package Stream;
import javax.sound.midi.Soundbank;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Student_Collection {
    public static void main(String[] args) {
//        Student_clo student_clo = new Student_clo();
//        Student_clo student_1_clo = new Student_clo();
//        Student_clo student_2_clo = new Student_clo();
        ArrayList<Student_clo<String,Integer,String>> student = new ArrayList<>(3);
        student.add(new Student_clo<>("jgdabc",12,"snka"));
        student.add(new Student_clo<>("jgdb",11,"45"));
        student.add(new Student_clo<>("sjns",19,"asjsa"));
        List<Student_clo<String, Integer, String>> list_sort = student.stream().sorted((p1,p2)->p1.getAge()-p2.getAge()).collect(Collectors.toList());
        for(Student_clo l: list_sort)
        {
            System.out.println(l.getAge()+l.getName());
        }
        System.out.println(list_sort);
    }
}

5： limit（）

5:limit（long n）

返回前n个元素，也就是对处理返回的元素做一个限制

List<Student_clo<String, Integer, String>> list_sort = student.stream().sorted((p1,p2)->p1.getAge()-p2.getAge()).limit(2).collect(Collectors.toList());

6：skip()

6:skip(long n)

这个方法是用来过滤掉前n个元素，也可以认为是跳过

List<Student_clo<String, Integer, String>> list_sort = student.stream().sorted((p1,p2)->p1.getAge()-p2.getAge()).limit(2).skip(1).collect(Collectors.toList());

7：forEach（）

7:forEach（）方法

该方法可用于对集合进行一个遍历输出

8：map（）

8:映射(转换)：map

实现将流中的元素映射到另一个流当中

其中接口类型为Function，在写lambda需要注意一下泛型接口就可以

list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);

9：count()

9:count()

也可以认为是一个终结方法，主要是对元素进行计数，例如返回的的计数。比较简单，对象当然还是操作在Stream流上。

10：concat（）

10：concat（）方法

对流进行一个合并

// 取前四个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        //跳过两个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        //合并需求两个流
        Stream.concat(s1,s2).forEach(System.out::println);

11：flatMap()

11:flatMap()

对比map 方法的话，区别在于如果map中有流中嵌套了，那么一次遍历是得不到想要的结果的，需要两次遍历，如果我们要flapMap它只需要一次遍历，也就是它会把每个流打开，那么当然只需要一次遍历。

12： peek（）

12 peek（） peek 函数会按照消费接口Consumer函数进行消费处理，并可以改变函数的一些属性。

list.stream().peek(s-> System.out.println(s));
  list.stream().peek(System.out::print);
  list.stream().peek(StringBuffer::new);

13：iterate()

13：iterate() 方法

返回有序无限连续 Stream由函数的迭代应用产生 f至初始元素 seed ，产生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等

Stream.iterate(0,x->x+1).limit(6).forEach(System.out::println);
        //0,1,2,3,4,5

14： reduce()

14: reduce() 方法

对集合形成的流对象进行一个归约

使用 associative累积函数对此流的元素执行 reduction ，并返回描述减小值的 Optional （如果有）。

8的api说的十分精准而难懂。

我们可以用它来做对集合形成的流对象中的元素进行求和。

ArrayList<Integer> list_i = new ArrayList<>();
        list_i.add(1);
        list_i.add(2);
        list_i.add(3);
        Integer sum = list_i.stream().reduce(0, Integer::sum);
        System.out.println(sum);//6

15： max()/min()

15: max()/min() 方法

还是操作流对象，只不过可以用这个方法来进行获取最大的对象，继而获取值。

先定义了一个Student_clo类

package Stream;
public class Student_clo<S, I extends Number, S1> {
    private String name;
    private Integer age;
    private String id;
    public Student_clo(S jgdabc, I i, S snka) {
        this.name = (String) jgdabc;
        this.age = (Integer) i;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}

ArrayList<Student_clo<String,Integer,String>> student = new ArrayList<>(3);
        student.add(new Student_clo<>("jgdabc",12,"snka"));
        student.add(new Student_clo<>("jgdb",11,"45"));
        student.add(new Student_clo<>("sjns",19,"asjsa"));
        Optional<Student_clo<String, Integer, String>> max = student.stream().max((e1, e2) -> e1.getAge() - e2.getAge());
        System.out.println(max.get().getAge());//返回到最大年龄为19

16：allMatch()/anyMatch()/noneMatch()

16:allMatch()/anyMatch()/noneMatch()

很明显就是作为匹配，分别对应全部匹配，一个或者一个以上的匹配，不匹配。如果满足对应的条件，就返回True,反之，返回false。

具体去用的话就十分清楚明了。

boolean b = list_i.stream().allMatch(i -> i > 0);
  boolean b1 = list_i.stream().anyMatch(i -> i > 2);
  boolean b2 = list_i.stream().noneMatch(i -> i - 3 >= 0);

创建Stream 流

通过Collection集合提供的stream（）方法

在介绍方法的上面已经说明了。就是Collection集合系列。基本该说的都说了。前面运用的方法基本都是在集合的基础上进行说明。

Stream<String> stream2 = list.stream();

使用数组

用流将数组包围起来以后，就可以更加方便的使用一些方法（Stream流上的一些处理）

String arr[] = {"jgdabc","dnkas","esfnsa"};
        Stream<String> arr1 = Stream.of(arr);
        Stream<String> limit = arr1.limit(1);
        limit.forEach(System.out::println);

也可以使用数组中的方法去转换为stream流

final IntStream stream1 = Arrays.stream(new int[]{1, 2, 3});

Stream.iterate()

完整格式

Stream.iterate(final T seed, final UnaryOperator f)

基本在方法说明上也说了。

从参数上具体分析的话，就是一个常量seed,可指定泛型，然后呢，生成到f,f是UnaryOpeartor类型的。

这个类型是什么呢？查看源码的话，还是返现也就是一个继承Function的接口，然后里面有一个静态的方法。

很明显的就是一个函数式接口，稍微了解下就好。

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
    /**
     * Returns a unary operator that always returns its input argument.
     *
     * @param <T> the type of the input and output of the operator
     * @return a unary operator that always returns its input argument
     */
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

具体使用这个iterate的时候也就可以正如上面方法中提到的。做到一个类似遍历取值的效果。

Stream.iterate(0, n -> n + 1).limit(5).forEach(a -> {
            System.out.println(a);//0，1，2，3，4
        });

Stream.generate()

其实和iterate一样创建的是无限流。

怎么体现，随机数生成，就可以体现。因为无限流的特点，一般需要用limit（）去进行限制。配合使用。还是挺好玩的。只要了解到lambda，函数式编程，好奇的话，看看源码，接口，就完事。

如果你不限制的话，生成时不会结束的。有趣。

Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(10));

限制一下

Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(10)).limit(10);
        stream.forEach(e -> System.out.println(e));

parallelStream(并行流)

我们也可以去用一个并行流

其实这个流，可以直接放在集合这边去归结，但是感觉这个并行流还是十分有特点的。并行的一个流，采用了多线程的方式。既然采用多线程，那么如果我foreach()进行终结遍历stream所包含的集合的元素，那么一个输出无需。为了好区分，避开使用set集合去验证这个特点。

ArrayList<String> list = new ArrayList<>();
list.add("10");
list.add("20");
list.add("30");
list.add("13");
list.add("50");
Integer arr[] = {1,2,3,4};
list.parallelStream().forEach(System.out::println);

并行可以提高效率，原理使用的还是forkjoin线程池。就简单介绍一下。从集合Collection的并行流的这个方法一直追溯源码的话，会一直找到其实是使用了forkjoin线程池。

Java从入门到精通十七(Stream 流)

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料