Collections.sort isn't sorting

Question

I am building a web application using Java EE (although my problem is more Java based)

In a Servlet, I am getting a list of orders from the EJB. In this list of orders, there is a list of states for this order (sent, on dock, non received ...)

I want to sort this list of states by the date of the state. So I use Collections.sort like this:

    for (Command c : commands) {
        c.getStateList().sort(new Comparator<State>() {
                @Override
                public int compare(State o1, State o2) {
                    return o1.getStateDate().compareTo(o2.getStateDate());
                }
        });

        c.getStateList().sort(Collections.reverseOrder());
    }
request.setAttribute("commands", commands);

But when I display the results, the states are not sorted.

I tried to reverse the order as you can see, but it isn't working either.

As you can also see, I replaced the Collections.sort with the ListIWantToSort.sort. Still not working.

Any ideas on why it does not work or how I could repair it?

EDIT : Here is the getter for the list and its instanciation :

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "ciiCommande")
    private List<Etat> etatList;

    @XmlTransient
    public List<Etat> getEtatList() {
        return etatList;
    }

    List<Commande> commandes = new ArrayList<Commande>();

And I get my commands by a findAll Method.

To display them, I use that :

<c:forEach items="${commandes}" var="cmd">
    <td>${cmd.etatList[0].codeStatut.libelleSituation}</td>
</c:forEach>

Answer 1

Try:

for (Commande c : commandes) {
                c.getEtatList().sort(Collections.reverseOrder(new Comparator<Etat>() {

                    @Override
                    public int compare(Etat o1, Etat o2) {
                        return o1.getDateEtat().compareTo(o2.getDateEtat());
                    }
                }));
            }

Since the sort method your using has been added to the List interface in Java SE 8, I guess you're using Java SE 8. Then you can rewrite it to the following:

commandes.foreach(c -> 
  c.getEtatList().sort(Comparator.comparing(Etat::getDateEtat).reversed());
);

Answer 2

You are first sorting the list using the custom comparator. Then you are re-sorting it according to the reversed natural ordering of the elements - not the custom ordering you already applied. So the first sort is not taking effect as the list is re-ordered by the second sort. Note that Collections.reverseOrder() does not reverse the list - it is the reverse of the natural ordering (so the elements in getEtatList() must already be Comparable).

Try losing the second sort and doing:

c.getEtatList().sort(new Comparator<Etat>() {
    @Override
    public int compare(Etat o1, Etat o2) {
        // Note o2/o1 reversed.
        return o2.getDateEtat().compareTo(o1.getDateEtat());
    }
});

Answer 3

This should be what you need:

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

    for (Commande c : commandes) {
        Collections.sort(c.getEtatList(), comparator);
        // or this one: Collections.sort(c.getEtatList(), Collections.reverseOrder(comparator));
    }

Answer 4

This works as expected, your problem is somewhere else:

public static void main(String[] args) {
  List<State> states = Arrays.asList(new State(2015, 1, 1),
                                     new State(2014, 1, 1),
                                     new State(2016, 1, 1));
  System.out.println(states); //not ordered
  states.sort(new Comparator<State>() {
    @Override public int compare(State o1, State o2) {
      return o1.getStateDate().compareTo(o2.getStateDate());
    }
  });
  System.out.println(states); //ordered
}

public static class State {
  private final LocalDate stateDate;
  public State(int year, int month, int day) {
    this.stateDate = LocalDate.of(year, month, day);
  }
  public LocalDate getStateDate() { return stateDate; }
  @Override public String toString() { return stateDate.toString(); }
}

Note that you seem to be using Java 8 and your comparator can be written:

states.sort(comparing(State::getStateDate));

Answer 5

After days of struggle, I managed to find a solution.

The list isn't sorted after every attempt I made. I still don't know why.

But I found an annotation, @OrderBy, that sorts the list the way I want.

Thank you all for your help, maybe one day this problem will be sorted out (see the pun ? I am so funny).

Cheers

Answer 6

I appreciate your question, as I have just experienced this. I implemented 'Comparable' (as I have done many other times) on my JPA Entity class. When doing a Collections.sort on myMainJPA_Object.getMyList(), the overriden comparable method does not get invoked.

My work-around has been to create a new List as an ArrayList (for example), do a .addAll(myObject.getMyList()), then do Collections.sort on that new list, and then the sort works (my comparable method is invoked on the sort). For example:

List<ObjectsToSort> tempList = new ArrayList<>();
tempList.addAll(jpaEntity.getListOfStuff());
Collections.sort(tempList);
//Then you could set the list again
jpaEntity.setListOfStuff(tempList);

I really don't like this solution, but I don't know any other way around it, and haven't found anything about this problem (until your post). I liked your @OrderBy annotation suggestion, in my case though I need to re-sort again on a different method call, so this solution works for me.