Vergleichen Sie 2 Java arraylists verschiedene Objekte und fügen Sie die passenden Zeilen in eine neue Liste

Da sehe ich keine Oberklassen, aus denen Sie zu erweitern, Sie manuell zu Durchlaufen und Ihre Listen. Ich gehe davon aus, dass eine Menge, zum Beispiel, dass Sie Getter und setter für die Attribute, die PersonNpi.name ist mehr oder weniger das gleiche wie Person.firstname + Person.lastname, dass Sie eine Funktion in Address wie boolean checkEquality(String street1, String street2, String city, String state, String zip), dass Ihr Person Klasse hat eine getName() - Methode zu vergleichen, mit PersonNpis. In diesem Fall wird eine Schleife durch die erste Reihe, und prüfen Sie für jedes Element, wenn die zweite hat nichts ihm gleich.

ArrayList<Employee> employees = new ArrayList<Employee>();
for(Person person : personList) {
  for(PersonNpi personNpi : npiList) {
    if (person.getName().equals(personNpi.getName()) && 
        person.getAddress().checkEquality(...address parts here...)) {
      employees.add(new Employee(person, personNpi));
    }
  }
}

Wieder, ich habe eine Menge von Annahmen, auch die, die Sie haben eine Employee Konstruktor, der nur erfordert die Person und die PersonNpi ab und ruft die erforderlichen Informationen entsprechend.

Sollten Sie mehr erarbeiten, verwenden Oberklassen, und verwenden Sie die contains() Funktion. In anderen Worten, stellen Sie einen Vergleich der Person und die PersonNpi einfacher durch eine Funktion.

Bearbeiten: deine zweite Frage ist sehr, wenn nicht extrem abhängig, Ihre weitere Umsetzung der Employee, Person und PersonNpi. Für jetzt, ich werde noch einmal angenommen, Sie haben einige Methoden, die überprüfen, Gleichheit zwischen Employee, Person und PersonNpi.

Ich würde vorschlagen, um nicht die Kontrolle in einer Schleife, da haben Sie zwei ArrayLists die lief durch. Die PersonNpi-Liste lief durch für jeden Datensatz in der ersten List. Also, was könnte passieren, nachdem wir alles überprüft, ein paar Persons Links sind unerreicht und ein paar PersonNpis Links sind unerreicht, da wir nicht die fahne, die Persons und PersonNpis haben wir abgestimmt.

Abschließend: für Leichtigkeit halber, fügen Sie einfach diesen Teil:

ArrayList<Object> nonMatchedPersons = new ArrayList<Object>();
for (Person person : personList) 
    if (!employees.contains(person))
        nonMatchedPersons.add(person);
for (PersonNpi personNpi : npiList) 
    if (!employees.contains(personNpi))
        nonMatchedPersons.add(personNpi);

Diese Methode erfordert die Implementierung der equals(Object) Methode für alle 3 person-Klassen, die Sie vielleicht in Erwägung ziehen, unter einer Superklasse wie Human. In diesem Fall können Sie die Object ArrayList in eine ArrayList<Human>

Mit einer Schleife (erfordert equals(Object) Methode für die 3 person-Klassen):

List<Employee> employees = new ArrayList<Employee>();
ArrayList<Object> nonMatchedPersons = new ArrayList<Object>();

Iterator<Person> personIterator = personList.iterator();
while (personIterator.hasNext()) {
    Iterator<PersonNpi> npiIterator = npiList.iterator();
    while(npiIterator.hasNext()) {
        Person person = personIterator.next();
        PersonNpi personNpi = npiIterator.next();
        if (person.equals(personNpi)) {
            employees.add(new Employee(person, personNpi));
            personIterator.remove();
            npiIterator.remove();
        }
    }
}

nonMatchedPersons.addAll(personList);
nonMatchedPersons.addAll(npiList);

Erklärung: wir Schleife mit Iterators durch die beiden Listen, uns zu ermöglichen, entfernen Sie aus der Liste während der Iteration. So in der personList und die npiList nur die singles bleiben, wie wir hinzufügen, verdoppelt sich der Employee-Liste, sofort entfernen Sie Sie aus den beiden anderen Listen. Fügen wir die verbleibenden Einzel in die beiden Listen auf unserer nonMatchedPerson-Liste mit den addAll Methode.

Edit2: Wenn Sie nicht Bearbeiten können Sie diese Klassen, aus welchem Grund auch immer, 3 wrapper Klassen, so etwas wie:

public class PersonWrapper {
    private Person person;

    public PersonWrapper(Person person) {
        this.person = person;
    }

    @override
    public boolean equals(Object other) {
        if (other == null) 
            return false;
        if (other instanceof PersonWrapper) {
            //etc etc, check for equality with other wrappers.
            ...
        }
    }
}

Wenn Sie diesen Ansatz verwenden, ändern Sie diese Zeile in der Schleife:

if (person.equals(personNpi)) {

zu diesem:

if (new PersonWrapper(person).equals(new PersonNpiWrapper(personNpi))) {

Anhand dieser können Sie noch implementieren Ihre eigenen equals() Methode.

Andere Lösung könnte sein, dass Sie eine statische Methode wie diese:

public static boolean equals(Object this, Object that) {
    if (this instanceof Person || this instanceof PersonNpi) //et cetera, et cetera
        return true;
    return false;
}

Nun rufen Person.equals(person, personNpi), vorausgesetzt, Sie setzen die Methode in der Klasse Person.

Etwas wie dies funktionieren sollte. Es wird davon ausgegangen, dass Sie einen Weg für den Bau einer Employee aus einer Person und ein PersonNpi. Auch, weil Sie nicht sagen, die Struktur einer Address werde ich überlasse es Ihnen, um die Adresse zu schreiben matching-Logik.

public List<Employee> findCommonElements(List<Person> list1,
                                         List<PersonNpi> list2)
{
    List<Employee> common = new ArrayList<Employee>();
    for (Person p1 : list1) {
        PersonNpi p2 = find(list2, p1);
        if (p2 != null) {
            common.add(new Employee(p1, p2));
        }
    }
}

private PersonNpi find(List<PersonNpi> list, Person p) {
    for (PersonNpi p2 : list) {
        if (matches(p, p2)) {
            return p2;
        }
    }
    return null;
}

private boolean matches(Person p1, PersonNpi p2) {
    return /* logic for comparing name and address info */;
}

Dies ist eine O(n²) - operation. Könnten Sie diese Fahrt wesentlich durch die Sortierung beider arrays mit name und Adresse. Die Sortier-operation ist O(n log(n)) und Vergleich könnte dann umgesetzt werden als O(n) - operation.