› ›

运算符：数组

编辑

运算符：数组

编辑

数组初始化

编辑

使用数组初始化运算符 '[] {}' 在堆上分配一个一维数组类型实例，其中包含一组预定义的元素。用于初始化数组类型实例中每个元素的每个值在插入时都会强制转换为指定的元素类型值。指定值的顺序保持不变。

错误

如果某个值无法转换为指定的类型值。

语法

array_initialization: 'new' TYPE '[' ']' '{' expression_list '}'
                    | 'new' TYPE '[' ']' '{' '}';
expression_list: expression (',' expression);

示例

使用静态值初始化数组。

int[] x = new int[] {1, 2, 3};

声明 int[] x; 分配长度为[3]的一维整数数组实例 → 一维整数数组引用; 将整数 1存储到一维整数数组引用的索引[0]；将整数 2存储到一维整数数组引用的索引[1]；将整数 3存储到一维整数数组引用的索引[2]；将一维整数数组引用存储到x;

使用非静态值初始化数组。

int i = 1;      
long l = 2L;    
float f = 3.0F; 
double d = 4.0; 
String s = "5"; 
def array = new def[] {i, l, f*d, s};

	声明 `int i`; 将`整数 1`存储到`i`
	声明 `long l`; 将`长整数 2`存储到`l`
	声明 `float f`; 将`浮点数 3.0`存储到`f`
	声明 `double d`; 将`双精度浮点数 4.0`存储到`d`
	声明 `String s`; 将`字符串 "5"`存储到`s`
	声明 `def array`; 分配长度为`[4]`的一维def数组实例 → `一维def数组引用`; 从`i`加载 → `整数 1`; 将`整数 1`隐式转换为`def` → `def`; 将`def`存储到`一维def数组引用`的`索引[0]`; 从`l`加载 → `长整数 2`; 将`长整数 2`隐式转换为`def` → `def`; 将`def`存储到`一维def数组引用`的`索引[1]`; 从`f`加载 → `浮点数 3.0`; 从`d`加载 → `双精度浮点数 4.0`; 提升`浮点数 3.0`和`双精度浮点数 4.0`：结果`双精度浮点数`; 将`浮点数 3.0`隐式转换为`双精度浮点数 3.0` → `双精度浮点数 3.0`; 将`双精度浮点数 3.0`和`双精度浮点数 4.0`相乘 → `双精度浮点数 12.0`; 将`双精度浮点数 12.0`隐式转换为`def` → `def`; 将`def`存储到`一维def数组引用`的`索引[2]`; 从`s`加载 → `字符串 "5"`; 将`字符串 "5"`隐式转换为`def` → `def`; 将`def`存储到`一维def数组引用`的`索引[3]`; 将`一维整数数组引用`隐式转换为`def` → `def`; 将`def`存储到`array`

数组访问

编辑

使用数组访问运算符 '[]' 将值存储到数组类型值或从中加载值。数组类型值的每个元素都使用int类型值访问，以指定要存储/加载的索引。数组中可访问的元素范围为[0, size)，其中size是在分配时指定的元素数。使用负int类型值作为索引，以从数组类型值的末尾反向访问范围为[-size, -1]的元素。

错误

如果提供非int类型值或可转换为int类型值的作为索引。
如果访问超出有效范围的元素。

语法

brace_access: '[' expression ']'

示例

使用一维数组进行数组访问。

int[] x = new int[2]; 
x[0] = 2;             
x[1] = 5;             
int y = x[0] + x[1];  
int z = 1;            
int i = x[z];

	声明 `int[] x`; 分配长度为`[2]`的一维整数数组实例 → `一维整数数组引用`; 将`一维整数数组引用`存储到`x`
	从`x`加载 → `一维整数数组引用`; 将`整数 2`存储到`一维整数数组引用`的`索引[0]`;
	从`x`加载 → `一维整数数组引用`; 将`整数 5`存储到`一维整数数组引用`的`索引[1]`;
	声明 `int y`; 从`x`加载 → `一维整数数组引用`; 从`一维整数数组引用`的`索引[0]`加载 → `整数 2`; 从`x`加载 → `一维整数数组引用`; 从`一维整数数组引用`的`索引[1]`加载 → `整数 5`; 将`整数 2`和`整数 5`相加 → `整数 7`; 将`整数 7`存储到`y`
	声明 `int z`; 将`整数 1`存储到`z`;
	声明 `int i`; 从`x`加载 → `一维整数数组引用`; 从`z`加载 → `整数 1`; 从`一维整数数组引用`的`索引[1]`加载 → `整数 5`; 将`整数 5`存储到`i`;

