Jak mogę posortować listę alfabetycznie?

Mam List<String>obiekt, który zawiera nazwy krajów. Jak mogę posortować tę listę alfabetycznie?

Zakładając, że są to ciągi, użyj wygodnej metody statycznej sort…

 java.util.Collections.sort(listOfCountryNames)

Rozwiązanie z kolekcji.sort

Jeśli jesteś zmuszony do korzystania z tej listy lub jeśli twój program ma podobną strukturę

• Sporządzać listę
• Dodaj kilka nazw krajów
• posortuj je raz
• nigdy więcej nie zmieniaj tej listy

wtedy odpowiedź Thilos będzie najlepszym sposobem na zrobienie tego. Jeśli połączysz to z radą Toma Hawtina - tackline , otrzymasz:

java.util.Collections.sort(listOfCountryNames, Collator.getInstance());

Rozwiązanie z zestawem TreeSet

Jeśli możesz swobodnie decydować i twoja aplikacja może stać się bardziej złożona, możesz zmienić kod, aby zamiast tego użyć TreeSet. Ten rodzaj kolekcji sortuje wpisy tylko po ich wstawieniu. Nie trzeba wywoływać sort ().

Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.

Uwaga dodatkowa na temat tego, dlaczego wolę TreeSet

Ma to pewne subtelne, ale ważne zalety:

• Jest po prostu krótszy. Jednak tylko o jeden wiersz krótszy.
• Nie martw się, ta lista jest teraz naprawdę posortowana, ponieważ zestaw TreeSet jest zawsze sortowany, bez względu na to, co robisz.
• Nie możesz mieć zduplikowanych wpisów. W zależności od twojej sytuacji może to być plus lub minus. Jeśli potrzebujesz duplikatów, trzymaj się swojej listy.
• Doświadczony programista patrzy TreeSet<String> countyNamesi natychmiast wie: jest to posortowana kolekcja ciągów bez duplikatów, i mogę być pewien, że jest to prawdą w każdej chwili . Tyle informacji w krótkiej deklaracji.
• Rzeczywista wydajność wygrywa w niektórych przypadkach. Jeśli używasz listy i wstawiasz wartości bardzo często, a listę można czytać między tymi wstawkami, musisz posortować listę po każdym wstawieniu. Zestaw robi to samo, ale robi to znacznie szybciej.

Używanie odpowiedniej kolekcji do właściwego zadania jest kluczem do pisania krótkiego i wolnego od błędów kodu. W tym przypadku nie jest tak demonstracyjny, ponieważ zapisujesz tylko jedną linię. Przestałem jednak liczyć, jak często widzę, jak ktoś korzysta z Listy, gdy chce się upewnić, że nie ma w nim nikogo, a potem sam tę funkcję buduje. Albo jeszcze gorzej, używając dwóch list, gdy naprawdę potrzebujesz mapy.

Nie zrozumcie mnie źle: używanie kolekcji.sort nie jest błędem ani wadą. Ale w wielu przypadkach TreeSet jest znacznie czystszy.

Możesz utworzyć nową posortowaną kopię za pomocą Java 8 Stream lub Guava:

// Java 8 version
List<String> sortedNames = names.stream().sorted().collect(Collectors.toList());
// Guava version
List<String> sortedNames = Ordering.natural().sortedCopy(names); 

Inną opcją jest sortowanie w miejscu za pośrednictwem interfejsu API kolekcji:

Collections.sort(names);

Lepiej późno niż wcale! Oto jak możemy to zrobić (tylko w celu uczenia się) -

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class SoftDrink {
    String name;
    String color;
    int volume; 

    SoftDrink (String name, String color, int volume) {
        this.name = name;
        this.color = color;
        this.volume = volume;
    }
}

public class ListItemComparision {
    public static void main (String...arg) {
        List<SoftDrink> softDrinkList = new ArrayList<SoftDrink>() ;
        softDrinkList .add(new SoftDrink("Faygo", "ColorOne", 4));
        softDrinkList .add(new SoftDrink("Fanta",  "ColorTwo", 3));
        softDrinkList .add(new SoftDrink("Frooti", "ColorThree", 2));       
        softDrinkList .add(new SoftDrink("Freshie", "ColorFour", 1));

        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((SoftDrink)softDrinkOne).name
                        .compareTo(((SoftDrink)softDrinkTwo).name);
            }
        }); 
        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.name + " - " + sd.color + " - " + sd.volume);
        }
        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //comparision for primitive int uses compareTo of the wrapper Integer
                return(new Integer(((SoftDrink)softDrinkOne).volume))
                        .compareTo(((SoftDrink)softDrinkTwo).volume);
            }
        });

        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.volume + " - " + sd.color + " - " + sd.name);
        }   
    }
}

W jednym wierszu za pomocą Java 8:

list.sort(Comparator.naturalOrder());

