Java 8 中Stream用法

Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。废话不多说直接上代码

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

package com.example.demo;
 
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
 
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
@SpringBootTest
class DemoApplicationTests {
 
    /*
      1.filter:用于根据指定条件过滤元素.它接收一个条件作为参数, 只保留满足条件的元素, 并生成一个新的Stream
     */
    @Test
    void filterTest() {
        List<String> tempList = Arrays.asList("初一", "初二", "初三", "初四");
        List<String> resList = tempList.stream()
                .filter(s -> s.contains("二"))
                .collect(Collectors.toList());
        System.out.println(resList.toString());
    }
 
    /*
    2.map:用于对每个元素执行映射操作, 将元素转换成另一种类型.它接收一个Function（映射函数）作为参数,
          对每个元素应用该映射函数, 并生成一个新的Stream.
    */
    @Test
    void mapTest() {
        List<String> tempList = Arrays.asList("初一", "初二", "初三", "初四");
        List<String> resList = tempList.stream()
                .map(s -> "今天: " + s)
                .collect(Collectors.toList());
        System.out.println(resList.toString());
    }
 
    /*
    3.sorted():用于对Stream中的元素进行排序，默认按照自然顺序进行排序。也可以传入自定义的Comparator来指定排序规则。
    */
    @Test
    void sortedTest() {
        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);
    }
 
    /*
    4.distinct():用于去除 Stream 中重复的元素，确保最终的 Stream 中每个元素都是唯一的。
    */
    @Test
    void distinctTest() {
        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);
    }
 
    /*
   5.limit(long n):用于限制Stream的大小，返回一个最大包含前n个元素的新Stream。
   */
    @Test
    void limitTest() {
        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);
    }
 
    /*
    6.skip(long n):用于跳过Stream中的前n个元素，返回一个丢弃了前n个元素后剩余元素的新Stream。
    */
    @Test
    void skipTest() {
        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);
    }
 
    /*
    7.forEach(Consumer):对Stream中的每个元素执行指定的操作，接收一个Consumer（消费者函数）作为参数。它通常用于对Stream中的元素进行输出或执行某些操作，但不会返回任何结果。
    */
    @Test
    void forEachTest() {
        // 给公司工资普涨 500
        List<Integer> salaryList = Arrays.asList(12000, 20000, 30000, 4000);
        salaryList.stream()
                .map(s -> s + 500)
                .forEach(s -> {
                    System.out.println("--工资普涨后:" + s);
                });
    }
 
    /*
    8.collect(Collector):用于将Stream中的元素收集到一个容器中，接收一个Collector（收集器）作为参数。它允许你在Stream中执行各种集合操作，
    例如将元素收集到List、Set、Map等容器中。
 
    如下代码的含义是创建一个人员集合,通过 stream() 转换为 Stream 流,使用 collect() 方法把元素归集,
    利用 Collectors.toMap() 收集器转换为 Map 后,内部接收会遍历每个元素,Collectors.toMap(User::getName, User::getSalary)是简写,
    详细的写法如下:Collectors.toMap(s -> s.getName(), s -> s.getSalary())
    */
    @Test
    void collectTest() {
        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);
        });
    }
 
    /*
    9.anyMatch(Predicate) / allMatch(Predicate) / noneMatch(Predicate)
    Stream 类的 anyMatch(), allMatch(), 和 noneMatch() 是用于检查流中元素是否满足特定条件的终端操作。
    它们返回一个布尔值，表示流中的元素是否满足指定的条件。这些方法在遇到满足条件的元素后可能会提前终止流的处理。
    anyMatch检查是否有任意元素满足条件，allMatch检查是否所有元素都满足条件，noneMatch检查是否没有元素满足条件。
    */
    @Test
    void MatchTest() {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
 
        // 使用anyMatch()检查是否存在元素大于5
        boolean anyGreaterThan5 = integerStream.anyMatch(num -> num > 5);
        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);
    }
 
 
    /*
   10.findFirst() / findAny()
        Stream 类的 findFirst() 和 findAny()
        方法用于在流中查找元素的终端操作。它们都返回一个 Optional 对象，表示找到的元素或元素的可能性。
   */
    @Test
    void findTest() {
        // 示例整数流
        Stream<Integer> integerStream = Stream.of(1, 5, 3, 8, 2);
 
        // 使用findFirst()找到第一个元素
        Optional<Integer> firstElementOptional = integerStream.findFirst();
        System.out.println("发现第一个元素: " + firstElementOptional.get());
 
        //isPresent() 判断流是否为null
        if (firstElementOptional.isPresent()) {
            System.out.println("发现第一个元素: " + firstElementOptional.get());
        } else {
            System.out.println("流为空!");
        }
 
         // 使用findAny()找到任意一个元素
        Stream<Integer> stream = Stream.of(1, 2, 3);
        Optional<Integer> any = stream.findAny();
        System.out.println("找到任意一个元素: " +any.get());
        // 资料说：可能输出 1、2 或 3 但实际操作每次都输出1
 
    }
 
 
}

package com.example.demo;
 
public class User {
    private String name;
    private Double salary;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getSalary() {
        return salary;
    }
 
    public void setSalary(Double salary) {
        this.salary = salary;
    }
 
    public User(String name, Double salary) {
        this.name = name;
        this.salary = salary;
    }
}