声明、定义、赋值

1// Syntax
2 // dataType[] arrayName;
3 // dataType[] arrayName = new dataType[arrayLength];
4 // dataType[] arrayName = {value1, value2, value3};
5 // All dataType
6 // byte[], char[], int[], float[], String[], Object
7 
8 // Occasion#1
9 int[] a;          // declare
10 void setup() {
11 a = new int[5]; // create
12 a[0] = 0;       // assign
13 }
14 
15 // Occasion#2
16 int[] a = new int[5]; // declare & create
17 void setup() {
18 a[0] = 0;           // assign
19 }
20 
21 // Occasion#3
22 // declare & create & assign
23 int[] a = { 19, 40, 75, 76, 90 }; 
24 
25 // Occasion#4
26 // assign with for
27 int[] a = new int[5]; 
28 void setup() {
29 for (int i = 0; i < a.length; i++) {
30 a[i] = i;
31 }
32 }
33

数组的读取

1
2int[] points = {100, 100, 200, 200 };
3 void setup() {
4 size(500, 500);
5 rectMode(CORNERS);
6 rect(points[0], points[1], points[2], points[3]);
7 }
8 

arrayCopy() - 复制

• 复制数组#1 到数组#2。
• 此方法比 for 复制数组效率高。
• 数组#2 长度不能大于数组#1。

1// arrayCopy(original, originalStartPos, new, newStartPos, length)  
2 int[] a = {0, 1, 2};
3 int[] b = {3, 4, 5};
4 void setup() {
5 arrayCopy(a, 1, b, 0, 2);
6 printArray(b); // {1, 2, 5};
7 }
8 
9 // arrayCopy(original, new, length)  
10 int[] a = {0, 1, 2};
11 int[] b = {3, 4, 5};
12 void setup() {
13 arrayCopy(a, b, 2);
14 printArray(b); // {0, 1, 5};
15 }
16 
17 // arrayCopy
18 int[] a = {0, 1, 2};
19 int[] b = {3, 4, 5};
20 void setup() {
21 arrayCopy(a, b);
22 printArray(b); // {0, 1, 2};
23 }
24 

append() - 增长

• 在数组末尾添加一个元素，并返回一个新的数组。

1// append(array, value)
2 int[] append(int[] array, int value) {
3 // declare & create an array with one more element than before
4 int[] newArray = new int[array.length + 1];
5 // copy the old array to the new array
6 arrayCopy(array, newArray);
7 // assign the value to the last element
8 newArray[newArray.length - 1] = value;
9 // return the array
10 return newArray;
11 }
12 
13 // example
14 int[] a = {0, 1};
15 void setup() {
16 a = append(a, 2);
17 printArray(a);  // {0, 1, 2}
18 }
19 

shorten() - 缩短

• 在数组末尾删除一个元素，并返回一个新的数组。

1// shorten(array)
2 int[] shorten(int[] array) {  
3 // declare & create an array with one more element than before
4 int[] newArray = new int[array.length - 1];
5 // assign each value but the last
6 for (int i = 0; i < newArray.length; i++) {
7 newArray[i] = array[i];
8 }
9 // return the array
10 return newArray;
11 }
12 
13 // example
14 int[] a = {0, 1, 2};
15 void setup() {
16 a = shorten(a);
17 printArray(a);  // {0, 1}
18 }
19 

expand() - 增长&缩短

• 重新更改数组大小，多补 0，少丢失。

1// expand(array)  
2 int[] expand(int[] array) {
3 // declare & create an array with double-size of the array
4 int[] newArray = new int[array.length * 2];
5 // copy the old array to the new array 
6 arrayCopy(array, newArray);
7 // return the array
8 return newArray;
9 }
10 
11 // expand(array, size)  
12 int[] expand_(int[] array, int size) {
13 // declare & create an array with double-size of the array
14 int[] newArray = new int[size];
15 // reduce the old to prevent size < array.length
16 while (array.length > size) {
17 array = shorten(array);
18 }
19 // copy the old array to the new array 
20 arrayCopy(array, newArray);
21 // return the array
22 return newArray;
23 }
24 
25 // example
26 int[] a = {0, 1, 2, 3};
27 void setup() {
28 a = expand(a);
29 println(a.length);  // 8
30 a = expand(a, 512);
31 println(a.length);  // 512
32 a = expand(a, 2);
33 println(a.length);  // 2
34 }
35

