Java数组

数组

本质上就是能 “批量” 创建相同类型的变量（在Java中，数组中包含的变量必须是相同类型）。

数组的定义：
数据类型[] 数组变量名 = new 数据类型[整数]; //整数：数组的长度
数据类型[] 数组变量名 = {值1,值2,值3…值n}; //（静态初始化）
数据类型[] 数组变量名 = new 数据类型[]{值1,值2,值3…值n}; //（动态初始化）

数组（引用类型）：
数组的下标不要越界使用，否则会报错（编译阶段不报错，运行报异常）

二维数组的定义：
数据类型[][] 数组变量名 = new 数据类型[整数][整数];

数组是引用类型，引用类型有可能发生空指向的问题。
int[] arr=null;    //null空指向
引用数据类型可以赋值成 null，这就代表是空指向。
if(arr != null && arr.length != 0)

注意：

1. 使用 arr.length 能够获取到数组的长度，这个操作为成员访问操作符。
2. 使用 [] 按下标取数组元素。需要注意，下标从 0 开始计数。
3. 使用 [] 操作既能读取数据，也能修改数据。
4. 下标访问操作不能超出有效范围 [0, length - 1]，如果超出有效范围，会出现下标越界异常。

遍历数组：

// for 循环遍历数组
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// 使用 for-each 遍历数组
for (int x : arr) {
    System.out.println(x);
}

创建一个数组（初识JVM内存模型）

创建一个引用只是相当于创建了一个很小的变量，这个变量保存了一个整数，这个整数表示内存中的一个地址。

例如：int[] arr=new int[]{1,2,3};
a) 当创建 new int[]{1,2,3} 的时候，相当于创建了一块内存空间保存三个 int

b) 然后执行 int[] arr=new int[]{1,2,3} 相当于有创建了一个 int[] 变量，这个变量是一个引用类型，里面只保存了一个整数（数组的起始内存地址）

c) 接下来进行传参相当于 int[] a=arr

d) 然后修改 a[0]，此时是根据 0x100 这样的地址找到对应的内存位置，将值改成 100

此时已经将 0x100 地址的数据改成了 100，那么根据实参 arr 来获取数组内容 arr[0]，本质上也是获取 0x100 地址上的数据，也是 100。

总结：所谓的 “引用” 本质上只是存了一个地址。
Java 将数组设定成引用类型，这样后续进行数组参数传参，其实只是将数组的地址传入到函数形参中，这样可以避免对整个数组的拷贝(数组可能比较长，那么拷贝开销就会很大)。

数组作为方法的返回值

// 没有返回值
// 但破坏了原有数组，若不破坏原数组, 就要在方法内部创建一个新的数组，并由方法返回出来
public static void transform(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[i] * 2;
    }
}

// 有返回值
// 数组是引用类型，返回时只是将这个数组的首地址返回给函数调用者，没有拷贝数组内容，从而比较高效
public static int[] transform(int[] arr) {
    int[] ret = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        ret[i] = arr[i] * 2;
    }
    return ret;
}

数组Exercise

// 使用二进制搜索算法搜索指定数组的指定值
(int)Arrays.binarySearch(int[] a,int key)
(int)Arrays.binarySearch(int[] a,int fromIndex,int toIndex,int key)   // [fromIndex,toIndex)

// 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。
(int[])Arrays.copyOf(int[] original,int newLength)
// 将指定数组的指定范围复制到新数组中
(int[])Arrays.copyOfRange(int[] original,int from,int to)   // [from,to)

// 如果两个指定的int数组彼此相等，则返回 true
(boolean)Arrays.equals(int[] a1,int[] a2)

// 将val值赋给指定的int数组的每个元素。
(void)Arrays.fill(int[] a,int val)
// 将val值赋给指定的int数组的指定范围的每个元素。 
(void)Arrays.fill(int[] a,int fromIndex,int toIndex,int val)

// 根据指定数组的内容返回哈希码
(int)Arrays.hashCode(int[] a)

