Question

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

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

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是另一个类中的List delcared public。

Answer 1

您可以做的是创建一个实现Comparator<Edge>的类。然后，您可以使用比较方法从界面实现该方法。

完成此操作后，您可以使用比较器使用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。

如果您有数组而不是列表，则可以使用与Collections.sort相同的方式使用Array.sort。

Answer 2

您可以使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
    }
    ...
}

然后，您可以使用普通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());

Answer 3

晚会，但这是一个可能的实施。你可以通过调用方法中的Collections.sort而不是main来避免使Comparators变为静态，这实际上是你要做的。请注意，有两个比较器。你可以自由地想要有多种方法来排序，即在这种情况下，升序与降序。这只是调用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)
*/

用数字对排序数组

3 个答案: