Einfache Möglichkeit zum Sortieren von Zeichenfolgen in der (groß-Kleinschreibung) alphabetischer Reihenfolge

Ich muss Sortieren Liste von strings in alphabetischer Reihenfolge:

List<String> list = new ArrayList();
list.add("development");
list.add("Development");
list.add("aa");
list.add("AA");
list.add("Aa");

Einen gemeinsamen Weg, es zu tun, ist die Verwendung Komparator:

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

Das problem der CaseInsensitiveComparator, dass "AA -" ist gleich "aa". Zeichenfolgen werden in der Folge gemäß der Reihenfolge der Zugabe für die gleichen Werte, und es ist nicht richtig:

"aa","AA","Aa","development","Development"

InformationsquelleAutor der Frage Michael | 2012-06-24

  1. 63

    Wenn Sie nicht möchten, hinzufügen einer Abhängigkeit Guave (nach Michael ' s Antwort) dann ist dieser Komparator ist äquivalent:

    private static Comparator<String> ALPHABETICAL_ORDER = new Comparator<String>() {
    public int compare(String str1, String str2) {
        int res = String.CASE_INSENSITIVE_ORDER.compare(str1, str2);
        if (res == 0) {
            res = str1.compareTo(str2);
        }
        return res;
    }
};

Collections.sort(list, ALPHABETICAL_ORDER);

    Und ich denke, es ist genauso einfach zu verstehen und code ...

    Den letzten 4 Zeilen der Methode kann geschrieben prägnanter wie folgt:

            return (res != 0) ? res : str1.compareTo(str2);

    InformationsquelleAutor der Antwort Stephen C

  2. 15

    Den einfachen Weg, das problem zu lösen, ist die Verwendung ComparisonChain aus Guave
    http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/ComparisonChain.html

    private static Comparator<String> stringAlphabeticalComparator = new Comparator<String>() {
        public int compare(String str1, String str2) {
            return ComparisonChain.start().
                                compare(str1,str2, String.CASE_INSENSITIVE_ORDER).
                                compare(str1,str2).
                                result();
         }
 };
Collections.sort(list, stringAlphabeticalComparator);

    Den ersten Komparator aus der Kette Sortieren von Zeichenfolgen nach die groß-und Kleinschreibung um, und der zweite Komparator-Sortieren von Zeichenfolgen nach die groß-und Kleinschreibung um.
    Als vorbehalten Zeichenfolgen werden in der Folge nach der alphabetischen Reihenfolge:

    "AA","Aa","aa","Development","development"

    InformationsquelleAutor der Antwort Michael

  3. 1

    Ich habe vor kurzem eine ähnliche Frage beantwortet hier. Die Anwendung der gleichen Vorgehensweise, um Ihr problem ergäbe folgende Lösung:

    list.sort(
  p2Ord(stringOrd, stringOrd).comap(new F<String, P2<String, String>>() {
    public P2<String, String> f(String s) {
      return p(s.toLowerCase(), s);
    }
  })
);

    InformationsquelleAutor der Antwort missingfaktor

  4. 1

    Verwenden Sie einfach

    java.util.Collections.sort(list)

    ohne String.CASE_INSENSITIVE_ORDER comparator-parameter.

    InformationsquelleAutor der Antwort L. G.

  5. -1
    import java.util.Arrays;
import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {

        String a;
        String b;
        try (Scanner scan = new Scanner(System.in)) {
            a = scan.next();
            b = scan.next();
        }
        boolean ret = isAnagram(a, b);
        System.out.println((ret) ? "Anagrams" : "Not Anagrams");

    }

    static boolean isAnagram(String a, String b) {
        int l1 = a.length();
        int l2 = b.length();
        boolean rat = false;

        if (l1 <= 50) {
            if (l1 == l2) {

                char[] chars1 = a.toLowerCase().toCharArray();
                char[] chars2 = b.toLowerCase().toCharArray();
                Arrays.sort(chars1);
                Arrays.sort(chars2);
                String Ns1 = new String(chars1);
                String Ns2 = new String(chars2);
                if (Ns1.equals(Ns2)) {
                    rat = true;
                }
            }
        }
        return rat;
    }
}

    InformationsquelleAutor der Antwort Darshana Ekanayake

Schreibe einen Kommentar