使用比较器和泛型对链表进行排序java

Question

我想用泛型对链表进行排序，但是我遇到了一些铸造问题。代码抛出总线不能被投射到节点。我知道问题出在比较器中（我转到Bus），否则我不知道如何调用Bus中定义的方法（无论是Bus还是其他对象，只是随机测试）。我一直在研究互联网，但找不到解决方案。下面是代码：

/** 
* 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>代表人类吗？

如果你有一个容器，那么你必须检索包含的值;这不能通过铸造容器来实现！

或者，为了继续使用奇怪的图片：通过将盒子声明为鸡蛋，您不会获得一个鸡蛋。你打开盒子，取出蛋。