一文详解Java中Stream流的使用

? class User {

     private String name;

     private Integer age;

     public User(String name, Integer age) {

         this .name = name;

         this .age = age;

     }

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this .name = name;

     }

     public Integer getAge() {

         return age;

     }

     public void setAge(Integer age) {

         this .age = age;

     }

     @Override

     public String toString() {

         return "User{" +

                 "name='" + name + '\ '' +

                 ", age=" + age +

                 '}' ;

     }

}

List<String> list = new ArrayList<>();

Stream<String> stream = list.stream();  //串行流

Stream<String> parallelStream = list.parallelStream(); //并行流

Integer[] nums = new Integer[ 10 ];

Stream<Integer> stream = Arrays.stream(nums);

Stream<Integer> stream = Stream.of( 1 , 2 , 3 , 4 , 5 , 6 );

stream.forEach(System.out::println); 

// 输出：1 2 3 4 5 6

Stream<Integer> stream2 = Stream.iterate( 0 , (x) -> x + 2 ).limit( 6 );

stream2.forEach(System.out::println);

// 输出：0 2 4 6 8 10

Stream<Double> stream3 = Stream.generate(Math::random).limit( 2 );

stream3.forEach(System.out::println);

// 输出：两个随机数

BufferedReader reader = new BufferedReader( new FileReader( "F:\\test_stream.txt" ));

Stream<String> lineStream = reader.lines();

lineStream.forEach(System.out::println);

Pattern pattern = Pattern测试数据pile( "," );

Stream<String> stringStream = pattern.splitAsStream( "a,b,c,d" );

stringStream.forEach(System.out::println); 

//输出：a b c d

List<Integer> list = new ArrayList<>(Arrays.asList( 6 , 4 , 6 , 7 , 3 , 9 , 8 , 10 , 12 , 14 , 14 ));

List<Integer> newList = list.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

         .collect(Collectors.toList());

List<User> list = new ArrayList<User>() {{

     add( new User( "Tony" , 20 , "12" ));

     add( new User( "Pepper" , 20 , "123" ));

     add( new User( "Tony" , 22 , "1234" ));

     add( new User( "Tony" , 22 , "12345" ));

}};

//只通过名字去重

List<User> streamByNameList = list.stream().collect(Collectors.collectingAndThen(

         Collectors.toCollection(() -> new TreeSet<>(Comparator测试数据paring(User::getName))), ArrayList:: new

));

System.out.println(streamByNameList);

//[User{name='Pepper', age=20, Phone='123'},

// User{name='Tony', age=20, Phone='12'}]

//通过名字和年龄去重

List<User> streamByNameAndAgeList = list.stream().collect(Collectors.collectingAndThen(

         Collectors.toCollection(

                 () -> new TreeSet<>(Comparator测试数据paring(o -> o.getName() + o.getAge()))), ArrayList:: new

));

System.out.println(streamByNameAndAgeList);

//[User{name='Pepper', age=20, Phone='123'},

// User{name='Tony', age=20, Phone='12'},

// User{name='Tony', age=22, Phone='1234'}]

List<String> list = Arrays.asList( "a,b,c" , "1,2,3" );

//将每个元素转成一个新的且不带逗号的元素

Stream<String> s1 = list.stream().map(s -> s.replaceAll( "," , "" ));

s1.forEach(System.out::println);

// abc  123

Stream<String> s2 = list.stream().flatMap(s -> {

     //将每个元素转换成一个stream

     String[] split = s.split( "," );

     Stream<String> s3 = Arrays.stream(split);

     return s3;

});

s2.forEach(System.out::println);

// a b c 1 2 3

User u1 = new User( "aa" , 10 );

User u2 = new User( "bb" , 20 );

User u3 = new User( "cc" , 10 );

List<User> list = Arrays.asList(u1, u2, u3);

Set<Integer> ageSet = list.stream().map(User::getAge).collect(Collectors.toSet());

ageSet.forEach(System.out::println); 

//20 10

int [] ageInt = list.stream().map(User::getAge).mapToInt(Integer::intValue).toArray();

//下边这样也可以

//Integer[] ages = list.stream.map(User::getAge).toArray(Integer[]::new);

for ( int i : ageInt) {

     System.out.println(i);

}

//10 20 10

List<String> list = Arrays.asList( "aa" , "ff" , "dd" );

//String 类自身已实现Comparable接口

