Java8 Stream流

Stream流

Stream不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的,它更像一个高级版本的Iterator.原始版本的Iterator用户只能显式地一个一个遍历元素并对其执行某些操作;对于Stream,用户只要给出需要对其包含的元素执行什么操作,Stream 会隐式地在内部进行遍历,做出相应的数据转换.

Stream流本质上也是对一组元素进行操作(不局限于集合),类似于Iterator,但是使用比其更加便捷.

和迭代器又不同的是,Stream可以并行化操作,迭代器只能命令式地,串行化操作

用于每次操作的返回值都是Stream,所以Stream流可以链式操作

Stream的另外一大特点是,数据源本身可以是无限的.


创建Stream流

常用方式

  1. Stream接口中的静态方法(jdk8中,接口允许有静态方法)

    1. of(T t)
    2. of(T... t)
    3. generate()
    4. iterate()
  2. Collection接口的默认方法stream()和parallelStream()
  3. BufferedReader的lines()方法
  4. Arrays的stream()方法

示例

Stream<String> s1 = Stream.of("asdfas", "asdfasdf", "asdfasf");
IntStream s2 = Arrays.stream(arr);
Stream<String> s3 = list.stream();

对于基本数值型,目前有三种对应的包装类型 Stream: IntStream, LongStream, DoubleStream.当然也可以用 Stream,但是boxing和unboxing会很耗时,所以特别为这三种基本数值型提供了对应的Stream


转换Stream

distinct()

  1. 去重,产生的流中没有重复元素
  2. 依赖于元素的equals()方法
static int[] arr = {0,6,2,3,4,5,5,6,7,2,1,0,3,4};
static void run2(){
    IntStream s = Arrays.stream(arr);
 s = s.distinct();
 int[] arr3 = s.toArray();
 for(int o:arr3){
        System.out.print(o+"t");
 }
    System.out.println();
}
执行结果
0 6 2 3 4 5 7 1

filter(Predicate p)

  1. 根据给定函数进行过滤
  2. Predicate接口是一个函数接口,需要实现其test方法
  3. boolean test(T t);
  4. 建议使用lambda表达式或者方法引用
IntStream s = Arrays.stream(arr);
s = s.filter(x -> {
    return x > 2;
});
show(s);
6 3 4 5 5 6 7 3 4

map(Function f)

  1. 根据给定函数,对流中的元素进行转换操作(可以是类型上的转换),新生成的流中只包含转换后的元素
  2. 包含三个针对于基本类型的变种方法mapToInt,mapToLong和mapToDouble
  3. Function接口也是一个函数接口,需要实现其apply方法
  4. R apply(T t);
IntStream s = Arrays.stream(arr);
s = s.map(x -> {
            if (x < 3) {
                x += 10;
 }
            return x;
 }
);
show(s);
10 6 12 3 4 5 5 6 7 12 11 10 3 4

flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

  1. 和map类似,不同的是其每个元素转换得到的是Stream对象,会把子Stream中的元素压缩到父集合中
  2. image.png
  3. flatMap把inputStream中的层级结构扁平化,就是将最底层元素抽出来放到一起,最终output的新Stream里面有List,都是直接的数字.

peek(Consumer c)

  1. 元素不变,但是每个元素都会执行给定的函数
  2. Consumer为函数接口
  3. void accept(T t);
IntStream s = Arrays.stream(arr);
s = s.peek(x -> {
    System.out.print("x: "+x*2+"t");
});
show(s);
x: 0 x: 12 x: 4 x: 6 x: 8 x: 10 x: 10

sorted(Comparator c)

  1. 对元素进行排序
  2. Comparator,即之前学过的比较器
  3. int compare(T o1, T o2);
static class User{
    int age ;
 public User(int age) {
        this.age = age;
 }
    @Override
 public String toString() {
        return "User{" +
                "age=" + age +
                '}';
 }
}
static void run6(){
    Stream<User> s = Stream.of(new User(12), new User(1), new User(18));
 s = s.sorted((o1,o2)-> o1.age>o2.age?1:-1);
 Object[] objects = s.toArray();
 for (Object o : objects) {
        System.out.print(o + "t");
 }
    System.out.println();
}
User{age=1} User{age=12} User{age=18}

findFirst

  1. 它总是返回Stream的第一个元素,或者空

limit(long l)

  1. 对流进行截断操作,只获取前l个元素
  2. generate(),iterate()获取的流一定要使用

skip(long l)

  1. 跳过前l个元素,如果流中元素个数小于l,则返回null

reduce

  1. 这个方法的主要作用是把Stream元素组合起来.
  2. 它提供一个起始值,然后依照运算规则(BinaryOperator),和前面 Stream的第一个,第二个,第n个元素组合.
  3. 从这个意义上说,字符串拼接,数值的sum,min,max,average都是特殊的reduce
  4. 例如Stream的sum就相当于
  5. Integer sum = integers.reduce(0, (a, b) -> a+b); 或
  6. Integer sum = integers.reduce(0, Integer::sum);

image.png


min/max

  1. min和max的功能也可以通过对Stream元素先排序,再findFirst来实现.但前者的性能会更好,为O(n),而sorted的成本是O(nlogn)

allMatch,anyMatch,noneMatch

  1. allMatch:Stream中全部元素符合传入的predicate,返回true
  2. anyMatch:Stream中只要有一个元素符合传入的predicate,返回true
  3. noneMatch:Stream中没有一个元素符合传入的predicate,返回true
  4. 它们都不是要遍历全部元素才能返回结果.返回结果后自动关闭流.
int[] arr = {0, 6, 2, 3, 4, 5, 5, 6, 7, 2, 1, 0, 3, 4};
IntStream s = Arrays.stream(arr);
boolean b1 = s.allMatch(x -> {
    return x > 3;
});
System.out.println(b1);
false

Reduce操作(归约操作?)

返回一个数组

toArray()
例如Object[] s0 = status0Express.toArray();

返回一个集合

collect()
借助Collectors时使用更加简便
collect(Collectors.toList())

示例

Object[] arr2 = s1.toArray();
int[] arr3 = s2.toArray();
List<String> list1 = s3.collect(Collectors.toList());

评论

暂无评论