Сопоставимый < type > массив VS Сравнимый массив

Question

У меня есть класс Point, который реализует Comparable. Я хочу сделать Point f = arr[first];

Теперь, я прочитал, что использование необработанного типа Comparable и т. Д. Плохо. Итак, если я делаю arr[] типа Comparable<Point>[] вместо Comparable[] Что я буду делать неправильно?

Это украденный код, мне понравилось, и я украл его.

private static void sort(Comparable[] a, Point compPoint, int lo, int hi) { 
    if (hi <= lo) 
     return; 
    int lt = lo; 
    int gt = hi; 
    int i = lo; 
    int count = 0; 
    Comparator comp = compPoint.SLOPE_ORDER; 
    Comparable v = a[lo]; 
    ArrayList<Point> line = new ArrayList<Point>(); 
    line.add(compPoint); 
    while (i <= gt) { 
     int cmp = comp.compare(a[i], v); 
     if (cmp < 0) 
      exch(a, lt++, i++); 
     else if (cmp > 0) 
      exch(a, i, gt--); 
     else { 
      count++; 
      line.add((Point) a[i]); 
      i++; 
     } 
    } 
    if (count >= 3) { 
     Collections.sort(line, new Comparator<Point>() { 
      public int compare(Point v, Point w) { 
       return v.compareTo(w); 
      } 
     }); 
     for (int j = 0; j < line.size(); j++) { 
      if (j == line.size() - 1) 
       StdOut.println(line.get(j).toString()); 
      else 
       StdOut.print(line.get(j).toString() 
        + " -> "); 
     } 

     line.get(0).drawTo(line.get(line.size() - 1)); 
    } 

    sort(a, compPoint, lo, lt - 1); 
    sort(a, compPoint, gt + 1, hi); 
} 



private static void exch(Comparable[] a, int v, int w) { 
    Comparable tmp = a[v]; 
    a[v] = a[w]; 
    a[w] = tmp; 
} 

Я хочу знать, есть ли лучший способ, чем иметь сырой тип.

Answer 1

Нет ничего плохого в реорганизации кода для использования генериков. Кажется, что этот метод используется только для Point s, поэтому я бы пошел с Point[] вместо Comparable<Point>[]. Из того, что я вижу, вам также придется реорганизовать класс Point и метод compare Comaprator SLOPE_ORDER.

Если вам разрешено, просто загрузите весь код и отредактируйте его. Если он скомпилирует все будет хорошо, то это точка java generics: это помогает во время компиляции ничего плохого. Во время работы все это в любом случае из-за type erasure.

Answer 2

Как теперь, вы могли бы назвать это так:

String[] array = {"a", "b"}; 
sort(array, point, 1, 2); 

Очевидно, что это смешно. Сравнивая String с точкой, нет смысла.

Кажется, что код в методе будет работать для любого сопоставимого типа. Рассмотрите возможность изменения подписи, таким образом:

private static <T extends Comparable<T>> void sort(T[] a, T comp, int lo, int hi) { 

Answer 3

Вот куча вещей, которые вы должны сделать:

• class Point implements Comparable должен стать class Point implements Comparable<Point>
• Comparator должен стать Comparator<Point>
• Заменить Comparable[] с Point[] - если вы собираетесь отбросить элементы до Point s, вы можете также объявить их как точки

• Заменить

  Collections.sort(line, new Comparator<Point>() { 
      public int compare(Point v, Point w) { 
       return v.compareTo(w); 
      } 
  }); 
  

  с менее избыточными

  Collections.sort(line);