Wie zwei Hash-Sets in Java zu vergleichen?

Question

Wie kann ich zwei Hash-Sets in Java vergleichen? Meine ersten Hash-Sets sehen wie folgt aus.

static Set<String> nounPhrases = new HashSet<>(); 

Das obige Hash-Set enthält Elemente wie dieses.

Liste der Noun Parse: [java, jsp, Buch]

zweiten Hash-Set

static Set<String> nounPhrases2 = new HashSet<>(); 

Liste der Noun Parse: [web, PHP, Java, Buch]

Hinweis - Ich muss prüfen, ob es gleiche Substantive in beiden Sätzen gibt. und wenn sie ähnliche Substantive haben, dann muss ich eine andere Aufgabe tun

Answer 1

public class SetUtils { 

    public static boolean equals(Set<?> set1, Set<?> set2){ 

     if(set1 == null || set2 ==null){ 
      return false; 
     } 

     if(set1.size()!=set2.size()){ 
      return false; 
     } 

     return set1.containsAll(set2); 

    } 
} 

Answer 2

Also meinst du so?

public static void main(String[] args) { 

    final Set<String> nounPhrases = new HashSet<>(); 
    nounPhrases.add("java"); 
    nounPhrases.add("jsp"); 
    nounPhrases.add("book"); 

    final Set<String> nounPhrases2 = new HashSet<>(); 
    nounPhrases2.add("web"); 
    nounPhrases2.add("php"); 
    nounPhrases2.add("java"); 
    nounPhrases2.add("book"); 

    // Checking for every element in first set 
    for (final String element : nounPhrases) { 

     // if second set has the current element 
     if (nounPhrases2.contains(element)) { 
      System.out.println("They have " + element); 
     } 
    } 
} 

Meine Ausgabe:

They have java 
They have book 

Edit: auf Ihrem Kommentar Basierend, wenn ich richtig verstehe, wenn Sie die gemeinsamen Elemente in beiden Sätzen erhalten möchten, nur die Werte speichern und sie zurück:

public static void main(String[] args) { 

    final Set<String> nounPhrases = new HashSet<>(); 
    nounPhrases.add("java"); 
    nounPhrases.add("jsp"); 
    nounPhrases.add("book"); 

    final Set<String> nounPhrases2 = new HashSet<>(); 
    nounPhrases2.add("web"); 
    nounPhrases2.add("php"); 
    nounPhrases2.add("java"); 
    nounPhrases2.add("book"); 

    System.out.println(getCommon(nounPhrases, nounPhrases2)); 
} 

public final static Set<String> getCommon(Set<String> setA, Set<String> setB) { 

    final Set<String> result = new HashSet<>(); 
    for (final String element : setA) { 
     if (setB.contains(element)) { 
      result.add(element); 
     } 
    } 
    return result; 
} 

Sie Generika verwenden könnte die Methode der Arbeit für andere Elemente als Strings zu machen:

public final static <T> Set<T> getCommon(Set<T> setA, Set<T> setB) { 

    final Set<T> result = new HashSet<>(); 
    for (final T element : setA) { 
     if (setB.contains(element)) { 
      result.add(element); 
     } 
    } 
    return result; 
} 

Wenn die Leistung wichtig ist, sollten Sie zuerst die Größen überprüfen und nur über die Elemente der kleineren Menge iterieren. Wenn Sie einen Satz mit 1 Elementen und einen Satz mit 100 haben, erhalten Sie beginnend mit dem kleineren eine Iteration, während Sie beginnend mit dem größeren 100 Punkte haben, bei denen nur 1 in beiden Sätzen hätte sein können.

Answer 3

Wenn u wollen, dann das gemeinsame Element zu finden, benutzen Sie sammeln (Collectors.toList()) anstelle des Grafen, Wenn u einfach finden möchten, wie viele Satz gemeinsames Element hat mit Java 8

long count = nounPhrases.stream().filter(tempstring -> { 
      return nounPhrases2.stream().anyMatch(tempstring2 -> { 
       return tempstring.equals(tempstring2); 
      }); 
     }).count(); 
     if (count > 0) 
      System.out.println("has common elements-"+count); 
     else 
      System.out.println("not common"); 

Answer 4

Durch die Verwendung von Java apache.commons.collections Paket können wir implementieren

package com.StackoverFlow; 

import java.util.Collection; 
import java.util.HashSet; 
import java.util.Set; 
import org.apache.commons.collections.CollectionUtils; 
public class MainClass { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     // TODO Auto-generated method stub 


     Set hs_1 = new HashSet(); 
     hs_1.add("A"); 
     hs_1.add("B"); 
     hs_1.add("C"); 
     hs_1.add("D"); 

     Set hs_2 = new HashSet(); 
     hs_2.add("A"); 
     hs_2.add("B"); 
     hs_2.add("C"); 
     hs_2.add("D"); 

     Collection result = CollectionUtils.subtract(hs_1, hs_2); 
     System.out.println(result); 
     if(result.isEmpty()){ 
      System.out.println("perform Task-->>Value maches "); 

     }else{ 
      System.out.println("perform Task-->>Value not maches "); 
     } 

    } 

} 

Answer 5

Dies ist ein Rad bereits erfunden.

Set#equals() vergleicht Sätze in der Art und Weise, die Sie erwarten:

set1.equals(set2) 

Wenn Sie zwei Set-Variablen wollen, die beide null sind als „gleich“, verwenden Sie dann:

Objects.equals(set1, set2)