87

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?

Improve this question
1

15 Answers 15

Reset to default
169

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

What if they want to sort more than one time?
Edited the answer, please check. Obviously its not a big deal if it is understandable how to use the comparator. If you can do it one time, it can be done n times also :)
Aye ... if class implement comparable then dont need to pass comparator ...nice ..ta
The method sort(List<T>, Comparator<? super T>) in the type Collections is not applicable for the arguments (Collection, Comparator) you cannot pass a Collection to sort method which is dead annoying
The sort method works for Lists, not Collections. The type of the list variable should be changed to List for this example to work.
|
36

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);
Improve this answer

3 Comments

I asked this question 4 years ago and you are answering now.
Thanks for u reply. Really appreciate it. 4 years and still wrong answer is marked as correct one. Who is the bad guy?
@Makky becuase it answers for a List, not a collection
12

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;
  }
});
Improve this answer

4 Comments

The if statement you implemented does exactly what compareTo() does already.
The difference is that in this example the class ClassOne is not a comparable class, it doesn't implement Comparable. I was just trying to show an example of how you can use a collection and a comparator to sort non comparable objects. ClassOne has no compareTo method..
doesnt work with java 6 (Collections.sort limited to List)
You won't find a Collections.sort taking a Set in Java 7 or 8. By definition a List is an ordered sequence of elements whereas Set is a distinct list of elements which is unordered. If you want ordering in a Set look at TreeSet
8

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());
Improve this answer

Comments

5

Implement the Comparable interface on your customObject.

Improve this answer

Comments

5

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));
Improve this answer

Comments

5

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.

Improve this answer

Comments

4

Comparator is the way

Also See

Improve this answer

Comments

2

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.)

Improve this answer

Comments

1

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));
Improve this answer

Comments

0

SortedSet and Comparator. Comparator should honour the id field.

Improve this answer

1 Comment

@Qwerky - I know he has a list. I am suggesting him to use a Set. Unless he wants to maintain duplicates and insertion order.
0

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

Improve this answer

Comments

0

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.

Improve this answer

Comments

-1

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);
Improve this answer

Comments

-3

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)

Improve this answer

1 Comment

Totall irrelevant answer.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.