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

运算符：数组

编辑

运算符：数组编辑

数组初始化编辑

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

错误

  • 如果一个值不能转换为指定类型的值。

语法

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

示例

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

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

    声明 int[] x; 分配 1-d int 数组 实例，长度为 [3] → 1-d int 数组引用; 将 int 1 存储到 1-d int 数组引用 的 索引 [0] 中; 将 int 2 存储到 1-d int 数组引用 的 索引 [1] 中; 将 int 3 存储到 1-d int 数组引用 的 索引 [2] 中; 将 1-d 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-d def 数组 实例，长度为 [4] → 1-d def 数组引用; 从 i 加载 → int 1; 隐式转换 int 1 为 def → def; 将 def 存储到 1-d def 数组引用 的 索引 [0] 中; 从 l 加载 → long 2; 隐式转换 long 2 为 def → def; 将 def 存储到 1-d 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-d def 数组引用 的 索引 [2] 中; 从 s 加载 → String "5"; 隐式转换 String "5" 为 def → def; 将 def 存储到 1-d def 数组引用 的 索引 [3] 中; 隐式转换 1-d 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-d int 数组 实例，长度为 [2] → 1-d int 数组引用; 将 1-d int 数组引用 存储到 x 中

    从 x 加载 → 1-d int 数组引用; 将 int 2 存储到 1-d int 数组引用 的 索引 [0] 中;

    从 x 加载 → 1-d int 数组引用; 将 int 5 存储到 1-d int 数组引用 的 索引 [1] 中;

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

    声明 int z; 将 int 1 存储到 z 中;

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

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

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

    声明 int x; 从 d 加载 → def 隐式转换 def 为 1-d int 数组引用 → 1-d int 数组引用; 从 1-d int 数组引用 的 索引 [0] 加载 → int 2; 从 d 加载 → def 隐式转换 def 为 1-d int 数组引用 → 1-d int 数组引用; 从 1-d 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-d int 数组引用 → 1-d int 数组引用; 从 y 加载 → def; 隐式转换 def 为 int 1 → int 1; 从 1-d 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-d int 数组 实例，长度为 [2, 3, 4] → 3-d int 数组引用; 将 3-d int 数组引用 存储到 ia3 中

    从 ia3 加载 → 3-d int 数组引用; 将 int 99 存储到 3-d int 数组引用 的 索引 [1, 2, 3] 中

    声明 int i; 从 ia3 加载 → 3-d int 数组引用; 从 3-d 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-d int 数组 实例，长度为 [2] → 1-d int 数组引用; 将 1-d int 数组引用 存储到 x 中

    声明 int l; 加载 x → 1-d int 数组引用; 从 1-d 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; 使用 length [5] 分配 1-d int 数组 实例 → 1-d int 数组引用; 将 1-d int 数组引用 存储到 x 中

    使用 length [10] 分配 1-d int 数组 实例 → 1-d int 数组引用; 将 1-d int 数组引用 存储到 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] 分配 2-d int 数组 实例 → 2-d int 数组引用; 将 2-d int 数组引用 隐式转换为 def → def; 将 def 存储到 z 中;
« 运算符：参考 语句 »