Question

我有一个结构列表，我想根据结构的特定元素进行排序：

private class myStruct {

    public Boolean GUI;
    public float CallTime;
    public String ReqID;
    public String ReqGUID;
    public String Stereotype;
    public String StereotypeGUID;

}

private List<myStruct> DataList = new ArrayList<myStruct>();

如何在没有硬编码的情况下按“ReqID”元素对DataList进行排序？是否有可能使用Arrays.sort()？

Answer 1

您应该使用Comparator。

 class YourComparator implements Comparator<myStruct>{

         public int compare(myStruct s1, myStruct s2){
              //here comes the comparison logic
         }
 }

然后使用sort()方法的这种形式：

 Arrays.sort(T[] arrayToSort, Comparator<T> yourComparator);

使用集合或数组作为数据结构还不是很清楚。

如果您使用列表，请使用Collections.sort()。

Answer 2

对于自定义排序，您可以实现Comparable界面。

使用此界面，您可以创建一个方法compareTo()，该方法返回一个负数，0或正数。基于返回码Collections.sort()可以判断元素是否必须在另一个元素之前或之后。

如何使用它的一个很好的例子可以在这个答案中找到：java class implements comparable

Answer 3

像这样使用Comparator界面

public static void main(String[] args) {
    List<myStruct> DataList = new ArrayList<myStruct>();
    //ADD Objects to DataList here

    Collections.sort(DataList, new Comparator() {

        public int compare(Object o1, Object o2) {
            myStruct p1 = (myStruct) o1;
            myStruct p2 = (myStruct) o2;
            int ret = -1;
            //business logic here
            if (Integer.parseInt(p1.ReqGUID) == Integer.parseInt(p2.ReqGUID)) {
                ret = 0;
            } else if (Integer.parseInt(p1.ReqGUID) > Integer.parseInt(p2.ReqGUID)) {
                ret = 1;
            } else if (Integer.parseInt(p1.ReqGUID) < Integer.parseInt(p2.ReqGUID)) {
                ret = -1;
            }//end business logic
            return ret;
        }
    });

}

这里是Collections.sort（）方法，我实现了Comparator接口并重写了compare（）方法。这实际上将根据您在compare（）方法中实现的业务逻辑对列表进行排序;

Answer 4

你的班级结构对我来说很奇怪..你在私人班级里面有公共领域.. 理想情况下，您的字段应标记为私有，您可以使用getter和setter来访问它们。

至于你的问题，你可以看看为这类工作定义的两个重要界面： - http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Comparator.html和http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html ..

如果希望有多种方法来比较类实例，可以使用Comparator。您可以创建一个实现Comparator接口的类，并将此类的实例传递给Collections.sort（）方法以使用此Comparator进行排序。在这种情况下，compare（）方法用于完成比较工作。

或者，您只能通过使该类实现Comparable接口来关联比较类实例的一种方法。在这种情况下，您需要覆盖compareTo（）方法..

以下是使用Comparator的示例代码： -

public class MyComparator implements Comparator<Box> {
    @Override
    public int compare(Box box0, Box box1) {
        int w0 = box0.getWeight();
        int w1 = box1.getWeight();

        return (w0 > w1? -1 : (w0 == w1) ? 0 : 1);
    }
}

public class Box {
    private int weight;

    public Box() {      
    }

    public Box(int weight) {
            this.weight = weight;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

和你的主要

public class Main {

    public static void main(String args[]) {
        List<Box> boxList = new ArrayList<Box>();
        Collections.sort(boxList, new MyComparator());
    }
}

希望有所帮助......

Answer 5

您可以定义自己的Comparator并使用Collections.sort()，将比较器传入。这样您就可以定义不同的比较器，以便使用不同的字段进行搜索。

或者，您的结构可以实现Comparable接口，Collections.sort()可以使用此进行排序。这是使用自然排序顺序调用的，因为它隐含在您的类中。

这里是Java tutorial on sorting and ordering。

Answer 6

将java.util.Collections.sort()与Comparator实例一起使用。请参阅JavaDocs。

Answer 7

使用Arrays.sort(T[] a, Comparator<? super T> c)

或Collections.sort(List a, Comparator c)

Answer 8

最简单的解决方案

只需在您的类中实现java.lang.Comparable接口，如下所示：

class MyStruct implements Comparable<MyStruct>{

  public Boolean GUI;
  public float CallTime;
  public String ReqID;
  public String ReqGUID;
  public String Stereotype;
  public String StereotypeGUID;

  @Override
  public int compareTo(MyStruct other) {
    return ReqID.compareTo(other.ReqID); 
    /* also you can use ReqID.compareToIgnoreCase(other.ReqID); */
  }

  @Override
  public String toString() {
    return "(" + ReqID + ")";
  } 
}

还覆盖toString（）方法，仅用于打印。

另外，请记住 String的compareTo（）方法使用词典顺序进行排序。如果您需要数字ID，最好使用 int 或其他数字类型。以下是使用Arrays.sort（）以及Collections.sort（）进行排序的完整代码 - 选择适合您的选项：）

public class MyStructSort {

  private final static String[] STRUCT_IDS = {"C", "D", "A", "Aa", "B", "Z", "Aaa" };

  private static List<MyStruct> createList() {

    List<MyStruct> structList  = new ArrayList<MyStruct>();
    for (String id: STRUCT_IDS) {
      MyStruct struct = new MyStruct();
      struct.ReqID = id;
      structList.add(struct);
    }
    return structList;
  }

  public static void main(String[] args) {

    List<MyStruct> dataList = createList();

    /* Sort using Lists (Collections) */
    Collections.sort(dataList);
    System.out.println("List sort:\t" + dataList);

    /* Sort using arrays */
    MyStruct[] dataArray = dataList.toArray(new MyStruct[dataList.size()]); 
    Arrays.sort(dataArray);
    // print sorted array
    System.out.print("Array sort:\t");
    for (MyStruct struct: dataArray) {
      System.out.print(struct+" ");                        
    }
  }
}

这只是演示代码，因此需要一些空检查和getter以及setter才能使其完美。

如何在java中按结构元素对结构列表进行排序

8 个答案: