J'ai besoin de comparer deux listes d'objets avec leurs valeurs de champ à l'aide de flux

Par exemple

List<Object> originalObjectList
List<Object> modifiedObjectList

J'ai besoin de trouver des différences entre les objets de deux listes au niveau du champ et d'obtenir la liste des différences comme ci-dessous

J'essaye avec cette approche

originalObjectList
.stream()
.map(originalObject -> modifiedObjectList
.stream()
.map(modifiedObject -> findDifferences(originalObject.getField1(), modifiedObject.getField1())
.collect(// not understanding how to collect the result returned from findDifferences)

//Method

Result findDifferences(String originalValue, String modifiedValue){
Result result = new Result();

if(StringUtils.isEmpty(originalValue) && StringUtils.isNotEmpty(modifiedValue)){
     result.setStatus("ADDED");
     result.setValue(modifiedValue);
}
else if(StringUtils.isNotEmpty(originalValue) && StringUtils.isEmpty(modifiedValue)){
          result.setStatus("DELETED");
          result.setValue(originalValue);
}
else if(!originalValue.equals(modifiedValue)){
          result.setStatus("MODIFIED");
          result.setValue(modifiedValue);
        }
return result;
}

Le résultat doit contenir la valeur du champ et l'état du champ comme « Supprimé », « Modifié » ou « Ajouté » Veuillez suggérer s'il existe un meilleur moyen d'y parvenir ? Je suis nouveau sur les flux java

-2
Rohit 14 févr. 2020 à 09:46

1 réponse

Meilleure réponse

Quelque chose comme ça. Sentez-vous libre de poser des questions.

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 + '\'' +
                '}';
    }
}
1
Eugene Kortov 17 févr. 2020 à 09:09