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

我有一个包含国家名称的

列表

对象。如何按字母顺序排列此列表？

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

使用Collections.sort的解决方案 如果您被迫使用该列表，或者如果您的程序具有类似

• 创建列表
• 添加一些国家名称
• 把它们分类一次
• 再也不要改变这个清单了

那么这个答案就是最好的办法了。如果你结合Tom Hawtin-tackline的建议，你会得到：

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

树集解法 如果您可以自由决定，并且您的应用程序可能会变得更复杂，那么您可以将代码更改为使用树集。这种集合在条目插入时对条目进行排序。无需调用sort（）

Collection countryNames=
新树集（Collator.getInstance（））；
国家名称。添加（“英国”）；
国家名称。添加（“德国”）；
国家名称。添加（“澳大利亚”）；
//塔达。。。分类。

关于我为什么喜欢树集的旁注 这有一些微妙但重要的优势：

• 它只是比较短。不过，只有一行短了
• 不要担心这个列表现在是否真的被排序了，因为不管你做什么，树集总是被排序的
• 您不能有重复的条目。根据你的情况，这可能是赞成或反对。如果你需要重复的，坚持你的清单
• 一位经验丰富的程序员看着TreeSet countyNames，马上就知道：这是一个有序的字符串集合，没有重复项，我可以肯定这在任何时候都是正确的。这么多的信息在一个简短的声明
• 在某些情况下，真正的表现会赢得胜利。如果您使用列表，并且经常插入值，并且在这些插入之间可能会读取列表，那么您必须在每次插入后对列表进行排序。布景也一样，但速度要快得多

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

---

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

将两个参数用于of

Collections.sort

。您需要一个合适的

比较器

，该比较器根据大小写进行处理（即进行词法排序，而不是UTF16排序），例如可通过

java.text.Collator.getInstance

获得的比较器。您可以使用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); 

---

迟做总比不做好！以下是我们如何做到这一点（仅用于学习目的）-

import java.util.List；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
高级软饮料{
字符串名；
字符串颜色；
国际卷；
软饮料（字符串名称、字符串颜色、整数体积）{
this.name=名称；
这个颜色=颜色；
这个。体积=体积；
}
}
公共类ListItemComparison{
公共静态void main（字符串…参数）{
List softDrinkList=new ArrayList（）；
添加（新的软饮料（“Faygo”，“ColorOne”，4））；
添加（新的软饮料（“Fanta”，“ColorTwo”，3））；
添加（新的软饮料（“Frooti”，“ColorThree”，2））；
添加（新的软饮料（“Freshie”，“ColorFour”，1））；
Collections.sort（softDrinkList，newcomparator（）{
@凌驾
公共整数比较（对象softDrinkOne、对象softDrinkTwo）{
//使用instanceof验证引用是否确实属于所讨论的类型
return（（软饮料）softDrinkOne）.name
.compareTo（（（软饮料）软饮料两个）.name）；
}
}); 
用于（软饮料sd:softDrinkList）{
System.out.println（sd.name+“-”+sd.color+“-”+sd.volume）；
}
Collections.sort（softDrinkList，newcomparator（）{
@凌驾
公共整数比较（对象softDrinkOne、对象softDrinkTwo）{
//原语int的比较使用包装整数的compareTo
返回（新整数（（（软饮料）softDrinkOne.volume））
.比较（（（软饮料）软饮料两种）。体积；
}
});
用于（软饮料sd:softDrinkList）{
System.out.println（sd.volume+“-”+sd.color+“-”+sd.name）；
}   
}
}

//这里是按字母顺序排序的列表，已同步
包com.mnas.technology.automation.utility；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.Iterator；
导入java.util.List；
导入org.apache.log4j.Logger；
/**
* 
*@作者manoj.kumar
*/
公共类SynchronizedArrayList{
静态记录器log=Logger.getLogger（SynchronizedArrayList.class.getName（））；
@抑制警告（“未选中”）
公共静态void main（字符串[]args）{
List synchronizedList=Collections.synchronizedList（新的ArrayList（））；
synchronizedList.add（新员工（“Aditya”）；
synchronizedList.add（新员工（“Siddharth”）；
synchronizedList.add（新员工（“Manoj”）；
Collections.sort（synchronizedList，newcomparator（））{
公共int比较（对象同步列表一、对象同步列表二）{
//使用instanceof验证引用是否确实属于所讨论的类型
return（（员工）synchronizedListOne）.name
.compareTo（（（员工）synchronizedListTwo）.name）；
}
}); 
/*对于（员工sd:synchronizedList）{
log.info（“排序的同步数组列表…”+sd.name）；
}*/
//在对同步列表进行迭代时，我们需要同步对同步列表的访问
已同步（synchronizedList）{
迭代器
Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.

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

Collections.sort(names);

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

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

}
}

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

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]

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]

listOfCountryNames.sort(String::compareToIgnoreCase)

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

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

list.sort(Comparator.naturalOrder());