21、深入探索Nashorn中的集合操作

深入探索Nashorn中的集合操作

1. ArrayBuffer相关操作

在Nashorn中，ArrayBuffer是处理二进制数据的重要对象。它有两个关键内容值得关注：一是 isView(args) 静态方法，二是 slice(start, end) 方法。

isView(args) 方法用于判断传入的参数是否代表一个数组缓冲区视图。不过在Java 8u40的Nashorn中，该方法并未实现，相关的bug已在 这里 提交。以下是使用该方法的示例代码：

// Creates an array buffer view of length 4
var int8View = new Int8Array(4);

// Assigns true to isView1
var isView1 = ArrayBuffer.isView(int8View);

// Assigns false to isView2
var isView2 = ArrayBuffer.isView({});

由于在Java 8u40中该方法不存在，上述代码会抛出异常。

slice(start, end) 方法用于创建并返回一个新的ArrayBuffer，其内容是原ArrayBuffer从起始索引（包含）到结束索引（不包含）的副本。若起始或结束索引为负数，则表示从缓冲区末尾开始的索引；若未指定结束索引，则默认为ArrayBuffer的 byteLength 属性。起始和结束索引会被限制在0到 byteLength - 1 之间。示例代码如下：

// Create an ArrayBuffer of 4 bytes. Bytes have indexes 0, 1, 2, and 3
var buffer = new ArrayBuffer(4);

// Manipulate buffer using one of the typed views here...

// Copy the last 2 bytes from buffer to buffer2
var buffer2 = buffer.slice(2, 4);

// Copy the bytes from buffer from index 1 to the end (last 3 bytes) 
// to buffer3
var buffer3 = buffer.slice(1);

2. ArrayBuffer的视图类型

ArrayBuffer有两种视图类型：
- 类型化数组视图（Typed Array Views）
- 数据视图（DataView Views）

2.1 类型化数组（Typed Arrays）

类型化数组视图是类似数组的对象，用于处理特定类型的值，如32位有符号整数。它们提供了一种向ArrayBuffer读写特定类型数据的方式，且所有数据值大小相同。以下是类型化数组视图的列表：
| 类型化数组视图 | 字节大小 | 描述 |
| ---- | ---- | ---- |
| Int8Array | 1 | 8位二进制补码有符号整数 |
| Uint8Array | 1 | 8位无符号整数 |
| Uint8ClampedArray | 1 | 8位无符号整数（钳位） |
| Int16Array | 2 | 16位二进制补码有符号整数 |
| Uint16Array | 2 | 16位无符号整数 |
| Int32Array | 4 | 32位二进制补码有符号整数 |
| Uint32Array | 4 | 32位无符号整数 |
| Float32Array | 4 | 32位IEEE浮点数 |
| Float64Array | 8 | 64位IEEE浮点数 |

需要注意的是，类型化数组是固定长度、密集的类似数组的对象，而普通的Array对象是可变长度的数组，可能是稀疏或密集的。以 Uint8Array 和 Uint8ClampedArray 为例，它们的元素都是8位无符号整数，范围从0到255。 Uint8Array 使用模256来存储值，而 Uint8ClampedArray 将值钳位在0到255之间。例如：

var uint8Array = new Uint8Array(1);
uint8Array[0] = 260; // 存储4，因为260 % 256 = 4

var uint8ClampedArray = new Uint8ClampedArray(1);
uint8ClampedArray[0] = 260; // 存储255

每个类型化数组视图对象都定义了两个属性：
- BYTES_PER_ELEMENT ：表示类型化数组元素的字节大小。
- name ：表示视图的名称。

类型化数组视图提供四种构造函数，以 Int8Array 为例：
- Int8Array(arrayBuffer, byteOffset, elementCount) ：从ArrayBuffer创建类型化数组视图，可以是完整或部分视图。
- Int8Array(length) ：根据指定长度创建一个适当大小的ArrayBuffer，并返回其完整视图。
- Int8Array(typedArray) ：从另一个类型化数组创建新的类型化数组。
- Int8Array(arrayObject) ：从普通数组对象创建新的类型化数组。

