我已经尝试了很多不同的解决方案在互联网上，但解决方案，这对我来说是可行的在下面的链接。
https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html

这些代码片段可能很有用。如果要对我的案例中的对象进行排序，我希望按volumename进行排序：

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

这很有效。我在jsp中使用它。

customcomparator类必须实现java.util.comparator才能使用。它还必须覆盖compare（）和equals（）
compare（）必须回答以下问题：对象1是否小于、等于或大于对象2？
完整文档：http://java.sun.com/j2se/1.5.0/docs/api/java/util/comparator.html

您可以尝试点Guava：

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

java 8 lambda表达式

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

或

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

使用java 8，您可以使用比较器的方法参考：

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

由于技术每天都在出现，答案会随着时间而改变。我看了一下lambdaj，看起来很有趣。
您可以尝试使用lambdaj解决这些任务。你可以在这里找到它：http://code.google.com/p/lambdaj/
这里有一个例子：
排序迭代

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

用lambda排序

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge());

当然，这种美观会影响性能（平均2倍），但是您能找到更可读的代码吗？

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}

使用Java8的最佳简单方法是使用英文字母排序
类实现

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

分类

Collections.sort(Your List);

如果要对包含非英语字符的字母表进行排序，可以使用区域设置。。。下面的代码使用土耳其语字符排序。。。
类实现

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));

   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

分类

Collections.sort(your array list,new NewspaperClass());

函数和方法参考

这个 Collections.sort 方法可以对 List 使用 Comparator 你通过了。那个 Comparator 可以使用 Comparator.comparing 方法，其中可以根据需要传递方法引用 Function . 幸运的是，实际的代码比这个描述简单得多，也短得多。
对于java 8：

Collections.sort(list, comparing(ClassName::getName));

或

Collections.sort(list, comparing(ClassName::getName).reversed());

另一种方法是

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

您可以使用Java8进行排序

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));

从…起 Java 8 从那时起，我们不必使用 Collections.sort() 直接的。 List 接口有一个默认值 sort() 方法：

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());});

看见http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html.

Java8Lambda缩短了排序。

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

您可以使用bean比较器对自定义类中的任何属性进行排序。

是的，这是可能的，比如在这个答案中，我按属性排序 v 班上的 IndexValue ```
// Sorting by property v using a custom comparator.
Arrays.sort( array, new Comparator(){
public int compare( IndexValue a, IndexValue b ){
return a.v - b.v;
}
});

如果您注意到这里，我正在创建一个匿名内部类（这是闭包的java），并将其直接传递给 `sort` 课堂教学方法 `Arrays` 您的对象也可以实现 `Comparable` （这就是string和java中的大多数核心库所做的），但这将定义类本身的“自然排序顺序”，并且不允许插入新的排序顺序。