Java Stream 常用方法【详尽篇】

转载：https://blog.csdn.net/Fine_Cui/article/details/131913537

public static void main(String[] args) {
	List<String> tempList = Arrays.asList("刘一手", "杜子腾", "林大蛋", "Ekko");
	List<String> resList = tempList.stream()
	        .filter(s -> s.contains("大"))
	        .collect(Collectors.toList());
	System.out.println(resList.toString());
}

[林大蛋]

public static void main(String[] args) {
	List<String> tempList = Arrays.asList("刘一手", "杜子腾", "林大蛋", "Ekko");
	List<String> resList = tempList.stream()
	        .map(s -> "姓名: " + s)
	        .collect(Collectors.toList());
	System.out.println(resList.toString());
}

@Data
static class Personnel {
    // 人员姓名
    private String name;
    // 人员标签
    private List<String> tagList;

    public Personnel(String name, List<String> tagList) {
        this.name = name;
        this.tagList = tagList;
    }
}

public static void main(String[] args) {
    Personnel personA = new Personnel("张三", Arrays.asList("抽烟", "喝酒", "烫头"));
    Personnel personB = new Personnel("李斯", Arrays.asList("编码", "喝酒", "踢足球"));
    List<Personnel> personnelList = Arrays.asList(personA, personB);
    personnelList.stream()
            .flatMap(p -> p.getTagList().stream())
            .forEach(s -> System.out.print(s + " "));
}

public class SortedTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(10, 20, 18, 300, 30, 2);
        // ① 默认排序
        List<Integer> orderList = numList.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.printf("① 默认排序: %s%n", orderList);
        // ② 自定义排序
        List<Integer> orderDescList = numList.stream()
                .sorted((x, y) -> {
                    return y.compareTo(x);
                })
                .collect(Collectors.toList());
        System.out.printf("② 自定义排序: %s%n", orderDescList);
    }
}

public class DistinctStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(1,1,1,1,2,3,2,2);
        List<Integer> distinctList = numList.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(distinctList);
    }
}

public class LimitStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(1,2,3,4,5,6,7,8);
        List<Integer> limitList = numList.stream()
                .limit(4)
                .collect(Collectors.toList());
        System.out.println(limitList);
    }
}

public class SkipStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        List<Integer> skipList = numList.stream()
                .skip(numList.size() - 2)
                .collect(Collectors.toList());
        System.out.println(skipList);
    }
}

public class PeekStreamTest {
    public static void main(String[] args) {
        List<Integer> numList = Arrays.asList(5, 6, 7, 8);
        List<Integer> resList = numList.stream()
                .peek(System.out::println)
                .filter(s -> s == 5)
                .peek(s -> System.out.printf("过滤后的:%d%n", s))
                .collect(Collectors.toList());
    }
}

public class ForEachStreamTest {
    public static void main(String[] args) {
        // 给公司工资普涨 500
        List<Integer> salaryList = Arrays.asList(12000, 20000, 30000, 4000);
        salaryList.stream()
                .peek(s -> System.out.print("工资普涨前:" + s))
                .map(s -> s + 500)
                .forEach(s -> {
                    System.out.println("--工资普涨后:" + s);
                });
    }
}

public class CollectStreamTest {
    public static void main(String[] args) {
        List<User> userList = Arrays.asList(new User("张三", 2000.5),
                new User("李斯", 11000.5),
                new User("王二", 12000.5),
                new User("张六", 32000.5),
                new User("赵公子", 1000000.0));
        Map<String, Double> userSalaryMap = userList.stream()
                .collect(Collectors.toMap(User::getName, User::getSalary));
        userSalaryMap.forEach((k, v) -> {
            System.out.printf("姓名:%s,工资:%.2f%n", k, v);
        });
    }

    @Data
    @AllArgsConstructor
    static class User {
        private String name;
        private Double salary;
    }
}

public class ToArrayStreamTest {
    public static void main(String[] args) {
        // 示例整数流
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5);

        // 使用toArray()将流中的元素收集到一个数组中
        int[] intArray = intStream.toArray();
        
        // 输出结果数组
        System.out.println(Arrays.toString(intArray));
    }
}

public class ReduceStreamTest {
    public static void main(String[] args) {
        // 示例整数流
        IntStream intStream = IntStream.of(1, 2, 3, 4, 5);

        // 使用reduce()将流中的整数相加得到总和
        OptionalInt sumOptional = intStream.reduce((a, b) -> a + b);

        // 获取结果总和，如果流为空，则给出一个默认值0
        int sum = sumOptional.orElse(0);

        // 输出结果总和
        System.out.println("总和: " + sum);
    }
}

Optional<T> min(Comparator<? super T> comparator)

Optional<T> max(Comparator<? super T> comparator)

public class MinMaxStreamTest {
    public static void main(String[] args) {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用min()找到最小值
        Optional<Integer> minOptional = integerStream.min(Integer::compareTo);
        if (minOptional.isPresent()) {
            System.out.println("最小值为: " + minOptional.get());
        } else {
            System.out.println("流为空.");
        }

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用max()找到最大值
        Optional<Integer> maxOptional = newIntegerStream.max(Integer::compareTo);
        if (maxOptional.isPresent()) {
            System.out.println("最大值为: " + maxOptional.get());
        } else {
            System.out.println("流为空.");
        }
    }
}

public class CountStreamTest {
    public static void main(String[] args) {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用count()计算流中的元素个数
        long count = integerStream.count();

        // 输出元素个数
        System.out.println("元素数量: " + count);
    }
}

boolean anyMatch(Predicate<? super T> predicate)

boolean allMatch(Predicate<? super T> predicate)

boolean noneMatch(Predicate<? super T> predicate)

public class MatchStreamTest {

    public static void main(String[] args) {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用anyMatch()检查是否存在元素大于5
        boolean anyGreaterThan5 = integerStream.anyMatch(num -> num > 4);
        System.out.println("是否存在元素大于 5 ?" + anyGreaterThan5);

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用allMatch()检查是否所有元素都小于10
        boolean allLessThan10 = newIntegerStream.allMatch(num -> num < 10);
        System.out.println("所有元素都小于10 ? " + allLessThan10);

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newestIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用noneMatch()检查是否没有元素等于10
        boolean noneEqualTo10 = newestIntegerStream.noneMatch(num -> num == 10);
        System.out.println("是否没有元素等于 10 ? " + noneEqualTo10);
    }
}

Optional<T> findFirst()

Optional<T> findAny()

public class FindStreamTest {
    public static void main(String[] args) {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用findFirst()找到第一个元素
        Optional<Integer> firstElementOptional = integerStream.findFirst();
        if (firstElementOptional.isPresent()) {
            System.out.println("发现第一个元素: " + firstElementOptional.get());
        } else {
            System.out.println("流为空!");
        }

        // 重新创建一个整数流，因为流已被消耗
        Stream<Integer> newIntegerStream = Stream.of(1, 5, 3, 8, 2);

        // 使用findAny()找到任意一个元素
        Optional<Integer> anyElementOptional = newIntegerStream.findAny();
        if (anyElementOptional.isPresent()) {
            System.out.println("找到任意一个元素: " + anyElementOptional.get());
        } else {
            System.out.println("流为空!");
        }
    }
}