使用def类型进行数组访问。

def d = new int[2];  
d[0] = 2;            
d[1] = 5;            
def x = d[0] + d[1]; 
def y = 1;           
def z = d[y];

	声明 `def d`; 分配长度为`[2]`的一维整数数组实例 → `一维整数数组引用`; 将`一维整数数组引用`隐式转换为`def` → `def`; 将`def`存储到`d`
	从`d`加载 → `def` 将`def`隐式转换为`一维整数数组引用` → `一维整数数组引用`; 将`整数 2`存储到`一维整数数组引用`的`索引[0]`;
	从`d`加载 → `def` 将`def`隐式转换为`一维整数数组引用` → `一维整数数组引用`; 将`整数 5`存储到`一维整数数组引用`的`索引[1]`;
	声明 `int x`; 从`d`加载 → `def` 将`def`隐式转换为`一维整数数组引用` → `一维整数数组引用`; 从`一维整数数组引用`的`索引[0]`加载 → `整数 2`; 从`d`加载 → `def` 将`def`隐式转换为`一维整数数组引用` → `一维整数数组引用`; 从`一维整数数组引用`的`索引[1]`加载 → `整数 5`; 将`整数 2`和`整数 5`相加 → `整数 7`; 将`整数 7`隐式转换为`def` → `def`; 将`def`存储到`x`
	声明 `def y`; 将`整数 1`隐式转换为`def` → `def`; 将`def`存储到`y`;
	声明 `int i`; 从`d`加载 → `def` 将`def`隐式转换为`一维整数数组引用` → `一维整数数组引用`; 从`y`加载 → `def`; 将`def`隐式转换为`整数 1` → `整数 1`; 从`一维整数数组引用`的`索引[1]`加载 → `整数 5`; 将`整数 5`隐式转换为`def`; 将`def`存储到`z`;

使用多维数组进行数组访问。

int[][][] ia3 = new int[2][3][4]; 
ia3[1][2][3] = 99;                
int i = ia3[1][2][3];

	声明 `int[][][] ia`; 分配长度为`[2, 3, 4]`的三维整数数组实例 → `三维整数数组引用`; 将`三维整数数组引用`存储到`ia3`
	从`ia3`加载 → `三维整数数组引用`; 将`整数 99`存储到`三维整数数组引用`的`索引[1, 2, 3]`
	声明 `int i`; 从`ia3`加载 → `三维整数数组引用`; 从`三维整数数组引用`的`索引[1, 2, 3]`加载 → `整数 99`; 将`整数 99`存储到`i`

数组长度

编辑

数组类型的值包含一个名为length的只读成员字段。length字段存储数组的大小，其类型为int，大小是在分配时指定的元素数量。使用字段访问运算符从数组类型的值中加载length字段。

示例

访问length字段。

int[] x = new int[10]; 
int l = x.length;

	声明 `int[] x`; 分配长度为`[2]`的一维整数数组实例 → `一维整数数组引用`; 将`一维整数数组引用`存储到`x`
	声明 `int l`；加载 `x` → `一维整型数组引用`；从 `一维整型数组引用`加载 `length` → `int 10`；将 `int 10` 存储到 `l`；

新建数组

编辑

使用new array 运算符 'new []' 将数组类型实例分配到堆中。在new标记后指定元素类型。使用[和]标记指定每个维度。每个维度的尺寸由[和]标记之间的一个int类型值指定。

错误

如果为维度的尺寸指定的值不是int类型值，或者不能转换为int类型的值。

语法

new_array: 'new' TYPE ('[' expression ']')+;

示例

不同数组类型的分配。

int[] x = new int[5];    
x = new int[10];         
int y = 2;               
def z = new def[y][y*2];

	声明 `int[] x`；分配具有`length [5]` 的`一维整型数组`实例 → `一维整型数组引用`；将`一维整型数组引用`存储到`x`
	分配具有`length [10]` 的`一维整型数组`实例 → `一维整型数组引用`；将`一维整型数组引用`存储到`x`
	声明 `int y`；将 `int 2` 存储到 `y`；
	声明 `def z`；从 `y` 加载 → `int 2 @0`；从 `y` 加载 → `int 2 @1`；将 `int 2 @1` 乘以 `int 2 @2` → `int 4`；分配具有长度`[2, 4]`的`二维整型数组`实例 → `二维整型数组引用`；将`二维整型数组引用`隐式转换为`def` → `def`；将`def`存储到`z`；

« 运算符：参考语句 »