以下是使用不同构造函数创建 Int8Array 对象的示例：

// Create an ArrayBuffer of 8 bytes
var buffer = new ArrayBuffer(8);

// Create an Int8Array that is a full view of buffer
var fullView = new Int8Array(buffer);

// Create an Int8Array that is the first half view of buffer
var firstHalfView = new Int8Array(buffer, 0, 4);

// Create an Int8Array that is the copy of the firstHalfView array
var copiedView = new Int8Array(firstHalfView);

// Create an Int8Array using elements from an Array object
var ids = new Int8Array([10, 20, 30]);

所有类型化数组对象都有以下属性：
- length ：数组中的元素数量。
- byteLength ：数组的字节长度。
- buffer ：底层ArrayBuffer对象的引用。
- byteOffset ：从其ArrayBuffer起始处的字节偏移量。

创建类型化数组后，可以像使用普通数组对象一样使用它。例如：

// Create an Int8Array of 3 elements. Each element is an 8-bit sign integer.
var ids = new Int8Array(3);

// Populate the array
ids[0] = 10;
ids[1] = 20.89; // 20 will be stored
ids[2] = 140;   // -116 is stored as byte's range is -128 to 127.

// Read the elements
print("ids[0] = " + ids[0]);
print("ids[1] = " + ids[1]);
print("ids[2] = " + ids[2]);

还可以使用同一个ArrayBuffer存储不同类型的值。例如，创建一个8字节的ArrayBuffer，在前4字节存储32位有符号整数，在后4字节存储32位有符号浮点数：

// Create an 8=byte buffer
var buffer = new ArrayBuffer(8);

// Create an Int32Array view for the first 4 bytes. byteOffset is 0
// and element count is 1
var id = new Int32Array(buffer, 0, 1);

// Create a Float32Array view for the second 4 bytes. The first 4 bytes
// will be used for integer value. byteOffset is 4 and element count is 1
var salary = new Float32Array(buffer, 4, 1);

// Use the Int32Array view to store an integer
id[0] = 1001;

// Use the Float32Array view to store a floating-point number
salary[0] = 129019.50;

// Read and print the two values using the two views
print("id = " + id[0]);
print("salary = " + salary[0]);

需要注意的是，当通过提供ArrayBuffer的长度来创建类型化数组时，ArrayBuffer的长度必须是元素大小的倍数。例如，创建 Int32Array 时，其缓冲区大小必须是4的倍数，否则会抛出异常：

var buffer = new ArrayBuffer(15);

// Throws an exception because an element of Int32Array takes 4 bytes and
// 15, which is the buffer size for the view, is not a multiple of 4
var id = new Int32Array(buffer);

可以使用 slice() 方法复制部分ArrayBuffer，并在复制的缓冲区上创建新的视图：

// Create an ArrayBuffer of 4 bytes
var buffer = new ArrayBuffer(4);

// Create an Int8Array from buffer
var int8View1 = new Int8Array(buffer);

// Populate the array
int8View1[0] = 10;
int8View1[1] = 20;
int8View1[2] = 30;
int8View1[3] = 40;

print("In original buffer:")
for(var i = 0; i < int8View1.length; i++) {
    print(int8View1[i]);
}

// Copy the last two bytes from buffer to buffer2
var buffer2 = buffer.slice(2, 4);

// Create an Int8Array from buffer2
var int8View2 = new Int8Array(buffer2);

print("In copied buffer:");
for(var i = 0; i < int8View2.length; i++) {
    print(int8View2[i]);
}

由于类型化数组是类似数组的对象，因此可以使用Array对象的大多数方法。例如，使用 join() 方法连接 Int32Array 的元素：

// Create an Int32Array of 4 elements
var ids = new Int32Array(4);

// Populate the array
ids[0] = 101;
ids[1] = 102;
ids[2] = 103;
ids[3] = 104;

// Call the join() method of the Array.prototype object and print the result
var idsList = Array.prototype.join.call(ids);
print(idsList);

2.2 数据视图（DataView View）

