Type[] variableName = new Type[capacity];
Type[] variableName = {comma-delimited values};
Type variableName[] = new Type[capacity];
Type variableName[] = {comma-delimited values};
int item = value;
int [] one_dimensional_array = { value, value, value, .., value };
int [][] two_dimensional_array =
{
{ value, value, value, .. value },
{ value, value, value, .. value },
.. .. .. ..
{ value, value, value, .. value }
};
如果它是一个对象,那么它就是相同的概念
Object item = new Object();
Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() };
Object [][] two_dimensional_array =
{
{ new Object(), new Object(), .. new Object() },
{ new Object(), new Object(), .. new Object() },
.. .. ..
{ new Object(), new Object(), .. new Object() }
};
对于对象,您需要将其分配给 null 以使用 new Type(..) 初始化它们,类如 String 和 Integer 是特殊情况,将按以下方式处理
String [] a = { "hello", "world" };
// is equivalent to
String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };
Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };
通常,您可以创建 M 维度的数组
int [][]..[] array =
// ^ M times [] brackets
{{..{
// ^ M times { bracket
// this is array[0][0]..[0]
// ^ M times [0]
}}..}
// ^ M times } bracket
;
值得注意的是,创建一个 M 维数组在空间方面是昂贵的 . 因为当你在所有维上创建一个 M 维数组 N 时,数组的总大小大于 N^M ,因为每个数组都有一个引用,而在M维上有一个(M-1)维数组参考文献 . 总大小如下
Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
// ^ ^ array reference
// ^ actual data
117
int[] SingleDimensionalArray = new int[2]
int[][] MultiDimensionalArray = new int[3][4]
23
以下显示了数组的声明,但未初始化该数组:
int[] myIntArray = new int[3];
以下显示了数组的声明和初始化:
int[] myIntArray = {1,2,3};
现在,以下还显示了数组的声明和初始化:
int[] myIntArray = new int[]{1,2,3};
但是第三个显示了匿名数组对象创建的属性,它由引用变量“myIntArray”指向,所以如果我们只写“new int [] {1,2,3};”那么这就是如何创建匿名数组对象 .
如果我们只写:
int[] myIntArray;
这不是数组的声明,但以下语句使上述声明完成:
myIntArray=new int[3];
1
声明和初始化ArrayList的另一种方法:
private List<String> list = new ArrayList<String>(){{
add("e1");
add("e2");
}};
238
您也可以使用 java.util.Arrays 执行此操作:
List<String> number = Arrays.asList("1", "2", "3");
Out: ["1", "2", "3"]
这个很漂亮 simple 直截了当 . 我没有在其他答案中看到它,所以我想我可以添加它 .
23
制作数组有两种主要方法:
这个,对于一个空数组:
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 ...} ...};
32
以原始类型 int 为例 . 有几种方法可以声明和 int 数组:
int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};
int[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};
对于类,例如 String ,它是相同的:
String[] myStringArray = new String[3];
String[] myStringArray = {"a","b","c"};
String[] myStringArray = new String[]{"a","b","c"};
当您首先声明数组然后初始化它时,第三种初始化方法很有用 . 演员是必要的 .
String[] myStringArray;
myStringArray = new String[]{"a","b","c"};
13
或者,
// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];
这声明了一个名为 arrayName 且大小为10的数组(你要使用的元素为0到9) .
7
声明一个对象引用数组:
class Animal {}
class Horse extends Animal {
public static void main(String[] args) {
/*
* Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
*/
Animal[] a1 = new Animal[10];
a1[0] = new Animal();
a1[1] = new Horse();
/*
* Array of Animal can hold Animal and Horse and all subtype of Horse
*/
Animal[] a2 = new Horse[10];
a2[0] = new Animal();
a2[1] = new Horse();
/*
* Array of Horse can hold only Horse and its subtype (if any) and not
allowed supertype of Horse nor other subtype of Animal.
*/
Horse[] h1 = new Horse[10];
h1[0] = new Animal(); // Not allowed
h1[1] = new Horse();
/*
* This can not be declared.
*/
Horse[] h2 = new Animal[10]; // Not allowed
}
}
3
要创建类对象的数组,可以使用 java.util.ArrayList . 定义一个数组:
public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();
为数组赋值:
arrayName.add(new ClassName(class parameters go here);
21 回答
也是有效的,但我更喜欢类型之后的括号,因为更容易看到变量的类型实际上是一个数组 .
如果你想使用反射创建数组,那么你可以这样做:
使用局部变量类型推断,您只需指定一次类型:
要么
此外,如果您想要更动态的东西,还有List接口 . 这不会表现得那么好,但更灵活:
为Java 8及更高版本声明并初始化 . 创建一个简单的整数数组:
为[-50,50]和双精度[0,1E17]之间的整数创建一个随机数组:
二次幂序列:
对于String [],您必须指定构造函数:
多维数组:
有两种类型的数组 .
一维数组
默认值的语法:
或者(不太喜欢)
给定值的语法(变量/字段初始化):
或者(不太喜欢)
注意:为了方便int [] num更可取,因为它清楚地告诉你这里是关于数组的 . 否则没什么区别 . 一点也不 .
多维数组
宣言
要么
要么
初始化
要么
粗糙阵列(或非矩形阵列)
所以我们在这里明确定义列 .
Another Way:
用于访问:
或者:
粗糙的数组是多维数组 .
有关解释,请参阅the official java tutorials处的多维数组详细信息
我发现如果您理解每个部分会很有帮助:
Type[]
是名为name的变量的类型("name"称为标识符) . 文字"Type"是基本类型,括号表示这是该基数的数组类型 . 数组类型依次是它们自己的类型,它允许您创建多维数组,如Type[][]
(Type []的数组类型) . 关键字new
表示为新数组分配内存 . 括号之间的数字表示新数组的大小和分配的内存量 . 例如,如果Java知道基类型Type
需要32个字节,并且您需要大小为5的数组,则需要在内部分配32 * 5 = 160个字节 .您还可以使用已存在的值创建数组,例如
它不仅会创建空白空间,还会使用这些值填充它 . Java可以告诉基元是整数,并且它们中有5个,因此可以隐式确定数组的大小 .
数组是项目的顺序列表
如果它是一个对象,那么它就是相同的概念
对于对象,您需要将其分配给
null
以使用new Type(..)
初始化它们,类如String
和Integer
是特殊情况,将按以下方式处理通常,您可以创建
M
维度的数组值得注意的是,创建一个
M
维数组在空间方面是昂贵的 . 因为当你在所有维上创建一个M
维数组N
时,数组的总大小大于N^M
,因为每个数组都有一个引用,而在M维上有一个(M-1)维数组参考文献 . 总大小如下以下显示了数组的声明,但未初始化该数组:
以下显示了数组的声明和初始化:
现在,以下还显示了数组的声明和初始化:
但是第三个显示了匿名数组对象创建的属性,它由引用变量“myIntArray”指向,所以如果我们只写“new int [] {1,2,3};”那么这就是如何创建匿名数组对象 .
如果我们只写:
这不是数组的声明,但以下语句使上述声明完成:
声明和初始化ArrayList的另一种方法:
您也可以使用
java.util.Arrays
执行此操作:这个很漂亮 simple 直截了当 . 我没有在其他答案中看到它,所以我想我可以添加它 .
制作数组有两种主要方法:
这个,对于一个空数组:
而这一个,对于一个初始化的数组:
您还可以创建多维数组,如下所示:
以原始类型
int
为例 . 有几种方法可以声明和int
数组:在所有这些中,您可以使用
int i[]
而不是int[] i
.使用反射,您可以使用
(Type[]) Array.newInstance(Type.class, capacity);
请注意,在方法参数中,
...
表示variable arguments
. 基本上,任何数字参数很好 . 使用代码更容易解释:在方法内部,
varargs
被视为普通int[]
.Type...
只能在方法参数中使用,因此int... i = new int[] {}
将无法编译 .请注意,将
int[]
传递给方法(或任何其他Type[]
)时,您无法使用第三种方式 . 在int[] i = *{a, b, c, d, etc}*
语句中,编译器假定{...}
表示int[]
. 但那是因为你要声明一个变量 . 将数组传递给方法时,声明必须是new Type[capacity]
或new Type[] {...}
.多维数组
多维数组很难处理 . 本质上,2D数组是一个数组数组 .
int[][]
表示int[]
的数组 . 关键是如果int[][]
被声明为int[x][y]
,则最大索引为i[x-1][y-1]
. 基本上,矩形int[3][5]
是:您可以使用数组声明或数组文字(但只有在声明并立即影响变量时,才能使用数组文字重新分配数组) .
对于原始类型:
对于类,例如
String
,它是相同的:当您首先声明数组然后初始化它时,第三种初始化方法很有用 . 演员是必要的 .
或者,
这声明了一个名为
arrayName
且大小为10的数组(你要使用的元素为0到9) .声明一个对象引用数组:
要创建类对象的数组,可以使用
java.util.ArrayList
. 定义一个数组:为数组赋值:
从数组中读取:
注意:
variableName
是对数组的引用,意味着操纵variableName
将操纵arrayName
for循环:
for循环,允许您编辑
arrayName
(常规for循环):在Java 9中
使用不同的IntStream.iterate和IntStream.takeWhile方法:
在Java 10中
使用Local Variable Type Inference:
您可以通过多种方式在Java中声明数组:
您可以在Sun tutorial站点和JavaDoc中找到更多信息 .
在Java 8中,您可以像这样使用 .