使用java streams比较具有字段的两个对象列表

我需要使用流将两个对象列表与其字段值进行比较

比如说

List<Object> originalObjectList
List<Object> modifiedObjectList

结果应包含字段值和字段状态，如“已删除”、“已修改”或“已添加”

---

请建议是否有更好的方法来实现这一点？我是java streams的新手

类似的东西。请随意提问

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class App6 {
    public static final String ADDED = "ADDED";
    public static final String DELETED = "DELETED";
    public static final String MODIFIED = "MODIFIED";
    public static final String NOT_MODIFIED = "NOT_MODIFIED";

    public static void main(String[] args) {
        List<A> originalObjectList = Arrays.asList(new A("a"), new A(""), new A("a"), new A("a"));
        List<A> modifiedObjectList = Arrays.asList(new A("a"), new A("b"), new A("b"), new A(""));

        List<Result> results = IntStream
                .range(0, originalObjectList.size())
                .mapToObj(i -> {
                    A original = originalObjectList.get(i);
                    A modified = modifiedObjectList.get(i);
                    return compare(original, modified);
                })
                .collect(Collectors.toList());
        System.out.println(results);
    }

    public static Result compare(A or, A mod) {
        if (or == null || mod == null) {
            throw new IllegalArgumentException("Comparable objects should not be null");
        }
        if (or.field == null || mod.field == null) {
            throw new IllegalArgumentException("Comparable fields of objects should not be null");
        }
        if (or.field.equals(mod.field)) {
            return new Result(NOT_MODIFIED, or.field);
        } else if (or.field.isEmpty() && !mod.field.isEmpty()) {
            return new Result(ADDED, mod.field);
        } else if (!or.field.isEmpty() && mod.field.isEmpty()) {
            return new Result(DELETED, or.field);
        } else {
            return new Result(MODIFIED, mod.field);
        }
    }
}

class A {
    String field;

    public A(String field) {
        this.field = field;
    }
}

class Result {
    String status;
    String value;

    public Result(String status, String value) {
        this.status = status;
        this.value = value;
    }

    @Override
    public String toString() {
        return "Result{" +
                "status='" + status + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
}

导入java.util.array；
导入java.util.List；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
公共类App6{
公共静态最终字符串ADDED=“ADDED”；
公共静态最终字符串DELETED=“DELETED”；
公共静态最终字符串MODIFIED=“MODIFIED”；
public static final String NOT_MODIFIED=“NOT_MODIFIED”；
公共静态void main（字符串[]args）{
List originalObjectList=Arrays.asList（新A（“A”）、新A（“A”）、新A（“A”）、新A（“A”）；
List modifiedObjectList=Arrays.asList（新A（“A”）、新A（“b”）、新A（“b”）、新A（“b”）；
列表结果=IntStream
.range（0，originalObjectList.size（））
.mapToObj（i->{
A original=originalObjectList.get（i）；
A modified=modifiedObjectList.get（i）；
返回比较（原始、修改）；
})
.collect（Collectors.toList（））；
系统输出打印项次（结果）；
}
公共静态结果比较（or、mod）{
if（or==null | | mod==null）{
抛出新的IllegalArgumentException（“可比较对象不应为null”）；
}
if（or.field==null | | mod.field==null）{
抛出新的IllegalArgumentException（“对象的可比较字段不应为空”）；
}
如果（或字段等于（模块字段））{
返回新结果（未修改，或.field）；
}else if（或.field.isEmpty（）&&！mod.field.isEmpty（））{
返回新结果（添加，修改字段）；
}如果（！or.field.isEmpty（）&&mod.field.isEmpty（）），则为else{
返回新结果（已删除或.field）；
}否则{
返回新结果（已修改，修改字段）；
}
}
}
甲级{
字符串字段；
公用A（字符串字段）{
this.field=字段；
}
}
班级成绩{
字符串状态；
字符串值；
公共结果（字符串状态、字符串值）{
这个状态=状态；
这个值=值；
}
@凌驾
公共字符串toString（）{
返回“结果{”+
“状态=”+“状态+”\“”+
，value=''+value+'\''+
'}';
}
}

如果

modifiedObjectList

是由

originalObjectList

组成的，为什么你不能简单地

modifiedObjectList.stream.（.map（original->compare（modify（original），original））.collect（Collectors.toList（））

？这是家庭作业

.collect（Collectors.toList（））

应该在我使用Collectors.toList（）时执行这个技巧，并在列表中捕获它表示不兼容类型的响应。预期的结果类型是什么？为什么要使用

StringUtils.isNotEmpty（string）

而不是

string.isEmpty（）

？你真的想过这个第三方库方法和内置方法之间的区别吗？

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class App6 {
    public static final String ADDED = "ADDED";
    public static final String DELETED = "DELETED";
    public static final String MODIFIED = "MODIFIED";
    public static final String NOT_MODIFIED = "NOT_MODIFIED";

    public static void main(String[] args) {
        List<A> originalObjectList = Arrays.asList(new A("a"), new A(""), new A("a"), new A("a"));
        List<A> modifiedObjectList = Arrays.asList(new A("a"), new A("b"), new A("b"), new A(""));

        List<Result> results = IntStream
                .range(0, originalObjectList.size())
                .mapToObj(i -> {
                    A original = originalObjectList.get(i);
                    A modified = modifiedObjectList.get(i);
                    return compare(original, modified);
                })
                .collect(Collectors.toList());
        System.out.println(results);
    }

    public static Result compare(A or, A mod) {
        if (or == null || mod == null) {
            throw new IllegalArgumentException("Comparable objects should not be null");
        }
        if (or.field == null || mod.field == null) {
            throw new IllegalArgumentException("Comparable fields of objects should not be null");
        }
        if (or.field.equals(mod.field)) {
            return new Result(NOT_MODIFIED, or.field);
        } else if (or.field.isEmpty() && !mod.field.isEmpty()) {
            return new Result(ADDED, mod.field);
        } else if (!or.field.isEmpty() && mod.field.isEmpty()) {
            return new Result(DELETED, or.field);
        } else {
            return new Result(MODIFIED, mod.field);
        }
    }
}

class A {
    String field;

    public A(String field) {
        this.field = field;
    }
}

class Result {
    String status;
    String value;

    public Result(String status, String value) {
        this.status = status;
        this.value = value;
    }

    @Override
    public String toString() {
        return "Result{" +
                "status='" + status + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
}