« 运算符：参考 语句 »
Elastic 文档 ›Painless 脚本语言 [8.17] ›Painless 语言规范

运算符：数组

编辑

运算符：数组

编辑

数组初始化

编辑

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

错误

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

语法

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

示例

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

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

    声明 int[] x；分配 1 维 int 数组 实例，长度为 [3] → 1 维 int 数组引用；将 int 1 存储到 1 维 int 数组引用的 索引 [0]；将 int 2 存储到 1 维 int 数组引用的 索引 [1]；将 int 3 存储到 1 维 int 数组引用的 索引 [2]；将 1 维 int 数组引用 存储到 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；将 int 1 存储到 i

    声明 long l；将 long 2 存储到 l

    声明 float f；将 float 3.0 存储到 f

    声明 double d；将 double 4.0 存储到 d

    声明 String s；将 String "5" 存储到 s

    声明 def array；分配 1 维 def 数组 实例，长度为 [4] → 1 维 def 数组引用；从 i 加载 → int 1；隐式转换 int 1 到 def → def；将 def 存储到 1 维 def 数组引用的 索引 [0]；从 l 加载 → long 2；隐式转换 long 2 到 def → def；将 def 存储到 1 维 def 数组引用的 索引 [1]；从 f 加载 → float 3.0；从 d 加载 → double 4.0；提升 float 3.0 和 double 4.0：结果为 double；隐式转换 float 3.0 到 double 3.0 → double 3.0；将 double 3.0 和 double 4.0 相乘 → double 12.0；隐式转换 double 12.0 到 def → def；将 def 存储到 1 维 def 数组引用的 索引 [2]；从 s 加载 → String "5"；隐式转换 String "5" 到 def → def；将 def 存储到 1 维 def 数组引用的 索引 [3]；隐式转换 1 维 int 数组引用 到 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；分配 1 维 int 数组 实例，长度为 [2] → 1 维 int 数组引用；将 1 维 int 数组引用 存储到 x

    从 x 加载 → 1 维 int 数组引用；将 int 2 存储到 1 维 int 数组引用的 索引 [0]；

    从 x 加载 → 1 维 int 数组引用；将 int 5 存储到 1 维 int 数组引用的 索引 [1]；

    声明 int y；从 x 加载 → 1 维 int 数组引用；从 1 维 int 数组引用的 索引 [0] 加载 → int 2；从 x 加载 → 1 维 int 数组引用；从 1 维 int 数组引用的 索引 [1] 加载 → int 5；将 int 2 和 int 5 相加 → int 7；将 int 7 存储到 y

    声明 int z；将 int 1 存储到 z；

    声明 int i；从 x 加载 → 1 维 int 数组引用；从 z 加载 → int 1；从 1 维 int 数组引用的 索引 [1] 加载 → int 5；将 int 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；分配 1 维 int 数组 实例，长度为 [2] → 1 维 int 数组引用；隐式转换 1 维 int 数组引用 到 def → def；将 def 存储到 d

    从 d 加载 → def 隐式转换 def 到 1 维 int 数组引用 → 1 维 int 数组引用；将 int 2 存储到 1 维 int 数组引用的 索引 [0]；

    从 d 加载 → def 隐式转换 def 到 1 维 int 数组引用 → 1 维 int 数组引用；将 int 5 存储到 1 维 int 数组引用的 索引 [1]；

    声明 int x；从 d 加载 → def 隐式转换 def 到 1 维 int 数组引用 → 1 维 int 数组引用；从 1 维 int 数组引用的 索引 [0] 加载 → int 2；从 d 加载 → def 隐式转换 def 到 1 维 int 数组引用 → 1 维 int 数组引用；从 1 维 int 数组引用的 索引 [1] 加载 → int 5；将 int 2 和 int 5 相加 → int 7；隐式转换 int 7 到 def → def；将 def 存储到 x

    声明 def y；隐式转换 int 1 到 def → def；将 def 存储到 y；

    声明 int i；从 d 加载 → def 隐式转换 def 到 1 维 int 数组引用 → 1 维 int 数组引用；从 y 加载 → def；隐式转换 def 到 int 1 → int 1；从 1 维 int 数组引用的 索引 [1] 加载 → int 5；隐式转换 int 5 到 def；将 def 存储到 z；

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

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

    声明 int[][][] ia；分配 3 维 int 数组 实例，长度为 [2, 3, 4] → 3 维 int 数组引用；将 3 维 int 数组引用 存储到 ia3

    从 ia3 加载 → 3 维 int 数组引用；将 int 99 存储到 3 维 int 数组引用的 索引 [1, 2, 3]

    声明 int i；从 ia3 加载 → 3 维 int 数组引用；从 3 维 int 数组引用的 索引 [1, 2, 3] 加载 → int 99；将 int 99 存储到 i

数组长度

编辑

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

示例

  • 访问 length 字段。

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

    声明 int[] x；分配 1 维 int 数组 实例，长度为 [2] → 1 维 int 数组引用；将 1 维 int 数组引用 存储到 x

    声明 int l；加载 x → 1 维 int 数组引用；从 1 维 int 数组引用 加载 length → int 10；将 int 10 存储到 l；

新数组

编辑

使用 新数组运算符 '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; 分配一个 一维整数数组 实例，长度为 [5] → 一维整数数组引用; 将 一维整数数组引用 存储到 x

    分配一个 一维整数数组 实例，长度为 [10] → 一维整数数组引用; 将 一维整数数组引用 存储到 x

    声明 int y; 将 整数 2 存储到 y;

    声明 def z; 从 y 加载 → 整数 2 @0; 从 y 加载 → 整数 2 @1; 将 整数 2 @1 乘以 整数 2 @2 → 整数 4; 分配一个 二维整数数组 实例，长度为 [2, 4] → 二维整数数组引用; 将 二维整数数组引用 隐式转换为 def → def; 将 def 存储到 z;
« 运算符：参考 语句 »