Finden Sie den Schnittpunkt zwischen hashmaps mit retainAll()

Question

Ich muss den Schnittpunkt zwischen 2 Hash-Maps, wo der Wert ist ein String-Array, Es scheint, dass die retainAll() Arrays nach Adresse vergleicht, Gibt es eine Möglichkeit, RetainAll () funktioniert so, wie ich es erwartet habe?

String[] aa={"aa"}; 
String[] bb={"aa"}; 
Map<String, String[]> requestParameters=new HashMap<String, String[]>(); 
requestParameters.put("A",aa); 
Map<String, String[]> redirectParameters=new HashMap<String, String[]>(); 
redirectParameters.put("A",bb); 

Map<String, String[]> intersectionMap = new HashMap<>(requestParameters); 
intersectionMap.entrySet().retainAll(redirectParameters.entrySet()); 
System.out.println(""+ intersectionMap.entrySet()); 

Answer 1

Die retainAll() Methode vergleicht Objekte mit ihrer equals() Methode, die im Fall von Arrays ihre Identitäten vergleicht. Das Entry-Objekt ruft nur die gleichen Methoden des Schlüssels und des Wertes in its equals method auf und ruft so die gleiche Methode des Arrays auf, die nicht wie erwartet funktioniert. Es gibt mehrere Möglichkeiten, dieses Problem zu umgehen:

Eine Möglichkeit wäre, Guanva's filter wie in Andersoj Antwort here beschrieben zu verwenden.

Eine andere Möglichkeit wäre, eine Wrapper-Klasse für Ihre String-Arrays zu erstellen, die die equals-Methode dieses Wrappers überschreibt, um die beiden Arrays Element für Element zu vergleichen. Dies wurde auch in der answer by Ralph zur gleichen Frage wie zuvor beschrieben.

Wenn Sie den Wrapper umgehen möchten, können Sie auch Listen verwenden, da wie erwartet implementiert ist. Es wird true zurückgegeben, wenn beide Listen dieselben Elemente in derselben Reihenfolge enthalten.

Answer 2

Könnte das Array wickeln:

import java.util.*; 

class Test { 

    private static class StringArrayWrapper { 

    private String[] data; 

    public String[] getArray() { 
     return data; 
    } 

    public StringArrayWrapper(String[] data) { 
     this.data = data; 
    } 

    public boolean equals(Object other) { 
     return (other instanceof StringArrayWrapper) && Arrays.equals(data, ((StringArrayWrapper)other).data); 
    } 

    public String toString() { 
     return Arrays.toString(data); 
    } 

    public int hashCode() { 
     return Arrays.hashCode(data); 
    } 

    } 

    private static StringArrayWrapper wrap(String[] a) { 
    return new StringArrayWrapper(a); 
    } 


    public static void main(String[]args) { 
    String[] aa={"aa"}; 
    String[] bb={"aa"}; 
    Map<String, StringArrayWrapper> requestParameters=new HashMap<String, StringArrayWrapper>(); 
    requestParameters.put("A", wrap(aa)); 
    Map<String, StringArrayWrapper> redirectParameters=new HashMap<String, StringArrayWrapper>(); 
    redirectParameters.put("A", wrap(bb)); 

    Map<String, StringArrayWrapper> intersectionMap = new HashMap<>(requestParameters); 
    intersectionMap.entrySet().retainAll(redirectParameters.entrySet()); 
    System.out.println(""+ intersectionMap.entrySet()); 
    } 
} 

Diese Drucke:

[A=[aa]] 

Aber normalerweise würde man mit Schlüsselkarten schneiden wollen, wie here.