list.stream().sorted().forEach(System.out::println);

System.out.println( "------------------------------------" );

User u1 = new User( "dd" , 40 );

User u2 = new User( "bb" , 20 );

User u3 = new User( "aa" , 20 );

User u4 = new User( "aa" , 30 );

List<User> userList = Arrays.asList(u1, u2, u3, u4);

//按年龄升序

userList.stream().sorted(Comparator测试数据paring(User::getAge))

         .forEach(System.out::println);

System.out.println( "------------------------------------" );

//先按年龄升序，年龄相同则按姓名升序

userList.stream().sorted(

         (o1, o2) -> {

             if (o1.getAge().equals(o2.getAge())) {

                 return o1.getName()测试数据pareTo(o2.getName());

             } else {

                 return o1.getAge()测试数据pareTo(o2.getAge());

             }

         }

).forEach(System.out::println);

User u1 = new User( "dd" , 40 );

User u2 = new User( "bb" , 20 );

User u3 = new User( "aa" , 20 );

User u4 = new User( "aa" , 30 );

List<User> list = Arrays.asList(u1, u2, u3, u4);

List<User> list1 = list.stream()

         .peek(o -> o.setAge( 100 ))

         .collect(Collectors.toList());

System.out.println(list1);

List<Integer> 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

User u1 = new User( "dd" , 40 );

User u2 = new User( "bb" , 20 );

User u3 = new User( "aa" , 20 );

User u4 = new User( "aa" , 30 );

List<User> list = Arrays.asList(u1, u2, u3, u4);

//获取最小年龄的用户。

User user1 = list.stream()

         .min(Comparator测试数据paring(User::getAge))

         .get();

System.out.println(user1);

System.out.println( "------------------------------------" );

//获取先按姓名升序，姓名相同则按年龄升序。然后获取最小的那个（第一个）

User user = list.stream().min((o1, o2) -> {

     if (o1.getAge().equals(o2.getAge())) {

         return o1.getName()测试数据pareTo(o2.getName());

     } else {

         return o1.getAge()测试数据pareTo(o2.getAge());

     }

}).get();

System.out.println(user);

User u1 = new User( "dd" , 40 );

User u2 = new User( "bb" , 20 );

User u3 = new User( "aa" , 20 );

User u4 = new User( "aa" , 30 );

List<User> list = Arrays.asList(u1, u2, u3, u4);

String joinName = list.stream().map(User::getName).collect(Collectors.joining( "," , "(" , ")" ));

System.out.println(joinName);

//(dd,bb,aa,aa)

List<Integer> ageList = list.stream().map(User::getAge).collect(Collectors.toList());

System.out.println(ageList);

//[40, 20, 20, 30]

Set<Integer> ageSet = list.stream().map(User::getAge).collect(Collectors.toSet());

System.out.println(ageSet);

//[20, 40, 30]

User s1 = new User( "dd" , 40 );

User s2 = new User( "bb" , 20 );

User s3 = new User( "aa" , 20 );

List<User> list = Arrays.asList(s1, s2, s3);

Map<String, Integer> ageMap = list.stream().collect(Collectors.toMap(User::getName, User::getAge));

System.out.println(ageMap);

//{aa=20, bb=20, dd=40}

User u1 = new User( "aa" , 10 );

User u2 = new User( "bb" , 20 );

User u3 = new User( "cc" , 10 );

User u4 = new User( "bb" , 30 );

List<User> list = new ArrayList<>(Arrays.asList(u1, u2, u3, u4));

Map<String, List<User>> listMap = list.stream().collect(Collectors.toMap(User::getName,

                 o -> {

                     List<User> list1 = new ArrayList<>();

                     list1.add(o);

                     return list1;

                 },

                 (r1, r2) -> {

                     r1.addAll(r2);

                     return r1;

                 }

         )

);

System.out.println(listMap);

//1.用户总数

Long count = list.stream().collect(Collectors.counting());

System.out.println(count);

//4

//2.最大年龄 (最小的minBy同理)

Integer maxAge = list.stream().map(User::getAge).collect(Collectors.maxBy(Integer::compare)).get();

System.out.println(maxAge);

//40

//3.所有人的年龄

Integer sumAge = list.stream().collect(Collectors.summingInt(User::getAge));

System.out.println(sumAge);

//110

//4.平均年龄

Double averageAge = list.stream().collect(Collectors.averagingDouble(User::getAge));

