Java 为什么我的泛型数组元素为空？（正在尝试将元素复制到新数组中）

我有一个符号表类，它使用两个通用的和可比较的数组，键[]和值[]。在main（）中，我读取输入（一个文本文件），并相应地填充符号表数组。我正在尝试创建一个方法，其中我希望将Value[]vals复制到一个新数组中。但是，与键[]键一起构成符号表的my vals[]元素打印为null。为什么我会变空，更重要的是，解决这个问题的一般方法是什么

由于符号表已实例化，并且数组随后已由put（）填充，因此我希望VAL[z]包含一些可用于复制到另一个数组中的整数值，但整个数组为空？下面省略了一些代码，显示了主要函数put（）、get（）和rank（）

公共类可符号化{
私钥[]密钥；
私人价值[]VAL；
私有整数N=0；
//尝试复制泛型数组时出现问题
公共空函数（整数x，整数y）{
//将VAL复制到VALCopy中
价值[]副本；
VALCOPY=（值[]）新的可比[VAL.length]；
对于（int z=0；z=valscopy.length-（（y-x）+1）；i--）{
StdOut.println（valscopy[i]+“”+vals[i]）；i；j--）{
键[j]=键[j-1]；
VAL[j]=VAL[j-1]；
}
//插入键和值
键[i]=键；
val[i]=val；
N++；
}
公共整数等级（密钥）{
int-lo=0，hi=N-1；
while（lo0）{
lo=中间+1；
}否则返回中间；
}
返回lo；
}
布尔包含（键）{
return get（key）！=null；
}
公共整数大小（）{
返回N；
}
布尔isEmpty（）{
返回大小（）==0；
}
公共静态void main（字符串[]args）{
SymbolTable st=新的SymbolTable（2000年）；
字串=”；
而（！StdIn.isEmpty（））{
word=StdIn.readString（）；//读取单词/键
如果（！st.contains（word））st.put（word，1）；
else-st.put（单词，st.get（单词）+1）；
}
st功能（3,7）；
}
}

您的类中没有“contains”方法。你试过编译你的代码吗？@mentalurg出于极简主义的考虑，我没有在这里展示它，因为它很琐碎。我的整个程序运行得非常好，但是我想添加的新函数（）给我带来了问题，我不明白为什么VAL[]中的元素为空。这对于调试器来说太好了。@mentalurg我现在已经添加了必要的函数，包括contains（）、isEmpty（）和size（）@0jnats3看看这个：。你在上面发布的内容并没有重现这个问题——它没有在本地为我编译。

public class SymbolTable<Key extends Comparable<Key>, Value extends Comparable<Value>> {
    private Key[] keys;
    private Value[] vals;
    private int N = 0;

    // problem here when trying to copy generic arrays
    public void function(int x, int y){
        // Copy vals into valscopy
        Value[] valscopy;
        valscopy = (Value[]) new Comparable[vals.length];
        for(int z = 0; z < valscopy.length; z++){
            valscopy[z] = vals[z]; 
        }


        for(int i = valscopy.length-1; i >= valscopy.length-((y-x)+1); i--){
            StdOut.println(valscopy[i] + " " + vals[i]); <------ both print null
        }
    }



    public SymbolTable(int capacity)
    {
        keys = (Key[]) new Comparable[capacity];
        vals = (Value[]) new Comparable[capacity];
    }

    public Value get(Key key) {
        if (isEmpty()) {
            return null;
        }
        int i = rank(key);
        if (i < N && keys[i].compareTo(key) == 0) {
            return vals[i];
        } else {
            return null;
        }
    }


    public void put(Key key, Value val) {
        int i = rank(key);
        // if the same key is found, update value
        if (i < N && keys[i].compareTo(key) == 0) {
            vals[i] = val;
            return;
        }
        // make room for new key,value pair to be inserted at position i
        for (int j = N; j > i; j--) {
            keys[j] = keys[j - 1];
            vals[j] = vals[j - 1];
        }
        // insert key and value
        keys[i] = key;
        vals[i] = val;
        N++;
    }

    public int rank(Key key) {
        int lo = 0, hi = N - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            int cmp = key.compareTo(keys[mid]);
            if (cmp < 0) {
                hi = mid - 1;
            } else if (cmp > 0) {
                lo = mid + 1;
            } else return mid;
        }
        return lo;
    }

    boolean contains(Key key) {
        return get(key) != null;
    }
    public int size() {
        return N;
    }
    boolean isEmpty() {
        return size() == 0;
    }

    public static void main(String[] args) {

        SymbolTable<String, Integer> st = new SymbolTable<String, Integer>(2000);

        String word = "";

        while (!StdIn.isEmpty()) { 

            word = StdIn.readString(); // Read words/keys 
            if (!st.contains(word)) st.put(word, 1); 
            else st.put(word, st.get(word) + 1); 
        }

        st.function(3, 7);
    }
}