package com.example.demo.test;
import org.apache.commons.compress.utils.Lists;
import java.math.BigDecimal;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Collectors;
 * 比较两个集合设置集合对象中的属性
public class streamTest4 {
    public static void main(String[] args) {
        // 获取商品对象
        List<GoodInfo> goodInfos=getGoodModelList();
        List<ImgInfo> imgInfo=getImgInfo();
        System.out.println("===== 商品属性集合 =====");
        System.out.println(goodInfos);
        // 设置另外一个集合的对象属性
        for (ImgInfo img:imgInfo){
            goodInfos.stream().filter(p -> img.getGoodNumber().equals(p.getNumber())).forEach(
                    p -> {p.setImg(img.getImg());p.setImgDescribe(img.getImgDescribe());}
        System.out.println("===== 设置后的属性集合 =====");
        System.out.println(goodInfos);
        // 获取所有商品的总金额 BigDecimal 求和
        System.out.println("===== 求和 =====");
        BigDecimal price=goodInfos.stream().map(GoodInfo::getPrice).reduce(BigDecimal.ZERO,BigDecimal::add);
        // 基本类型求和
        int count=goodInfos.stream().mapToInt(GoodInfo::getCount).sum();
        System.out.println("商品总金额为:"+price);
        System.out.println("商品总件数:"+count);
        // 最贵的商品 求金额最大值  如果比较件数，后面的使用Integer
        System.out.println("===== 最大值 =====");
        BigDecimal maxPrice=goodInfos.stream().map(GoodInfo::getPrice).max(BigDecimal::compareTo).get();
        Integer maxCount=goodInfos.stream().map(GoodInfo::getCount).max(Integer::compareTo).get();
        System.out.println("最贵的商品价格为："+maxPrice);
        // 求金额最小值
        System.out.println("===== 最小值 =====");
        BigDecimal minPrice=goodInfos.stream().map(GoodInfo::getPrice).min(BigDecimal::compareTo).get();
        System.out.println("最便宜的商品价格为："+minPrice);
        // list转map
        System.out.println("===== 转map =====");
        Map<String,GoodInfo> mapGoodInfo=goodInfos.stream().collect(Collectors.toMap(GoodInfo::getNumber,p -> p,(k1,k2)->k1));
        System.out.println(mapGoodInfo);
        // 排序 根据商品升序
        System.out.println("===== 排序 =====");
        goodInfos.stream().sorted(Comparator.comparing(GoodInfo::getPrice));
        System.out.println(goodInfos);
        // 分组
        System.out.println("===== 分组 =====");
        Map<String,List<GoodInfo>> groupMap=goodInfos.stream().collect(Collectors.groupingBy(GoodInfo::getSerialNumber));
        // 遍历分组
        List<GoodInfo> entryUserList=Lists.newArrayList();
        for (Map.Entry<String, List<GoodInfo>> entryUser : groupMap.entrySet()) {
            String key = entryUser.getKey();
            entryUserList = entryUser.getValue();
            System.out.println("key:"+key);
            System.out.println("value:"+entryUserList);
    public static List<ImgInfo> getImgInfo(){
        List<ImgInfo> imgInfos=Lists.newArrayList();
        ImgInfo imgInfo=new ImgInfo();
        imgInfo.setGoodNumber("10001");
        imgInfo.setImg("这是一张小米8SE的图片.jpg");
        imgInfo.setImgDescribe("小米8SE");
        ImgInfo imgInfo1=new ImgInfo();
        imgInfo1.setGoodNumber("10003");
        imgInfo1.setImg("这是一张小米的图片.jpg");
        imgInfo1.setImgDescribe("小米8");
        imgInfos.add(imgInfo);
        imgInfos.add(imgInfo1);
        return imgInfos;
    public static List<GoodInfo> getGoodModelList(){
        List<GoodInfo> goodModelList= Lists.newArrayList();
        GoodInfo goodModel=new GoodInfo();
        goodModel.setNumber("10001");
        goodModel.setSerialNumber("X243");
        goodModel.setName("小米8SE");
        goodModel.setDescribe("8G运行内存 128G机身内存 不支持NFC");
        goodModel.setCount(20);
        goodModel.setPrice(new BigDecimal("1899"));
        GoodInfo goodModel1=new GoodInfo();
        goodModel1.setNumber("10002");
        goodModel1.setSerialNumber("X243");
        goodModel1.setName("小米8青春版");
        goodModel1.setDescribe("8G运行内存 128G机身内存 外形美观");
        goodModel1.setCount(20);
        goodModel1.setPrice(new BigDecimal("2999"));
        GoodInfo goodModel2=new GoodInfo();
        goodModel2.setNumber("10003");
        goodModel2.setSerialNumber("X477");
        goodModel2.setName("小米8");
        goodModel2.setDescribe("8G运行内存 128G机身内存 外形美观 支持NFC");
        goodModel2.setCount(20);
        goodModel2.setPrice(new BigDecimal("1999"));
        GoodInfo goodModel3=new GoodInfo();
        goodModel3.setNumber("10004");
        goodModel3.setSerialNumber("X499");
        goodModel3.setName("小米10");
        goodModel3.setDescribe("16G运行内存 256G机身内存 外形美观 支持NFC");
        goodModel3.setCount(20);
        goodModel3.setPrice(new BigDecimal("9999"));
        goodModelList.add(goodModel);
        goodModelList.add(goodModel1);
        goodModelList.add(goodModel2);
        goodModelList.add(goodModel3);
        return goodModelList;
class GoodInfo{
    private String number;
    private String name;
    private String SerialNumber;
    private String describe;
    private BigDecimal price;
    private Integer count;
    private String img;
    private String imgDescribe;
    public String getNumber() {
        return number;
    public void setNumber(String number) {
        this.number = number;
    public String getSerialNumber() {
        return SerialNumber;
    public void setSerialNumber(String serialNumber) {
        SerialNumber = serialNumber;
    public String getDescribe() {
        return describe;
    public void setDescribe(String describe) {
        this.describe = describe;
    public BigDecimal getPrice() {
        return price;
    public void setPrice(BigDecimal price) {
        this.price = price;
    public String getImg() {
        return img;
    public void setImg(String img) {
        this.img = img;
    public String getImgDescribe() {
        return imgDescribe;
    public void setImgDescribe(String imgDescribe) {
        this.imgDescribe = imgDescribe;
    public String getName() {
        return name;
    public void setName(String name) {
        this.name = name;
    public Integer getCount() {
        return count;
    public void setCount(Integer count) {
        this.count = count;
    @Override
    public String toString() {
        return "GoodInfo{" +
                "number='" + number + '\'' +
                ", name='" + name + '\'' +
                ", SerialNumber='" + SerialNumber + '\'' +
                ", describe='" + describe + '\'' +
                ", price='" + price + '\'' +
                ", img='" + img + '\'' +
                ", imgDescribe='" + imgDescribe + '\'' +
                '}';
class ImgInfo{
    private String goodNumber;
    private String img;
    private String imgDescribe;
    public String getGoodNumber() {
        return goodNumber;
    public void setGoodNumber(String goodNumber) {
        this.goodNumber = goodNumber;
    public String getImg() {
        return img;
    public void setImg(String img) {
        this.img = img;
    public String getImgDescribe() {
        return imgDescribe;
    public void setImgDescribe(String imgDescribe) {
        this.imgDescribe = imgDescribe;
在Stream处理中，我们通常会遇到if/else的判断情况，对于这样的问题我们怎么处理呢？
还记得我们在上一篇文章lambda最佳实践中提到，lambda表达式应该越简洁越好，不要在其中写臃肿的业务逻辑。
接下来我们看一个具体的例子。
假如我们有一个1 to 10的list，我们想要分别挑选出奇数和偶数出来，传统的写法，我们会这样使用：
    public void inForEach(){
        List ints = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
                                    上述代码中，将两个List类型的对象list1和list2转换为Stream类型，并调用filter方法筛选出不同的对象。最后通过collect方法将不同的对象转换为List类型，并输出结果。可以使用Java8的Stream API来比较两个List的差异，并取出不同的对象。2. 调用Stream的filter方法，将不同的对象过滤出来；3. 将过滤出的不同的对象转换为List类型。1. 将两个List转换为Stream类型；
Java 8中针对使用容器进行随机采样的问题的一组算法。
 储层采样是一类随机算法，用于从包含n项的列表S中随机选择k项的样本，其中n是很大或未知数。 通常， n足够大，以致该列表无法放入主内存中。 [1]在这种情况下，将k项目的样本称为sample ，将列表S称为stream 。
 该软件包将这些算法分为两个主要类别：在源流的每个项目中分配权重的算法和未在源流的每个项目中分配权重的算法。 这些将分别称为加权和非加权随机采样算法。 在非加权算法中，流中的每个项目出现在样本中的概率为k/n 。 在加权算法中，这种可能性取决于额外的参数weight 。 每种算法可能以不同的方式解释此参数，例如，在[2]中提到了两种可能的解释。
您可以从项目中添加依赖项，如下所示：
 使用Maven 
< dependency>
  < groupId>gr.james</ groupId 
                                    思路：首先获取两个list的id，通过id比较获取id的交并差集，再通过一次获取list对象里面的交并差集元素
代码直接可运行，个人觉得java8的stream非常类似ES6的集合运算，filter、foreach、map、reduce基本可以一一对应
package com.stream;
import java.util.ArrayList;
import java.util...
                                    //应用场景：批量添加权限，表中userId和roleId相同则认为数据相同不插入，需要从数据中过滤出需要插入的数据
    public void study(){
        //需要插入的实体
        ArrayList<ExampleUserEntity> exampleUserEntity = null;
        //数据库中过滤过只有含有exampleUserEntity的userId的数据
        List<ExampleUserEntity&gt
                                    工作需要 要查出来两个list对象得差值 是根据其中一个字段的 正好这段时间再用stream  就试了一下
//需要求相同的只需要把第二行！去掉就行
 List<AlarmComparisonDto> collect = lastWeekHostAlarmNum.stream()
                .filter(item -> !thisWeekHostAlarmNum.stream()
                        .map(e -> e.getH
                                    今天开发一个需求时，要对A和B两个List集合遍历，并比较出集合A有，而集合B没有的值。
比如说List集合A有’one’,‘two’,‘three’三个值，List集合B有’one’,‘three’两个值。
那么最终打印’two’。
下面我就用stream流来做个例子。
例子中，集合A的泛型为HashMap，集合B的泛型为String。
Stream流中，forEach()方法用于对一个流进行结尾动作，同时对最终过滤后的元素结果进行一个遍历操作。
我们可以在forEach()中直接写入类和其对应方法名，来
JDK8提供的对集合数据进行处理的一种方式
流中的元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算
数据源流的来源。 可以是集合，数组，I/O channel， 产生器generator 等
有聚合操作 类似SQL语句一样的操作， 比如filter, ma
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        HjHsCode hjHsCode = (HjHsCode) o;
        return Objects.equals(hsCode, hj
                                    在Stream中distinct()可以进行去重,内部原理是通过构建一个ConcurrentHashMap并使用putIfAbsent()来去重,但是由于ConcurrentHashMap与HashMap一样是通过hashCode()和equals()方法来查找和比对的而如果对象所属的类没有将hashCode()和equals()重写的话就会导致同一个类的多个new出来的对象是无法判定为"相等"的...
                                    点击关注公众号，利用碎片时间学习Java8的新特性——Stream常用于处理集合，它不会改变集合原有的结构，优点是Stream的代码会比用for循环处理简洁不少本文主要说的是：获取两个Li...