Java8新特性之Stream流（五）映射

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);//line2
    IntStream mapToInt(ToIntFunction<? super T> mapper);//line3
    LongStream mapToLong(ToLongFunction<? super T> mapper);//line4
    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);//line5
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);//line6
    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);//line7
    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);//line8
    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);//line9
}

@FunctionalInterface
public interface Function<T, R> {
     R apply(T t);
}

private static void learnMap() {
     List<Integer> lists = new ArrayList<>();
        lists.add(1);
        lists.add(2);
        lists.add(3);
     //使用并行流来处理
     Integer product = lists.parallelStream().reduce(1, (a, b) -> a *  (b * 2),
                                                        (a, b) -> a * b);
     System.out.println("product:" + product);//48

     //使用映射来处理 
     //Integer productMap = lists.parallelStream().map((a) -> a * 2).reduce(1, (a, b) -> a * b);
     Stream<Integer> productNewMapStream = lists.parallelStream().map((a) -> a * 2);
     Integer productMap = productNewMapStream.reduce(1, (a, b) -> a * b);
     System.out.println("productMap:" + productMap);//48
}

#玩家使用的英雄以及当前获得的金币数
public class HeroPlayerGold {
    /** 使用的英雄名字 */
    private String hero;
    /** 玩家的ID */
    private String player;
    /** 获得的金币数 */
    private int gold;

    public HeroPlayerGold(String hero, String player, int gold) {
        this.hero = hero;
        this.player = player;
        this.gold = gold;
    }
  //省略get/set/toString
}

#玩家获得的金币数
public class Gold {
    /** 获得的金币数 */
    private int gold;

    public Gold(int gold) {
        this.gold = gold;
    }
 //省略get/set/toString
｝

#测试类
public class Main {
    public static void main(String[] args) {
        learnMap2th();
    }

    private static void learnMap2th() {
        List<HeroPlayerGold> lists = new ArrayList<>();
        lists.add(new HeroPlayerGold("盖伦", "RNG-Letme", 100));
        lists.add(new HeroPlayerGold("诸葛亮", "RNG-Xiaohu", 300));
        lists.add(new HeroPlayerGold("露娜", "RNG-MLXG", 300));
        lists.add(new HeroPlayerGold("狄仁杰", "RNG-UZI", 500));
        lists.add(new HeroPlayerGold("牛头", "RNG-Ming", 500));

        //计算团队经济
        int teamMoney = lists.stream()
                .map(player -> new Gold(player.getGold()))//note1
                .mapToInt(Gold::getGold)
                .reduce(0, (a, b) -> a + b);
        System.out.println("团队经济：" + teamMoney);//1700


        //计算团队经济2
        double teamMoney2 = lists.stream()
                .mapToDouble(HeroPlayerGold::getGold)
                .reduce(0, (a, b) -> a + b);
        System.out.println("团队经济：" + teamMoney2);//1700.0
    }
}

private static void learnMap2th() {
       List<HeroPlayerGold> lists = new ArrayList<>();
       lists.add(new HeroPlayerGold("盖伦", "RNG-Letme", 100));
       lists.add(new HeroPlayerGold("诸葛亮", "RNG-Xiaohu", 300));
       lists.add(new HeroPlayerGold("露娜", "RNG-MLXG", 300));
       lists.add(new HeroPlayerGold("狄仁杰", "RNG-UZI", 500));
       lists.add(new HeroPlayerGold("牛头", "RNG-Ming", 500));
       
       //计算两个C位的经济和
       lists.stream()
               .filter(player-> "RNG-Xiaohu".equals(player.getPlayer()) || "RNG-UZI".equals(player.getPlayer()))
               .map(player->new Gold(player.getGold()))
               .mapToInt(Gold::getGold)
               .reduce((a,b)->a+b)
               .ifPresent(System.out::println);//800
   }

/* <p>If {@code orders} is a stream of purchase orders, and each purchase
 * order contains a collection of line items, then the following produces a
 * stream containing all the line items in all the orders:
 * <pre>{@code
 *     orders.flatMap(order -> order.getLineItems().stream())...
 * }</pre>
 */

private static void learnFlatMap() {
       //(广州  深圳  上海  北京)的全拼的一些组合,下面我们就把每一个城市都划分一下
       List<String> citys = Arrays.asList("GuangZhou ShangHai", "GuangZhou ShenZhen",
               "ShangHai ShenZhen", "BeiJing ShangHai", "GuangZhou BeiJing", "ShenZhen BeiJing");

       //这里打印的数组对应的地址
       citys.stream().map(mCitys -> Arrays.stream(mCitys.split(" "))).forEach(System.out::println);//note1

       System.out.println();

       //流里面的元素还是一个数组
       citys.stream()
               .map(mCities -> Arrays.stream(mCities.split(" ")))//流里面的每个元素还是数组
               .forEach(cities ->cities.forEach(city-> System.out.print(city+" ")));//note2

       System.out.println();
       System.out.println();

       //直接一个flatMap()就把数组合并到映射流里面了
       citys.stream().flatMap(mCities->Arrays.stream(mCities.split(" "))).forEach(System.out::println);//note3

       System.out.println();

       //使用distinct()方法去重！
       citys.stream().flatMap(mCities->Arrays.stream(mCities.split(" "))).distinct().forEach(System.out::println);//note4

   }