Java8 Stream 常用简书

1.forEach（遍历）

List<String> strings = Arrays.asList("123", "", "ac", "bgd", "tyu","", "dd",null);
//遍历所有项
strings.stream().forEach(s -> System.out.println(s));

2.map/flatMap（映射到对应的结果）

List<Integer> numbers = Arrays.asList(4, 3, 2, 3, 5, 6, 5);
// 获取对应的平方数
System.out.println("numbers = " + numbers.stream().map(i -> i*i).collect(Collectors.toList()));

//将两个集合合并成一个集合
List<String> list = Arrays.asList("h,jj,t,ab", "1,2,3,4");
List<String> listNew = list.stream().flatMap(s -> {
       // 将每个元素转换成一个stream
       String[] split = s.split(",");
        Stream<String> s2 = Arrays.stream(split);
         return s2;
    }).collect(Collectors.toList());

System.out.println("处理前的集合：" + list);
System.out.println("处理后的集合：" + listNew);

3.filter（过滤）

List<String> strings = Arrays.asList("123", "", "ac", "bgd", "tyu","","1234", "dd",null);
//过滤字符串不为空的并收集为集合
System.out.println(strings.stream().filter(s -> StringUtils.isNotBlank(s)).collect(Collectors.toList()));
//匹配第一个值
System.out.println("匹配第一个值："+strings.stream().filter(s -> StringUtils.contains(s,"d")).findFirst().get());
//匹配任意一个 并行比较快
System.out.println("匹配任意一个值：" + strings.parallelStream().filter(s -> StringUtils.contains(s, "123")).findAny().get());
//字符串数据中是否存在 "tyu" 字符串
System.out.println("是否存在 'tyu' 字符串"+strings.stream().anyMatch( s -> StringUtils.contains(s,"tyu")));

4.limit（分页）

List<String> strings = Arrays.asList("123", "32", "ac", "bgd", "tyu","", "dd",null);
//取两条记录并收集为数组
System.out.println(strings.stream().limit(2).collect(Collectors.toList()));

5.sorted（排序）

List<Integer> numbers = Arrays.asList(4, 3, 2, 3, 5, 6, 5);
//默认排序升序
System.out.println(numbers.stream().sorted().collect(Collectors.toList()));
//降序
System.out.println(numbers.stream().sorted((x,y) -> y-x).collect(Collectors.toList()));
System.out.println(numbers.stream().sorted(Comparator.reverseOrder())
.collect(Collectors.toList()));

//排序前输出
StudentInfo.printStudents(studentList);
//按年龄排序(Integer类型)
List<StudentInfo> studentsSortName = studentList.stream().sorted(Comparator
.comparing(StudentInfo::getAge).reversed().thenComparing(StudentInfo::getHeight)).collect(Collectors.toList());
//排序后输出
StudentInfo.printStudents(studentsSortName);

 

6.distinct（去重）

List<Integer> numbers = Arrays.asList(4, 3, 2, 3, 5, 6, 5);
//去重(注意：对象慎用，可能不会去重)
System.out.println(numbers.stream().distinct().collect(Collectors.toList()));

7.reduce（规约（缩减）：流缩减一个值，实现求和、求积、求最值）

List<Integer> list = Arrays.asList(1, 3, 2, 8, 5, 4);
// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);

// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);

// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);

// 求最大值写法2
Integer max2 = list.stream().reduce(1, Integer::max);

// 求最大值写法3
Integer max3 = list.stream().max(Comparator.comparing(s -> s)).get();

System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
System.out.println("list求积：" + product.get());
System.out.println("list求和：" + max.get() + "," + max2);
System.out.println("list求和：" + max3);

8.groupingBy（分组）及max（最大）

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
static
class User {
    private long id;
    private String name;
}

User user1 = new User(1, "123");
User user2 = new User(2, "456");
User user3 = new User(1, "789");
User user4 = new User(3, "000");
ArrayList<User> users = Lists.newArrayList(user1, user2, user3,user4);
//根据id分组  结果{1=[ApiCompanyInfoController.User(id=1, name=123), ApiCompanyInfoController.User(id=1, name=789)], 2=[ApiCompanyInfoController.User(id=2, name=456)]}
System.out.println(users.stream().filter(u -> 3 != u.getId()).collect(Collectors.groupingBy(User::getId)));

//分组统计  结果{1=2, 2=1}
System.out.println(users.stream().filter(u -> 3 != u.getId()).collect(Collectors.groupingBy(User::getId,Collectors.counting())));

//找到id最大的对象  结果User(id=3, name=000)
System.out.println(users.stream().max(Comparator.comparing(User::getId)).get());

9.findFirst（返回第一个）

List<String> list = Arrays.asList("A", "B", "F", "A", "C");
// 返回 A 
list.stream().findFirst().ifPresent(System.out::println);

10.anyMatch（检查流是否包含至少一个满足给定谓词的元素）

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.anyMatch(s -> s.contains("C"));
// 返回 true
System.out.println(match);

11.allMatch（检查流是否所有都满足给定谓词的元素）

Stream<String> stream = Stream.of("A", "B", "C", "D");
boolean match = stream.allMatch(s -> s.contains("C"));
// 返回 false
System.out.println(match);

12.peek（打印个日志）

List<String> result = Stream.of("程序员baoli", "baoli小男孩", "捡瓶子的小男孩")
            .filter(a -> a.contains("baoli"))
            .peek(a -> System.out.println("tag:" + a)).collect(Collectors.toList());
// tag:程序员baoli
// tag:baoli小男孩
// [程序员baoli, baoli小男孩]
System.out.println(result);

13.常用函数式接口

其实lambda离不开函数式接口，我们来看下JDK8常用的几个函数式接口：

• Function<T, R>（转换型）: 接受一个输入参数，返回一个结果

• Consumer<T> （消费型）: 接收一个输入参数，并且无返回操作

• Predicate<T> （判断型）: 接收一个输入参数，并且返回布尔值结果

• Supplier<T> （供给型）: 无参数，返回结果

Function<T, R> 是一个功能转换型的接口，可以把将一种类型的数据转化为另外一种类型的数据

//获取每个字符串的长度，并且返回
Function<String, Integer> function = String::length;
Stream<String> stream = Stream.of("程序员baoli", "baoli小男孩", "捡瓶子的小男孩");
Stream<Integer> resultStream = stream.map(function);
resultStream.forEach(System.out::println);

Consumer<T>是一个消费性接口，通过传入参数，并且无返回的操作

Consumer<String> comsumer = System.out::println;
Stream<String> stream = Stream.of("程序员baoli", "baoli小男孩", "捡瓶子的小男孩");
stream.forEach(comsumer);

Predicate<T>是一个判断型接口,并且返回布尔值结果

Predicate<Integer> predicate = a -> a > 18;
User user = new User(2, "程序员baoli", 27);
System.out.println(predicate.test(userInfo.getAge()));

Supplier<T>是一个供给型接口,无参数，有返回结果

Supplier<Integer> supplier = () -> Integer.valueOf("666");
System.out.println(supplier.get());

希望能帮你到，点赞留名，内容不断的更新，敬请期待哦