DataView视图提供了一个底层接口，用于从ArrayBuffer读写不同类型的数据。通常在ArrayBuffer中的数据包含不同类型的数据时使用。需要注意的是，DataView不是类型化数组，只是ArrayBuffer的一个视图。其构造函数的签名为：

DataView(arrayBuffer, byteOffset, byteLength)

它创建一个指定arrayBuffer的视图，从 byteOffset 索引开始引用 byteLength 字节。若未指定 byteLength ，则从 byteOffset 开始引用到数组末尾；若 byteOffset 和 byteLength 都未指定，则引用整个arrayBuffer。

与类型化数组视图不同，DataView对象可以使用混合数据类型的值，因此它没有 length 属性，但有 buffer 、 byteOffset 和 byteLength 属性。它包含以下用于读写不同类型值的getter和setter方法：
- getInt8(byteOffset)
- getUint8(byteOffset)
- getInt16(byteOffset, littleEndian)
- getUint16(byteOffset, littleEndian)
- getInt32(byteOffset, littleEndian)
- getUint32(byteOffset, littleEndian)
- getFloat32(byteOffset, littleEndian)
- getFloat64(byteOffset, littleEndian)
- setInt8(byteOffset, value)
- setUint8(byteOffset, value)
- setInt16(byteOffset, value, littleEndian)
- setUint16(byteOffset, value, littleEndian)
- setInt32(byteOffset, value, littleEndian)
- setUint32(byteOffset, value, littleEndian)
- setFloat32(byteOffset, value, littleEndian)
- setFloat64(byteOffset, value, littleEndian)

对于多字节值类型的getter和setter方法，有一个布尔类型的可选最后参数 littleEndian ，用于指定读写的值是小端还是大端格式；若未指定，则默认为大端格式。以下是使用DataView读写32位有符号整数和32位浮点数的示例：

// Create an ArrayBuffer of 8 bytes
var buffer = new ArrayBuffer(8);

// Create a DataView from the ArrayBuffer
var data = new DataView(buffer);

// Use the first 4 bytes to store a 32-bit signed integer
data.setInt32(0, 1001);

// Use the second 4 bytes to store a 32-bit floating-point number
data.setFloat32(4, 129019.50);

var id = data.getInt32(0);
var salary = data.getFloat32(4);
print("id = " + id);
print("salary = " + salary);

3. 使用列表、映射和集合

Nashorn没有提供内置对象来表示通用的映射和集合。不过可以使用任何Nashorn对象作为键为字符串的映射，也可以创建对象来表示映射和集合，但这有些重复造轮子。Java编程语言提供了多种类型的集合，包括映射和集合，可以在Nashorn中直接使用这些集合。下面重点介绍Java列表和映射在Nashorn中的特殊处理。

3.1 将Java列表用作Nashorn数组

Nashorn允许将Java列表视为Nashorn数组来读取和更新列表元素，但不能使用数组索引向列表添加元素。可以使用索引访问和更新列表元素，Nashorn会为Java列表实例添加 length 属性，使其可以像数组对象一样处理。以下是使用Java列表的示例代码：

// list.js
var ArrayList = Java.type("java.util.ArrayList");
var nameList = new ArrayList();

// Add few names using List.add() Java method
nameList.add("Lu");
nameList.add("Do");
nameList.add("Yu");

// Print the List
print("After adding names:");
for(var i = 0, len = nameList.size(); i < len; i++) {
    print(nameList.get(i));
}

// Update names using array indexes
nameList[0] = "Su";
nameList[1] = "So";
nameList[2] = "Bo";

// The following statement will throw an IndexOutOfBoundsException because
// it is trying to add a new element using teh array syntax. You can only
// update an element, not add a new element, using the array syntax.
// nameList[3] = "An";

print("After updating names:");
for(var i = 0, len = nameList.length; i < len; i++) {
    print(nameList[i]);
}

// Sort the list in natural order
nameList.sort(null);

// Use the Array.prototype.forEach() method to print the list
print("After sorting names:");
Array.prototype.forEach.call(nameList, function (value, index, data) {
    print(value);
});

