Java 基于另一个ArrayList添加或更新ArrayList的元素

我有两个

教室

对象的数组列表，下面显示了

教室

类：

public class ClassRoom {

    private String className; // className is unique here
    private List<Student> students = new ArrayList<>();

    public ClassRoom(String className, List<Student> students) {
        this.className = className;
        this.students = students;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }

    @Override
    public String toString() {

        String ss = "[";
        for (int i = 0; i < students.size(); i++) {
            ss += "{name:'" + students.get(i).getName() + "',age:" + students.get(i).getAge() + "}";
            ss += (i == (students.size() - 1)) ? "" : ",";
        }
        ss += "]";
        return "{'" + className + "':" + ss + "}";
    }

}

我已经创建了两个

教室

对象列表，如下所示：

List<ClassRoom> list1 = new ArrayList<>();

list1.add(new ClassRoom("A", Arrays.asList(new Student("Sam", 20), new Student("Peter", 40), new Student("Aaron", 15))));
list1.add(new ClassRoom("B", Arrays.asList(new Student("Ronnie", 33), new Student("Daniel", 41), new Student("Gabe", 35))));
list1.add(new ClassRoom("C", Arrays.asList(new Student("Fabian", 42), new Student("Edgar", 33))));
list1.add(new ClassRoom("D", Arrays.asList(new Student("Peter", 39), new Student("Calvin", 45))));

List<ClassRoom> list2 = new ArrayList<>();

list2.add(new ClassRoom("A", Arrays.asList(new Student("Sam", 26), new Student("Aaron", 18))));
list2.add(new ClassRoom("B", Arrays.asList(new Student("Daniel", 38), new Student("Eddy", 29))));
list2.add(new ClassRoom("C", Arrays.asList(new Student("Fabian", 42), new Student("Edgar", 33))));

List<ClassRoom> mergedList = merge(list1, list2);

for (ClassRoom classRoom : mergedList) {
    System.out.println(classRoom.toString());
    /* Expected output here
    {'A':[{name:'Sam',age:26},{name:'Peter',age:40},{name:'Aaron',age:18}]}
    {'B':[{name:'Ronnie',age:33},{name:'Daniel',age:38},{name:'Gabe',age:35},{name:'Eddy',age:29}]}
    {'C':[{name:'Fabian',age:42},{name:'Edgar',age:33}]}
    {'D':[{name:'Peter',age:39},{name:'Calvin',age:45}]}
   */
}

下面解释我的

merge

方法：

public static List<ClassRoom> merge(List<ClassRoom> listA, List<ClassRoom> listB) {

      ArrayList<ClassRoom> collect = Stream.of(listA, listB).collect(ArrayList<ClassRoom>::new, (item1, item2) -> {
          item2.forEach((c2) -> {
            item1.forEach((c1) -> {
                if (c2.getClassName().equalsIgnoreCase(c1.getClassName())) {
                    // Student list update goes here
                } else {
                    item1.add(c2);
                }
            });
        });
      }, (item1, item2) -> {

      });

    return collect;
 }

公共静态列表合并（列表A、列表B）{
ArrayList collect=Stream.of（listA，listB）.collect（ArrayList:：new，（item1，item2）->{
项目2.forEach（（c2）->{
项目1.forEach（（c1）->{
if（c2.getClassName（）.equalsIgnoreCase（c1.getClassName（）））{
//学生名单更新到这里
}否则{
项目1.增加（c2）；
}
});
});
}，（第1项、第2项）->{
});
回款到付；
}

到目前为止，我遇到的问题是在merge方法调用之后产生一个空列表。如有任何建议，我们将不胜感激。

您可以这样做：

公共静态列表合并（列表A、列表B）{
Map Map=newhashmap（）；
listA.forEach（item->map.put（item.getClassName（），新HashSet（item.getStudents（））；
用于（教室：列表B）{
Set Set=map.getOrDefault（教室.getClassName（），新HashSet（））；
set.addAll（教室.getStudents（））；
map.put（class.getClassName（），set）；
}
列表=新的ArrayList（）；
map.forEach（（k，v）->list.add（新教室（k，新阵列列表（v）））；
退货清单；
}

并在学生中添加以下内容：

@覆盖
公共布尔等于（对象o）{
如果（this==o）返回true；
如果（！（o学生实例））返回false；
学生=（学生）o；
返回getName（）！=null？getName（）.equals（student.getName（））：student.getName（）==null；
}
@凌驾
公共int hashCode（）{
返回getName（）！=null？getName（）.hashCode（）：0；
}

