java - 如何按字母顺序对列表进行排序？

Question

我有一个List<String>包含国家名称的对象。如何按字母顺序对这个列表进行排序？

Answer 1

假设那些是字符串，使用方便的静态方法sort……</p>

 java.util.Collections.sort(listOfCountryNames)

Answer 2

Collections.sort 的解决方案

如果您被迫使用该列表，或者您的程序具有类似的结构

• 创建列表
• 添加一些国家名称
• 排序一次
• 永远不要再更改该列表

那么 Thilos 的回答将是最好的方法。如果你将它与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 总是排序的。
• 您不能有重复的条目。根据您的情况，这可能是有利的或不利的。如果您需要重复，请坚持您的清单。
• 一个有经验的程序员一看就TreeSet<String> countyNames知道：这是一个没有重复的有序字符串集合，我可以确定这在每一刻都是正确的。一个简短的声明中有这么多信息。
• 在某些情况下，真正的性能会获胜。如果您使用列表并经常插入值，并且可能在这些插入之间读取列表，那么您必须在每次插入后对列表进行排序。这套装置做同样的事情，但做起来要快得多。

为正确的任务使用正确的集合是编写简短且无错误的代码的关键。在这种情况下，它没有那么明显，因为您只需保存一行。但是我已经停止计算我看到有人使用列表的频率，他们想要确保没有重复项，然后自己构建该功能。或者更糟糕的是，当你真的需要一个地图时使用两个列表。

不要误会我的意思：使用 Collections.sort 不是错误或缺陷。但是在很多情况下，TreeSet 更干净。

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

另一种选择是通过 Collections API 就地排序：

Collections.sort(names);

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

Answer 5

在一行中，使用 Java 8：

list.sort(Comparator.naturalOrder());

Answer 6

除非您仅以无重音的英语对字符串进行排序，否则您可能希望使用Collator. 它将正确排序变音符号，可以忽略大小写和其他特定于语言的内容：

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

您可以设置整理者强度，请参阅 javadoc。

这是斯洛伐克语的一个例子，Š应该去哪里S，但在 UTFŠ中是在后面的某个地方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]

Answer 7

对 of 使用两个参数Collections.sort。您将需要一个合适Comparator的大小写（即进行词汇排序，而不是 UTF16 排序），例如可通过java.text.Collator.getInstance.

Answer 8

这是您正在寻找的

listOfCountryNames.sort(String::compareToIgnoreCase)

Answer 9

通过使用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]

Answer 10

降序字母：

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

Answer 11

您可以使用以下行

Collections.sort(listOfCountryNames, String.CASE_INSENSITIVE_ORDER)

它类似于 Thilo 的建议，但不会区分大小写字符。

Answer 12

爪哇 8 ,

countries.sort((country1, country2) -> country1.compareTo(country2));

如果String 的 compareTo不适合您的需要，您可以提供任何其他比较器。

Answer 13

在 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 14

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

}
}