Comment trier par ordre alphabétique sans tenir compte de la casse?
J'ai ce code, mais ne fonctionne que pour les lettres minuscules. Je veux que cela trie la liste en ignorant les majuscules.
package sortarray.com;
import Java.util.ArrayList;
import Java.util.List;
import Android.app.Activity;
import Android.os.Bundle;
import Android.util.Log;
import Android.widget.TextView;
public class SortArray extends Activity {
ArrayList<String[]> matchedFruits = new ArrayList<String[]>();
TextView selection;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
String fruits[] = new String[7];// Sorted array
fruits[0] = "Apple";
fruits[1] = "apricot";
fruits[2] = "banana";
fruits[3] = "mango";
fruits[4] = "melon";
fruits[5] = "pineapple";
fruits[6] = "Peach";
char currChar = fruits[0].charAt(0);// Get first char of first element
boolean match = false;
int len = fruits.length;
List<String> tmp = new ArrayList<String>();
for (int i = 1; i < len; i++) {
Log.d("Comparing ", fruits[i].charAt(0) + "," + currChar);
if (fruits[i].charAt(0) == currChar) {
if (match == false)// new match?
{
match = true;// Reset search
tmp.clear();// clear existing items
tmp.add(fruits[i - 1]);
Log.d("Started new list ", fruits[i - 1]);
} else {
tmp.add(fruits[i - 1]);
Log.d("Added to list ", fruits[i - 1]);
}
} else {
match = false;
tmp.add(fruits[i - 1]);
matchedFruits.add(tmp.toArray(new String[tmp.size()]));// add to
// final
// list
Log.d("Finished a list ", fruits[i - 1]);
tmp.clear();// clear existing items
}
currChar = fruits[i].charAt(0);
}
tmp.add(fruits[len - 1]);
matchedFruits.add(tmp.toArray(new String[tmp.size()]));// add left over
// items
printList();
}
void printList()
{
//Print the list
TextView selection = (TextView) findViewById(R.id.tv);
String mssg="";
for(int i=0;i<matchedFruits.size();i++)
{
String tmp2[]= matchedFruits.get(i);
for (int j = 0; j < tmp2.length; j++) {
//Log.d("Final list", "Array #" + i + "[" + j + "]," + tmp2[j]);
mssg += tmp2[j].toString();
}
//selection.setText("\n");
selection.setText(mssg);
}
}
}
Voici un exemple simple en Java du meilleur moyen de le faire:
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Comparator;
import Java.util.List;
public class Sorter {
String fruits[] = new String[7];
List<String> lst;
Sorter() {
lst = new ArrayList<String>();
// initialise UNSORTED array
fruits[0] = "Melon"; fruits[1] = "apricot"; fruits[2] = "Peach";
fruits[3] = "mango"; fruits[4] = "Apple"; fruits[5] = "pineapple";
fruits[6] = "banana";
}
public static void main(String[] args) {
Sorter srt = new Sorter();
srt.anyOldUnstaticMethod();
}
public void anyOldUnstaticMethod() {
Collections.addAll(lst, fruits);
System.out.println("Initial List");
for (String s : lst)
System.out.println(s);
Collections.sort(lst);
System.out.println("\nSorted List");
for (String s : lst)
System.out.println(s);
Collections.sort(lst, new SortIgnoreCase());
System.out.println("\nSorted Ignoring Case List");
for (String s : lst)
System.out.println(s);
}
public class SortIgnoreCase implements Comparator<Object> {
public int compare(Object o1, Object o2) {
String s1 = (String) o1;
String s2 = (String) o2;
return s1.toLowerCase().compareTo(s2.toLowerCase());
}
}
}
Collections.sort(listToSort, String.CASE_INSENSITIVE_ORDER);
Collections.sort() vous permet de passer un comparateur personnalisé pour la commande. Pour les commandes insensibles à la casse, la classe String fournit un comparateur final statique appelé CASE_INSENSITIVE_ORDER.
Donc, dans votre cas, tout ce dont vous avez besoin est:
Collections.sort(caps, String.CASE_INSENSITIVE_ORDER);
Je ne peux pas croire que personne n'ait fait référence au Collator . Presque toutes ces réponses ne fonctionneront que pour la langue anglaise.
Vous devez presque toujours utiliser un collecteur pour le tri basé sur un dictionnaire .
Pour un assembleur insensible à la casse recherchant la langue anglaise, procédez comme suit:
Collator usCollator = Collator.getInstance(Locale.US);
usCollator.setStrength(Collator.PRIMARY);
Collections.sort(listToSort, usCollator);
J'aime la classe de comparaison SortIgnoreCase, mais l'aurais utilisée
public class SortIgnoreCase implements Comparator<String> {
public int compare(String s1, String s2) {
return s1.compareToIgnoreCase(s2); // Cleaner :)
}
}
Passez Java.text.Collator.getInstance() à la méthode Collections.sort; il va trier alphabétiquement en ignorant les majuscules et les minuscules.
ArrayList<String> myArray = new ArrayList<String>();
myArray.add("zzz");
myArray.add("xxx");
myArray.add("Aaa");
myArray.add("bb");
myArray.add("BB");
Collections.sort(myArray,Collator.getInstance());
Depuis Java 8, vous pouvez trier à l'aide de l'API Streams:
List<String> fruits = Arrays.asList("Apple", "Apricot", "banana");
List<String> sortedFruit = fruits.stream()
.sorted(String.CASE_INSENSITIVE_ORDER)
.collect(Collectors.toList())
La différence avec Collections.sort est que cela retournera une nouvelle liste et ne modifiera pas la liste existante.
Dans votre classe d'usine de comparaison, effectuez les opérations suivantes:
private static final Comparator<String> MYSTRING_COMPARATOR = new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.compareToIgnoreCase(s2);
}
};
public static Comparator<String> getMyStringComparator() {
return MYSTRING_COMPARATOR;
Ceci utilise la méthode compare to qui respecte la casse (pourquoi écrire la vôtre). De cette façon, vous pouvez utiliser le type de collections comme ceci:
List<String> myArray = new ArrayList<String>();
//fill your array here
Collections.sort(MyArray, MyComparators. getMyStringComparator());
Dans votre cas, vous avez une List de chaînes et la plupart des solutions déjà proposées (j'aime particulièrement la réponse @guyblank) sont très bien mais !!!, si vous avez une List de beans, ce qui est mon cas, vous pouvez utiliser l'interface Comparable dans votre haricot comme ceci:
public class UserBean implements Comparable<UserBean> {
private String name;
private String surname;
private Integer phone;
// GETTERS AND SETTERS
public int compareTo(UserBean bean) {
return name.compareToIgnoreCase(bean.name);
}
}
Ensuite, il vous suffit de créer votre ArrayList<UserBean> userBeanArray = new ArrayList<UserBean>();, de le remplir et de le trier: Collections.sort(userBeanArray);
Et vous l'avez fait!
J'espère aider à la communauté ;-)
Vous pouvez appeler directement la méthode sort par défaut sur la liste comme ceci:
myList.sort(String.CASE_INSENSITIVE_ORDER); // reads as the problem statement and cleaner
ou:
myList.sort(String::compareToIgnoreCase); // reads as the problem statement and cleaner
avez-vous essayé de convertir le premier caractère de la chaîne en minuscule dans les instructions if(fruits[i].charAt(0) == currChar) et char currChar = fruits[0].charAt(0)?
Exemple utilisant Collections et ArrayList:
Développez une classe statique interne comme dans l'exemple "CompareStrings".
Appelez la classe statique interne dans la méthode main.
Facile à comprendre et fonctionne bien!
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Comparator;
public class MainClass {
public static void main(String[] args) {
ArrayList<String> myArray = new ArrayList<String>();
myArray.add("zzz");
myArray.add("xxx");
myArray.add("Aaa");
myArray.add("bb");
myArray.add("BB");
Collections.sort(myArray, new MainClass.CompareStrings());
for(String s : myArray) {
System.out.println(s);
}
}
public static class CompareStrings implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
return s1.compareToIgnoreCase(s2);
}
}
}