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

Java8Lambda缩短了排序。

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

从…起 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.

您可以使用Java8进行排序

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

or

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

函数和方法参考

这个 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的最佳简单方法是使用英文字母排序
类实现

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

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

}

}

由于技术每天都在出现，答案会随着时间而改变。我看了一下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倍），但是您能找到更可读的代码吗？

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

import static java.util.Comparator.comparing;

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

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)

自从 Date 工具 Comparable ，它有一个 compareTo 方法就像 String 做
那你的习惯呢 Comparator 可能是这样的：

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

这个 compare() 方法必须返回一个 int ，因此您无法直接返回 boolean 就像你计划的那样。
您的排序代码将与您所写的大致相同：

Collections.sort(Database.arrayList, new CustomComparator());

如果您不需要重用比较器，那么编写所有这些的一种略短的方法是将其作为内联匿名类编写：

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

自java-8以来

现在，您可以使用lambda表达式为 Comparator :

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

及 List 有一个 sort(Comparator) 方法，因此您可以进一步缩短：

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

这是一个非常常见的习惯用法，有一个内置的方法来生成 Comparator 对于一个有 Comparable 关键：

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

所有这些都是等价形式。

是的，你可以。有两个选项用于比较项目，可比较接口和比较器接口。
这两个接口都允许不同的行为。comparable允许您使对象的行为与刚才描述的字符串类似（实际上，字符串实现了comparable）。第二个是comparator，它允许你做你要求做的事情。你可以这样做：

Collections.sort(myArrayList, new MyComparator());

这将导致collections.sort方法使用comparator作为其排序机制。如果arraylist中的对象实现了comparable，则可以执行以下操作：

Collections.sort(myArrayList);

collections类包含许多有用的通用工具。

用于分类 ArrayList 您可以使用以下代码段：

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

具有自然排序顺序的类（例如，类编号）应实现可比较接口，而没有自然排序顺序的类（例如，类主席）应提供比较器（或匿名比较器类）。
两个例子：

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

用法：

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});