concat() - 合并

• 合并两个数组。

1// concat(array1, array2)
2 int[] concat(int[] array1, int[] array2) {
3 // create a new array with the size of the sum of array1 & array 2
4 int[] newArray = new int[array1.length + array2.length];
5 // copy first array
6 arrayCopy(array1, newArray);
7 // copy second array after the first
8 arrayCopy(array2, 0, newArray, array1.length, array2.length);
9 // return the array
10 return newArray;
11 }
12 
13 // example
14 int[] a = {0, 1, 2};
15 int[] b = {3, 4, 5};
16 void setup() {
17 printArray(concat(a, b)); // {0, 1, 2, 3, 4, 5}
18 }
19 

reverse() - 翻转

• 将数组翻转

1// reverse(array)
2 int[] reverse(int[] array) {
3 // declare and create an array with the size of the old
4 int[] newArray = new int[array.length];
5 // reverse it by assign the start of the newArray with the end of the old 
6 for (int begin = 0, end = array.length - 1; end >= 0; end--, begin++) {
7 newArray[begin] = array[end];
8 }
9 return newArray;
10 }
11 
12 // example
13 int[] a = {0, 1, 2};
14 void setup() {
15 printArray(reverse(a)); // {2, 1, 0}
16 }
17 

sort() - 排序

• 将数组从小到大排序

1// sort(array)
2 int[] a = {0, 2, 5, 1, 3, 4};
3 void setup() {
4 printArray(sort(a)); // {0, 1, 2, 3, 4, 5}
5 }
6 
7 // sort(array, count)
8 int[] a = {0, 2, 5, 1, 3, 4};
9 void setup() {
10 printArray(sort(a, 3)); // {0, 2, 5, 1, 3, 4}
11 }
12 

subset() - 子集

• 获得数组的特定部分。

1// subset(array, startIndex)
2 int[] subset(int[] array, int index) {
3 // create an array with the size of array.length - index
4 int[] newArray = new int[array.length - index];
5 // copy elements in range
6 arrayCopy(array, index, newArray, 0, newArray.length);
7 // return
8 return newArray;
9 }
10 
11 // example
12 int[] a = {0, 1, 2, 3, 4, 5, 6};
13 void setup() {
14 a = subset(a, 1);
15 printArray(a); // {1, 2, 3, 4, 5, 6}
16 }
17 
18 // subset(array, startIndex, count)
19 int[] subset_(int[] array, int index, int count) {
20 // create an array with the size of count
21 int[] newArray = new int[count];
22 // copy elements in range
23 arrayCopy(array, index, newArray, 0, count);
24 // return
25 return newArray;
26 }
27 
28 // example
29 int[] a = {0, 1, 2, 3, 4, 5, 6};
30 void setup() {
31 a = subset(a, 1, 2);
32 printArray(a); // {1, 2}
33 }
34 

splice() - 添加值

• 在数组特定位置添加一个值。

1// splice(array, value, position)
2 int[] splice_(int[] array, int value, int index) {
3 // create an array with the size of index + 1
4 int[] newArray = new int[index + 1];
5 // create a sub array with the first "half" part
6 int[] temp = subset(array, 0, index);
7 // append the value to it and copy it to the new
8 arrayCopy(append(temp, value), newArray);
9 // create a sub array with the last part
10 temp = subset(array, index);
11 // concat it
12 newArray = concat(newArray, temp);
13 // return
14 return newArray;
15 }
16 
17 // example
18 int[] a = {0, 1, 3};
19 void setup() {
20 a = splice(a, 2, 2);
21 printArray(a); // {0, 1, 2, 3}
22 }
23 

(★) 编程题#1 - 查找整数

描述：在一个不重复数组中，找到一个整数

输入：数组模拟用户输入，变量模拟需要查找的整数。

输出：如果找到，输出下标；如果没找到，输出”-1”。

(★★) 编程题#2 - 冒泡排序

描述：一次比较两个元素，如果它们的顺序错误就把它们交换过来。

输入：数组模拟用户输入。

输出：排序好的数组。