Java排序中的Linkedlist实现不起作用

Question

我创建了自己的linkedlist。我想使用集合对我的linkedlist进行排序。排序方法。所以我将MyLinkedList类扩展到java。util。链接列表。我还创建了Comparator和Comparable实现。但两者都不起作用。请查找下面的代码。

//链接列表实现。

package com.java.dsa;

class Node<E> {
    E data;
    Node<E> nextLink;
    public Node(E data) {
        this.data = data;
    }
}

public class MyLinkedList<E> extends java.util.LinkedList<E>{

    private static final long serialVersionUID = 1L;
    private Node<E> firstNodePointer;
    private Node<E> nodePointer;

    public boolean isEmpty() {
        return nodePointer == null;
    }

    public boolean add(E data) {
        super.add(data);

        Node<E> node = new Node<E>(data);

        if (firstNodePointer == null) {
            firstNodePointer = node;
            nodePointer = node;
        }else{
            nodePointer.nextLink = node;
        }
        nodePointer = node;
        return true;
    }

    public boolean remove(Object data){
        super.remove(data);

        Node<E> counterNodePointer = firstNodePointer;
        Node<E> tempNodePointer = firstNodePointer;

        while (counterNodePointer != null && !counterNodePointer.data.equals(data)) {
            tempNodePointer = counterNodePointer;
            counterNodePointer = counterNodePointer.nextLink;
        }
        if(tempNodePointer.equals(firstNodePointer)){
            firstNodePointer = firstNodePointer.nextLink;
            return true;
        }
        else if(counterNodePointer != null && tempNodePointer != null){
            tempNodePointer.nextLink = counterNodePointer.nextLink;
            return true;
        }
        return false;
    }

    public void printList() {
        Node<E> counterNodePointer = firstNodePointer;
        while (counterNodePointer != null) {
            System.out.println(counterNodePointer.data);
            counterNodePointer = counterNodePointer.nextLink;
        }
    }
}

//测试链接列表

package com.java.dsa;

import java.util.Collections;
import java.util.Comparator;

//员工类

class Employee implements Comparable<Employee> {
    private String name;
    private int id;

    public Employee(String name, int id) {
        super();
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    @Override
    public String toString() {
        return this.name + " " + this.id;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Employee employee) {
        return this.id - employee.id;
    }
}

class EmployeeSort implements Comparator<Employee> {

    @Override
    public int compare(Employee emp1, Employee emp2) {

        if (emp2.getId() - emp1.getId() > 0)
            return 1;
        else
            return -1;
    }
}

public class TestLinkedList {
    public static void main(String[] args) {
        MyLinkedList<Employee> myList = new MyLinkedList<Employee>();

        for (int i = 10; i > 0; i--) {
            Employee emp = new Employee("Sohan "+i, i);
            myList.add(emp);
        }
        myList.printList();
        Collections.sort(myList, new EmployeeSort());
        myList.printList();
    }
}

Answer 1

java。util。LinkedList不是为子类化而设计的类，您的代码可能只是破坏了它的内部结构和不变量。

如果您想自己实现一个链表，但是想省去实现完整List接口的工作量，那么请使用AbstractList作为您的基类。这门课的明确目的正是你想做的。

Answer 2

事实上它是有效的。只是您的内部数据结构没有被集合更新。sort（），并且由于断言程序不在printList（）的输出上工作，并且这依赖于该数据结构，因此可以看到未触及的元素顺序。请改用此方法：

public void printParentDataStructure() {
  for ( E e : this ) System.out.println( e );
}

看到你的比较器完美地完成它的工作。所以你的问题是你有两个数据结构，并且没有保持它们同步。你的下一个问题可能是“我如何保持它们同步？”-嗯，本质上你应该重写每一个方法，并调用超级（），就像在add（）和删除（）中一样。别那么做！这完全是胡说八道。

很明显，您想要实现一个链表来学习数据结构，但是也许您应该首先更好地理解OOP编程的基本原理。