Question

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

那么这些是对的吗？

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

Vector x = new Vector（）;

将元素添加到数组中 -

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

基本上，就像引用任何其他对象一样，只有在这里，我还要指定索引号，对吗？

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

Answer 1

如果不了解您需要优化的案例，很难知道建议给您什么。

例如，围绕地图的这个简单包装是sparse 2D matrix优化用于设置和获取特定索引（根本不需要“增长”），但迭代所有索引都不好。

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

您可以使用等同于动态数组的ArrayList。

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]，我将如何在arraylist中执行此操作？

x[2][3]表示第3行和第4列的值。因此，Fisrt代码行将改变如下:(以容纳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既没有2D数组也没有2D生长向量。

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

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

Vector x= new Vector();

类似于增长类型Object[] x

的数组

所以，当你这样做时

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

Java做“装箱”，即确实

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

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

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，你可以通过监视数组大小来实现自己的增长int[][]添加元素。

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

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

矢量可以在Java中引用二维数组吗？

5 个答案: