在 1 次交互中从未排序的数组列表生成排序的数组列表？

Question

假设我有 arraylist A 并比较 A 的 2 个对象，我做 a.getDistanceFromPlayer() < b.getDistanceFromPlayer()。

我现在想要列出B，它将包含A 的所有对象，但排序在第一个对象最接近玩家的位置，最后一个对象最远。

最快的方法是什么？

谢谢

Answer 1

让 A 实现 Comparable，然后像这样定义方法 compareTo(Object other)：

public int compareTo(Object other) {
  if( this.getDistanceFromPlayer() < other.getDistanceFromPlayer() ) {
      return -1;
  } else if( this.getDistanceFromPlayer() > other.getDistanceFromPlayer())  {
      return 1;
  }
  return 0;
}

现在您可以在对象列表中调用 Collections.sort()

Answer 2

将 Collections.sort 与自定义比较器一起使用。

eg.
public class DistanceComparator implements Comparator<Integer>{

    @Override
    public int compare(YourObject o1, YourObject o2) {
        if (o1.getDistanceFromPlayer() > o2.getDistanceFromPlayer())
        {
           return 1;
        } 
        else if (o1.getDistanceFromPlayer() < o2.getDistanceFromPlayer())
        {
           return -1;
        }
        return 0;
    }
}

然后在你的程序中，调用

Collections.sort(YourArrayInstance, new DistanceComparator())

Answer 3

你应该让你的类实现Comparable。

然后您可以使用Collections.sort() 对您的列表进行排序。

如果您想要一个排序列表AND一个未排序列表，您必须制作一个副本。

---

另一种选择是创建Comparator。

如果您阅读 documentation for Collections，您会发现它有两个 sort 方法。

排序基于对象的compareTo 方法（即它们的“自然顺序”）。

另一个基于作为第二个参数传递的 Comparator 进行排序。

---

这是另一个问题的链接，提供了 Comparable 的示例实现：

• Example implementation of Comparable

Answer 4

使用Custom Comparator：

B = Collections.sort(A, new CustomComparator());

public class CustomComparator implements Comparator<ClassA> {

    @Override
    public int compare(final ClassA a, final ClassA b) {
         //Make sure you check that neither a nor b are null..
         //..
         if (a.getDistanceFromPlayer() < b.getDistanceFromPlayer()) {
             return 1;
         } else if (a.getDistanceFromPlayer() > b.getDistanceFromPlayer()) {
             return -1;
         }
         return 0;

   }
}

Answer 5

您可以使用自定义Comparator 和sort 您的ArrayList，如下所示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class Main {
    public static class Player {
        private final float distance;

        public Player (final float position) {
            this.distance = position;           
        }

        public float getDistanceFrom () {
            return distance;
        }

        @Override
        public String toString() {
            return "Player [distance=" + distance + "]";
        }
    }

    public static void main(String[] args) throws Exception {
        final ArrayList<Player> players = new ArrayList<Player> ();

        players.add (new Player (2));
        players.add (new Player (5));
        players.add (new Player (-3));
        players.add (new Player (1));

        Collections.sort(players, new Comparator<Player> () {
            @Override
            public int compare(Player o1, Player o2) {
                final float distance1 = o1.getDistanceFrom();
                final float distance2 = o2.getDistanceFrom();
                return (int) Math.signum (distance1 - distance2);
            }           
        });
        System.out.println(players);
    }
}

还有一个fiddle。