Stream流操作符

2019-01-15 本文已影响2人 shz_Minato

一概述

Stream操作符分为两类中间操作和终止操作。
中间操作：返回一个Stream流
终止操作：返回非Stream类型的对象
注意点：在终止操作调用之前，中间操作并不执行。

     stringList.stream()
               .map(it -> {
                    String result = it.substring(0, 1).toUpperCase() + it.substring(1);
                    System.out.println("test");
                    return result;
                });
     //运行上面的例子并不会打印"test",原因在与这个Stream操作没有终止操作。
     
    
     stringList.stream()
                .map(it -> {
                    String result = it.substring(0, 1).toUpperCase() + it.substring(1);
                    System.out.println("test");
                    return result;
                })
                .forEach(System.out::println);
        
      //运行上面的离职，在打印每一个元素之前，会打印test字符串
      //因为，forEach是终止操作，会将中间操作激活执行。

二常见操作符介绍

filter(Predicate predicate)
predicate：接受一个参数，返回一个boolean值。用于判断参数是否满足给定的断言条件。
含义：返回一个新的流，流中的元素是旧流中满足predicate的元素。见名知意--->过滤
属性：返回一个流，因此就是中间操作。
实例：

    //打印一个数字集合中所有的奇数元素
    
    public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(2, 4, 1, 4, 3, 6, 7, 10, 23);

        //原有的方式
        for (int i = 0; i < integerList.size(); i++) {
            if (integerList.get(i) % 2 != 0)
                System.out.println(integerList.get(i));
        }

        //Stream方式
        integerList.stream()//创建流
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) {
                        return integer % 2 != 0;
                    }
                })//给定筛选条件 第一处
                .forEach(System.out::println);//打印符合的元素

        //Stream方式
        integerList.stream()//创建流
                .filter(it -> it % 2 != 0)//给定筛选条件 第二处
                .forEach(System.out::println);//打印符合的元素
    }
}

   //第一处
   Predicate 的类型是接受一个参数，返回一个boolean。(T t)->{boolean}
   因此lambda表达式就是 第二处 it的含义就是元素

map(Function mapper)
mapper：接受一个参数，返回一结果。用于将参数类型按着给定的行为转为结果类型
含义：返回一个新的流，流中的元素是旧流中元素mapper之后的元素。见名知意--->转换
属性：返回一个流，因此就是中间操作。
实例：

  //将数字集合中的元素平方后打印
  public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(2, 4, 1, 4, 3, 6, 7, 10, 23);

        integerList.stream()//创建流
                .map(it->it*it)//转换操作  it就是带转换的元素  it*it就是转换的方式
                .forEach(System.out::println);// 遍历 打印
    }
}

flatMap(Function mapper)
mapper：接受一个参数，返回一结果。用于将参数类型按着给定的行为转为结果类型。但是接受的参数是T，返回的类型的Stream。也就是说：将T类型转为Stream流。比如我可以将List、数组、字符串等转为一个单独的流。
含义：返回一个新的流，新流中的元素是旧流中的元素mapper之后的流。也就是新流的初始元素是流，至于开发者对流如何操作，那么结果就会不同。见名知意--->扁平转换,将旧流中的元素构造出子流(开发者编写)，子流汇总成总流(JDK完成)
属性：返回一个流，因此就是中间操作。
实例：将集合中的单词拆开输出

public class StreamTest {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("Hello", "Java");

        //目标：将集合中的单词拆开输出
        //匿名类
        stringList.stream()
                .flatMap(new Function<String, Stream<?>>() {
                    @Override
                    public Stream<?> apply(String s) {//第一处
                        return Arrays.stream(s.split(""));//第二处
                    }
                })
                .forEach(System.out::println);

        //flatMap是一个中间操作，会产生一个流（总流），总流是由第二处的子流汇聚而成。
        //就是说  flatMap是一个汇总的流。至于是由什么子流汇总的，就需要开发者再第二处定义出来
        
        //上面的例子分析
        //单词有字符组成，用单词构成数组子流，然后数组子流汇总成总流
        //第一处的参数s 就是我们旧流中的元素，这里是Hello  Java字符串
        //第二处，我们就需要根据字符串生成数组子流。
        