System.out.println(averageAge);

// 27.5

// 统计上边所有数据

DoubleSummaryStatistics stat = list.stream().collect(Collectors.summarizingDouble(User::getAge));

System.out.println( "count:" + stat.getCount() + " max:" + stat.getMax() + " sum:" + stat.getSum()

         + " average:" + stat.getAverage());

//count:4 max:40.0 sum:110.0 average:27.5

//根据年龄分组

Map<Integer, List<User>> listMap = list.stream().collect(Collectors.groupingBy(User::getAge));

for (Map.Entry<Integer, List<User>> entry : listMap.entrySet()) {

     System.out.println(entry.getKey() + "-->" + entry.getValue());

}

//20-->[User{name='bb', age=20}, User{name='aa', age=20}]

//40-->[User{name='dd', age=40}]

//30-->[User{name='aa', age=30}]

// 先根据年龄分再根据

Map<Integer, Map<String, List<User>>> ageNameMap = list.stream().collect(

         Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getName)));

for (Map.Entry<Integer, Map<String, List<User>>> entry : ageNameMap.entrySet()) {

     System.out.println(entry.getKey() + "-->" + entry.getValue());

}

//20-->{aa=[User{name='aa', age=20}], bb=[User{name='bb', age=20}]}

//40-->{dd=[User{name='dd', age=40}]}

//30-->{aa=[User{name='aa', age=30}]}

//分成两部分，一部分大于10岁，一部分小于等于10岁

Map<Boolean, List<User>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 20 ));

for (Map.Entry<Boolean, List<User>> entry : partMap.entrySet()) {

     System.out.println(entry.getKey() + "-->" + entry.getValue());

}

//false-->[User{name='bb', age=20}, User{name='aa', age=20}]

//true-->[User{name='dd', age=40}, User{name='aa', age=30}]

//toList 源码

public static <T> Collector<T, ?, List<T>> toList() {

     return new CollectorImpl<>((Supplier<List<T>>) ArrayList:: new , List::add,

             (left, right) -> {

                 left.addAll(right);

                 return left;

             }, CH_ID);

}

//为了更好地理解，我们转化一下源码中的lambda表达式

public <T> Collector<T, ?, List<T>> toList() {

     Supplier<List<T>> supplier = () -> new ArrayList();

     BiConsumer<List<T>, T> accumulator = (list, t) -> list.add(t);

     BinaryOperator<List<T>> combiner = (list1, list2) -> {

         list1.addAll(list2);

         return list1;

     };

     Function<List<T>, List<T>> finisher = (list) -> list;

     Set<Collector.Characteristics> characteristics = Collections.unmodifiableSet

                            (EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));

     return new Collector<T, List<T>, List<T>>() {

         @Override

         public Supplier supplier() {

             return supplier;

         }

         @Override

         public BiConsumer accumulator() {

             return accumulator;

         }

         @Override

         public BinaryOperator combiner() {

             return combiner;

         }

         @Override

         public Function finisher() {

             return finisher;

         }

         @Override

         public Set<Characteristics> characteristics() {

             return characteristics;

         }

     };

}

List<Integer> list = Arrays.asList( 1 , 2 , 3 , 4 , 5 );

Integer v = list.stream().reduce((x1, x2) -> x1 + x2).get();

System.out.println(v);

// 15

Integer v0 = list.stream().reduce((x1, x2) -> x1 + x2).get();

System.out.println(v0);

//15

Integer v1 = list.stream().reduce( 10 , (x1, x2) -> x1 + x2);

System.out.println(v1);

//25

Integer v2 = list.stream().reduce( 0 ,

         (x1, x2) -> {

             System.out.println( "stream accumulator: x1:" + x1 + "  x2:" + x2);

             return x1 - x2;

         },

         (x1, x2) -> {

             System.out.println( "stream combiner: x1:" + x1 + "  x2:" + x2);

             return x1 * x2;

         });

System.out.println(v2);

// -15

Integer v3 = list.parallelStream().reduce( 0 ,

         (x1, x2) -> {

             System.out.println( "parallelStream accumulator: x1:" + x1 + "  x2:" + x2);

             return x1 - x2;

         },

         (x1, x2) -> {

             System.out.println( "parallelStream combiner: x1:" + x1 + "  x2:" + x2);

             return x1 * x2;

         });

System.out.println(v3);

//-120