如何通过 2 个浮点属性对 ArrayList 中的对象进行排序？

Question

I aim to sort an arraylist of a class

 public class AnimSprite
    {
    float x,y,z;
    //...//
    }

ArrayList<AnimSprite> listofsprites = new ArrayList<AnimSprite>();

    //...//

list.add( new AnimSprite(1f,10f,0f) );      //x,y,z
list.add( new AnimSprite(15f,25f,1f) );
list.add( new AnimSprite(30f,-62f,0f) );
list.add( new AnimSprite(150f,-62f,2f) );
list.add( new AnimSprite(55f,-65f,0f) );

    //...//

Then of course I loop to draw it

for (AnimSprite s: listofsprites) { s.draw();}

Before draw instruction, how could we sort the array list? (ordered by y ascending and then z ascending)

Eg expected result:

obj0 -> AnimSprite(55f,-65f,0f)
obj1 -> AnimSprite(30f,-62f,0f) 
obj2 -> AnimSprite(1f,10f,0f)
obj3 -> AnimSprite(15f,25f,1f)
obj4 -> AnimSprite(150f,-62f,2f)

for the moment, as below, I sort ascending by y and z but I am not sure it is state of art?

  public static class AnimSprite implements Comparable<AnimSprite >
    {
    //...//
   Override
       public int compareTo(AnimSprite o)
    {
        float result = this.z - o.z;
        if (result == 0f) result = this.y - o.y;
        return ((int)(result));
        }   

Answer 1

You can use Collection.sort(list) to sort your ArrayList but AnimSprite must implement the Comparable Interface to let the sort method to know how to compare two AnimSprite objects.

public class AnimSprite implements Comparable
{
    float x,y,z;
    //...//

   @Override
   public int compareTo(AnimSprite o)
{
    float result = this.z - o.z;
    if (result == 0f) result = this.y - o.y;
    return ((int)(result));
    }   
}

ArrayList<AnimSprite> listofsprites = new ArrayList<AnimSprite>();

    //...//

listofsprites.add( new AnimSprite(1f,10f,0f) );      //x,y,z
listofsprites.add( new AnimSprite(15f,25f,1f) );
listofsprites.add( new AnimSprite(30f,-62f,0f) );
listofsprites.add( new AnimSprite(150f,-62f,2f) );
listofsprites.add( new AnimSprite(55f,-65f,0f) );

//...//

Collection.sort(listofsprites);

for (AnimSprite s: listofsprites) { s.draw();}

Another solution is to use the overloaded method sort that accept the Comparator implementation as second argument, and use the Lambda expression to write less code:

Collections.sort(listofsprites, (s1, s2) -> {
    float result = s1.z - s2.z;
    if (result == 0f) result = s1.y - s2.y;
    return ((int)(result));
});

Answer 2

There are two simple ways to achieve what you want. Both boil down to the idea that the elements of the array should be "comparable" to each other.

Option 1:

Implement Comparable interface in AnimSprite . Define compareTo method (that you'll have to since you implement the interface) to rely on 2 numbers for comparison.

Then use:

Collections.sort(yourArray);

Option 2:

Can be used when you can't really change AnimSprite class. In this case you can implement the Comparator interface effectively externalizing comparison logic:

Collections.sort(yourArray, new Comparator<AnimSprite> {
     public int compare(AnimSprite s1, AnimSprite s2) {
                ...
     }
 });

Of course you can also use lambda if you're using java 8+

Answer 3

Yes. You can also do something like this:

    Collections.sort(list,
            Comparator.comparing((AnimSprite a) -> a.z)
                    .thenComparing((AnimSprite a) -> a.y));