乐字节-Java8核心特性实战之Stream（流）

public static void main(string[] args) {
    /**
         * 定义集合l1 并为集合创建串行流
         */
    list<string> l1 = arrays.aslist("周星驰", "周杰伦", "周星星", "周润发");
    // 返回串行流
    l1.stream();
    // 返回并行流
    l1.parallelstream();
}

 /**
 * 这里以int 为例   long double 不再举例
 */
 stream stream = arrays.stream(arrays.aslist(10, 20, 30, 40).toarray());
 // 根据数组索引范围创建指定stream
 stream = arrays.stream(arrays.aslist(10, 20, 30, 40).toarray(), 0, 2);

stream = files.lines(paths.get("c:\\java\\jdbc.properties"));
system.out.println(stream.collect(collectors.tolist()));
// 指定字符集编码
stream = files.lines(paths.get("c:\\java\\jdbc.properties"), charset.forname("utf-8"));
system.out.println(stream.collect(collectors.tolist()));

 // 重100 开始 生成偶数流
 stream.iterate(100, n -> n + 2);
 // 产生1-100 随机数
 stream.generate(() ->(int) (math.random() * 100 + 1));

@data
public class order {
    // 订单id
    private integer id;
    // 订单用户id
    private integer userid;
    // 订单编号
    private string orderno;
    // 订单日期
    private date orderdate;
    // 收货地址
    private string address;
    // 创建时间
    private date createdate;
    // 更新时间
    private date updatedate;
    // 订单状态  0-未支付  1-已支付  2-待发货  3-已发货  4-已接收  5-已完成
    private integer status;
    // 是否有效  1-有效订单  0-无效订单
    private integer isvalid;
    //订单总金额
    private  double total;
  }

order order01 = new order(1, 10, "20190301",
                new date(), "上海市-浦东区", new date(), new date(), 4, 1, 100.0);
order order02 = new order(2, 30, "20190302",
                    new date(), "北京市四惠区", new date(), new date(), 1, 1, 2000.0);
order order03 = new order(3, 20, "20190303",
                    new date(), "北京市-朝阳区", new date(), new date(), 4, 1, 500.0);
order order04 = new order(4, 40, "20190304",
                    new date(), "北京市-大兴区", new date(), new date(), 4, 1, 256.0);
order order05 = new order(5, 40, "20190304",
                    new date(), "上海市-松江区", new date(), new date(), 4, 1, 1000.0);
orderslist = arrays.aslist(order01, order02, order03, order04, order05);

//过滤有效订单 根据用户id 进行排序
orderslist.stream().filter((order) -> order.getisvalid() == 1)
    .sorted((o1, o2) -> o1.getuserid() - o2.getuserid())
    .foreach(system.out::println);    

 //或者等价写法 
orderslist.stream().filter((order) -> order.getisvalid() == 1)
    .sorted(comparator.comparingint(order::getuserid))
    .foreach(system.out::println);

//过滤有效订单  如果订单状态相同 根据订单创建时间排序 反之根据订单状态排序
orderslist.stream().filter((order) -> order.getisvalid() == 1)
    .sorted((o1, o2) -> {
        if (o1.getstatus().equals(o2.getstatus())) {
            return o1.getcreatedate().compareto(o2.getcreatedate());
        } else {
            return o1.getstatus().compareto(o2.getstatus());
    }})
    .foreach(system.out::println);


// 等价形式
orderslist.stream().filter((order) -> order.getisvalid() == 1)
    .sorted(comparator.comparing(order::getcreatedate)
    .thencomparing(comparator.comparing(order::getstatus)))
    .foreach(system.out::println);

// 计算有效订单总金额
        system.out.println("有效订单总金额:" + 
                            orderslist.stream()
                                .filter((order) -> order.getisvalid() == 1)
                                .map(order::gettotal)
                                .reduce(double::sum)
                                .get()
                          );

