palabras - ordenar fechas java

¿Cómo puedo ordenar una lista alfabéticamente?

Question

Tengo un objeto List<String> que contiene nombres de países. ¿Cómo puedo ordenar esta lista alfabéticamente?

Answer 1

Solución con Collections.sort

Si se ve obligado a usar esa lista, o si su programa tiene una estructura como

• Crear lista
• Agregue algunos nombres de países
• ordenarlos una vez
• nunca más cambies esa lista

entonces la respuesta de Thilos será la mejor manera de hacerlo. Si lo combinas con el consejo de Tom Hawtin - tackline , obtienes:

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

Solución con un TreeSet

Si puede decidir libremente, y si su aplicación puede ser más compleja, entonces puede cambiar su código para usar un TreeSet. Este tipo de colección clasifica tus entradas justo cuando se insertan. No es necesario llamar a sort ().

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

Nota al margen sobre por qué prefiero TreeSet

Esto tiene algunas ventajas sutiles, pero importantes:

• Es simplemente más corto. Solo una línea más corta, sin embargo.
• Nunca se preocupe, esta lista realmente está ordenada en este momento porque un TreeSet siempre está ordenado, sin importar lo que haga.
• No puedes tener entradas duplicadas. Dependiendo de su situación, esto puede ser un problema o una estafa. Si necesita duplicados, quédese con su Lista.
• Un programador experimentado observa TreeSet<String> countyNames y lo sabe al instante: se trata de una colección ordenada de cadenas sin duplicados, y puedo estar seguro de que esto es cierto en todo momento . Tanta información en una breve declaración.
• El rendimiento real gana en algunos casos. Si usa una Lista e inserta valores muy a menudo, y la lista puede leerse entre esas inserciones, entonces debe ordenar la lista después de cada inserción. El conjunto hace lo mismo, pero lo hace mucho más rápido.

Usar la colección correcta para la tarea correcta es una clave para escribir código corto y libre de errores. No es tan demostrativo en este caso, porque solo guarda una línea. Pero he dejado de contar la frecuencia con la que veo a alguien usando una Lista cuando quieren asegurarse de que no haya duplicidades, y luego construyo esa funcionalidad por sí mismos. O aún peor, usando dos Listas cuando realmente necesita un Mapa.

No me malinterprete: el uso de Collections.sort no es un error o un defecto. Pero hay muchos casos cuando TreeSet es mucho más limpio.

Answer 2

¡Mejor tarde que nunca! Aquí es cómo podemos hacerlo-

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

Answer 3

A menos que esté ordenando cadenas en un inglés libre de acentos, es probable que desee utilizar un Collator . Clasificará correctamente las marcas diacríticas, puede ignorar el caso y otras cosas específicas del idioma:

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

Puede establecer la fortaleza del clasificador , consulte el javadoc.

Aquí hay un ejemplo para eslovaco:

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]

Answer 4

Al usar Collections.sort() , podemos ordenar una lista.

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

salida:

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

Answer 5

En una línea, usando Java 8:

list.sort(Comparator.naturalOrder());

Answer 6

Esto es lo que estás buscando

listOfCountryNames.sort(String::compareToIgnoreCase)

Answer 7

Lo mismo en 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));

Answer 8

Puede crear una nueva copia ordenada utilizando 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); 

Otra opción es clasificar in situ a través de la API de colecciones:

Collections.sort(names);

Answer 9

Puedes intentar usar un método que hice.

String key : será el orden que desee y, en este caso, en orden alfabético. Solo pon "abc ...".

String list[] - la lista que desea ordenar usando la tecla.

int index - establecido como 0, configurará el desplazamiento para la tecla.

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

Answer 10

Suponiendo que se trata de cadenas, utilice el método estático conveniente sort ...

 java.util.Collections.sort(listOfCountryNames)

Answer 11

Usa los dos argumentos para Collections.sort . Usted querrá un Comparator adecuado que trate el caso apropiado (es decir, realiza el léxico, no el ordenamiento UTF16), como el que se puede obtener a través de java.text.Collator.getInstance .

Answer 12

alfabeto descendente:

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

Answer 13

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

}
}