Java Set<String> l'égalité ignorer la casse

Je veux vérifier si tous les éléments de deux ensembles de la Chaîne sont égaux en ignorant la lettre du cas.

Set<String> set1 ;
Set<String> set2 ;
.
.
.
if(set1.equals(set2)){ //all elements of set1 are equal to set2 
 //dosomething
}
else{
 //do something else
}

Cependant, ce contrôle d'égalité ne l'ignore pas, le cas de la chaîne. Est-il un autre moyen de le faire?

Je pense que nous avons besoin d'un peu plus d'infos. Un String ne peut apparaître qu'une fois dans une Set<String>. Mais est-il possible, à votre demande, pour les deux chaînes, s1 et s2, à la fois d'être dans un ensemble si s1.equalsIgnoreCase(s2) est true? Si oui, quel est le critère pour les deux ensembles étant égales par ailleurs, si un ensemble contient deux ou plus de l'équivalent des chaînes? Je pense que la solution va dépendre de nuances comme ça.

InformationsquelleAutor nafas | 2014-07-03

Alternativement, vous pouvez utiliser TreeSet.

public static void main(String[] args){
    Set<String> s1 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    s1.addAll(Arrays.asList(new String[] {"a", "b", "c"}));

    Set<String> s2 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    s2.addAll(Arrays.asList(new String[] {"A", "B", "C"}));

    System.out.println(s1.equals(s2));
}

Notez que bien que cette méthode fonctionne, il est très dangereux de supposer que l'égalité sera basé sur le Comparateur et non pas sur la méthode equals (). La mise en œuvre pourrait changer dans le futur.

InformationsquelleAutor Syam S

3

Malheureusement, Java ne permet pas d'alimentation externe "comparateur d'égalité": lorsque vous utilisez des chaînes, HashSet utilise uniquement intégré dans hashCode et equals.

Vous pouvez contourner ce problème par le remplissage d'un auxiliaire HashSet<String> avec des chaînes de caractères convertie à une utilisation spécifique (c'est à dire supérieur ou inférieur), et alors la vérification de l'égalité, comme ceci:
```
boolean eq = set1.size() == set2.size();
if (eq) {
    Set<String> aux = new HashSet<String>();
    for (String s : set1) {
        aux.add(s.toUpperCase());
    }
    for (String s : set2) {
        if (!aux.contains(s.toUpperCase())) {
            eq = false;
            break;
        }
    }
}
if (eq) {
    //The sets are equal ignoring the case
}
```
- Basé sur quelque chose que j'ai commencé à étudier il y a quelques temps (mais n'a pas tout à fait fini): je crois que les solutions qui impliquent à la normalisation des chaînes de caractères (comme toUpperCase) de travail si les lettres dans le Strings sont tous dans le A-Z ou A-z gamme, ou toutes en Latin-1 (0 à 255). Mais si les lettres peuvent inclure toutes les lettres de l'Unicode ensemble, il y a certaines lettres que, je crois, vis tente à une simple normalisation de la fonction.
InformationsquelleAutor dasblinkenlight

Pas testé, mais c'est l'idée générale:

public boolean setEqualsIgnoreCase(Set<String> a, Set<String>b)
{
    if (a.size() != b.size()) return false;
    Iterator<String> ai = a.iterator();
    Iterator<String> bi = b.iterator();
    while(ai.hasNext())
    {
         if (!ai.next().equalsIgnoreCase(bi.next())) return false;
    }
    return true;
}

InformationsquelleAutor Jim Garrison

Pas que je sache.

La meilleure solution que je peux voir, quoique conçu, serait de créer votre custom titulaire de la classe de la tenue d'une String champ d'instance (String est final et ne peut pas être héritée).

Vous pouvez ensuite remplacer equals /hashCode où pour deux String propriétés equalsIgnoreCase dans les deux cas, equals serait de retour trueet hashCodes serait égal.

Cela implique:

hashCode renvoie un code de hachage basée sur une inférieure (ou supérieure) tubé
propriété du code de hachage.

equals est basé sur equalsIgnoreCase

class MyString {
String s;
MyString(String s) {
this.s = s;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((s == null) ? 0 : s.toLowerCase().hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
MyString other = (MyString) obj;
if (s == null) {
if (other.s != null)
return false;
}
else if (!s.equalsIgnoreCase(other.s))
return false;
return true;
}
}
public static void main(String[] args) {
Set<MyString> set0 = new HashSet<MyString>(
Arrays.asList(new MyString[]
{
new MyString("FOO"), new MyString("BAR")
}
)
);
Set<MyString> set1 = new HashSet<MyString>(
Arrays.asList(new MyString[]
{
new MyString("foo"), new MyString("bar")
}
)
);
System.out.println(set0.equals(set1));
}

Sortie

true

... comme dit, au-dessus de l'ingénierie (mais de travail).

merci beaucoup, votre solution fonctionne vraiment. quelqu'un vient de poster cette page intéressante, puis supprimé [Ce Lien].(stackoverflow.com/questions/12214576/...). Cela va me faire trop.
vous êtes les bienvenus. Liés solution semble effectivement beaucoup mieux que le mien 🙂

InformationsquelleAutor Mena

Je voudrais construire quelque chose comme ceci (dans une certaine forme de pseudo-code Java):

Set<String> set1;
Set<String> set2;
if (set1.size() != set2.size()) {
return NOT_EQUAL;
} else {
Set<String> set3 = new HashSet<String>();
for (String s: set1) set3.add(s.toUpperCase());
for (String s: set2) set3.add(s.toUpperCase());
return set1.size() == set3.size() ? EQUAL : NOT_EQUAL;
}

InformationsquelleAutor spa

-4

Vous pouvez utiliser une boucle et equalsIgnoreCase
```
testString.equalsIgnoreCase()
```
- la question est au sujet de la comparaison Set<String>, tandis que vous faites allusion à une méthode de String. Ce ne sont pas interchangeables, mais je suppose que vous pourriez transformer en un bon de répondre par l'ajout d'une boucle autour de.
InformationsquelleAutor Othya

Vous devez vous connecter pour publier un commentaire.