Jak uporządkować listę kodowanym przez element struktury w java

Question

mam listę kodowanym, że chciałbym, aby posortować według określonego elementu struktury:

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>(); 

Jak mogłem sort DataList według elementu "ReqID" bez zakodowania go? Czy istnieje możliwość użycia Arrays.sort()?

Answer 1

Możesz zdefiniować swój własny Comparator i użyć Collections.sort(), przekazując ten Komparator. W ten sposób możesz zdefiniować różne komparatory do wyszukiwania przy użyciu różnych pól.

Alternatywnie twoja struktura może implementować interfejs Comparable i może sortować używając tego. Nazywa się to przy użyciu sortowania naturalnego , ponieważ jest to niejawne dla twojej klasy.

Oto Java tutorial on sorting and ordering.

Answer 2

Powinieneś użyć Comparator.

class YourComparator implements Comparator<myStruct>{ 

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

a następnie użyć tej formy metodą sort():

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

To nie jest bardzo jasne, czy używasz zbieranie lub tablicę jako struktury danych.

Jeśli korzystasz z listy, użyj Collections.sort().

Answer 3

Do niestandardowego sortowania można wdrożyć interfejs Comparable.

Za pomocą tego interfejsu tworzy się metodę compareTo(), która zwraca liczbę ujemną, 0 lub liczbę dodatnią. Na podstawie kodu powrotu Collections.sort() można stwierdzić, czy element musi występować przed czy po innym elemencie.

Dobrym przykładem, jak go używać można znaleźć w tej odpowiedzi: java class implements comparable

Answer 4

Korzystając java.util.Collections.sort() z instancji Comparator. Zobacz JavaDocs.

Answer 5

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

lub Collections.sort(List a, Comparator c)

Answer 6

użyciu interfejs Komparator jak ten

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; 
     } 
    }); 

} 

Tutaj wewnątrz metody Collections.sort() Jestem wykonawczego interfejs Komparator i przesłanianie porównać() metoda. To faktycznie posortuje twoją listę w oparciu o logikę biznesową zaimplementowaną wewnątrz metody compare();

Answer 7

Najprostszym rozwiązaniem

Wystarczy wdrożyć java.lang.Porównywalne interfejs w was klasy jak następuje:

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 + ")"; 
    } 
} 

Zastąp także toString() metodę tylko do drukowania.

Ponadto, należy pamiętać, że CompareTo struny() metoda sortuje użyciu leksykograficznego zamówienia. Jeśli chcesz mieć identyfikatory numeryczne, lepiej jest użyć int lub innego typu liczbowego. Poniżej pełny kod uporządkować za pomocą Arrays.sort(), jak również Collections.sort() - wybrać to, co najbardziej Ci odpowiada :)

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+" ");       
    } 
    } 
} 

Jest to kod tylko demonstracja, więc niektóre null kontrole i pobierające i ustawiające byłby potrzebny, aby był idealny.

Answer 8

strukturę klasy wyglądać dziwnie na mnie .. Trzeba pól publicznych wewnątrz prywatnej klasie .. Idealnie wasze pola powinny być oznaczone jako prywatne i można mieć pobierające i ustawiające im dostęp ..

Co do twojego problem można również zapoznać się z dwóch ważnych interfejsów taht są określone dla tego rodzaju pracy: - http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Comparator.html i http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Comparable.html ..

użyć komparatora, gdy chcesz mieć wiele sposobów, aby porównać swoje wystąpienie klasy .. można po prostu utwórz klasę implementującą interfejs Komparatora i przekaż instancję tej klasy do Collections.sort() metoda użycia tego komparatora do sortowania .. W tym przypadku metoda compare() służy do porównania.

Alternatywnie, można powiązać tylko jeden sposób porównywania instancji klasy dokonując tej klasy realizacji porównywalnych interfejs .. W tym przypadku trzeba zastąpić metodę compareTo() ..

Oto przykładowy kod za pomocą komparatora: -

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; 
    } 
} 

a głównym

public class Main { 

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

Nadzieja to pomaga ..