java8 stream 流常用方法合集-mile米乐体育

目录

• 一、概述
• 二、分类
• 三、具体用法
• 1. 流的常用创建方法
• 2. 流的中间操作
• 3. 流的终止操作

一、概述

stream 是 java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用stream api 对集合数据进行操作，就类似于使用 sql 执行的数据库查询。也可以使用 stream api 来并行执行操作。

• 不是数据结构，不会保存数据。
• 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
• 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。

二、分类

• 指元素的处理不受之前元素的影响；
• 指该操作只有拿到所有元素之后才能继续下去。
• 指必须处理所有元素才能得到最终结果；
• 指遇到某些符合条件的元素就可以得到最终结果，如 a || b，只要a为true，则无需判断b的结果。

三、具体用法

1. 流的常用创建方法

1.1 使用​​collection​​下的​​stream()​​和​​parallelstream()​​方法

list list = new arraylist<>(); stream stream = list.stream(); //获取一个顺序流 stream parallelstream = list.parallelstream(); //获取一个并行流

1.2 使用arrays 中的​​stream()​​方法，将数组转成流

integer[] nums = new integer[10]; stream stream = arrays.stream(nums);

1.3 使用stream中的静态方法：​​of()​​、​​iterate()​​、​​generate()​​

stream stream = stream.of(1,2,3,4,5,6); stream stream2 = stream.iterate(0, (x) -> x 2).limit(6); stream2.foreach(system.out::println); // 0 2 4 6 8 10 stream stream3 = stream.generate(math::random).limit(2); stream3.foreach(system.out::println);

1.4 使用​​bufferedreader.lines()​​方法，将每行内容转成流

bufferedreader reader = new bufferedreader(new filereader("f:\\test_stream.txt")); stream linestream = reader.lines(); linestream.foreach(system.out::println);

1.5 使用​​pattern.splitasstream()​​方法，将字符串分隔成流

pattern pattern = pattern.compile(","); stream stringstream = pattern.splitasstream("a,b,c,d"); stringstream.foreach(system.out::println);

2. 流的中间操作

• filter：过滤流中的某些元素
• limit(n)：获取n个元素
• skip(n)：跳过n元素，配合limit(n)可实现分页
• distinct：通过流中元素的hashcode()和equals()去除重复元素

stream stream = stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14); stream newstream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14 .distinct() //6 7 9 8 10 12 14 .skip(2) //9 8 10 12 14 .limit(2); //9 8 newstream.foreach(system.out::println);

• 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

list list = arrays.aslist("a,b,c", "1,2,3"); //将每个元素转成一个新的且不带逗号的元素 stream s1 = list.stream().map(s -> s.replaceall(",", "")); s1.foreach(system.out::println); // abc 123 stream s3 = list.stream().flatmap(s -> { //将每个元素转换成一个stream string[] split = s.split(","); stream s2 = arrays.stream(split); return s2; }); s3.foreach(system.out::println); // a b c 1 2 3

• ​​sorted()​​：自然排序，流中元素需实现comparable接口
• ​​sorted(comparator com)​​：定制排序，自定义comparator排序器

list list = arrays.aslist("aa", "ff", "dd"); //string 类自身已实现compareable接口 list.stream().sorted().foreach(system.out::println);// aa dd ff student s1 = new student("aa", 10); student s2 = new student("bb", 20); student s3 = new student("aa", 30); student s4 = new student("dd", 40); list studentlist = arrays.aslist(s1, s2, s3, s4); //自定义排序：先按姓名升序，姓名相同则按年龄升序 studentlist.stream().sorted( (o1, o2) -> { if (o1.getname().equals(o2.getname())) { return o1.getage() - o2.getage(); } else { return o1.getname().compareto(o2.getname()); } } ).foreach(system.out::println);

• ​​peek​​：如同于map，能得到流中的每一个元素。但map接收的是一个function表达式，有返回值；而peek接收的是consumer表达式，没有返回值。

student s1 = new student("aa", 10); student s2 = new student("bb", 20); list studentlist = arrays.aslist(s1, s2); studentlist.stream() .peek(o -> o.setage(100)) .foreach(system.out::println); //结果： student{name='aa', age=100} student{name='bb', age=100}

3. 流的终止操作

• ​​allmatch​​：接收一个 predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
• ​​nonematch​​：接收一个 predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
• ​​anymatch​​：接收一个 predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
• ​​findfirst​​：返回流中第一个元素
• ​​findany​​：返回流中的任意元素
• ​​count​​：返回流中元素的总个数
• ​​max​​：返回流中元素最大值
• ​​min​​：返回流中元素最小值

list list = arrays.aslist(1, 2, 3, 4, 5); boolean allmatch = list.stream().allmatch(e -> e > 10); //false boolean nonematch = list.stream().nonematch(e -> e > 10); //true boolean anymatch = list.stream().anymatch(e -> e > 4); //true integer findfirst = list.stream().findfirst().get(); //1 integer findany = list.stream().findany().get(); //1 long count = list.stream().count(); //5 integer max = list.stream().max(integer::compareto).get(); //5 integer min = list.stream().min(integer::compareto).get(); //1

• optional reduce(binaryoperator accumulator)：第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。
• t reduce(t identity, binaryoperator accumulator)：流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，而第二个参数为流中的第一个元素。
• u reduce(u identity,bifunction accumulator,binaryoperator combiner)：在串行流(stream)中，该方法跟第二个方法一样，即第三个参数combiner不会起作用。在并行流(parallelstream)中,我们知道流被fork join出多个线程进行执行，此时每个线程的执行流程就跟第二个方法reduce(identity,accumulator)一样，而第三个参数combiner函数，则是将每个线程的执行结果当成一个新的流，然后使用第一个方法reduce(accumulator)流程进行规约。