// 按照数字顺序排列指定的数组
(void)Arrays.parallelSort(int[] a)
// 按照数字顺序排列数组的指定范围
(void)Arrays.parallelSort(int[] a，int fromIndex,int toIndex)

// 按照数字顺序排列指定的数组
(void)Arrays.sort(int[] a)
// 按升序排列数组的指定范围
(void)Arrays.sort(int[] a，int fromIndex,int toIndex)

// 返回指定数组的内容的字符串表示形式
(String)Arrays.toString(int[] a)

数组转字符串

int[] arr = {1,2,3,4,5,6}; 
String newArr = Arrays.toString(arr); 
System.out.println(newArr); 

// 执行结果
[1, 2, 3, 4, 5, 6]

数组拷贝

int[] arr = {1,2,3,4,5,6}; 
int[] newArr = Arrays.copyOf(arr, arr.length); 
System.out.println("newArr: " + Arrays.toString(newArr)); 

注意：
相比于 newArr = arr 这样的赋值，copyOf 是将数组进行了深拷贝，即又创建了一个数组对象，拷贝原有数组中的所有元素到新数组中。因此，修改原数组，不会影响到新数组。

最大值

public static int max(int[] arr) { 
	int max = arr[0]; 
    for (int i = 1; i < arr.length; i++) { 
    	if (arr[i] > max) { 
    		max = arr[i]; 
    	} 
    } 
 	return max; 
}

平均值

public static double avg(int[] arr) { 
	int sum = 0; 
 	for (int x : arr) { 
 		sum += x; 
 	} 
 	// 结果要用 double 来表示
 	return (double)sum / (double)arr.length; 
} 

// 执行结果
3.5

查找指定元素

public static int find(int[] arr, int toFind) { 
 	for (int i = 0; i < arr.length; i++) { 
 		if (arr[i] == toFind) { 
 			return i; 
 		} 
 	} 
 	return -1; // 表示没有找到
}

有序数组，二分查找

public static int binarySearch(int[] arr, int toFind) { 
 	int left = 0; 
 	int right = arr.length - 1; 
 	
 	while (left <= right) { 
 		int mid = (left + right) / 2; 
 		if (toFind < arr[mid]) { 
 			// 去左侧区间找
 			right = mid - 1; 
 		} else if (toFind > arr[mid]) { 
 			// 去右侧区间找
 			left = mid + 1; 
 		} else { 
 			// 相等, 说明找到了
 			return mid; 
 		} 
	} 
 	// 循环结束, 说明没找到
 	return -1; 
} 

检查数组有序性

public static boolean isSorted(int[] arr) { 
 	for (int i = 0; i < arr.length - 1; i++) { 
 		if (arr[i] > arr[i + 1]) { 
 			return false; 
 		} 
 	} 
 	return true; 
}

数组排序

public static void main(String[] args) { 
 	int[] arr = {9, 5, 2, 7}; 
 	Arrays.sort(arr); 
 	System.out.println(Arrays.toString(arr)); 
}

数组逆序

public static void reverse(int[] arr) { 
 	int left = 0; 
 	int right = arr.length - 1; 
 	
 	while (left < right) { 
 		int tmp = arr[left]; 
 		arr[left] = arr[right]; 
 		arr[right] = tmp; 
 		left++; 
 		right--; 
 	} 
}

偶数在前，奇数在后

public static void transform(int[] arr) { 
 	int left = 0; 
 	int right = arr.length - 1; 
 	
 	while (left < right) { 
 		// 该循环结束, left 就指向了一个奇数
 		while (left < right && arr[left] % 2 == 0) { 
 			left++; 
 		} 
 		
 		// 该循环结束, right 就指向了一个偶数
 		while (left < right && arr[right] % 2 != 0) { 
 			right--; 
 		} 
 		
 		// 交换两个位置的元素
 		int tmp = arr[left]; 
 		arr[left] = arr[right]; 
 		arr[right] = tmp; 
 	} 
}