3

好的，假设我有一个如下所示的对象数组： obj(from, to) 我想通过比较 from 和 to 对该数组进行排序。我想要做的一个例子：假设我有这些参数的对象 (0,2) (2,4) (0,3) (4,5) (2,3)
我希望对象按此顺序排序: (0,2) (0,3) (2,3) (2,4) (4,5)

我希望比较前两个“来自”变量并将较低的变量放在前面。如果它们相等，那么我想要比较第二对数字。为此，我创建了一个比较方法

public int compare (EdgeI e1, EdgeI e2) {
  if(e1.from < e2.from) { return -1; }
  else if(e1.from == e2.from) {
    if(e1.to < e2.to) { return -1; }
    else if(e1.to == e2.to) { return 0; }
    else if(e1.to > e2.to) { return 1; }
  }
  return 1;
}

这行得通吗？如果是这样，我将如何通过数组运行这种排序？谢谢你的帮助。

编辑

    public class mySorter implements Comparator <EdgeI> {

  public int compare(EdgeI e1, EdgeI e2) {
    if(e1.from < e2.from) { return -1; }
    else if(e1.from == e2.from) {
      if(e1.to < e2.to) { return -1; }
      else if(e1.to == e2.to) { return 0; }
      else if(e1.to > e2.to) { return 1; }
    }
    return 1;
  }

  public void sorterM () {
    Collections.sort(tet2, new mySorter());
  }

}

我收到错误集合无法解析，并且 tet2 无法解析。Tet2 是另一个类中的公共列表。

4

3 回答 3

2

您可以做的是创建一个实现Comparator<Edge>. 然后，您可以使用您的 compare 方法从接口实现该方法。

完成此操作后，您可以使用比较器对Edge对象列表进行排序Collections.sort()。

这看起来像这样：

import java.util.Collections;
import java.util.List;
import java.util.Comparator;

public class EdgeComparator implements Comparator<Edge> {
    public int compare(Edge l, Edge r) { ... }
}

void yourCode() {
    List<Edge> edges = ...;
    Collections.sort(edges, new EdgeComparator());
    //edges now contains the sorted edges
}

这是关于Comparator和Collections.sort的 javadoc 。

如果你有一个数组而不是一个列表，你可以像使用Array.sort一样使用 Array.sort Collections.sort。

于 2012-10-12T00:37:20.547 回答
1

您可以使您的 EdgeI 对象具有可比性，也可以创建一个单独的比较器来处理比较 EdgeI 对象。在这种情况下，（假设您编写了 EdgeI 类），更面向对象的方法是实现 Comparable。

public class EdgeI implements Comparable<EdgeI> {
    ...
    public int compareTo(EdgeI other) {
        // implement your compare method to use this and other instead of e1 and e2
    }
    ...
}

然后，您可以使用 plain ，该方法将根据继承方法指定的自然顺序Arrays.sort对边缘进行排序。compareTo

EdgeI[] edges = ...;
Arrays.sort(edges);

或者，您可以实现一个 Comparator 并将其与目标数组一起传递给 sort 方法以进行排序。

public class EdgeComparator implements Comparator<EdgeI> {

    public int compare(EdgeI e1, EdgeI e2) {
        // your method in its exact format
    }
}

然后对其进行排序：

EdgeI[] edges = ...;
Arrays.sort(edges, new EdgeComparator());
于 2012-10-12T00:37:50.003 回答
0

迟到了，但这是一种可能的实施方式。您可以通过在方法中调用 Collections.sort 来避免将比较器设为静态，而不是在主方法中，这实际上是您会做的。请注意，有两个比较器。如果您希望有不止一种排序方式，即在这种情况下是升序与降序，您可以随意进行任意数量的排序。这只是一个调用Collections.sort(edges, ORIGINAL);或的问题Collections.sort(edges, REVERSE);。

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

public class EdgeI{

    private int from;
    private int to;

    public EdgeI(int f, int t)
    {
        from = f;
        to = t;
    }

    public void setFromTo(int f, int t)
    {
        from = f;
        to = t;
    }

    public int getFrom()
    {
        return from;
    }

    public int getTo()
    {
        return to;
    }

    public final static Comparator<EdgeI> REVERSE = new Comparator<EdgeI>()
    {
    @Override
    public int compare(EdgeI e1, EdgeI e2)
    {
        if(e1.from < e2.from)
            return 1;
        if(e1.from > e2.from)
            return -1;
        //else they are equal
        if(e1.to < e2.to)
            return 1;
        if(e1.to > e2.to)
            return -1;
        //else both edges are equal
        return 0;
    }
    };

    public final static Comparator<EdgeI> ORIGINAL = new Comparator<EdgeI>()
    {
    @Override
    public int compare(EdgeI e1, EdgeI e2)
    {
          if(e1.from < e2.from) { return -1; } 
          else if(e1.from == e2.from)
          { 
            if(e1.to < e2.to) { return -1; } 
            else if(e1.to == e2.to) { return 0; } 
            else if(e1.to > e2.to) { return 1; } 
          } 
          return 1; 
    } 
    };

    public static void main(String[] args) {
        ArrayList<EdgeI>edges = new ArrayList<EdgeI>(5);
        edges.add(new EdgeI(0, 2));
        edges.add(new EdgeI(2, 4));
        edges.add(new EdgeI(0, 3));
        edges.add(new EdgeI(4, 5));
        edges.add(new EdgeI(2, 3));

        System.out.println("\nBefore sorting:");
        for(EdgeI i : edges)
            System.out.println("("+i.getFrom()+", "+i.getTo()+")");

        Collections.sort(edges, ORIGINAL);

        System.out.println("\nAfter sorting:");
        for(EdgeI i : edges)
            System.out.println("("+i.getFrom()+", "+i.getTo()+")");

    }
}
/*
Output on the console:

Before sorting:
(0, 2)
(2, 4)
(0, 3)
(4, 5)
(2, 3)

ORIGINAL:
After sorting:
(0, 2)
(0, 3)
(2, 3)
(2, 4)
(4, 5)

REVERSE:
After sorting:
(4, 5)
(2, 4)
(2, 3)
(0, 3)
(0, 2)
*/
于 2012-10-12T01:24:54.570 回答