相关疑难解决方法(0)

switch (dimensions) {
    case 1:  double[] array = new double[10];                     break;
    case 2:  double[][] array = new double[10][];                 break;
    case 3:  double[][][] array =  new double[10][][];            break;
    case 4:  double[][][][] array = new double[10][][][];         break;
    case 5:  double[][][][][] array = new double[10][][][][];     break;
    case 6:  double[][][][][][] array = new double[10][][][][][]; break;
    default: System.out.println("Sorry, too many dimensions");    break;
}

有没有办法以更好的方式完成上述工作？我希望它能够创建任意数量的数组,也...

假设我有一个带泛型参数T的泛型类,它是一个Number子类.我想在课程构建期间初始化一个T数组.可能吗？如果有,怎么样？如果不是为什么？

public class AClass<T extends Number>{

    private T array[];
    private int arrayOfInt[];

    public AClass(int size){
        arrayOfInt = new int[size];
        array = ? //what should I put here?
    } 
} 

当我正在开发一个涉及Java 8新流的项目时,我注意到当我调用Stream#toArray()一个流时,它返回的是一个Object[]而不是一个T[].惊讶,因为我是,我开始挖掘到Java 8的源代码,但没有找到任何原因,他们没有实现Object[] toArray();的T[] toArray();.这背后有什么理由,还是只是一致性？

编辑1:我在答案中注意到很多人说这是不可能的,但是这段代码片段会编译并返回预期的结果？

import java.util.Arrays;

public class Test<R> {

    private Object[] items;

    public Test(R[] items) {
        this.items = items;
    }

    public R[] toArray() {
        return (R[]) items;
    }

    public static void main(String[] args) {
        Test<Integer> integerTest = new Test<>(new Integer[]{
            1, 2, 3, 4
        });

        System.out.println(Arrays.toString(integerTest.toArray()));
    }

}

我想找到并重用(如果可能的话)具有以下属性的map实现:

1. 虽然条目数很少,比如<32,但是底层存储应该在这样的数组中完成[key0,val0,key1,val1,...]这种存储方案可以避免许多小的Entry对象并提供极快的查找速度(即使它们是顺序扫描!)在现代CPU上由于CPU的缓存未被无效以及缺少指针间接到堆中.

2. 无论与LinkedHashMap类似的条目数如何,映射都应保持键/值对的插入顺序

我们正在研究Scala中大量(数百万个节点/边缘)图形的内存表示,并且使用这样的Map可以让我们以更高效的方式存储节点/边缘属性以及每个节点的边缘,达到99%具有少量属性或邻居的节点和边缘的+,同时保留属性和边缘的按时间顺序的插入顺序.

如果有人知道具有这些特征的Scala或Java地图,我将非常感激不尽.

感谢名单

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

我的任务是用Java编写哈希表,它必须适用于任何数据类型.我写的代码的规则如下: - 哈希表必须有一个数组作为底层数据结构,在构造对象时确定的大小 - 当发生冲突时,应该放置碰撞的元素到链表中,它包含哈希表中该索引(键)的所有元素

因此,对于底层数据类型,我创建了一个LinkedList类型的数组(自定义,而不是Java API LinkedList).

private LinkedList<T>[] table;

当然,问题是实例化这个数组.以下是我的一些尝试:

public HashTable(int size) {
  table = new LinkedList<T>[size];
}

这会引发编译时泛型数组创建错误.

public HashTable(int size) {
  table = (LinkedList<T>[])(new Object[size]);
}

这会ClassCastException在运行时导致错误(java.lang.Object无法转换为LinkedList).

项目负责人也不确定如何处理这个问题.有什么方法可以更改我的代码,以便哈希表仍然有一个数组作为其底层数据结构,并将冲突放在LinkedList中？

这是我正在使用的代码

public class aClass<T> {

    private T[] elements;

    public aClass(T[] elements) {
        this.elements = elements;
    }

    public void doSomething() {
        T[] newArray = (T[]) new Object[5];
        ...
    }

}

我见过有人说创建像这样的数组是一个坏主意,因为它不是类型安全的.但是,每次我使用它,我都没有问题.何时创建这样的数组会导致问题？

谢谢

我正在通过Robert Sedgewick参加Coursera的算法讲座.当罗伯特先生指出一个人不能使用Generics with Arrays时,我有点困惑,因为它是不允许的.但Collection Framework中的ArrayList在内部使用Arrays,允许使用Generic数据类型.我的意思是说我们可以执行以下操作:

ArrayList<Integer> list = new ArrayList<Integer>();

他指出的一个黑客是这样的:

public class FixedCapacityStack<Item>{
    private Item[] s;
    private int N = 0;

public FixedCapacityStack(int capacity)
{  s = (Item[]) new Object[capacity];} //this hack

他还提到这是一个丑陋的黑客,必须避免,它也会在编译过程中产生警告.

我的问题是:

1.)ArrayList如何在内部表示各种泛型类型？

2.)如果(假设)他们使用上面提到的hack,为什么在用ArrayList编译程序时它不会产生警告？

3.)除了上面的演员之外还有更好的方法吗？

所以我有这个我正在开发的通用HashTable类,我想将它一般用于任意数量的传入类型,我想将内部存储数组初始化为LinkedList的数组(用于冲突),其中每个LinkedList都是提前指定的(对于类型安全性),它是HashTable类中泛型的类型.我怎么能做到这一点？以下代码最能说明我的意图,但当然不能编译.

public class HashTable<K, V>
{
    private LinkedList<V>[] m_storage;

    public HashTable(int initialSize)
    {
        m_storage = new LinkedList<V>[initialSize];
    }
}

如何在java中创建通用项的多维数组？

考虑班级:

class A<T>
  {
    T t;
    public A(T t) { this.t = t; }
  }

当我尝试创建一个多维数组时:

A<String>[][] array = new A<String>[2][3];

我收到以下错误:

generic array creation
A<String>[][] array = new A<String>[2][3];
                      ^

我尝试了以下方法:

A<String>[][] array = (A<String>[][]) (new Object[2]3]);

但这只是抛出: java.lang.ClassCastException

有什么问题？

(我预计人们会建议使用列表.请解释如何使用数组实现此目的.)

我ClassCastException运行这个时遇到错误,因为在运行代码时d隐式转换为double.但是,如果我将引用更改为d in,Object[]则它不能成为set函数的参数.如果我将set函数更改为接受a Object[]然后一切正常,但是如果有人在非类型的对象上调用set,那么该类将在运行时失败N.

我需要一个可以get()使用旧数组(或其克隆)并且可以将set()数据传输到新数组的解决方案.

public class Foo<N> {

    public static void main(String[] args) {
        Foo<Double> foo = new Foo<Double>();
        Double[] d = foo.get();

        // do stuff to d ...

        foo.set(d);
    }

    N[] data;

    public Foo() {
        data = (N[]) new Object[2];
    }

    public N[] get() {
        return (N[]) data;
    }

    public void set(N[] data) {
        this.data = data;
    }

}