// 筛选所有有效订单并收集订单列表
orderslist.stream()
    .filter((order) -> order.getisvalid() == 1)
    .collect(collectors.tolist())
    .foreach(system.out::println);

// 筛选所有有效订单 并收集订单号 与 订单金额
map<string,double> map=orderslist.stream().filter((order) -> order.getisvalid() == 1).
    collect(collectors.tomap(order::getorderno, order::gettotal));
// java8 下对map进行遍历操作 如果 map的key重复,会报错
map.foreach((k,v)->{
    system.out.println("k:"+k+":v:"+v);
});

system.out.println("count结果:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .collect(collectors.counting())
                  );
system.out.println("count结果:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .count()
                  );

system.out.println("订单总金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .collect(collectors.summarizingdouble(order::gettotal))
                  );
system.out.println("订单总金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .maptodouble(order::gettotal)
                               .sum()
                  );
system.out.println("订单总金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .map(order::gettotal)
                               .reduce(double::sum)
                               .get()
                  );

system.out.println("用户id=20 有效订单平均每笔消费金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .filter((order -> order.getuserid()==20))
                               .collect(collectors.averagingdouble(order::gettotal))
                  );
system.out.println("用户id=20 有效订单平均每笔消费金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .filter((order -> order.getuserid()==20))
                               .maptodouble(order::gettotal)
                               .average()
                               .getasdouble()
                  );

system.out.println("用户id=20 有效订单平均每笔消费金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .filter((order -> order.getuserid()==20))
                               .collect(collectors.summarizingdouble(order::gettotal))
                               .getaverage()
                  );

system.out.println("订单总金额:"+
                           orderslist.stream()
                               .filter((order) -> order.getisvalid() == 1)
                               .collect(collectors.summingdouble(order::gettotal))
                  );

system.out.println("最小订单金额:"+
                        orderslist.stream()
                            .filter((order) -> order.getisvalid() == 1)
                            .map(order::gettotal)
                            .collect(collectors.minby(double::compare))
                  );

// 筛选所有有效订单 并计算最大订单金额
system.out.println("最大订单金额:"+
                        orderslist.stream()
                            .filter((order) -> order.getisvalid() == 1)
                            .map(order::gettotal)
                            .collect(collectors.maxby(double::compare))
                  );

map<integer,list<order>> g01=orderslist.stream()
                                .filter((order) -> order.getisvalid() == 1)
                                .collect(collectors.groupingby(order::getstatus));
g01.foreach((status,order)->{
    system.out.println("----------------");
    system.out.println("订单状态:"+status);
    order.foreach(system.out::println);
});

map<integer,map<string,list<order>>> g02= orderslist.stream()
                    .filter((order) -> order.getisvalid() == 1)
                    .collect(collectors.groupingby(order::getuserid,
                              collectors.groupingby((o)->{
                                    if(o.getstatus()==0){
                                        return "未支付";
                                    }else if (o.getstatus()==1){
                                        return "已支付";
                                    }else if (o.getstatus()==2){
                                        return "待发货";
                                    }else if (o.getstatus()==3){
                                        return "已发货";
                                    }else if (o.getstatus()==4){
                                        return "已接收";
                                    } else{
                                        return "已完成";
                                    }
                                }
                                ))
                            );
g02.foreach((userid,m)->{
    system.out.println("用户id:"+userid+"-->有效订单如下:");
    m.foreach((status,os)->{
        system.out.println("状态:"+status+"---订单列表如下:");
        os.foreach(system.out::println);
    });
    system.out.println("-----------------------");
});

map<boolean,list<order>> g03= orderslist.stream()
            .filter((order) -> order.getisvalid() == 1)
            .collect(collectors.partitioningby((o)->o.gettotal()>1000));
g03.foreach((b,os)->{
    system.out.println("分区结果:"+b+"--列表结果:");
    os.foreach(system.out::println);
});

string orderstr=orderslist.stream()
            .filter((order) -> order.getisvalid() == 1)
            .map(order::getorderno)
            .collect(collectors.joining(","));
system.out.println(orderstr);