Użyj dwóch argumentów dla Collections.sort. Będziesz potrzebował odpowiedniegoComparator który traktuje przypadek odpowiedni (tj. Robi leksykalne, a nie porządkowanie UTF16), taki jak ten, który można uzyskać java.text.Collator.getInstance.

O ile nie sortujesz ciągów tylko w języku angielskim bez akcentu, prawdopodobnie chcesz użyć Collator. Poprawnie sortuje znaki diakrytyczne, może ignorować wielkość liter i inne elementy specyficzne dla języka:

Collections.sort(countries, Collator.getInstance(new Locale(languageCode)));

Możesz ustawić siłę zbieracza , patrz javadoc.

Oto przykład słowackiego, gdzie Šnależy iść S, ale w UTF Šjest gdzieś po Z:

List<String> countries = Arrays.asList("Slovensko", "Švédsko", "Turecko");

Collections.sort(countries);
System.out.println(countries); // outputs [Slovensko, Turecko, Švédsko]

Collections.sort(countries, Collator.getInstance(new Locale("sk")));
System.out.println(countries); // outputs [Slovensko, Švédsko, Turecko]

Oto czego szukasz

listOfCountryNames.sort(String::compareToIgnoreCase)

Za pomocą Collections.sort()możemy posortować listę.

public class EmployeeList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<String> empNames= new ArrayList<String>();

        empNames.add("sudheer");
        empNames.add("kumar");
        empNames.add("surendra");
        empNames.add("kb");

        if(!empNames.isEmpty()){

            for(String emp:empNames){

                System.out.println(emp);
            }

            Collections.sort(empNames);

            System.out.println(empNames);
        }
    }
}

wynik:

sudheer
kumar
surendra
kb
[kb, kumar, sudheer, surendra]

alfabet malejący:

List<String> list;
...
Collections.sort(list);
Collections.reverse(list);

To samo w JAVA 8: -

//Assecnding order
        listOfCountryNames.stream().sorted().forEach((x) -> System.out.println(x));

//Decending order
        listOfCountryNames.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach((x) -> System.out.println(x));

//Here is sorted List alphabetically with syncronized
package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;
/**
* 
* @author manoj.kumar
*/
public class SynchronizedArrayList {
static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());
@SuppressWarnings("unchecked")
public static void main(String[] args) {

List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
synchronizedList.add(new Employee("Aditya"));
synchronizedList.add(new Employee("Siddharth"));
synchronizedList.add(new Employee("Manoj"));
Collections.sort(synchronizedList, new Comparator() {
public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
//use instanceof to verify the references are indeed of the type in question
return ((Employee)synchronizedListOne).name
.compareTo(((Employee)synchronizedListTwo).name);
}
}); 
/*for( Employee sd : synchronizedList) {
log.info("Sorted Synchronized Array List..."+sd.name);
}*/

// when iterating over a synchronized list, we need to synchronize access to the synchronized list
synchronized (synchronizedList) {
Iterator<Employee> iterator = synchronizedList.iterator();
while (iterator.hasNext()) {
log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
}
}

}
}
class Employee {
String name;
Employee (String name) {
this.name = name;

}
}

Możesz spróbować użyć metody, którą stworzyłem.

String key- będzie kolejność, którą chcesz, w tym przypadku alfabetycznie. Po prostu wstaw „abc ...”.

String list[] - lista, którą chcesz uporządkować za pomocą klucza.

int index - ustawiony na 0, ustawi przesunięcie dla klucza.

    public static String[] order(String key, String list[], int index) {
    ArrayList<String> order_List = new ArrayList<String>();
    ArrayList<String> temp_Order_List = null;
    char[] key_char = key.toCharArray();
    for (int offset = 0; offset < key_char.length; offset++) {
        if (key_char.length >= offset + index) {
            String str = (index > 1 ? list[0].substring(0, index - 1) : "")
                    + new String(key_char, offset, 1);
            for (int i = 0; i < list.length; i++) {
                temp_Order_List = new ArrayList<String>();
                for (int k = 0; k < list.length; k++) {
                    if (!order_List.contains(list[k])
                            && !temp_Order_List.contains(list[k])) {
                        if (list[k].equalsIgnoreCase(str))
                            order_List.add(list[k]);
                        else if (list[k].toLowerCase().startsWith(str.toLowerCase())) {
                            temp_Order_List.add(list[k]);

                        }
                    }
                }
                if (temp_Order_List.size() > 0) {
                    if (temp_Order_List.size() > 1) {
                        String[] add = order(key,
                                temp_Order_List.toArray(new String[temp_Order_List
                                        .size()]), index + 1);
                        for (String s : add) {
                            order_List.add(s);
                        }
                    } else {
                        order_List.add(temp_Order_List.get(0));
                    }
                }
            }
        }
    }
    return order_List.toArray(new String[order_List.size()]);
}