Question

我自己在学习算法，并尝试在LinkedList中使用通用类型从头开始实现Java。我有一个Object的版本效果很好，但是当我使用泛型类型更新它时，它会发出警告。任何人都可以帮助“未经检查或不安全的操作”来自哪里？

class LinkedListGeneric <T> {
    private Node<T> head; 
    private int size;

    public LinkedListGeneric() {
       head = null;
       size = 0; 
    }

    public int size() {
        return size;
    }

    public void add (T data) {
        if (head == null) {
            head = new Node<T> (data);
            size = 1;
        }
        else {
            Node<T> temp = new Node<T> (data);
            search(size).setNext(temp);
            size++;
        }
    }

    public void add (T data, int position) {
        if (position > size + 1 || position <= 0) {
            System.out.println ("error.");
            return;
        }
        Node<T> temp = new Node<T> (data);
        if (position == 1) {
            temp.setNext(head);
            head = temp;
            return;
        }
        Node<T> prev = search(position - 1);
        temp.setNext(prev.getNext());
        prev.setNext(temp);
    }

    public void delete (int position) {
        if (position > size || position <= 0) {
            System.out.println ("error.");
            return;
        }
        if (position == 1) {
            size--;
            head = head.getNext();
            return;
        }
        Node<T> prev = search(position - 1);
        prev.setNext(prev.getNext().getNext());
        size--;
    }

    public T getValue (int position) {
        if (position > size || position <= 0) {
            System.out.println ("error.");
            return null;
        }
        Node<T> temp = search(position);
        return temp.getData();
        //return search(position).getData();
    }

    public int searchData(T data) {
        Node<T> temp = head;
        int position = 1;
        boolean flag = false;
        while (temp != null) {
            if (temp.getData() == data) {
                flag = true;
                break;
            }
            else {
                temp = temp.getNext();
                position++;
            }
        }
        if (flag) return position;
        else return -1;
    }

    public void print() {
        Node<T> temp = head;
        int position = 1;
        while (temp != null) {
            System.out.println("Node " + position + ": " + temp.getData());
            temp = temp.getNext();
            position++;
        }
    }

    private Node<T> search (int position) {
        Node temp = head;
        while (position > 0) {
            temp = temp.getNext();
        }
        return temp;
    }

    private class Node<T> {
        private T data;
        private Node<T> next;
        public Node() {
           this.data = null;
           next = null; 
        }

        public Node(T data) {
           this.data = data;
           next = null; 
        }

        public T getData() {
            return data;
        }

        public Node getNext() {
            return next;
        }
        public void setNext(Node next) {
            this.next = next;
        }
    }
}

Answer 1

我看到的问题是，Node.getNext来电正在返回Node而不是Node<T>。这相当于返回Node<Object>而不是泛型类型的方法。

所以，你应该改变：

public Node getNext() {
    return next;
}

到

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

Answer 2

尽管sbochin的回答将解决您的一些警告，但执行以下操作将解决所有问题：

使用T替换Node课程中T2的所有getNext个实例，包括课程声明中的Node<T2>。
将setNext的回报更改为Node<T2>
将temp中的参数类型更改为search。
将Node<T>中@SuppressWarnings("unused")的类型更改为public Node()。
您可能还想将Node添加到LinkedListGeneric<T>，因为这也会生成编译器警告。

您可能还希望将Node类设为静态类，因为它的方法都不依赖于它所在的{{1}}对象。

完全或者，您可以从{{1}}中删除类型参数，除了未使用的警告之外，它会删除所有警告。但是，你必须让你的班级保持非静止状态。

需要有关未经检查的操作java的帮助

2 个答案: