我有一个结构列表，我想根据结构的特定元素对其进行排序：
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()？
您应该使用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().
对于自定义排序，您可以实现该Comparable接口。
使用此接口，您可以创建一个compareTo()返回负数0或正数的方法。根据返回码Collections.sort()可以判断元素是否必须在另一个元素之前或之后。
如何使用它的一个很好的例子可以在这个答案中找到：java class implements compatible
您的类结构对我来说看起来很奇怪..您在私有类中有公共字段..理想情况下，您的字段应该标记为私有，并且您可以使用 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() 方法。
这是使用比较器的示例代码： -
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());
}
}
希望能帮助到你..
像这样使用 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() 方法中实现的业务逻辑对您的列表进行排序；
最简单的解决方案
只需在您的类中实现 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 来使其完美。
您可以定义自己的Comparator并使用Collections.sort()，将 Comparator 传入。这样，您可以定义不同的比较器以使用不同的字段进行搜索。
或者，您的结构可以实现Comparable接口并Collections.sort()可以使用它进行排序。这称为使用自然排序顺序，因为它对您的类是隐含的。
java.util.Collections.sort()与Comparator实例一起使用。请参阅 JavaDocs。
利用Arrays.sort(T[] a, Comparator<? super T> c)
或者Collections.sort(List a, Comparator c)