Java通用节点数组

我正在用一个数组实现一个并发循环队列，该数组使用单独的锁 在队伍的头和尾。队列中的每个节点如下所示：

  private class Node<T> 
  {
        public T item;
        ReentrantLock lock = new ReentrantLock();
        Node(){}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
  }

我已找到解决方案，但此代码：

@SuppressWarnings("unchecked")
    Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];

@SuppressWarnings（“未选中”）
节点[]插槽=（节点[]）新节点[容量]；

给出以下编译器错误：

Cannot create a generic array of Queue<T>.Node<?>

无法创建Queue.Node的通用数组

我的问题是初始化泛型对象数组的正确方法是什么？

我认为

节点应该是静态的

private static class Node<T> 
{
    public T item;
    ReentrantLock lock = new ReentrantLock();

    void lock() {lock.lock();}
    void unlock() {lock.unlock();}
}

...

@SuppressWarnings("unchecked")
Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];

私有静态类节点
{
公共交通项目；
ReentrantLock=新的ReentrantLock（）；
void lock（）{lock.lock（）；}
void unlock（）{lock.unlock（）；}
}
...
@抑制警告（“未选中”）
节点[]插槽=（节点[]）新节点[容量]；

一般来说，我们有两种选择：

非静态类

public class Queue2<T> {

    public Queue2(int capacity) {   

        Queue2<T>.Node2[] slots2 =  new Queue2.Node2[capacity];     
    }


    private class Node2 
    {
        private T item;
        ReentrantLock lock = new ReentrantLock();

        public Node2(Object object) {}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

public class Queue<T>  {

    public Queue(int capacity) {

        Queue.Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];
    }   

    private static class Node<T> 
    {
        public T item;
        ReentrantLock lock = new ReentrantLock();

        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

公共类队列2{
公共队列2（整数容量）{
Queue2.Node2[]slots2=新队列2.Node2[容量]；
}
私有类节点2
{
私人物品；
ReentrantLock=新的ReentrantLock（）；
公共节点2（对象）{}
void lock（）{lock.lock（）；}
void unlock（）{lock.unlock（）；}
}
}

静态类

public class Queue2<T> {

    public Queue2(int capacity) {   

        Queue2<T>.Node2[] slots2 =  new Queue2.Node2[capacity];     
    }


    private class Node2 
    {
        private T item;
        ReentrantLock lock = new ReentrantLock();

        public Node2(Object object) {}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

public class Queue<T>  {

    public Queue(int capacity) {

        Queue.Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];
    }   

    private static class Node<T> 
    {
        public T item;
        ReentrantLock lock = new ReentrantLock();

        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

公共类队列{
公共队列（整数容量）{
Queue.Node[]slots=（Node[]）新节点[容量]；
}   
私有静态类节点
{
公共交通项目；
ReentrantLock=新的ReentrantLock（）；
void lock（）{lock.lock（）；}
void unlock（）{lock.unlock（）；}
}
}

第一个示例中的节点类称为
Queue2.node
，而第二个示例中的节点类称为
Queue.node

在这里显示的两个备选方案中，第二个更可取。不是
静态方法通过包含对封闭实例的引用来实现，因为它们通常可以访问该实例的组件。静态嵌套类通常既简单又高效

我认为
节点
应该是静态的

private static class Node<T> 
{
    public T item;
    ReentrantLock lock = new ReentrantLock();

    void lock() {lock.lock();}
    void unlock() {lock.unlock();}
}

...

@SuppressWarnings("unchecked")
Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];

私有静态类节点
{
公共交通项目；
ReentrantLock=新的ReentrantLock（）；
void lock（）{lock.lock（）；}
void unlock（）{lock.unlock（）；}
}
...
@抑制警告（“未选中”）
节点[]插槽=（节点[]）新节点[容量]；

一般来说，我们有两种选择：

非静态类

public class Queue2<T> {

    public Queue2(int capacity) {   

        Queue2<T>.Node2[] slots2 =  new Queue2.Node2[capacity];     
    }


    private class Node2 
    {
        private T item;
        ReentrantLock lock = new ReentrantLock();

        public Node2(Object object) {}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

public class Queue<T>  {

    public Queue(int capacity) {

        Queue.Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];
    }   

    private static class Node<T> 
    {
        public T item;
        ReentrantLock lock = new ReentrantLock();

        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

公共类队列2{
公共队列2（整数容量）{
Queue2.Node2[]slots2=新队列2.Node2[容量]；
}
私有类节点2
{
私人物品；
ReentrantLock=新的ReentrantLock（）；
公共节点2（对象）{}
void lock（）{lock.lock（）；}
void unlock（）{lock.unlock（）；}
}
}

静态类

public class Queue2<T> {

    public Queue2(int capacity) {   

        Queue2<T>.Node2[] slots2 =  new Queue2.Node2[capacity];     
    }


    private class Node2 
    {
        private T item;
        ReentrantLock lock = new ReentrantLock();

        public Node2(Object object) {}
        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

public class Queue<T>  {

    public Queue(int capacity) {

        Queue.Node<T>[] slots = (Node<T>[]) new Node<?>[capacity];
    }   

    private static class Node<T> 
    {
        public T item;
        ReentrantLock lock = new ReentrantLock();

        void lock() {lock.lock();}
        void unlock() {lock.unlock();}
    }
}

公共类队列{
公共队列（整数容量）{
Queue.Node[]slots=（Node[]）新节点[容量]；
}   
私有静态类节点
{
公共交通项目；
ReentrantLock=新的ReentrantLock（）；
void lock（）{lock.lock（）；}
void unlock（）{lock.unlock（）；}
}
}

第一个示例中的节点类称为
Queue2.node
，而第二个示例中的节点类称为
Queue.node

在这里显示的两个备选方案中，第二个更可取。不是
静态方法通过包含对封闭实例的引用来实现，因为它们通常可以访问该实例的组件。静态嵌套类通常既简单又高效

有两种其他方法可以使此文件编译

使
节点
成为公共类

将
节点保持为私有、非静态类，并从实例化中删除通配符：

节点[]插槽=（节点[]）新节点[容量]

有两种其他方法可以使此文件编译

使
节点
成为公共类

将
节点保持为私有、非静态类，并从实例化中删除通配符：

节点[]插槽=（节点[]）新节点[容量]

可能这个问题有帮助：可能重复的，请参阅已接受的答案。可能这个问题有帮助：可能重复的，请参阅已接受的答案。