相关疑难解决方法(0)

public K[] toArray()
{
    K[] result = (K[])new Object[this.size()];
    int index  = 0;
    for(K k : this)
        result[index++] = k;
    return result;
}

这段代码似乎不起作用,它会抛出异常:

java.lang.ClassCastException:[Ljava.lang.Object; 不能投...

有人能告诉我如何创建一个泛型类型的数组？谢谢.

可能重复:
Java如何:创建通用阵列

如何T[]在Java中创建类型数组？我无法使用,Arrays.newInstance()因为我没有任何对象Class<T>.是否有newInstance某个地方的通用版本？

我的方法原型如下:

public <T> T[][] distribute(T ... balls) {
   T[][] answer = ????

   // filling answer with data

   return answer;

}

UPDATE

对不起上面的例子,我可以上课balls.但是假设我没有这样的变量.

public <T> T[][] distribute() {
   T[][] answer = ????

   // filling answer with data

   return answer;

}

要么

class<T> {
   public T[][] distribute() {

      T[][] answer = ????

      // filling answer with data

      return answer;

   }
}

UPDATE2

此示例也不起作用:

public abstract class GenericArray<T> {

abstract …

我有Class<T>构造函数中提供的对象的泛型类型.我想T[][]在这个构造函数中创建二维数组,这可能吗？

我正在尝试使用以下两种方式创建数组：

方式#1-->

// 1-D String Array
String[] strs1 = new String[8];

// 2-D String Array
String[][] array1 = new String[8][8];

方式#2-->

// 1-D String Array
String[] strs1 = (String[]) Array.newInstance(String.class, 8);

// 2-D String Array
String[][] array2 = (String[][]) Array.newInstance(String.class, 8, 8);

以上两种创建数组的方式有什么区别？*哪个更好？* 请帮我解决这个问题。提前致谢！

我的问题很简单：

我的通用类中有以下方法（类型参数为A和B）

public void add(A elem, int pos, B[] assoc)

我想做的是创建一个方法

public void add(A elem, int pos)

它用assoc中的空Array调用upper方法。到目前为止，我没有找到解决方案，因为Java不允许实例化泛型类型的数组。

我正在编写一些java代码，我想在我的主类Array中编写方法。该类实现了 ImplementableClass。前者扩展了 Iterable。Array 类有一个类型。

实现类.java：

public interface ImplementableClass<E> extends Iterable<E>{

    public void insertObject(E obj);

    public E removeObj(E obj);

}

主要.java:

public class Array<Integer> implements ImplementableClass<E>{
    public void insertObject(E obj){

    }

    public E removeLastObject(E obj){

    }

    //... main method and others below...
}

我对上面两个文件中的代码有一些疑问。

阅读java文档，Iterable是E类型（泛型值）。据我了解，接口只是“实现”它们的类中必须使用的方法的“蓝图”。从基本的角度来看，这里不应该有任何变数。话虽如此，您可能会看到，我确实也在 Main 的 ImplementableClass 中声明了这些方法。话虽这么说，我有几个问题：

1. 当在我的 Array 类中声明 ImplementableClass 类的方法时，这会“覆盖”我的 ImplementableClass 类中的方法，对吗？

2. 由于“E obj”是两种方法中的参数，因此每当我在 Array 类中声明我的方法时，它们是否必须相同？我应该将什么传递给方法？“E obj”是什么意思？

3. 我想创建一个可以保存 E 类型对象的数组。这意味着每当我实例化一个新对象时，Array<Integer> theArray = new Array<Integer>我都可以在 Array 实例上调用 Array 类上的方法，对吗？（即 theArray.removeLastObject() ）我应该传递什么作为参数？

4. 为什么Iterable<E>在这种情况下有用？

我正在写一棵B树，它的一个节点可能有很多键，我遇到了一个问题。当我创建一个Int数组时，一切正常：

class Node<K: Comparable<K>> (val t: Int) {
    val keys: Array<Int?> = Array<Int?> (t*2-1, {null})
}

但我想创建一个泛型K数组：

class Node<K: Comparable<K>> (val t: Int) {
    val keys : Array<K?> = Array<K?> (t*2-1, {null})
}

在这种情况下，编译器会抛出以下错误消息：

'Kotlin: Cannot use 'K' as reified type parameter. Use a class instead.'

问题是如何创建泛型数组？

UPD：感谢所有回复！看来MutableList对于我的目标来说是一个很好的解决方案。

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

我有以下方法:

public static <T, U> T[] getKeysForValue(Map<T,U> map,U value){
    if(map == null || map.isEmpty()) {
        return null;
    }

    Set<T> keys = new HashSet<T>();

    for (Map.Entry<T,U> entry : map.entrySet()) {
        if (entry.getValue().equals(value)) {
            keys.add(entry.getKey());
        }
    }

    return keys.toArray(new T[keys.size()]);
}

我在线路上遇到编译错误:keys.toArray(new T[keys.size()])"无法创建T的通用数组",这很明显.我该如何解决这个问题？

我试图在Kotlin中基于java数组实现检查 。但是我将KClass与允许空值的通用参数类型一起使用时遇到问题。Stack<E><E>

interface Stack<E> {
    fun push(elem: E)
    fun pop(): E
}

class CheckedStack<E>(elementType: Class<E>, size: Int) : Stack<E> {

    companion object {
        inline fun <reified E> create(size: Int): CheckedStack<E> {
            //**compile error here**
            return CheckedStack(E::class.javaObjectType, size)
        }
    }

    @Suppress("UNCHECKED_CAST")
    private val array: Array<E?> = java.lang.reflect.Array.newInstance(elementType, size) as Array<E?>
    private var index: Int = -1

    override fun push(elem: E) {
        check(index < array.size - 1)
        array[++index] = elem …