java8中stream()的使用案例

	@Test
    public void t1(){
        List<Integer> ids = new ArrayList<>(Arrays.asList(1,1,2,3,1,5));
        List<String> productIds = new ArrayList<>(Arrays.asList("1","1","2","3"));

        // 1. flatMap(Collection::stream) 用于多个stream的合并成一个stream
        List<String> newProductIds = Stream.of(productIds).flatMap(Collection::stream).distinct().collect(Collectors.toList());
        log.info(newProductIds.toString());

        // 2. 聚合 Collectors.toCollection(Arraylist::new) === Collectors.toList()
        Set<String> set = Stream.of("a", "c", "b", "a").collect(Collectors.toCollection(HashSet::new));
        log.info(set.toString());

        // 3. 聚合 Collectors.summarizingXXX() 可以计算list中的max min count sum average等
        String a = productIds.stream().collect(Collectors.summarizingDouble(x -> Double.valueOf(x))).toString();
        log.info(a);

        // 4. 聚合 Collectors.averagingDouble() 可以求和、求平均等
        String b = productIds.stream().collect(Collectors.averagingDouble(x -> Integer.valueOf(x))).toString();
        log.info(b);

        // 5. 去重 distinct()
        List<String> list = productIds.stream().distinct().collect(Collectors.toList());
        log.info(list.toString());

        // 6. 是否存在 anyMatch() 和filter用法相同
        boolean anyMatch = productIds.stream().anyMatch(f -> f.equals("2"));    // 判断列表中是否【存在某个元素】
        boolean allMatch = productIds.stream().allMatch(g -> g.equals("1"));    // 判断列表是否【都是某个元素】
        boolean noneMatch = productIds.stream().noneMatch(j -> j.equals("3"));  // 判断列表中是否【不存在某个元素】
        log.info(anyMatch +"/"+ allMatch +"/"+ noneMatch);

        // 7. 最大值.max(有参数)
        // .max(Comparator.comparing(Object::property)) 按照对象中的某个属性求最大值
        //DiagnosisStandard standard = standards.stream().max(Comparator.comparing(DiagnosisStandard::getOrderNum)).get();

        // 8. 最大值.max(无参数)
        // .mapToDouble(Object::property).max() 其实就是map(Object::property)选出自己想要的属性，变成新的list之后在.max()
        //questionItemMaxScore = questionItems.stream().mapToDouble(QuestionMultipleType::getScore).max().getAsDouble();

        // 9. 按照某种条件查找第一次出现的位置 filter() + findFirst()
        Integer index = ids.stream().filter(k -> (k>2)).findFirst().get();
        log.info(index.toString());

        // 10. reduce()合并操作通常和map()一起用 --> map reduce
        // 发票集合
        List<Invoice> invoices = Arrays.asList(
                new Invoice("A01", BigDecimal.valueOf(9.99), BigDecimal.valueOf(1), 1.1D),
                new Invoice("A02", BigDecimal.valueOf(19.99), BigDecimal.valueOf(1.5), 2.2D),
                new Invoice("A03", BigDecimal.valueOf(4.99), BigDecimal.valueOf(2), 3.3D)
        );
        // map-reduce求和【.reduce(BigDecimal.ZERO, BigDecimal::add)】
        //【map()操作得到只要一个基本元素的stream】-->【reduce()操作的对象也只能是有一个基本元素的stream才可以】
        BigDecimal sum1 = invoices.stream()
                .map(x -> x.getQuantity().multiply(x.getPrice()))       // map，对集合中的元素进行操作得到只有基本元素的stream，而不是有复杂对象的stream
                .reduce(BigDecimal.ZERO, BigDecimal::add);              // reduce，将上一步得到的结果进行合并得到最终的结果
        // 结果 49.955
        System.out.println(sum1);
        // 使用setScale方法进行四舍五入 49.955 -> 49.96
        System.out.println(sum1.setScale(2, RoundingMode.HALF_UP));

        // 11. map-reduce对list中某个Double元素的求和【.reduce(Double::sum)】
        Double doubleSum = invoices.stream()
                .map(q -> q.getValue())
                .reduce(Double::sum)
                .get();
        log.info("---使用map-reduce-对stream中的元素求和---"+doubleSum);

        // 12. map-reduce 可以对计算进行初值的赋值，也可以不赋值，默认为空即可
        //T reduce(T identity, BinaryOperator<T> accumulator);
        // 1）identity：它允许用户提供一个循环计算的初始值
        // 2）accumulator：方法签名为apply(T t,U u)
        //    方法中第一个参数t为上次函数计算的返回值
        //    第二个参数u为Stream中的元素，这个函数把这两个值计算apply，得到的new-value值会被赋值给下次执行这个方法的第一个参数t
        System.out.println("给定个初始值，求和");   // 初值为100 计算过程为100+1+2+3+4=110 【i就是(1,2,3,4)集合中的每个元素】
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (sum, i) -> sum + i));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::sum));
        System.out.println("给定个初始值，求min");  // 初值为100  比较过程为Math.min(100, 1)-->min=1; Math.min(1, 2)-->min=1; Math.min(1, 3)-->min=1; ...
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (min, i) -> Math.min(min, i)));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::min));
        System.out.println("给定个初始值，求max");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (max, i) -> Math.max(max, i)));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::max));
        //Optional<T> reduce(BinaryOperator<T> accumulator);
        // 注意返回值，上面的返回是T,泛型，传进去啥类型，返回就是啥类型。
        // 下面的返回的则是Optional类型
        System.out.println("无初始值，求和");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::sum).orElse(0));
        System.out.println("无初始值，求max");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::max).orElse(0));
        System.out.println("无初始值，求min");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::min).orElse(0));

        // 13. peek是中间操作，不是终结操作（如forEach count collect），其返回值还是Stream
        // peek: 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；
        Stream.of("one", "two", "three", "four")
                .peek(e -> System.out.println("-----Peeked value: " + e))
                .map(String::toUpperCase)
                .peek(e -> System.out.println("-----Mapped value: " + e))
                .collect(Collectors.toList());
    }

