Другое событие NullPointerException
возникает, когда объявляется массив объектов, а затем сразу же пытается разыменовать его внутри.
String[] phrases = new String[10];
String keyPhrase = "Bird";
for(String phrase : phrases) {
System.out.println(phrase.equals(keyPhrase));
}
Этот конкретный NPE можно избежать, если порядок сравнения отменяется ; а именно, использовать .equals
для гарантированного непустого объекта.
Все элементы внутри массива инициализируются их общим начальным значением ; для любого типа массива объектов, это означает, что все элементы null
.
Вы должны инициализировать элементы в массиве перед доступом или разыменованием их.
String[] phrases = new String[] {"The bird", "A bird", "My bird", "Bird"};
String keyPhrase = "Bird";
for(String phrase : phrases) {
System.out.println(phrase.equals(keyPhrase));
}
Попробуйте заменить соответствующие строки на:
myStringArray[0][x-1] = "a string";
myStringArray[0][y-1] = "another string";
. Ваш код неверен, потому что подмассивы имеют длину y
, а индексация начинается с нуля. Поэтому установите значение myStringArray[0][y]
или myStringArray[0][x]
не будет работать, потому что индексы x
и y
находятся за пределами границ.
String[][] myStringArray = new String [x][y];
- это правильный способ инициализации прямоугольного многомерного массива. Если вы хотите, чтобы он был зазубрен (каждый подматрица потенциально имеет разную длину), вы можете использовать код, похожий на этот ответ . Обратите внимание, однако, что утверждение Джона о том, что вы должны создать подмассивы вручную, неверно в том случае, если вы хотите идеально прямоугольный многомерный массив.
В Java нет «истинных» многомерных массивов.
Например, arr[i][j][k]
эквивалентно ((arr[i])[j])[k]
. Другими словами, arr
представляет собой просто массив массивов массивов.
Итак, если вы знаете, как работают массивы, вы знаете, как работают многомерные массивы!
Объявление:
int[][][] threeDimArr = new int[4][5][6];
или с инициализацией:
int[][][] threeDimArr = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };
Доступ:
int x = threeDimArr[1][0][1];
или
int[][] row = threeDimArr[1];
Строковое представление:
Arrays.deepToString(threeDimArr);
дает
"[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]"
int[i][j][k]
имеет длину i
, поэтому на самом деле это эквивалентно ((int[k])[j])[i]
. Размеры в декларации записываются в обратном направлении по отношению к типам, я полагаю, что многомерные массивы более близки к матрицам в математике.
– Milosz
9 October 2017 в 23:00
Вы можете объявить многомерные массивы вроде:
// 4 x 5 String arrays, all Strings are null
// [0] -> [null,null,null,null,null]
// [1] -> [null,null,null,null,null]
// [2] -> [null,null,null,null,null]
// [3] -> [null,null,null,null,null]
String[][] sa1 = new String[4][5];
for(int i = 0; i < sa1.length; i++) { // sa1.length == 4
for (int j = 0; j < sa1[i].length; j++) { //sa1[i].length == 5
sa1[i][j] = "new String value";
}
}
// 5 x 0 All String arrays are null
// [null]
// [null]
// [null]
// [null]
// [null]
String[][] sa2 = new String[5][];
for(int i = 0; i < sa2.length; i++) {
String[] anon = new String[ /* your number here */];
// or String[] anon = new String[]{"I'm", "a", "new", "array"};
sa2[i] = anon;
}
// [0] -> ["I'm","in","the", "0th", "array"]
// [1] -> ["I'm", "in", "another"]
String[][] sa3 = new String[][]{ {"I'm","in","the", "0th", "array"},{"I'm", "in", "another"}};
Java не поддерживает true многомерные массивы. В Java двумерный массив представляет собой просто массив массивов, трехмерный массив представляет собой массив массивов массивов, четырехмерный массив представляет собой массив массивов массивов массивов и т. Д. ...
Мы можем определить двумерный массив как:
int[ ] num[ ] = {{1,2}, {1,2}, {1,2}, {1,2}}
int[ ][ ] num = new int[4][2]
num[0][0] = 1;
num[0][1] = 2;
num[1][0] = 1;
num[1][1] = 2;
num[2][0] = 1;
num[2][1] = 2;
num[3][0] = 1;
num[3][1] = 2;
Если вы не выделите, давайте скажем, num[2][1]
, он не инициализируется, а затем автоматически выделяется 0, то есть автоматически num[2][1] = 0
; num1.length
дает вам строки. num1[0].length
дает количество элементов, связанных с num1[0]
. Здесь num1[0]
имеет только связанные массивы num1[0][0]
и num[0][1]
. for
, который помогает нам вычислить num1[i].length
. Здесь i
увеличивается через цикл. class array
{
static int[][] add(int[][] num1,int[][] num2)
{
int[][] temp = new int[num1.length][num1[0].length];
for(int i = 0; i<temp.length; i++)
{
for(int j = 0; j<temp[i].length; j++)
{
temp[i][j] = num1[i][j]+num2[i][j];
}
}
return temp;
}
public static void main(String args[])
{
/* We can define a two-dimensional array as
1. int[] num[] = {{1,2},{1,2},{1,2},{1,2}}
2. int[][] num = new int[4][2]
num[0][0] = 1;
num[0][1] = 2;
num[1][0] = 1;
num[1][1] = 2;
num[2][0] = 1;
num[2][1] = 2;
num[3][0] = 1;
num[3][1] = 2;
If you don't allocate let's say num[2][1] is
not initialized, and then it is automatically
allocated 0, that is, automatically num[2][1] = 0;
3. Below num1.length gives you rows
4. While num1[0].length gives you number of elements
related to num1[0]. Here num1[0] has related arrays
num1[0][0] and num[0][1] only.
5. Here we used a 'for' loop which helps us to calculate
num1[i].length, and here i is incremented through a loop.
*/
int num1[][] = {{1,2},{1,2},{1,2},{1,2}};
int num2[][] = {{1,2},{1,2},{1,2},{1,2}};
int num3[][] = add(num1,num2);
for(int i = 0; i<num1.length; i++)
{
for(int j = 0; j<num1[j].length; j++)
System.out.println("num3[" + i + "][" + j + "]=" + num3[i][j]);
}
}
}
Вы также можете использовать следующую конструкцию:
String[][] myStringArray = new String [][] { { "X0", "Y0"},
{ "X1", "Y1"},
{ "X2", "Y2"},
{ "X3", "Y3"},
{ "X4", "Y4"} };
Вы можете посмотреть это, чтобы начать:
int [][][] i = { //third dimension curly brace
{ // second dimension curly brace
{ //first dimension curly brace
1,1,1 //elements
},
{3,3,3},
{2,2,2}
},
{
{
1,1,1
},
{3,3,3},
{2,2,2}
}
};
Я добавлю, что если вы хотите прочитать размеры, вы можете сделать это:
int[][][] a = new int[4][3][2];
System.out.println(a.length); // 4
System.out.println(a[0].length); // 3
System.out.println(a[0][0].length); //2
Вы также можете иметь зубчатые массивы , где разные строки имеют разные длины, поэтому a[0].length != a[1].length
.