【逻辑】简单合并两个数据源的数据

前言

最近在工作中，遇到一个需要合并两个数据集合的需求

过程分析

待补充

结论

首先新建一个数据类 Data，包含 type 和 data 两个成员变量，其中 type 是数据的来源，data 是真实的数据

然后重写 equals() 方法，判断两个 Data 的 data 变量是否相等

import java.util.Objects;

public class Data {
    public Integer type;
    public Integer data;

    public Data(Integer type, Integer data) {
        this.type = type;
        this.data = data;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        return Objects.equals(this.data, ((Data) o).data);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder().append("Data{").append("type=");
        if (type == 0) {
            sb.append("local");
        }
        else if (type == 1){
            sb.append("remote");
        }
        sb.append(", data=").append(data).append("}");
        return sb.toString();
    }
}

在测试中，一个是 remote 数据源，另一个是 local 数据源

遍历 local 数据源，以此判断 Data 数据 type 是否相等（调用数据类的 equals() 方法判断）

如果 remote 数据源不包含 Data 数据，则添加该 Data 数据至 remote 数据源

如果 remote 数据源包含 Data 数据，则根据 isOverwrite 判断是否需要覆盖

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static List<Data> merge(final List<Data> remote, final List<Data> local, boolean isOverwrite) {
        List<Data> result = new ArrayList<>(remote);
        for (Data localData : local) {
            if (result.contains(localData) && isOverwrite) {
                int remoteIndex = result.indexOf(localData);
                result.set(remoteIndex, localData);
            }
            else if (!result.contains(localData)) {
                result.add(localData);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<Data> remote = new ArrayList<>();
        remote.add(new Data(0, 1));
        remote.add(new Data(0, 2));
        remote.add(new Data(0, 3));
        List<Data> local = new ArrayList<>();
        local.add(new Data(1, 2));
        local.add(new Data(1, 3));
        local.add(new Data(1, 4));
        List<Data> merge = merge(remote, local, true);
        System.out.println(merge);
    }
}

当 isOverwrite 为 true 时，运行结果如下：

[Data{type=local, data=1}, Data{type=remote, data=2}, Data{type=remote, data=3}, Data{type=remote, data=4}]

当 isOverwrite 为 false 时，运行结果如下：

[Data{type=local, data=1}, Data{type=local, data=2}, Data{type=local, data=3}, Data{type=remote, data=4}]