        //为什么不用字符数组呢，因为Stream的静态方法不支持

        
        //lambda表达式
        stringList.stream()
                .flatMap(it->Arrays.stream(it.split("")))
                .forEach(System.out::println);
    }
}

distinct()
无参
含义：返回一个新的流，流中的元素是旧流中元素去重复的结果，元素相等的条件是equals方法。见名知意--->去重
属性：返回一个流，因此就是中间操作。
实例：数字集合去重后打印

public class StreamTest {
    public static void main(String[] args) {
       Arrays.asList(1,2,3,4,1,1)
               .stream()
               .distinct()
               .forEach(System.out::println);

    }
}

sorted()
无参
含义：返回一个新的流，流中的元素是旧流中元素自然排序的结果。见名知意--->排序
属性：返回一个流，因此就是中间操作。
实例：数字集合排序后打印

public class StreamTest {
    public static void main(String[] args) {
       Arrays.asList(1,2,3,4,1,1)
               .stream()
               .sorted()
               .forEach(System.out::println);

    }
}

peek(Consumer action)
action：接受一个参数，不返回结果。用于将参数执行一个处理
含义：返回一个新的流，流中的元素不变。见名知意--->瞥
属性：返回一个流，因此就是中间操作。
实例：

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 1, 1);

        integerList.stream()
                .peek(it -> {//第一处
                    it += 1;
                    System.out.println(it);
                    System.out.println("-");
                }).forEach(System.out::println);

        //peek只是对元素执行个处理，并不影响顶层源，也不影响新生成的流的元素。
        //也就是瞥一下，执行一个方法内的处理
    }
}
上述的执行的结果
2
-
1
3
-
2
4
-
3

第一个元素为例
第一个是1，首先加1就是第一行的1，然后打印-，接着打印新生成的流的元素，打印的还是1。
综上，peek不影响新生成的流元素，这就是和map的区别。

limit(long maxSize)
maxSize：最大长度
含义：返回一个新的流，流中元素的个数小于等于maxSize。如果旧流的元素大于等于maxSize，新的流就取前maxSize个。如果旧流元素个数小于maxSize，新流元素就是所有的元素。见名知意--->限制个数
属性：返回一个流，因此就是中间操作。
实例：取集合前两个元素

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 2, 3,3,4);

        integerList.stream()
                .limit(2)
                .forEach(System.out::println);
    }
}

skip(long n)
n：个数
含义：返回一个新的流，流中元素跳过了旧流中的前n个元素。见名知意--->跳过n个元素
属性：返回一个流，因此就是中间操作。
实例：跳过集合前两个元素遍历

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 2, 3,3,4);

        integerList.stream()
                .skip(2)
                .forEach(System.out::println);
    }
}

forEach(Consumer action)
action：接受一个参数，不返回结果的行为
含义：对流中的每一个元素，执行action。见名知意--->遍历执行
属性：不返回流，因此就是终止操作（及早求值）
实例：集合遍历等等

Object[] toArray()
无参
含义：根据流中元素生成一个数组。见名知意--->生成数组
属性：不返回流，因此就是终止操作（及早求值）
实例：

T reduce(T identity, BinaryOperator<T> accumulator)
identity：初始值
accumulator：升级版的BiFunction,接受两个参数，生成一个结果，其中参数类型和结果类型相同。
含义：将流中元素聚合成一个结果，聚合的初始值就是identity，聚合的函数就是accumulator。见名知意--->聚合
属性：不返回流，因此就是终止操作（及早求值）
实例：求数字集合的总和

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 2, 3, 3, 4);

        //匿名类的方式
        integerList.stream()
                .reduce(0, new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) {
                        return integer + integer2;//第一处
                    }
                });
        //identity是初始值  BinaryOperator是聚合函数:用什么方式去聚合
        //第一处的两个参数的含义
        //integer 是上次计算的结果（第一次执行的时候改值是初始值）  integer2是流中的元素


        //Lambda表达式
        integerList.stream()
                .reduce(0, (left, right) -> left + right);


        
        //常见的求和、最值、均值、字符串拼接都是聚合操作
        //他还可以支持并行的计算
    }
}

