流式编程

日常使用

前言：依旧使用购物车的数据

/**
 * 演示流的各种操作
 * @author user
 *
 */
public class StreamOperator {
    List<Sku> list;
    
    @Before
    public void init() {
        list=CarService.getCartSkuList();
    }
    
    /**
     * 过滤操作
     */
    @Test
    public void filterTest() {
        list.stream()
            .filter(sku->sku.getSkCategory().equals(SkCategoryEnum.BOOKS))
            .forEach(sku ->System.out.println(JSON.toJSONString(sku)));
            
    }
    
    /**
     * 转换操作
     */
    @Test
    public void mapTest() {
        list.stream()
            .map(sku-> sku.getSkuName())
            .forEach(item -> System.out.println(item));
    }
    
    
    /**
     * 将对象转换成流
     */
    @Test
    public void flatMapTest() {
        list.stream()
            .flatMap(sku->Arrays.stream(sku.getSkuName().split("")))
            .forEach(item -> System.out.println(item));
    }
    
    /**
     * 对流进行遍历操作，与forEach类似，但是是中间操作
     */
    @Test
    public void peek() {
        list.stream()
            .peek(sku->System.out.println(sku.getSkuName()))
            .forEach(sku ->System.out.println(JSON.toJSONString(sku)));
    }
    
    /**
     * 排序操作
     */
    @Test
    public void sorted() {
        list.stream()
            .peek(sku->System.out.println(sku.getSkuName()))
            .sorted(Comparator.comparing(Sku::getTotalPrice))
            .forEach(sku ->System.out.println(JSON.toJSONString(sku)));
    }
    
    /**
     * 去重
     */
    @Test
    public void distinctTest() {
        list.stream()
            .map(sku->sku.getSkCategory())
            .distinct()
            .forEach(sku ->System.out.println(JSON.toJSONString(sku)));
    }
    
    /**
     * 跳过前n条数据
     */
    @Test
    public void skipTest() {
        list.stream()
            .sorted(Comparator.comparing(Sku::getTotalPrice))
            .skip(3)
            .forEach(sku ->System.out.println(JSON.toJSONString(sku)));
    }
    
    /**
     * 截断前n条操作
     */
    @Test
    public void limitTest() {
        list.stream()
            .sorted(Comparator.comparing(Sku::getTotalPrice))
            .limit(3)
            .forEach(sku ->System.out.println(JSON.toJSONString(sku)));
    }
    
    //终端操作
    
    @Test
    public void allMatchTest() {
        // 判断所以商品总价是否都超过了100元
        boolean match=list.stream()
            .allMatch(sku->sku.getTotalPrice()>100);
        System.out.println(match);
    }
    

    @Test
    public void anyMatchTest() {
        // 有一个商品总价大于100返回ture
        boolean match=list.stream()
            .anyMatch(sku->sku.getTotalPrice()>100);
        System.out.println(match);
    }
    
    @Test
    public void noneMatchTest() {
        // 没有一个商品总价大于100返回ture
        boolean match=list.stream()
            .noneMatch(sku->sku.getTotalPrice()>100);
        System.out.println(match);
    }
    
    /**
     * 找第一个
     */
    @Test
    public void findFirstTest() {
        Optional<Sku> opSku =list.stream()
            .findFirst();
    }
    
    /**
     * 找任意一个
     */
    @Test
    public void findAnyTest() {
        Optional<Sku> opSku =list.stream()
                .findAny();
    }
    /**
     * 找最大
     */
    @Test
    public void maxTest() {
        
        OptionalDouble optionalDouble=list.stream()
            .mapToDouble(Sku::getTotalPrice)
            .max();
        System.out.println(optionalDouble.getAsDouble());
    }
    
    /**
     * 找最小
     */
    @Test
    public void minTest() {
        
        OptionalDouble optionalDouble=list.stream()
            .mapToDouble(Sku::getTotalPrice)
            .min();
        System.out.println(optionalDouble.getAsDouble());
    }
    
    /**
     * 统计
     */
    @Test
    public void countTest() {
        
        long count=list.stream()
            .count();
        System.out.println(count);
    }
}

生成流的方式

@Test
    public void streamFromValue() {
        Stream stream=Stream.of(1,2,3,4);
        stream.forEach(System.out::println);
    }
    
    @Test
    public void streamFromArray() {
        int[] nums= {1,2,3,4};
        IntStream stream=Arrays.stream(nums);
        stream.forEach(System.out::println);
    }
    
    @Test
    public void streamFromFile() throws IOException {
        Stream<String> stream=Files.lines(Paths.get("/common/src/main/java/com/fuiou/lambda/stream/StreamOperator.java"));
        stream.forEach(System.out::println);
    }
    
    
    @Test
    public void streamFromFunction() throws IOException {
        //Stream stream=Stream.iterate(0, n->n+2);
        Stream stream=Stream.generate(Math::random);
        stream
            .limit(100)
            .forEach(System.out::println);
    }

收集器

收集器：将流的元素累计成一个结果
比如：将筛选过的数据，收集成一个list

    /**
     * 收集成集合
     */
    @Test
    public void toList() {
        List<Sku> filterList=list.stream()
                  .filter(sku->sku.getTotalPrice()>100)
                  .collect(Collectors.toList());
        for (Sku sku2 : filterList) {
            System.out.println(sku2.getSkuName());
        }
    }
    
    /**
     * 分组
     */
    @Test
    public void groupingBy() {
        //Map<分组条件,结果集合>
        Map<Object,List<Sku>> map=list.stream()
                .collect(Collectors.groupingBy(sku->sku.getSkCategory()));
        System.out.println(map);
    }
    
    /**
     * 分区
     */
    @Test
    public void partition() {
        // 将数据分成总价>100和<=100的两组
        Map<Boolean,List<Sku>> map=list.stream()
                .collect(Collectors.partitioningBy(sku->sku.getTotalPrice()>100));
    }