java - 向量可以引用 Java 中的二维数组吗？

Question

基本上，我想创建一个在运行时变大的二维数组。我可以使用 Java 中的向量来执行此操作吗？

这些会是正确的吗？

int [] [] x = 新 x [100] [100];

向量 x= 新向量（）；

要将元素添加到数组中 -

for i=0 to 99
   for j=0 to 99
   x.addElement(x[i] [j]);

本质上，它就像引用任何其他对象一样，只是在这里，我还必须指定索引号，对吗？

我是Java的新手。所以我很感激任何帮助！

Answer 1

如果不知道需要优化的情况，很难知道向您建议什么。

例如，这个简单的地图包装器是一个稀疏的 2D 矩阵，针对设置和获取特定索引进行了优化（根本不需要“增长”），但不利于迭代所有索引。

public class SparseMatrix<T> {
    private final Map<Coordinates, T> map = new HashMap<Coordinates, T>();
    private final T defaultValue;

    public SparseMatrix(T defaultValue) {
       this.defaultValue = defaultValue;
    }

    private static class Coordinates {
        private final int[] coordinates;

        Coordinates(int... coordinates) {
            this.coordinates = coordinates;
        }

        @Override
        public boolean equals(Object o) {
            return Arrays.equals(coordinates, ((Coordinates)o).coordinates);
        }

        @Override
        public int hashCode() {
            return Arrays.hashCode(coordinates);
        }
    }

    public T get(int x, int y) {
        T value = map.get(new Coordinates(x, y));
        if ( value == null ) {
            return defaultValue;
        }
    }

    public T set(int x, int y, T val) {
        return map.put(new Coordinates(x, y), val);
    }
} 

用法：

SparseMatrix<Integer> matrix = new SparseMatrix<Integer>(0);
matrix.set(3, 5, 7);
int seven = matrix.get(3, 5);
int zero = matrix.get(3, 6); //not set yet, uses default    

它也可以很容易地适应 N 维。当然，在生产代码中你不会自己编写代码，你会使用一个做得更好的库。

Answer 2

你可以使用ArrayListwhich等价于动态数组。

ArrayList<ArrayList<Integer>> aDynamicArray = new ArrayList<ArrayList<Integer>>(2);
aDynamicArray.add(new ArrayList<Integer>());
aDynamicArray.add(new ArrayList<Integer>());

现在你可以使用你for的循环如下：

int [] [] x = new x [2] [100];
for i=0 to 1 
   for j=0 to 99
       aDynamicArray.get(i).add(x[i] [j]);

编辑：

如果我想访问 x[2] [3] ，我将如何在数组列表中执行此操作？

x[2][3]表示第 3 行第 4 列的值。因此，第一行代码将更改如下：（容纳 3 行）

ArrayList<ArrayList<Integer>> aDynamicArray = new ArrayList<ArrayList<Integer>>(3);
for(int i=0; i<3, i++)
{
    aDynamicArray.add(new ArrayList<Integer>());
}

然后以下行将使您可以访问x[2][3]：

aDynamicArray.get(2).get(3);

Answer 3

不幸的是，Java 既没有二维数组也没有二维增长向量。

它具有数组数组或向量向量。

在您的示例中，您创建了 s 的一维向量Object：

Vector x= new Vector();

类似于不断增长的类型数组Object[] x

所以，当你这样做

y.addElement(x[i][j]);

Java做“拳击”，即它做

y.addElement(new Integer(x[i][j]));

由于您将 100x100 元素添加到 1D 数组中，因此您需要自己计算位置

y.get(i*numcols+j)

因此，为避免这一切，请使用向量的向量，如下例所示。该示例将新固定大小的数组复制到向量的向量中：

   // creates fixed size 2D array with zeros
    int [] [] x = new int [50][50]; 

    // creates empty vector of vectors of integers
    // y is of type Vector<Vector<Integer>>
    // y.get(row) is of type Vector<Integer>>
    // y.get(row).get(col) is of type Integer
    Vector<Vector<Integer>> y = new Vector<Vector<Integer>>(); 

    // set the size of vector of vectors (number of rows)
    // each row will be null for now
    y.setSize(x.length);

    // enumerating rows
    for(int row=0; row<x.length; ++row) {

        log.info("row {}", row);

        // assign empty vector for row
        y.set(row, new Vector<Integer>());

        // set row size (number of columns)
        y.get(row).setSize(x[row].length);

        // enumerating columns of current row
        for(int col=0; col<x[row].length; ++col) {

            // setting the value for a cell
            y.get(row).set(col, x[row][col]);

        }
    }

Answer 4

在java中会是这样的：

int [][] x = new int [100] [100]

ArrayList <Integer> y = new ArrayList();

y.add(some number);

有关Arraylist的更多信息

Java 让您拥有由不同数据类型组成的集合。例如

ArrayList<Object> list = new ArrayList<Object>();
list.add(1);
list.add("Java");
list.add(3.14);

因此您也可以使用 ArrayList 的 ArrayList 等等。

Answer 5

如果你知道数组的大小（你提到的是99），你可以使用int[][] intA = new int[100][100]和如果你熟悉java，你可以通过在添加元素时监控数组大小来实现自己的Growing int[][]。

假设您intA[99][99] = someInt此时添加最后一个元素，您可以创建新数组int[][] newIntA = new int[intA.length+25][100];，然后您需要将现有intA数组的内容复制到newIntA

或者您可以使用ArrayList<ArrayList<Integer>>添加您的值或使用ArrayList[]您的选择。