Vergleich von Namen mit mehreren Vornamen ist jetzt toleranter

doc/release-notes.adoc

@@ -5,6 +5,7 @@
 == 2.2.1 (SNAPSHOT)
 
 * Adressvergleich kommt jetzt mit mehr Sonderfällen klar
+* Namensvergleich funktioniert jetzt auch mit unterschiedlicher Anzahl von Vornamen besser
 
 
 == 2.2 (27-Feb-2019)

src/main/java/de/jfachwert/post/Name.java

@@ -23,6 +23,9 @@
 import de.jfachwert.pruefung.NullValidator;
 import org.apache.commons.lang3.StringUtils;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.WeakHashMap;
 
 /**
@@ -78,18 +81,32 @@ public static Name of(String name) {
      * @return z.B. "Duck"
      */
     public String getNachname() {
-        return StringUtils.substringBefore(getCode(), ",");
+        return StringUtils.substringBefore(getCode(), ",").trim();
     }
 
     /**
-     * Liefert den oder die Nachnamen.
+     * Liefert den oder die Vornamen als ein String.
      *
      * @return z.B. "Donald"
      */
     public String getVorname() {
         return StringUtils.substringAfter(getCode(), ",").trim();
     }
 
+    /**
+     * Falls mehr als ein Vornamen exisitiert, kann dies hierueber als Liste
+     * von Vornamen angefragt werden.
+     *
+     * @return Liste mit Vornamen (kann auch leer sein)
+     */
+    public List<String> getVornamenListe() {
+        if (hasVorname()) {
+            return Arrays.asList(getVorname().split("\\s"));
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
     /**
      * Liefert 'true' zurueck, falls ein Vorname im abgespeicherten Namen
      * enthalten ist.
@@ -102,7 +119,7 @@ public boolean hasVorname() {
 
     @Override
     public int hashCode() {
-        return normalize(this).toLowerCase().hashCode();
+        return Text.replaceUmlaute(this.getNachname()).toLowerCase().hashCode();
     }
 
     /**
@@ -119,11 +136,31 @@ public boolean equals(Object obj) {
             return false;
         }
         Name other = (Name) obj;
-        return normalize(this).equalsIgnoreCase(normalize(other));
+        return isEquals(normalize(this), normalize(other));
     }
 
-    private static String normalize(Name name) {
-        return StringUtils.deleteWhitespace(name.replaceUmlaute().toString().replace("-", ""));
+    private static Name normalize(Name name) {
+        return Name.of(name.replaceUmlaute().toString().replace("-", " ").trim());
+    }
+
+    private static boolean isEquals(Name a, Name b) {
+        return a.getNachname().equalsIgnoreCase(b.getNachname()) &&
+                (shortenVorname(a).equalsIgnoreCase(shortenVorname(b)) ||
+                        equalsVornamen(a.getVornamenListe(), b.getVornamenListe()));
+    }
+
+    private static String shortenVorname(Name x) {
+        return StringUtils.deleteWhitespace(x.getVorname().replace("-", ""));
+    }
+
+    private static boolean equalsVornamen(List<String> a, List<String> b) {
+        int n = Math.min(a.size(), b.size());
+        for (int i = 0; i < n; i++) {
+            if (!a.get(i).equalsIgnoreCase(b.get(i))) {
+                return false;
+            }
+        }
+        return true;
     }
 
     /**

src/test/java/de/jfachwert/post/NameTest.java

@@ -21,6 +21,9 @@
 import org.junit.Test;
 import patterntesting.runtime.junit.ObjectTester;
 
+import java.util.List;
+
+import static org.hamcrest.Matchers.empty;
 import static org.junit.Assert.*;
 
 /**
@@ -55,6 +58,20 @@ public void testHasVorname() {
         assertFalse(Name.of("Duck").hasVorname());
     }
 
+    @Test
+    public void testGetVornamenListe() {
+        List<String> vornamen = Name.of("Was, Karl Otto").getVornamenListe();
+        assertEquals(2, vornamen.size());
+        assertEquals("Karl", vornamen.get(0));
+        assertEquals("Otto", vornamen.get(1));
+    }
+
+    @Test
+    public void testGetLeereVornamenListe() {
+        List<String> vornamen = Name.of("Nobody").getVornamenListe();
+        assertThat(vornamen, empty());
+    }
+
     /**
      * Umlaute sollten beim Vergleich keine Rolle spielen. Ebenso Gross- und
      * Kleinschreibung.
@@ -97,4 +114,11 @@ public void testEqualsKarlHeinz() {
         ObjectTester.assertEquals(b, c);
     }
 
+    @Test
+    public void testEquals2Vornamen() {
+        Name karl = Name.of("Otto, Karl");
+        Name karlheinz = Name.of("Otto, Karl Heinz");
+        ObjectTester.assertEquals(karl, karlheinz);
+    }
+
 }