Сортировка массивов с парами цифр

Question

Хорошо, предположим, у меня есть массив объектов, которые выглядят так: obj (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; 
} 

Будет ли это работать? И если да, то как мне запустить этот массив через массив? Спасибо за любую помощь.

EDIT

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 - это публикация списка delcared в другом классе.

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 
} 

Вот Javadoc на Comparator и Collections.sort.

Если у вас есть массив вместо списка, вы можете использовать Array.sort так же, как Collections.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); 

В качестве альтернативы вы можете реализовать Компаратор и передать его методу сортировки вместе с целевым массивом для сортировки.

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

Late к партии, но вот один из возможных реализаций. Вы можете избежать статики компараторов, вызвав метод 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) 
*/