我该如何在Java中声明和初始化数组?
我该如何在Java中声明和初始化数组?
你可以使用数组声明或数组字面量(但仅当你立即声明并赋值变量时,数组字面量不能用于重新分配一个数组)。
对于基元类型:
int[] myIntArray = new int[3]; // each element of the array is initialised to 0
int[] myIntArray = {1, 2, 3};
int[] myIntArray = new int[]{1, 2, 3};
// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html
int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort
对于类,例如String
,情况是一样的:
String[] myStringArray = new String[3]; // each element is initialised to null
String[] myStringArray = {"a", "b", "c"};
String[] myStringArray = new String[]{"a", "b", "c"};
当您首先声明一个数组,然后初始化它,传递一个数组作为函数参数或返回一个数组时,第三种初始化方式非常有用。需要明确指定类型。
String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};
return {1,2,3}
会出错,而return new int[]{1,2,3}
可以正常工作(当然,假设你的函数返回一个整数数组)。 - Skylar Ittner有两种类型的数组。
默认值的语法:
int[] num = new int[5];
或者(不太推荐)
int num[] = new int[5];
给定值的语法(变量/字段初始化):
int[] num = {1,2,3,4,5};
或者(不太推荐)
int num[] = {1, 2, 3, 4, 5};
注意:为了方便起见,int[] num 更可取,因为它清楚地表明你在谈论数组。否则没有区别。一点也不。
int[][] num = new int[5][2];
或者
int num[][] = new int[5][2];
或者
int[] num[] = new int[5][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[4][0]=1;
num[4][1]=2;
或者
int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };
int[][] num = new int[5][];
num[0] = new int[1];
num[1] = new int[5];
num[2] = new int[2];
num[3] = new int[3];
所以在这里我们明确定义列。
另一种方法:
int[][] num={ {1}, {1,2}, {1,2,3,4,5}, {1,2}, {1,2,3} };
for (int i=0; i<(num.length); i++ ) {
for (int j=0;j<num[i].length;j++)
System.out.println(num[i][j]);
}
或者:
for (int[] a : num) {
for (int i : a) {
System.out.println(i);
}
}
不规则数组是多维数组。
详见官方Java教程中有关多维数组的说明。
Type[] variableName = new Type[capacity];
Type[] variableName = {comma-delimited values};
Type variableName[] = new Type[capacity];
Type variableName[] = {comma-delimited values};
也是有效的,但我更喜欢类型后面的方括号,因为这样更容易看出变量的类型实际上是一个数组。
int[] a, b;
与int a[], b;
不是相同的,如果您使用后者的形式很容易犯错误。请注意避免混淆它们。 - Jeroen Vannevel我发现如果您理解每个部分,这会很有帮助:
Type[] name = new Type[5];
Type[]
是名为“name”的变量的类型(“name”被称为标识符)。文字“Type”是基本类型,方括号表示这是该基本类型的数组类型。数组类型本身也是一种类型,这使您可以创建多维数组,如Type[][]
(Type[] 的数组类型)。关键字new
表示为新数组分配内存。方括号中的数字表示新数组的大小和要分配的内存量。例如,如果Java知道基本类型Type
占用32个字节,并且您想要一个大小为5的数组,则它需要在内部分配32 * 5 = 160个字节的空间。您还可以创建已有值的数组,例如:int[] name = {1, 2, 3, 4, 5};
这不仅创建了一个空间,而且用这些值填充了它。Java 可以确定原始数据类型是整数,并且有 5 个,因此可以隐式确定数组的大小。
int[] name = new int[5]
吗? - Cookie Monsterint[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};
int[] myIntArray;
myIntArray=new int[3];
或者说,
// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];
这声明了一个名为arrayName
的数组,大小为10(你可以使用0到9的元素)。
此外,如果你想要更加动态的内容,可以使用List接口。虽然性能不如前者,但更加灵活。
List<String> listOfString = new ArrayList<String>();
listOfString.add("foo");
listOfString.add("bar");
String value = listOfString.get(0);
assertEquals( value, "foo" );
List
是一个泛型类,它有一个类型参数,用 <>
括起来。这很有帮助,因为你只需要定义一次泛型类型,然后就可以在多个不同的类型中使用它。要了解更详细的解释,请查看 https://docs.oracle.com/javase/tutorial/java/generics/types.html。 - Heimdall制作数组有两种主要方法:
对于空数组,可以使用以下方法之一:
int[] array = new int[n]; // "n" being the number of spaces to allocate in the array
而这一个是针对已初始化数组的:
int[] array = {1,2,3,4 ...};
你也可以创建多维数组,例如:
int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};
Arrays.setAll
(类似于Arrays.fill
,但接受生成器函数,该函数接受索引并生成该位置的期望值,从而提供更大的灵活性):int[] a = new int[5];
Arrays.setAll(a, index -> index + 1);
Out: [1, 2, 3, 4, 5]
IntStream.iterate
和IntStream.takeWhile
方法:int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();
Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();
Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
使用局部变量类型推断:
var letters = new String[]{"A", "B", "C"};