排序 Java 集合

Comparator is the way

Also See

• sorting-of-arraylist

SortedSet and Comparator. Comparator should honour the id field.

Use sort.

You just have to do this:

All elements in the list must implement the Comparable interface.

(Or use the version below it, as others already said.)

Implement the Comparable interface on your customObject.

You should implement the Comparator interface.

example:

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

Then you can use the Collections classes Collections.sort() method:

Collections.sort(list, new CustomComparator());

Use a Comparator:

List<CustomObject> list = new ArrayList<CustomObject>();
Comparator<CustomObject> comparator = new Comparator<CustomObject>() {
@Override
public int compare(CustomObject left, CustomObject right) {
return left.getId() - right.getId(); // use your logic
}
};


Collections.sort(list, comparator); // use the comparator as much as u want
System.out.println(list);

Additionally, if CustomObjectimplements Comparable, then just use Collections.sort(list)

With JDK 8 the syntax is much simpler.

List<CustomObject> list = getCustomObjectList();
Collections.sort(list, (left, right) -> left.getId() - right.getId());
System.out.println(list);

Much simplier

List<CustomObject> list = getCustomObjectList();
list.sort((left, right) -> left.getId() - right.getId());
System.out.println(list);

Simplest

List<CustomObject> list = getCustomObjectList();
list.sort(Comparator.comparing(CustomObject::getId));
System.out.println(list);

Obviously the initial code can be used for JDK 8 too.

A slightly different example say if you have a class that doesn't implement Comparable but you still want to sort it on a field or method.

Collections.sort(allMatching, new Comparator<ClassOne>() {
@Override public int compare(final ClassOne o1, final ClassOne o2) {
if (o1.getMethodToSort() > o2.getMethodToSort()) {
return 1;
} else if (o1.getMethodToSort() < o2.getMethodToSort()) {
return -1;
}
return 0;
}
});

As of Java 8 you now can do it with a stream using a lambda:

list.stream().sorted(Comparator.comparing(customObject::getId))
.foreach(object -> System.out.println(object));

The question is: "Sort Collection". So you can't use Collections.sort(List<T> l, Comparator<? super T> comparator).

Some tips:

For Collection type:

Comparator<String> defaultComparator = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
};


Collection<String> collection = getSomeStringCollection();
String[] strings = collection.toArray(new String[collection.size()]);
Arrays.sort(strings, defaultComparator);
List<String> sortedStrings = Arrays.asList(strings);


Collection<String> collection = getSomeStringCollection();
List<String> list = new ArrayList(collection);
Collections.sort(list, defaultComparator);
collection = list; // if you wish

For List type:

List<String> list = getSomeStringList();
Collections.sort(list, defaultComparator);

For Set type:

Set<String> set = getSomeStringSet();
// Than steps like in 'For Collection type' section or use java.util.TreeSet
// TreeSet sample:
// Sorted using java.lang.Comparable.
Set<String> naturalSorted = new TreeSet(set);


Set<String> set = getSomeStringSet();
Set<String> sortedSet = new TreeSet(defaultComparator);
sortedSet.addAll(set);

Java 8 version. There is java.util.List#sort(Comparator<? super E> c) method

List<String> list = getSomeStringList();
list.sort(defaultComparator);

or

List<String> list = getSomeStringList();
list.sort((String o1, String o2) -> o1.compareTo(o2));

or for types that implements Comparable:

List<String> list = getSomeStringList();
list.sort(String::compareTo);

With Java 8 you have several options, combining method references and the built-in comparing comparator:

import static java.util.Comparator.comparing;


Collection<CustomObject> list = new ArrayList<CustomObject>();


Collections.sort(list, comparing(CustomObject::getId));
//or
list.sort(comparing(CustomObject::getId));

You can also use:

Collections.sort(list, new Comparator<CustomObject>() {
public int compare(CustomObject obj1, CustomObject obj2) {
return obj1.id - obj2.id;
}
});
System.out.println(list);

A lot of correct answers, but I haven't found this one: Collections cannot be sorted, you can only iterate through them.

Now you can iterate over them and create a new sorted something. Follow the answers here for that.

You can use java Custom Class for the purpose of sorting.

To be super clear, Collection.sort(list, compartor) does not return anything so something like this list = Collection.sort(list, compartor); will throw an error (void cannot be converted to [list type]) and should instead be Collection.sort(list, compartor)

Your example:

Collection<CustomObject> list = new ArrayList<CustomObject>();

You can also use a comparator:

list.sort(Comparator.comparingLong(CustomObject::getSomethingToCompare));

Just replace the comparingLong method, there are quite a few options, but it depends on what you want to pass on the "getSomethingToCompare".

This link may help too.