コンパイラとジェネリックスでリンクされたリストをソートするjava

Question

ジェネリックスでリンクリストをソートしようとしていますが、いくつかのキャストに関する問題があります。コードは投げているバスは、ノードにキャストすることはできません。私は問題がコンパイラ（私はバスにキャスト）であることを知っているが、そうでなければ、私はバスで定義されたメソッド（バスまたは別のオブジェクトであるかどうかは無関係でテストする）私はインターネットを研究してきましたが、解決策を見つけることができませんでした。ここでは、コードは次のようになります。

/** 
* Swaps the current node's element with the previous one 
*/ 
public void swap(){ 
    Object previous = getCurrent().getElement(); 
    Object current = next().getElement(); 
    getCurrent().setElement(previous); 
    previous().setElement(current); 
} 

public AbstractList<T> orderBy(Comparator<Node<T>> comparator){ 
    setCurrent(getFirst()); 
    Node<T> aux; 
    Node<T> current; 
    boolean check = true; 
    while (check){ 
     check = false; 
     aux = getFirst(); 
     current = getFirst().getNext(); 
     while(hasNext()) { 
      if (comparator.compare(aux, current) > 0) { 
       check = true; 
       swap(); 
      } 
      aux = current; 
      current = current.getNext(); 
     } 
    } 
    return this; 
} 

コンパレータ：

import java.util.Comparator; 
public class InternComparator implements Comparator<Node<Bus>>{ 

@Override 
public int compare(Node<Bus> o1, Node<Bus> o2) { 
return ((Bus)o1.getElement()).getIntern() - ((Bus)o2.getElement()).getIntern(); 
     } //getIntern() returns an Integer 

AbstractList（教授によって与えられた）：

import java.util.NoSuchElementException; 
public class AbstractList<T> { 
    private Node<T> first; 
    private Node<T> current; 
    private Node<T> last; 
    private int size = 0; 


    public boolean hasNext(){ 
     return current != last; 
    } 

    public boolean hasPrevious(){ 
     return current != first; 
    } 

    public Node getCurrent(){ 
     return current; 
    } 

    public void setCurrent(Node<T> current) { 
     this.current = current; 
    } 

    public int size(){ 
     return size; 
    } 

    public boolean isEmpty(){ 
     return first == last || first == null; 
    } 

    public void add(T t){ 
     Node<T> a = new Node<T>(t); 
     if(first == null){ 
      first = a; 
     } 
     if(last == null && first != null){ 
      last = a; 
      last.setPrevious(first); 
      first.setNext(last); 
     } 

     Node<T> aux = last; 
     last.setNext(a); 
     last = a; 
     last.setPrevious(aux); 
     current = last; 
     size++; 
    } 

    public Node next(){ 
     if(!hasNext()){ 
      throw new RuntimeException("No elements available next."); 
     } 
     current = current.getNext(); 
     return current; 
    } 

    public Node previous(){ 
     if(!hasPrevious()){ 
      throw new RuntimeException("No elements available previous."); 
     } 
     current = current.getPrevious(); 
     return current; 
    } 

    public Node getFirst(){ 
     return first; 
    } 

    public Node getLast(){ 
     return last; 
    } 

    public void setFirst(Node<T> first){ 
     this.first = first; 
    } 

    public void setLast(Node<T> last) { 
     this.last = last; 
    } 

    public void remove(T t){ 
     current = first; 
     boolean removed = false; 
     while (hasNext()) { 

      if (current.getElement() == t || current.getElement().equals(t)) { 
       if(current != last && current != first) { 
        current.getNext().setPrevious(current.getPrevious()); 
        current.getPrevious().setNext(current.getNext()); 
       } else if(current == first){ 
        current.getNext().setPrevious(null); 
       } else if(current == last){ 
        current.getPrevious().setNext(null); 
       } 
       removed = true; 
       return; 
      } 

      current = next(); 
     } 

     if(removed){ 
      size--; 
     } else { 
      throw new NoSuchElementException("No such element on the list."); 
     } 
    } 

    public Node goTo(int pos){ 
     if(pos > size){ 
      throw new ArrayIndexOutOfBoundsException("Inexistent Position"); 
     } 
     current = first; 
     for(int i = 0; i < pos; i++){ 
      current = next(); 
     } 
     return current; 
    } 

    public void insertAfter(T t){ 
     Node<T> aux = new Node<>(t); 
     if(current != last) { 
      Node<T> next = current.getNext(); 
      Node<T> previous = current; 
      current.getNext().setPrevious(aux); 
      current.setNext(aux); 
      aux.setNext(next); 
      aux.setPrevious(previous); 
     } else { 
      current.setNext(aux); 
      aux.setPrevious(current); 
      last = aux; 
     } 
     size++; 
    } 

    public void insertPrevious(T t){ 
     Node<T> aux = new Node<>(t); 
     if(current != first) { 
      Node<T> previous = current.getPrevious(); 
      Node<T> next = current; 
      current.getPrevious().setNext(aux); 
      current.setPrevious(aux); 
      aux.setNext(next); 
      aux.setPrevious(previous); 
     } else { 
      Node<T> aux1 = current; 
      current.setPrevious(aux); 
      first = aux; 
      first.setNext(aux1); 
     } 
     size++; 
    } 

    @Override 
    public String toString() { 
     String result = ""; 
     current = first; 
     while(hasNext()) { 
      result += current.getElement() + ""; 
      next(); 
     } 
     return result; 
    } 
} 

class Node<T> { 
    private Object element; 
    private Node<T> prev; 
    private Node<T> next; 

    public Node(T element){ 
     this.element = element; 
    } 

    public Node(T element, Node next){ 
     this.element = element; 
     this.next = next; 
    } 

    public Node<T> getNext() { 
     return next; 
    } 

    public Node<T> getPrevious() { 
     return prev; 
    } 

    public Object getElement() { 
     return element; 
    } 

    public void setNext(Node<T> next) { 
     this.next = next; 
    } 

    public void setPrevious(Node<T> prev) { 
     this.prev = prev; 
    } 

    public void setElement(Object element) { 
     this.element = element; 
    } 
} 

Answer 1

が再び考える：あなたのオブジェクトがタイプNode<Bus>です。 Busへのキャストが失敗するのはなぜですか？

また、言い換えると、Bus<People>は人間を表しているとしますか？

コンテナがある場合は、含まれている値を取得する必要があります。それはコンテナを鋳造することによって達成することはできません！

また、奇妙な絵を使い続けるためには、ボックスを卵と宣言して卵を箱から出してはいけません。あなたは箱を開き、卵を取る。