it-swarm.com.de

Wie kann ich alphabetisch sortieren und dabei die Groß- und Kleinschreibung ignorieren?

Ich habe diesen Code, funktioniert aber nur für Kleinbuchstaben. Ich möchte die Liste sortieren und dabei die Großbuchstaben ignorieren.

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);

    }
    }
}
40
user934357

Hier ist ein einfaches Java-Beispiel für die beste Vorgehensweise:

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());
        }
    }
}
30
NickT
Collections.sort(listToSort, String.CASE_INSENSITIVE_ORDER);
131
guyblank

Es ist sehr unklar, was Sie versuchen, aber Sie können eine Liste wie folgt sortieren:

List<String> fruits = new ArrayList<String>(7);

fruits.add("Pineapple");
fruits.add("Apple");
fruits.add("apricot");
fruits.add("Banana");
fruits.add("mango");
fruits.add("melon");        
fruits.add("Peach");

System.out.println("Unsorted: " + fruits);

Collections.sort(fruits, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {              
        return o1.compareToIgnoreCase(o2);
    }
});

System.out.println("Sorted: " + fruits);
36

Mit Collections.sort() können Sie einen benutzerdefinierten Vergleicher zur Bestellung übergeben. Für die Groß- und Kleinschreibung unterscheidet String eine Klasse mit einem statischen Abschlusskomparator namens CASE_INSENSITIVE_ORDER.

In Ihrem Fall brauchen Sie also nur:

Collections.sort(caps, String.CASE_INSENSITIVE_ORDER);
28
user4363171

Ich kann nicht glauben, dass sich niemand auf den Collator bezogen hat. Fast alle diese Antworten funktionieren nur für die englische Sprache.

Sie sollten fast immer einen Collator für die wörterbuchbasierte Sortierung verwenden.

Wenn Sie nicht nach Groß- und Kleinschreibung suchen, suchen Sie nach englischer Sprache:

Collator usCollator = Collator.getInstance(Locale.US);
usCollator.setStrength(Collator.PRIMARY);
Collections.sort(listToSort, usCollator);
12
Adam Gent

Ich mag die Komparator-Klasse SortIgnoreCase, hätte sie aber verwendet

public class SortIgnoreCase implements Comparator<String> {
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);    // Cleaner :)
    }
}
4
Java Devil

Übergeben Sie Java.text.Collator.getInstance() an die Collections.sort-Methode. es wird alphabetisch sortiert, wobei die Groß- und Kleinschreibung ignoriert wird.

        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());
3
Hatem Badawi

Seit Java 8 können Sie mit der Streams-API sortieren:

List<String> fruits = Arrays.asList("Apple", "Apricot", "banana");

List<String> sortedFruit = fruits.stream()
      .sorted(String.CASE_INSENSITIVE_ORDER)
      .collect(Collectors.toList())

Der Unterschied zu Collections.sort ist, dass dies eine neue Liste zurückgibt und die vorhandene nicht ändert.

1
Andrejs

Führen Sie in Ihrer vergleichenden Factory-Klasse Folgendes aus:

 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;

Hierbei wird die Methode Compare to verwendet, bei der die Groß- und Kleinschreibung nicht berücksichtigt wird (warum sollten Sie Ihre eigene Methode schreiben). Auf diese Weise können Sie Collections wie folgt verwenden:

List<String> myArray = new ArrayList<String>();
//fill your array here    
Collections.sort(MyArray, MyComparators. getMyStringComparator());
1
user3561002

In Ihrem Fall haben Sie eine List von Strings und die meisten der bereits vorgeschlagenen Lösungen (ich mag insbesondere @guyblank answer) sind in Ordnung, aber !!! Wenn Sie eine List von Beans haben, was in meinem Fall der Fall ist, können Sie Comparable-Schnittstelle verwenden in deiner Bohne so:

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);
   }

}

Dann müssen Sie nur noch Ihre ArrayList<UserBean> userBeanArray = new ArrayList<UserBean>(); erstellen, füllen und sortieren: Collections.sort(userBeanArray);

Und du hast es geschafft!

Hoffe, zur Community zu helfen ;-)

0
CarlosLeo

Sie können die standardmäßige sort - Methode in der Liste direkt wie folgt aufrufen:

myList.sort(String.CASE_INSENSITIVE_ORDER); // reads as the problem statement and cleaner

oder:

myList.sort(String::compareToIgnoreCase);  // reads as the problem statement and cleaner
0
Aomine

haben Sie versucht, das erste Zeichen der Zeichenfolge in den Anweisungen if(fruits[i].charAt(0) == currChar) und char currChar = fruits[0].charAt(0) in Kleinbuchstaben zu konvertieren?

0
denolk

Beispiel mit Collections und ArrayList:

Entwickeln Sie eine interne statische Klasse wie im Beispiel "CompareStrings".

Rufen Sie die interne statische Klasse in der Hauptmethode auf.

Einfach zu verstehen und funktioniert gut!

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);
        }
    }
}
0
Hugo Silva