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

问题描述 投票：0回答：16

我有一个包含国家/地区名称的 

List<String>
对象。我如何按字母顺序排序此列表？

java list sorting collections alphabetical
16个回答
255
投票

假设这些是字符串，请使用方便的静态方法

sort
:

Collections.sort(listOfCountryNames)
159
投票

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");
// Voila... sorted.

旁注说明为什么我更喜欢 TreeSet

它有一些微妙但重要的优点：

  • 只是比较短而已。但只短了一行。
  • 永远不用担心这个列表现在真的排序了吗，因为无论你做什么，TreeSet 总是排序的。
  • 您不能有重复的条目。根据您的情况，这可能是有利的，也可能是不利的。如果您需要重复的内容，请遵守您的清单。
  • 经验丰富的程序员看到
    TreeSet<String> countyNames
    并立即知道：这是一个没有重复的有序字符串集合，我可以随时确定这是真的。一份简短的声明包含如此多的信息。
  • 在某些情况下真正的性能提升。如果您使用列表，并且经常插入值，并且可能会在这些插入之间读取列表，那么您必须在每次插入后对列表进行排序。该集合执行相同的操作，但速度更快。

为正确的任务使用正确的集合是编写简短且无错误的代码的关键。在这种情况下，它并不是那么具有说明性，因为您只保存了一行。 但我已经记不清有多少次我看到有人在想要确保没有重复项时使用列表，然后自己构建该功能。或者更糟糕的是，当您确实需要一张地图时使用两个列表。

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

37
投票

您可以使用 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);
28
投票

迟到总比不到好！这是我们如何做到的（仅供学习目的）-

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);
        }   
    }
}
21
投票

一行，使用 Java 8：

list.sort(Comparator.naturalOrder());
16
投票

除非您仅以无口音的英语对字符串进行排序，否则您可能需要使用 

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]
11
投票

使用 

Collections.sort
的两个参数。您将需要一个合适的 
Comparator
来处理适当的大小写（即进行词法排序，而不是 UTF16 排序），例如通过 
java.text.Collator.getInstance
获得的。

10
投票

这就是您要找的东西

listOfCountryNames.sort(String::compareToIgnoreCase)
7
投票

更简单的是，您可以使用方法参考。

 list.sort(String::compareTo);
5
投票

通过使用

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]
5
投票

您可以使用以下行

Collections.sort(listOfCountryNames, String.CASE_INSENSITIVE_ORDER)

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

4
投票

降序字母：

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

Java 8，

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

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

0
投票
public static void sortByAlphabetCountry(List<Employee> listCountry) {
    listCountry.sort((o1, o2) -> {
        return o1.getName().compareTo(o2.getName());
    });
}
0
投票

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));
-1
投票
//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;

}
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.