该示例执行了以下操作：
- 创建一个 java.util.ArrayList 实例。
- 使用Java列表接口的 add() 方法向列表添加三个元素。
- 使用列表接口的 size() 和 get() 方法打印元素。
- 使用Nashorn语法访问数组元素来更新和打印元素，使用Nashorn的 length 属性获取列表大小。
- 使用Java列表的 sort() 方法对元素进行自然排序。
- 使用 Array.prototype.forEach() 方法打印排序后的元素。

3.2 将Java映射用作Nashorn对象

Nashorn对象本质上是存储字符串 - 对象对的映射。Nashorn允许将Java映射用作Nashorn对象，其中可以将映射中的键用作对象的属性。以下是使用Java映射的示例代码：

// map.js
// Create a Map instance
var HashMap = Java.type("java.util.HashMap");
var map = new HashMap();

// Add key-value pairs to the map using Java methods
map.put("Li", "999-11-0001");
map.put("Su", "999-11-0002");

// You can treat the Map as an object and add key-value pairs
// as if you are adding proeprties to the object
map["Yu"] = "999-11-0003";
map["Do"] = "999-11-0004";

// Access values using the Java Map.get() method and the bracket notation
var liPhone = map.get("Li");  // Java way
var suPhone = map.get("Su");  // Java way
var yuPhone = map["Yu"];      // Nashorn way
var doPhone = map["Do"];      // Nashorn way

print("Li's Phone: " + liPhone);
print("su's Phone: " + suPhone);
print("Yu's Phone: " + yuPhone);
print("Do's Phone: " + doPhone);

4. 使用Java数组

在Nashorn脚本中可以使用Java数组。Java数组在Rhino和Nashorn中的创建方式有所不同。在Rhino中，需要使用 java.lang.reflect.Array 类的 newInstance() 静态方法创建Java数组，这种方式效率低且有局限性。Nashorn支持一种新的创建Java数组的方式，同时也支持Rhino的语法。

4.1 使用Rhino语法创建和访问Java数组

// Create a java.lang.String array of 2 elements, populate it, and print the
// elements. In Rhino, you were able to use java.lang.String as the first
// argument; in Nashorn, you need to use java.lang.String.class instead.
var strArray = java.lang.reflect.Array.newInstance(java.lang.String.class, 2);

strArray[0] = "Hello";
strArray[1] = "Array";

for(var i = 0; i < strArray.length; i++) {
    print(strArray[i]);
}

创建基本类型数组（如int、double等）时，需要使用其对应包装类的 TYPE 常量，示例如下：

// Create an int array of 2 elements, populate it, and print the elements
var intArray = java.lang.reflect.Array.newInstance(java.lang.Integer.TYPE, 2);

intArray[0] = 100;
intArray[1] = 200;

for(var i = 0; i < intArray.length; i++) {
    print(intArray[i]);
}

4.2 使用Nashorn新语法创建Java数组

先使用 Java.type() 方法获取适当的Java数组类型，然后使用 new 运算符创建数组。示例如下：

// Get the java.lang.String[] type
var StringArray = Java.type("java.lang.String[]");

// Create a String[] array of 2 elements
var strArray = new StringArray(2);

// Populate the array
strArray[0] = "Hello";
strArray[1] = "Array";

for(var i = 0; i < strArray.length; i++) {
    print(strArray[i]);
}

同样，创建基本类型数组也可以使用这种方式：

// Get the int[] type
var IntArray = Java.type("int[]");

// Create a int[] array of 2 elements
var intArray = new IntArray(2);

intArray[0] = 100;
intArray[1] = 200;
for(var i = 0; i < intArray.length; i++) {
    print(intArray[i]);
}

若要在Nashorn中创建多维Java数组，数组类型的声明与Java中相同。例如， Java.type("int[][]") 将导入Java的 int[][] 数组类型，使用 new 运算符对导入的类型进行操作将创建 int[][] 数组。

此外，Nashorn支持在需要Java数组的地方使用Nashorn数组，它会进行必要的转换。假设有一个 PrintArray 类，其 print() 方法接受一个字符串数组作为参数：

// PrintArray.java
package com.jdojo.script;