您可以这样做：

公共静态列表合并（列表A、列表B）{
Map Map=newhashmap（）；
listA.forEach（item->map.put（item.getClassName（），新HashSet（item.getStudents（））；
用于（教室：列表B）{
Set Set=map.getOrDefault（教室.getClassName（），新HashSet（））；
set.addAll（教室.getStudents（））；
map.put（class.getClassName（），set）；
}
列表=新的ArrayList（）；
map.forEach（（k，v）->list.add（新教室（k，新阵列列表（v）））；
退货清单；
}

并在学生中添加以下内容：

@覆盖
公共布尔等于（对象o）{
如果（this==o）返回true；
如果（！（o学生实例））返回false；
学生=（学生）o；
返回getName（）！=null？getName（）.equals（student.getName（））：student.getName（）==null；
}
@凌驾
公共int hashCode（）{
返回getName（）！=null？getName（）.hashCode（）：0；
}

覆盖

name

上

Student

中的

equals

和

hashCode

方法

使用IDE建议的默认实现覆盖

教室

中的

equals

和

hashCode

方法

将

list2

收集到

Map映射中

并处理

list1

的每个元素，如下所示：

Map Map=list2.stream（）
.collect（Collectors.toMap（教室：：getClassName，教室：：getStudents））；
list1.forEach（e->map.merge（e.getClassName（），
Stream.of（map.getOrDefault（e.getClassName（）、e.getStudents（）、e.getStudents（））
.flatMap（列表：：流）
.distinct（）
.collect（收集器.toList（）），
（v1，v2）->v2）
);

输出：

{A=[姓名：山姆，年龄：26岁，姓名：亚伦，年龄：18岁，姓名：彼得，年龄：40岁]， B=[姓名：丹尼尔，年龄：38，姓名：艾迪，年龄：29，姓名：罗尼，年龄：33， 姓名：盖布，年龄：35]，C=[姓名：费边，年龄：42，姓名：埃德加，年龄：33]， D=[姓名：彼得，年龄：39岁，姓名：卡尔文，年龄：45]}

覆盖

name

上

Student

中的

equals

和

hashCode

方法

使用IDE建议的默认实现覆盖

教室

中的

equals

和

hashCode

方法

将

list2

收集到

Map映射中

并处理

list1

的每个元素，如下所示：

Map Map=list2.stream（）
.collect（Collectors.toMap（教室：：getClassName，教室：：getStudents））；
list1.forEach（e->map.merge（e.getClassName（），
Stream.of（map.getOrDefault（e.getClassName（）、e.getStudents（）、e.getStudents（））
.flatMap（列表：：流）
.distinct（）
.collect（收集器.toList（）），
（v1，v2）->v2）
);

输出：

{A=[姓名：山姆，年龄：26岁，姓名：亚伦，年龄：18岁，姓名：彼得，年龄：40岁]， B=[姓名：丹尼尔，年龄：38，姓名：艾迪，年龄：29，姓名：罗尼，年龄：33， 姓名：盖布，年龄：35]，C=[姓名：费边，年龄：42，姓名：埃德加，年龄：33]， D=[姓名：彼得，年龄：39岁，姓名：卡尔文，年龄：45]}

可能会有所帮助。您不需要在

collect

中同时进行

forEach

循环，这会有所帮助。您不需要在

collect

public static List<ClassRoom> merge(List<ClassRoom> listA, List<ClassRoom> listB) {

      ArrayList<ClassRoom> collect = Stream.of(listA, listB).collect(ArrayList<ClassRoom>::new, (item1, item2) -> {
          item2.forEach((c2) -> {
            item1.forEach((c1) -> {
                if (c2.getClassName().equalsIgnoreCase(c1.getClassName())) {
                    // Student list update goes here
                } else {
                    item1.add(c2);
                }
            });
        });
      }, (item1, item2) -> {

      });

    return collect;
 }

@Override
public boolean equals(Object obj) {
    return Objects.equals(name, ((Student) obj).getName());
}

@Override
public String toString() {
    return "name: " + name + ", age: " + age;
}

Map<String, List<Student>> map = list2.stream()
            .collect(Collectors.toMap(ClassRoom::getClassName, ClassRoom::getStudents));

list1.forEach(e -> map.merge(e.getClassName(),
                                Stream.of(map.getOrDefault(e.getClassName(), e.getStudents()), e.getStudents())
                                .flatMap(List::stream)
                                .distinct()
                                .collect(Collectors.toList()),
                                    (v1, v2) -> v2)
                            );