相关疑难解决方法(0)

我有一个类,我需要构造函数来初始化变量数组.我在互联网上研究并堆栈溢出但现在我仍然坚持如何调用该方法.例如,我怎么能在我的例子中调用method1？

public class SomeClass<T>{

   public T[] array;

   //Constructor
   public SomeClass()
   {
        Method1(T, 5); //?  error
        Method1(5); //?   error
        Method1(new T().GetType(), 5); //? error
        // HOW CAN I CALL THAT METHOD?

        array = (T[])(new Object[5]); // this gives an error too
   }

   private void Method1(Class<T> type, int size)
   {
       array = (T[])Array.newInstance(type, size);
   }
}

我无法确定以下RHS预期的类型参数

ArrayList<Pair<ParseNode,ParseNode>>[] nodes = new ArrayList[indexes.length];

为什么副本<Pair<ParseNode,ParseNode>>不合法？

如何创建泛型类型的数组？泛型Arrays.copyOf()方法如何工作？它返回泛型数组的副本.因此可以创建通用数组.但是怎么样？如何编写类似的方法copyOf()？

我有以下代码

public class Container<T> {
    private T element;
    private T[] tarray;

    public T getElement() {
        return element;
    }

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

    public void add(T element) {
        tarray[0] = element;
    }

    public void CreateArray(int size) {
        //Can this be cleaned up better?
        tarray = (T[]) new Object[size];
    }

    public T get() {
        return tarray[0];
    }

    public Container(T someElement) {
        this.element = someElement;
    }

    public Container() {
    }

    public static void main(String[] args) {
        Container<String> myContaier1 …

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

上面的代码是从取此以下职位:

E通用类类型在哪里.当我们使用Object类型实例化数组时,编译器/ JVM如何知道需要分配多少内存.我的理解是,类型转换只允许更改引用类型,但不允许更改底层对象结构.

我编写了这个类,可以使用构建器模式构建类型为T的数组,将值存储在闭包中,直到实际构造数组.

public class ArrayBuilder<T> {

    final Class<T> type;

    public ArrayBuilder(Class<T> type){
        this.type = type;
    }

    private Supplier<Supplier<Store>> start = () -> {
        final Store element = new Store(-1, null, null);
        return () -> element;
    };

    private class Store {
        final Integer index;
        final T val;
        final Supplier<Store> getNextVal;

        public Store(Integer index, T val, Supplier<Store> getNextVal) {
            this.index = index;
            this.val = val;
            this.getNextVal = getNextVal;
        }
    }

    private Supplier<Store> queue(Integer index, T value, Supplier<Store> next) {
        final Store element = …

可能重复:
在Java中创建泛型类型的实例？
Java如何:通用阵列创建

我正在尝试创建一个泛型类.这是我的类文件.

public class TestClass<T> implements AbstractDataType<T>{

    T[] contents;

    public TestClass(int length) {
        this.contents = (T[])new Object[length];
    }
}

但内容只有从中继承的方法Object class.如何为内容创建抽象数组？

我有这个代码,它给我一个错误,"无法创建一个BST_Node的通用数组"

    BST_Node<Integer>[] arrayTree = new BST_Node<Integer>[treeSize];

我不知道为什么,因为我有

    Integer[] arrayTree = new Integer[treeSize];

它完美无缺.为什么它不能创建具有泛型类型的固定大小数组,这是正确的方法吗？

虽然此代码成功编译,但它会在运行时抛出类转换异常错误:

class Test {
    public static void main(String[] args) {
        MyArray<String> x = new MyArray<>();
        x.a[0] = "test string";
    }
}

class MyArray<T> {
    T[] a;

    MyArray() {
        this.a = (T[]) new Object[1];
    }
}

错误消息:

Exception in thread "main" java.lang.ClassCastException:
[Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
    at Test.main(Test.java:4)

我知道的一个可能但简单的解决方案是将数组声明为Object类型的数组,然后在想要从数组中检索数组时将数组元素转换回T,如下所示:

class Test {
    public static void main(String[] args) {
        MyArray<String> x = new MyArray<>();
        x.a[0] = "test string";
        System.out.println(x.get(0));
    }
}

class MyArray<T> {
    Object[] a;

    MyArray() { …

我在许多答案(例如,这个)中看到,使用泛型创建数组的方法如下:

T[] array = (T[]) new Object[SIZE];

我想尝试做类似的事情:

EntryRecipient<K,V>[] array = (EntryRecipient<K,V>[]) new Object[MAX_SIZE];

但是,这不起作用,抛出以下错误:

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [LHashTable$EntryRecipient;

我的代码是:

HashTableEntry(包含在HashTable的私有子类中)

class HashTableEntry<K,V> {
    private K key;
    private V value;

    public HashTableEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public V value() {
        return value;
    }

    public K key() {
        return key;
    }
}

EntryRecipient(作为HashTable的私有子类包含)

private class EntryRecipient<K,V> {
    private List<HashTableEntry<K,V>> entries;

    public EntryRecipient() { …