I have a Java collection:
Collection<CustomObject> list = new ArrayList<CustomObject>();CustomObject has an id field now before display list I want to sort this collection by that id.
Is there any way I could that do that?
115 Answers
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.
7The 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 wishFor 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);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; }
});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());Implement the Comparable interface on your customObject.
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));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.
Comparator is the way
Also See
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.)
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));SortedSet and Comparator. Comparator should honour the id field.
1You can use java Custom Class for the purpose of sorting.
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.
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);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)
