基本上,我想创建一个在运行时变大的二维数组。我可以使用 Java 中的向量来执行此操作吗?
这些会是正确的吗?
int [] [] x = 新 x [100] [100];
向量 x= 新向量();
要将元素添加到数组中 -
for i=0 to 99
for j=0 to 99
x.addElement(x[i] [j]);
本质上,它就像引用任何其他对象一样,只是在这里,我还必须指定索引号,对吗?
我是Java的新手。所以我很感激任何帮助!
基本上,我想创建一个在运行时变大的二维数组。我可以使用 Java 中的向量来执行此操作吗?
这些会是正确的吗?
int [] [] x = 新 x [100] [100];
向量 x= 新向量();
要将元素添加到数组中 -
for i=0 to 99
for j=0 to 99
x.addElement(x[i] [j]);
本质上,它就像引用任何其他对象一样,只是在这里,我还必须指定索引号,对吗?
我是Java的新手。所以我很感激任何帮助!
如果不知道需要优化的情况,很难知道向您建议什么。
例如,这个简单的地图包装器是一个稀疏的 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 维。当然,在生产代码中你不会自己编写代码,你会使用一个做得更好的库。
你可以使用ArrayList
which等价于动态数组。
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);
不幸的是,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]);
}
}
在java中会是这样的:
int [][] x = new int [100] [100]
ArrayList <Integer> y = new ArrayList();
y.add(some number);
Java 让您拥有由不同数据类型组成的集合。例如
ArrayList<Object> list = new ArrayList<Object>();
list.add(1);
list.add("Java");
list.add(3.14);
因此您也可以使用 ArrayList 的 ArrayList 等等。
如果你知道数组的大小(你提到的是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[]
您的选择。