La vérification de confinement dans un Ensemble de chaînes de caractères en Java

J'ai un Ensemble de String[]. Je veux vérifier si cet Ensemble contient une autre Chaîne de caractères[].

Set<String[]> s  = new HashSet<String[]>();
s.add(new String[] {"lucy", "simon"});
System.out.println(s.contains(new String[] {"lucy", "simon"}));

Toutefois, la valeur false est imprimé. Je suppose que c'est parce que les références sont comparés et non pas par les Chaînes. Il semble, la seule option que j'ai est de créer une classe, dire une Phrase, et de mettre en œuvre hashCode() et equals() (qui utilisent Arrays.hashCode(...)).

Est-il un autre moyen d'obtenir ce que je veux?

OriginalL'auteur athena | 2010-11-26

  1. 13

    Votre supposition est correcte: les tableaux ([]) ne pas mettre en œuvre une profonde méthode equals: ils sont égaux s'ils ont la même instance.

    La solution la plus simple serait: remplacement de String[] par List<String>

    Une autre façon (mais je ne le recommande pas) est de mettre en place votre propre Jeu, ce qui n'est pas basé sur Object.equals mais sur java.util.Arrays.equals(Object[]a, Object[]b)

    +1 pour la profondeur est égale explication

    OriginalL'auteur

  2. 11

    Convertir que String[] à List<String> et cela devrait fonctionner assez bien.

    Set<List<String>> s  = new HashSet<List<String>>();
s.add(Arrays.asList("lucy", "simon"));
System.out.println(s.contains(Arrays.asList("lucy", "simon")));

    OriginalL'auteur

  3. 3

    Pouvez les éléments de la Chaîne[] être dans des ordres différents et encore faire de l'ensemble de la baie être considéré comme l'égal d'un autre tableau contenant les mêmes éléments dans un autre ordre? Si oui, vous auriez du en effet être mieux mise en œuvre d'une classe de conteneur et primordial, equals et hashcode.

    si non, et si le stockage interne des éléments sous forme de Listes au lieu de tableaux est une alternative acceptable, alors vous pourriez faire ceci:

    package com.stackoverflow;


import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class StringContainment {

  public static void main(final String[] args) {
    final Set<String[]> s = new HashSet<String[]>();
    final Set<List<String>> s2 = new HashSet<List<String>>();

    s.add(new String[] {"lucy", "simon"});
    s2.add(Arrays.asList(new String[] { "lucy", "simon" }));

    System.out.println(s.contains(new String[] {"lucy", "simon"})); //false
    System.out.println(s2.contains(Arrays.asList(new String[] {"lucy", "simon"}))); //true
  }

}

    Le premier chèque sera de retour faux, le deuxième vrai.
    Peut-être plus facile si vous pouvez utiliser des listes.

    Si vous ne pouvez pas, vous pouvez l'utiliser aussi longtemps que vous n'avez pas besoin de faire cette comparaison trop souvent (ce n'est certainement pas une bonne idée en terme de performance).

    OriginalL'auteur

  4. 1

    Semble que vous avez déjà répondu à votre question. Une option consiste comme vous l'avez déjà dit. L'autre serait d'utiliser Set>, depuis l'API pour equals(Object) dit:

    Compare l'objet spécifié avec cette collection pour l'égalité.

    OriginalL'auteur

  5. 1

    Utilisation Set<Set<String>> ou Set<List<String>> au lieu de Set<String[]>

    Code:

    List<String> s1=Arrays.asList("1","2"),s2=Arrays.asList("1","2");
System.out.println(s1.equals(s2) + " "+s1.hashCode()+ " "+s2.hashCode());

    De sortie:

    true 2530 2530

    OriginalL'auteur

  6. 0

    Je venais de parcourir et d'appel des Tableaux.est égal à:

    quelque chose comme ceci:

    boolean contains(Set<String[]> s, String[] item) {
  for(String[] toCompare: s) {
    if(Arrays.equals(toCompare, item)) {
        return true;
    }
  }
  return false;
}

    ne sais pas si c'est le plus rapide, mais il devrait faire le travail bien

    OriginalL'auteur

  7. 0

    Avec Java8 flux d'introduction vous pouvez le faire de la manière suivante:

    Boolean res = s.stream()
  .anyMatch(elm -> elm.equals("lucy") || elm.equals("simon"));

    OriginalL'auteur