Java的Stream并行流

//Stream并行流
//流使得计算变得容易，它的操作也非常简单，但你需要遵守一些约定。默认情况下我们使用集合的stream方法
//创建的是一个串行流，你有两种办法让他变成并行流。
//
//调用Stream对象的parallel方法
//创建流的时候调用parallelStream而不是stream方法
//我们来用具体的例子来解释串行和并行流

 

package com.wxrem.controller;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author wxb
 * 操作的是一个数组可以使用Stream.of(1, 2, 3)方法将它转换为一个流。
 * @date 2020-08-04 11:15
 */
public class MyStreamTest {

    public static void main(String[] args) {
        ShopProperty p0 = new ShopProperty("叫了个鸡", 1000, 500, 2);
        ShopProperty p1 = new ShopProperty("叫了个鸡2", 1002, 100, 2);
        ShopProperty p2 = new ShopProperty("张三丰饺子馆", 2300, 1500, 3);
        ShopProperty p3 = new ShopProperty("永和大王", 580, 3000, 1);
        ShopProperty p4 = new ShopProperty("肯德基", 6000, 200, 4);
        List<ShopProperty> shopProperties = Arrays.asList(p0,p1,p2,p3,p4);
//        System.out.println(shopProperties);
        //筛选距离我最近的店铺
//        getCloseShop(shopProperties);

//        getMapShop(shopProperties);
//        getFlatMap();
//        getMaxPriceLevel(shopProperties);
//        getShopNameAndPriceLevel(shopProperties);
        getShopGroupByPriceLevel(shopProperties);

    }
    //参数和返回值不必属于同一种类型，但是lambda表达式必须是Function接口的一个实例
    private static void getMapShop(List<ShopProperty> shopProperties) {
        Stream<Integer> integerStream = shopProperties.stream().map(shopProperty -> shopProperty.distance);
        System.out.println(integerStream.collect(Collectors.toList()));

        Stream<ShopProperty> shopPropertyStream = shopProperties.stream().map(shopProperty -> {
            Integer distance = shopProperty.distance;
            String name = shopProperty.name;
            ShopProperty s = new ShopProperty(name ,distance ,0,0);
            return s;
        });
        System.out.println(shopPropertyStream.collect(Collectors.toList()));

    }
    //提取子流的操作，这种情况用的不多但是遇到flatMap将变得更容易处理。
    private static void getFlatMap() {
        List<List<String>> lists = new ArrayList<>();
        lists.add(Arrays.asList("apple", "click"));
        lists.add(Arrays.asList("boss", "dig", "qq", "vivo"));
        lists.add(Arrays.asList("c#", "biezhi"));
        List<String> collect = lists.stream().flatMap(Collection::stream)
                .filter(str -> str.length() == 2)
                .collect(Collectors.toList());
        System.out.println(collect);
    }
    private static void getFlatMap2() {
        String[] words = new String[]{"Hello", "World"};
        List<String> a = Arrays.stream(words)
                .map(word -> word.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());
        a.forEach(System.out::print);
    }
    private static void getCloseShop(List<ShopProperty> shopProperties) {
        String name1 = shopProperties.stream().sorted(Comparator.comparingLong(s -> s.distance))
                .findFirst().get().name;
        System.out.println("距离我最近的店铺是:" + name1);
        Collections.sort(shopProperties, (x,y) -> x.distance.compareTo(y.distance));
        String name2 = shopProperties.get(0).name;
        System.out.println("距离我最近的店铺是:" + name2);

    }
    // jdk7 提供方法 Files.readAllLines... 返回List<String>
    public static void getFileToList() {
        try {
            String readAllLines = Files.readAllLines(Paths.get("E:\\workspace\\github\\AllLinesFile.txt"))
                    .stream().collect(Collectors.joining("\n"));
            System.out.println(readAllLines.toString());
        }catch (IOException e){
            e.printStackTrace();
        }

    }
    //为了让Stream对象按照价格等级进行排序，需要传给它一个Comparator对象。
    //Java8提供了一个新的静态方法comparingInt，使用它可以方便地实现一个比较器。
    //放在以前，我们需要比较两个对象的某项属性的值，现在只需要提供一个存取方法就够了
    public static void getMaxPriceLevel(List<ShopProperty> shopProperties){
        Optional<ShopProperty> max = shopProperties.stream().max(Comparator.comparingInt(s -> s.priceLevel));
        System.out.println(max.get());
    }
    public static void getShopNameAndPriceLevel(List<ShopProperty> shopProperties){
        Map<String, Integer> shopNameAndPriceLevel = shopProperties.stream().
                collect(Collectors.toMap(ShopProperty::getName, ShopProperty::getPriceLevel));
        System.out.println(shopNameAndPriceLevel);
    }
    //所有价格等级的店铺：类似group by
    public static void getShopGroupByPriceLevel(List<ShopProperty> shopProperties){
        Map<Integer, List<ShopProperty>> getShopGroupByPriceLevel = shopProperties.stream().
                collect(Collectors.groupingBy(ShopProperty::getPriceLevel));
        System.out.println(getShopGroupByPriceLevel);

    }
    //Stream并行流
    //流使得计算变得容易，它的操作也非常简单，但你需要遵守一些约定。默认情况下我们使用集合的stream方法
    //创建的是一个串行流，你有两种办法让他变成并行流。
    //
    //调用Stream对象的parallel方法
    //创建流的时候调用parallelStream而不是stream方法
    //我们来用具体的例子来解释串行和并行流


    // 店铺属性
    static class ShopProperty {
        String  name;
        // 距离，单位:米
        Integer distance;
        // 销量，月售
        Integer sales;
        // 价格，这里简单起见就写一个级别代表价格段
        Integer priceLevel;
        public ShopProperty(String name, int distance, int sales, int priceLevel) {
            this.name = name;
            this.distance = distance;
            this.sales = sales;
            this.priceLevel = priceLevel;
        }

        @Override
        public String toString() {
            return "ShopProperty{" +
                    "name='" + name + '\'' +
                    ", distance=" + distance +
                    ", sales=" + sales +
                    ", priceLevel=" + priceLevel +
                    '}';
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getDistance() {
            return distance;
        }

        public void setDistance(Integer distance) {
            this.distance = distance;
        }

        public Integer getSales() {
            return sales;
        }

        public void setSales(Integer sales) {
            this.sales = sales;
        }

        public Integer getPriceLevel() {
            return priceLevel;
        }

        public void setPriceLevel(Integer priceLevel) {
            this.priceLevel = priceLevel;
        }
    }
}