public class PrintArray {
    public void print(String[] list) {
        System.out.println("Inside print(String[] list):" + list.length);
        for(String s : list) {
            System.out.println(s);
        }
    }
}

以下脚本将Nashorn数组传递给 PrintArray.print(String[]) 方法：

// Create a JavaScript array and populate it with three strings
var names = new Array();
names[0] = "Rhino";
names[1] = "Nashorn";
names[2] = "JRuby";

// Create an object of the PrintArray class
var PrintArray = Java.type("com.jdojo.script.PrintArray");
var pa = new PrintArray();

// Pass a JavaScript array to the PrintArray.print(String[] list) method
pa.print(names);

Nashorn还支持Java和Nashorn数组之间的类型转换，使用 Java.to() 和 Java.from() 方法。 Java.to() 方法将Nashorn数组类型转换为Java数组类型，它接受数组对象作为第一个参数，目标Java数组类型作为第二个参数，目标数组类型可以指定为字符串或类型对象。示例如下：

// Create a JavaScript array and populate it with three integers
var personIds = [100, 200, 300];

// Convert the JavaScript integer array to Java String[]
var JavaStringArray = Java.to(personIds, "java.lang.String[]")

若省略 Java.to() 函数的第二个参数，Nashorn数组将被转换为Java的 Object[] 。

Java.from() 方法将Java数组类型转换为Nashorn数组，该方法接受Java数组作为参数。示例如下：

// Create a Java int[]
var IntArray = Java.type("int[]");
var personIds = new IntArray(3);
personIds[0] = 100;
personIds[1] = 200;
personIds[2] = 300;

// Convert the Java int[] array to a Nashorn array
var jsArray = Java.from(personIds);

// Print the elements in the Nashorn array
for(var i = 0; i < jsArray.length; i++) {
    print(jsArray[i]);
}

综上所述，Nashorn提供了丰富的功能来处理集合、数组等数据结构，并且与Java的集合和数组有良好的交互，为开发者在脚本中使用Java的强大功能提供了便利。

深入探索Nashorn中的集合操作（续）

5. 操作流程总结与流程图

在前面的内容中，我们详细介绍了Nashorn中ArrayBuffer、类型化数组、DataView视图、Java列表、映射以及数组的相关操作。下面我们通过流程图和操作步骤总结，更清晰地梳理这些操作。

5.1 ArrayBuffer操作流程

graph TD;
    A[创建ArrayBuffer] --> B{选择操作};
    B -->|isView方法| C[判断是否为数组缓冲区视图];
    B -->|slice方法| D[创建新的ArrayBuffer副本];
    C --> E{结果};
    E -->|是| F[返回true];
    E -->|否| G[返回false];
    D --> H[指定起始和结束索引];
    H --> I[生成新的ArrayBuffer];

操作步骤：
1. 创建ArrayBuffer：使用 new ArrayBuffer(length) 创建指定长度的ArrayBuffer。
2. 使用 isView(args) 方法：传入参数，判断是否为数组缓冲区视图。
3. 使用 slice(start, end) 方法：指定起始和结束索引，创建新的ArrayBuffer副本。

5.2 类型化数组操作流程

graph TD;
    A[选择构造函数] --> B{构造函数类型};
    B -->|Int8Array(arrayBuffer, byteOffset, elementCount)| C[从ArrayBuffer创建视图];
    B -->|Int8Array(length)| D[根据长度创建视图];
    B -->|Int8Array(typedArray)| E[从另一个类型化数组创建];
    B -->|Int8Array(arrayObject)| F[从普通数组对象创建];
    C --> G[可选择部分或完整视图];
    D --> H[创建适当大小的ArrayBuffer];
    E --> I[复制内容];
    F --> J[复制内容];
    G --> K[操作类型化数组];
    H --> K;
    I --> K;
    J --> K;
    K --> L{操作类型};
    L -->|读写元素| M[使用索引操作];
    L -->|使用Array方法| N[调用Array对象方法];

操作步骤：
1. 选择构造函数：根据需求选择合适的构造函数创建类型化数组。
2. 操作类型化数组：
- 读写元素：使用索引操作类型化数组的元素。
- 使用Array方法：调用Array对象的方法处理类型化数组。

