Come posso ordinare un elenco in ordine alfabetico?

Ho un List<String>oggetto che contiene i nomi dei paesi. Come posso ordinare questa lista in ordine alfabetico?

Supponendo che si tratti di stringhe, utilizzare il metodo statico conveniente sort...

 java.util.Collections.sort(listOfCountryNames)

Soluzione con Collections.sort

Se sei costretto a usare quell'Elenco o se il tuo programma ha una struttura simile

• Crea elenco
• Aggiungi alcuni nomi di paesi
• ordinali una volta
• non cambiare mai più quella lista

allora la risposta di Thilos sarà il modo migliore per farlo. Se lo combini con i consigli di Tom Hawtin - tackline , otterrai:

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

Soluzione con un TreeSet

Se sei libero di decidere e se la tua applicazione potrebbe diventare più complessa, puoi invece modificare il codice per utilizzare TreeSet. Questo tipo di raccolta ordina le voci appena inserite. Non è necessario chiamare sort ().

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

Nota a margine sul perché preferisco TreeSet

Questo ha alcuni vantaggi sottili ma importanti:

• È semplicemente più breve. Solo una riga più corta, però.
• Non preoccuparti mai questo elenco è davvero ordinato in questo momento perché un TreeSet è sempre ordinato, qualunque cosa tu faccia.
• Non puoi avere voci duplicate. A seconda della situazione, questo può essere un pro o un contro. Se hai bisogno di duplicati, mantieni l'elenco.
• Un programmatore esperto guarda TreeSet<String> countyNamese sa immediatamente: questa è una raccolta ordinata di stringhe senza duplicati, e posso essere sicuro che ciò sia vero in ogni momento . Tante informazioni in una breve dichiarazione.
• Vittoria in prestazioni reali in alcuni casi. Se si utilizza un elenco e si inseriscono valori molto spesso e l'elenco può essere letto tra tali inserimenti, è necessario ordinare l'elenco dopo ogni inserimento. Il set fa lo stesso, ma lo fa molto più velocemente.

L'uso della raccolta giusta per l'attività corretta è una chiave per scrivere codice breve e privo di bug. In questo caso non è così dimostrativo, perché si salva solo una riga. Ma ho smesso di contare la frequenza con cui vedo qualcuno che utilizza un Elenco quando desidera assicurarsi che non vi siano duplicati e quindi crearlo da solo. O peggio ancora, usando due elenchi quando hai davvero bisogno di una mappa.

Non fraintendetemi: l'utilizzo di Collections.sort non è un errore o un difetto. Ma ci sono molti casi in cui TreeSet è molto più pulito.

È possibile creare una nuova copia ordinata utilizzando Java 8 Stream o Guava:

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

Un'altra opzione è ordinare sul posto tramite l'API Collections:

Collections.sort(names);

Meglio tardi che mai! Ecco come possiamo farlo (solo a scopo di apprendimento) -

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

In una riga, usando Java 8:

list.sort(Comparator.naturalOrder());

Usa i due argomenti per of Collections.sort. Sarà necessario un Comparatorcaso appropriato che tratti il ​​caso appropriato (ad es. Ordinamento lessicale, non UTF16), come quello ottenibile tramite java.text.Collator.getInstance.

A meno che tu non stia ordinando le stringhe solo in un inglese privo di accento, probabilmente vorrai usare a Collator. Ordinerà correttamente i segni diacritici, può ignorare il caso e altre cose specifiche della lingua:

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

È possibile impostare la forza del collatore , vedere il javadoc.

Ecco un esempio per slovacco dove Šdovrebbe andare dopo S, ma in UTF Šè da qualche parte dopo 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]

Ecco cosa stai cercando

listOfCountryNames.sort(String::compareToIgnoreCase)

Usando Collections.sort(), possiamo ordinare un elenco.

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

produzione:

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

alfabeto decrescente:

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

Lo stesso in 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;

}
}

Puoi provare a usare un metodo che ho creato.

String key- sarà l'ordine desiderato e in questo caso in ordine alfabetico. Basta inserire "abc ...".

String list[] - l'elenco che si desidera mettere in ordine utilizzando il tasto.

int index - impostato su 0, imposterà l'offset per il tasto.

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