Rendre l'élément ArrayList insensible à la casse

Dans mon application Java j'ai besoin de comparer les deux de la liste de l'élément s'il est similaire ou non.

En bref supposons que j'ai deux liste déclarée comme indiqué ci-dessous

List<String> a = new ArrayList<String>();
    a.add("one");
    a.add("three");
    a.add("two");
Collections.sort(a);


List<String> a1 = new ArrayList<String>();
    a1.add("ONE");
    a1.add("two");
    a1.add("THREE");
Collections.sort(a);

Si j'écris une condition de l'égalité, il ne parvient pas, comme certains de la liste de l'élément est dans des cas comme

if(a.equals(a1)){
    System.out.println("equal");
} else{
    System.out.println("not equal");
}

Il va afficher le résultat "Pas égal"

Alors merci de me dire comment je peux faire la liste de l'élément sensible à la casse dans le langage Java.

Merci et à l'égard

source d'informationauteur Satya

21

Pourquoi ne pas utiliser plutôt un SortedSet avec un casse comparateur ?
Avec le Chaîne de caractères.CASE_INSENSITIVE_ORDER comparateur de

Votre code est réduit à
```
Set<String> a = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    a.add("one");
    a.add("three");
    a.add("two");


Set<String> a1 = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
    a1.add("ONE");
    a1.add("two");
    a1.add("THREE");
```
Et vos égaux conditions devrait fonctionner sans problème

MODIFIER modifié en fonction des commentaires. Merci à vous tous de me corriger.
14

Vous devez utiliser
```
Collections.sort(a, String.CASE_INSENSITIVE_ORDER);
```
afin de trier ignorant la casse, vous pouvez utiliser le equalsIgnoreCase méthode sur la Chaîne à comparer à des valeurs

Vous pouvez bien sûr créer votre propre CaseInsensitiveList classe, nous avons un CaseInsensitiveSet & CaseInsensitiveMap dans notre base de code

Vous auriez à le faire manuellement:

public boolean equalsIgnoreCase(List<String> l1, List<String> l2) {
  if (l1.size() != l2.size()) {
    return false;
  }
  Iterator<String> i1=l1.iterator();
  Iterator<String> i2=l2.iterator();
  while(i1.hasNext()) {
    if (!i1.next().equalsIgnoreCase(i2.next()) {
      return false;
    }
  }
  return true;
}

Vous pouvez aussi enrouler une Ficelle dans une classe d'assistance et de mettre en œuvre la est égal à & comparer méthodes pour cela.

public class StringWrapper implements Comparable<StringWrapper> {
    private String value;

    StringWrapper(Strig value) {
        this.value = value;
    }

    @Override boolean equals(Object o) {
        returns String.CASE_INSENSITIVE_ORDER.equals(
            (StringWrapper) o).value
            this.value);
    }

    @Override int compareTo(StringWrapper sw) {
        returns String.CASE_INSENSITIVE_ORDER.compare(
            this.value
            sw.value);        
    }

    @Override String toString() {
        return this.value;
    }

    @Override int hashCode() {
        return this.value.toLowerCase.hashCode();
    }
}

And then :

List<StringWrapper> a = new ArrayList<StringWrapper>();
    a.add(StringWrapper("one"));
    a.add(StringWrapper("TWO"));
    a.add(StringWrapper("three"));
Collections.sort(a);

0

Vous aurez besoin de redéfinir la méthode equals() sur la liste, donc il fait ce que vous voulez. Jetez un oeil à la présente liste de tableaux.equals() et de l'adapter afin qu'il compare avec equalsIgnoreCase au lieu de equals().

Comment sur l'écriture d'une classe Wrapper de la Liste que vous utilisez, cela permettrait d'éviter d'avoir incohérent de stockage des éléments.

public class CaseInsensitiveStringList extends ArrayList<String> {

    @Override
    public void add(final int index, final String element) {
        super.add(index, element.toLowerCase());
    }

    @Override
    public boolean add(final String o) {
        return super.add(o.toLowerCase());
    }

    @Override
    public boolean addAll(final Collection<? extends String> c) {
        final ArrayList<String> temp = new ArrayList<String>(c.size());
        for (final String s : c) {
            temp.add(s.toLowerCase());
        }
        return super.addAll(temp);
    }

    @Override
    public boolean addAll(final int index, final Collection<? extends String> c) {
        final ArrayList<String> temp = new ArrayList<String>(c.size());
        for (final String s : c) {
            temp.add(s.toLowerCase());
        }
        return super.addAll(index, temp);
    }
}

0

Pour trier la liste des Chaînes en ignorant la casse
```
Arrays.sort(myArray, Collator.getInstance());
```

Vous devez vous connecter pour publier un commentaire.