5.3 DataView视图操作流程

graph TD;
    A[创建ArrayBuffer] --> B[创建DataView];
    B --> C{选择操作};
    C -->|getter方法| D[读取不同类型数据];
    C -->|setter方法| E[写入不同类型数据];
    D --> F[指定字节偏移量和可选参数];
    E --> G[指定字节偏移量、值和可选参数];
    F --> H[获取数据];
    G --> I[写入数据];

操作步骤：
1. 创建ArrayBuffer：使用 new ArrayBuffer(length) 创建指定长度的ArrayBuffer。
2. 创建DataView：使用 new DataView(arrayBuffer, byteOffset, byteLength) 创建DataView。
3. 使用getter和setter方法：
- getter方法：指定字节偏移量和可选参数，读取不同类型的数据。
- setter方法：指定字节偏移量、值和可选参数，写入不同类型的数据。

5.4 Java列表和映射操作流程

graph TD;
    A[使用Java列表] --> B[创建Java列表实例];
    B --> C{操作类型};
    C -->|添加元素| D[使用add方法];
    C -->|更新元素| E[使用索引操作];
    C -->|排序元素| F[使用sort方法];
    C -->|遍历元素| G[使用forEach方法];
    H[使用Java映射] --> I[创建Java映射实例];
    I --> J{操作类型};
    J -->|添加键值对| K[使用put方法或对象属性方式];
    J -->|获取值| L[使用get方法或括号表示法];

操作步骤：
1. 使用Java列表：
- 创建Java列表实例：使用 Java.type("java.util.ArrayList") 创建列表。
- 添加元素：使用 add() 方法添加元素。
- 更新元素：使用索引操作更新元素。
- 排序元素：使用 sort() 方法排序元素。
- 遍历元素：使用 forEach() 方法遍历元素。
2. 使用Java映射：
- 创建Java映射实例：使用 Java.type("java.util.HashMap") 创建映射。
- 添加键值对：使用 put() 方法或对象属性方式添加键值对。
- 获取值：使用 get() 方法或括号表示法获取值。

5.5 Java数组操作流程

graph TD;
    A{选择创建方式} --> B[Rhino语法创建];
    A --> C[Nashorn新语法创建];
    B --> D[使用java.lang.reflect.Array.newInstance];
    C --> E[使用Java.type获取类型];
    D --> F[指定类型和长度];
    E --> G[使用new运算符];
    F --> H[创建Java数组];
    G --> H;
    H --> I{操作类型};
    I -->|读写元素| J[使用索引操作];
    I -->|类型转换| K{转换方向};
    K -->|Nashorn转Java| L[使用Java.to方法];
    K -->|Java转Nashorn| M[使用Java.from方法];

操作步骤：
1. 选择创建方式：
- Rhino语法：使用 java.lang.reflect.Array.newInstance 创建Java数组。
- Nashorn新语法：使用 Java.type() 获取类型，再使用 new 运算符创建。
2. 操作Java数组：
- 读写元素：使用索引操作Java数组的元素。
- 类型转换：
- Nashorn转Java：使用 Java.to() 方法进行转换。
- Java转Nashorn：使用 Java.from() 方法进行转换。

6. 总结与注意事项

通过以上内容，我们全面了解了Nashorn中集合、数组等数据结构的操作，以及与Java的交互。在使用过程中，需要注意以下几点：
- 方法实现情况 ：如 ArrayBuffer.isView(args) 方法在Java 8u40的Nashorn中未实现，使用时会抛出异常。
- 类型化数组长度要求 ：创建类型化数组时，ArrayBuffer的长度必须是元素大小的倍数，否则会抛出异常。
- Java列表操作限制 ：将Java列表用作Nashorn数组时，只能更新元素，不能使用数组语法添加新元素。

掌握这些操作和注意事项，能让开发者在Nashorn环境中更高效地处理数据，充分发挥Java和JavaScript的优势。在实际开发中，可以根据具体需求，灵活运用这些操作，实现复杂的数据处理和交互。