Entity Invoice

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Invoice {

    // 发票号码
    String invoiceNo;

    // 价格
    BigDecimal price;

    // 数量
    BigDecimal quantity;

    // Double类型数据
    Double value;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Province {

    String name;

    List<String> city;

}

flatMap()

public calss Province{

	String name;

	List<String> city;

}

List<String> beijingcities = new ArrayList(Arrays.asList("海淀", "朝阳"));
List<String> shanghaicities = new ArrayList(Arrays.asList("静安", "闵行"));

List<Province> provinces = new ArrayList();
provinces.add("北京", beijingcities);
provinces.add("上海", shanghaicities);

provinces.stream().flatMap(a -> a.getCity().stream());

• JSON.parseObject(string, Object.class) 使用.collect(Collectors.toList());做收集
• JSON.parseArray(stringList, Object.class) 使用.collect(ArrayList::new, ArrayList::addAll, ArrayList::addAll);做收集

    @Test
    public void r(){
        String metricId = "1216d247-8534-4599-a19b-e97c86e793b1";
        String scaleId = "4a7e1689-082a-495c-9d75-bb4a01e0f125";
        // 1. JSON.parseObject(string, Object.class) parseOject只是反序列化得出一个Object对象
        List<DiagnosisStandard> standards = diagnosisStandardMapper.selectByScaleIdAndMetricId(metricId, scaleId);
        ArrayList<DiagnosisScoreRange> collect = (ArrayList<DiagnosisScoreRange>) standards.stream().map(a -> {
            DiagnosisScoreRange diagnosisScoreRange;
            // parseObject只得到一个对象，所有想要得到list需要.collect(Collectors.toList());
            diagnosisScoreRange = JSONObject.parseObject(a.getScoreRange(), DiagnosisScoreRange.class);
            return diagnosisScoreRange;
        }).collect(Collectors.toList());
        log.info("collect: "+JSON.toJSONString(collect));

		// parseObject和上边的相同，只是直接return parseObject后的对象，没有提前声明该对象
        ArrayList<DiagnosisScoreRange> collect1 = (ArrayList<DiagnosisScoreRange>) standards.stream().map(a -> {
            return JSONObject.parseObject(a.getScoreRange(), DiagnosisScoreRange.class);
        }).collect(Collectors.toList());
        log.info("collect1: "+JSON.toJSONString(collect1));

		// 2. JSON.parseArray(参数1为一个list对象的string, 参数2为.class)
		// .collect(ArrayList::new, ArrayList::addAll, ArrayList::addAll); 注意ArrayList::new
        ArrayList<DiagnosisScoreRange> collect2 = standards.stream().map(a -> {
            DiagnosisScoreRange diagnosisScoreRange = JSONObject.parseObject(a.getScoreRange(), DiagnosisScoreRange.class);
            List<DiagnosisScoreRange> list = new ArrayList<>();
            list.add(diagnosisScoreRange);
            String listString = JSON.toJSONString(list);
            // 所以需要注意参数是一个list的string：listString
            return JSON.parseArray(listString, DiagnosisScoreRange.class);
        }).collect(ArrayList::new, ArrayList::addAll, ArrayList::addAll);
        log.info("collect2: "+JSON.toJSONString(collect2));
    }