Как отсортировать список по алфавиту?

У меня есть объект List<String>, который содержит названия стран. Как отсортировать список по алфавиту?

ОТВЕТЫ

Ответ 1

Предполагая, что это строки, используйте удобный статический метод sort...

 java.util.Collections.sort(listOfCountryNames)

Ответ 2

Решение с Collections.sort

Если вы вынуждены использовать этот список или если ваша программа имеет структуру типа

  • Создать список
  • Добавить названия стран
  • сортировать их один раз
  • никогда не меняйте этот список снова

тогда ответ Тилоса будет лучшим способом сделать это. Если вы объедините его с советом от Tom Hawtin - tackline, вы получите:

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

Решение с TreeSet

Если вы можете принять решение, и если ваше приложение может стать более сложным, вы можете изменить свой код, чтобы вместо этого использовать TreeSet. Такая коллекция сортирует ваши записи только после их установки. Нет необходимости вызывать sort().

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

Боковое примечание о том, почему я предпочитаю TreeSet

Это имеет некоторые тонкие, но важные преимущества:

  • Это просто короче. Однако только одна строка короче.
  • Не беспокойтесь о том, что этот список действительно отсортирован прямо сейчас, потому что TreeSet всегда сортируется независимо от того, что вы делаете.
  • У вас нет дубликатов записей. В зависимости от вашей ситуации это может быть про или con. Если вам нужны дубликаты, придерживайтесь своего списка.
  • Опытный программист смотрит на TreeSet<String> countyNames и сразу же знает: это отсортированный набор строк без дубликатов, и я могу быть уверен, что это верно в каждый момент. Так много информации в короткой декларации.
  • Реальная победа в производительности в некоторых случаях. Если вы используете список и вставляете значения очень часто, и список может быть прочитан между этими вставками, вам нужно отсортировать список после каждой вставки. Набор делает то же самое, но делает это намного быстрее.

Использование правой коллекции для правильной задачи - это ключ для написания короткого кода и кода без ошибок. Это не так показательно в этом случае, потому что вы просто сохраняете одну строку. Но я перестал считать, как часто я вижу кого-то, кто пользуется списком, когда они хотят убедиться, что нет дупликов, а затем сами создайте эту функциональность. Или еще хуже, используя два списка, когда вам действительно нужна карта.

Не поймите меня неправильно: использование Collections.sort не является ошибкой или недостатком. Но есть много случаев, когда TreeSet намного чище.

Ответ 3

Вы можете создать новую отсортированную копию с помощью Java 8 Stream или Guava:

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

Другим вариантом является сортировка на месте через API коллекций:

Collections.sort(names);

Ответ 4

Лучше поздно, чем никогда! Вот как мы можем это сделать -

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

Ответ 5

Используйте два аргумента для Collections.sort. Вам понадобится подходящий Comparator, который относится к соответствующему случаю (т.е. Относится к лексическому, а не UTF16), например, к которому можно получить через java.text.Collator.getInstance.

Ответ 6

Если вы не сортируете строки только на английском языке без акцентов, вы, вероятно, захотите использовать Collator. Он правильно сортирует диакритические знаки, может игнорировать случай и другие специфические для языка вещи:

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

Вы можете установить силу collator, см. javadoc.

Вот пример словака:

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]

Ответ 7

Вот что вы ищете

listOfCountryNames.sort(String::compareToIgnoreCase)

Ответ 8

Используя Collections.sort(), мы можем отсортировать список.

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

выход:

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

Ответ 9

нисходящий алфавит:

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

Ответ 10

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

}
}

Ответ 11

То же самое в 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));

Ответ 12

Вы можете попробовать использовать метод, который я сделал.

String key - будет порядок, который вы хотите, и в этом случае в алфавитном порядке. Просто поставьте "abc...".

String list[] - список, который вы хотите упорядочить с помощью ключа.

int index - установить как 0, установить смещение для клавиши.

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