R collect(Supplier<R> supplier,
BiConsumer<R,T>accumulator,
BiConsumer<R, R>combiner)
supplier：不接受参数，返回一个结果
accumulator：接受两个参数，无返回值
combiner：接受一个两个参数，无返回值
泛型：R就是返回的类型，T就是流中元素的类型
含义：将流中元素收集成一个结果，结果就是supplier返回值，收集的方式就是accumulator和combiner(并行流时起作用)。见名知意--->收集
属性：不返回流，因此就是终止操作（及早求值）
实例：将集合中的String拼接

public class StreamTest {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("Hello", " Java", ",", " I", " am", " fine");

        //Lambda
        stringList.stream()
                .collect(() -> new StringBuilder(),//第一处
                        (builder, it) -> builder.append(it),//第二处
                        (left, right) -> left.append(right))
                .toString();//第三处

        //第一处 提供返回的结果 StringBuilder()  无参构造方法
        //第二处 提供收集的方式 append元素
        //第三处 并行时才有用，用于将多线程执行的结果汇总拼接

        //方法引用
        stringList.stream()
                .collect(StringBuilder::new, //无参
                        StringBuilder::append, //调用者时lambda的第一个参数，参数是第一个参数之后的参数
                        StringBuilder::append) //同上
                .toString();
                
        //  R result = supplier.get(); 返回的结果
        //  for (T element : this stream)
        //      accumulator.accept(result, element);//收集的行为
        //  return result;

    }
}

boolean anyMatch(Predicate predicate)
predicate：接受一个参数，返回一个boolean值
含义：判断流中是否存在满足predicate的条件的元素。见名知意--->有一个满足就返回true
属性：不返回流，因此就是终止操作（及早求值）
实例：判断集合元素是否存在奇元素

public class StreamTest {
    public static void main(String[] args) {
      
        List<Integer> integerList = Arrays.asList(2, 3, 4, 6, 8, 10);
        boolean match = integerList.stream()
                .anyMatch(it -> it % 2 != 0);

        System.out.println(match);
        //返回ture
    }
}

Optional<T> findFirst()
无参
含义：返回流中的第一个元素，需要配合Optional使用。见名知意--->找到第一个元素
属性：不返回流，因此就是终止操作（及早求值）
实例：找到集合中的第一个元素

public class StreamTest {
    public static void main(String[] args) {
       
        List<Integer> integerList = Arrays.asList(2, 3, 4, 6, 8, 10);
        integerList.stream()
                .findFirst()
                .ifPresent(System.out::println);
        
        //返回的类型是Optional
        //Optional是值的封装，用于避免空指针异常
        //ifPresent 用于判断值是否存在
    }
}

concat(Stream a, Stream b)
该方法是静态方法，用于创建流，参数是两个流对象
含义：返回一个新的流，新的流是a和b的拼接，需要a和b的类型一致。见名知意--->拼接
属性：返回一个流
实例：将两个集合拼接

public class StreamTest {
    public static void main(String[] args) {
       
        List<Integer> integerList = Arrays.asList(2, 3, 4, 6, 8, 10);
        List<Integer> integerList1 = Arrays.asList(11, 12, 13, 14, 15, 16);

        Stream.concat(integerList.stream(), integerList1.stream())
                .forEach(System.out::println);
    }
}

iterate(final T seed, final UnaryOperator f)
该方法是静态方法，用于创建流
seed产生流的种子
UnaryOperator的类型是接受一个参数，返回一个结果
含义：根据seed和f生成一个流，流的生成是这样的第一个是seed，第二个是f(seed),第三个是f(f(seed))以此类推。见名知意--->重演，流中的元素是无限产生的
属性：返回一个流，需要配合limit使用
实例：按着一定规则创建流

public class StreamTest {
    public static void main(String[] args) {
        Stream.iterate(2, it -> it + 2)
                .limit(6)
                .forEach(System.out::println);
    }
}

Stream流操作符

一概述

二常见操作符介绍

猜你喜欢

热点阅读

Stream流操作符

一 概述

二 常见操作符介绍

猜你喜欢

热点阅读

一概述

二常见操作符介绍