数组的部分练习

1.数组转字符串：

• 方法① 手动实现

public static String myToString(int[] array) {
	String ret = "[";
	for (int i = 0; i < array.length; i++) {
		ret += array[i];
		if (i < array.length - 1) {
		ret += ",";
		}
	}
	ret += "]";
	return ret;
}

• 方法② toString

使用 toString 方法后续打印数组就会很方便
Java 中提供了 java.util.Arrays 包，其中包含了一些操作数组的常用方法，可以去帮助文档自行查看

public static void main(String[] args) {
	int[] array = {1,2,3,4,5};
	String ret = Arrays.toString(array);
}

2.数组的拷贝：

将数组1 的内容 拷贝到数组2 中

• 方法① 手动实现

public static int[] copyArray(int[] array){
	//将array拷贝到 array2中
	int[] array2 = new int[array.length];
	for (int i = 0; i < array.length; i++) {
   		array2[i] = array[i];
	}
	return array2;
}

• 方法② copyOf

此处，返回了一个新的对象

public static void main(String[] args) {
	int[] array = {1,2,3,4,5,6};
	int[] ret = Arrays.copyOf(array,array.length);
	System.out.println(Arrays.toString(ret));
}

• 方法③ arraycopy

public static void main(String[] args) {
	int[] array = {1,2,3,4,5,6};
	int[] ret = new int[array.length];
	System.arraycopy(array,0,ret,0,array.length);
	System.out.println(Arrays.toString(ret));
}

看到这，你会发现，刚刚的方法②，底层调用的是System.arraycopy方法实现的
因为System.arraycopy是native的方法，故这几种方法种，方法③，即 System.arraycopy最快

• 方法④ clone

clone相当于产生了这个对象的一个副本
clone是Object的克隆方法，Object是所有类的父类

public static void main(String[] args) {
	int[] array = {1,2,3,4,5,6};
	int[] ret = array.clone();
	System.out.println(Arrays.toString(ret));
}

总结：

1. 这四种拷贝方式从本质上来说都是浅拷贝
2. copyOf 相对于数组元素来说：只有数组为一维数组，并且元素为基本类型、包装类或String类型时，才是深拷贝；其它都属于浅拷贝
3. 这四种方法，最快的是方法③，因为System.arraycopy是native方法，底层是C/C++代码实现的，而Array.copyOf的底层是调用了System.arraycopy，故方法③最快

3.找数组中的最大元素：

找出一个整型数组中的最大元素

public static int findMax(int[] array){
	int max = array[0];
	for (int i = 1; i < array.length; i++) {
		if(max < array[i]);
			max = array[i];
		}
		return max;
	}
public static void main(String[] args) {
	int[] array = {12,8,3,9,7,2,14,6};
	int ret = findMax(array);
	System.out.println("下标"+ ret);
}
输出结果：下标6

4.求数组中元素的平均值：

public static double aveArray(int[] array){
	int len = array.length;
	double ret = 0.0;
	int sum = 0;
	for (int i = 0; i < len; i++) {
		sum += array[i];
	}
	ret = sum/len;
	return ret;
}

此处注意结果要用double表示，因为可能会出现小数

5.查找数组中指定元素：

(1) 顺序查找：

public static int find1(int[] array,int toFind){
	for (int i = 0; i < array.length; i++) {
		if(array[i] == toFind) {
		return i;
		}
	}
	return -1; //表示没找到
}
public static void main(String[] args) {
	int[] array = {9,5,2,6,7,8,3,1,10};
	int ret = find1(array,8);
	System.out.println("下标："+ret);
}
执行结果 下标：5

(2) 二分查找 (折半查找) ：

针对有序数组， 可以使用二分查找，更高效
以升序数组为例，二分查找的思路是先取中间位置的元素，看要找的值比中间元素大还是小，如果小, 就去左边找；否则就去右边找
局限性：必须是一个有序数列

• 手动实现：

public static int binarySearch(int[] array,int toFind){
	int left = 0;
	int right = array.length-1;
	while(left <= right){
		int mid = (left + right) / 2;
		if(toFind < array[mid]){
			right = mid - 1;
		}
		else if(toFind > array[mid]){
			left = mid + 1;
		}
		else {
			return mid;
		}
	}
	return -1; //表示没找到
}

• 使用Arrays工具类

int[] array = {1,3,5,7,9,10,13};
System.out.println(Arrays.binarySearch(arrar,10));

6.判断数组是否有序：

给定一个数组，判断是否是升序 / 降序
以升序为例：

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

🔺7.数组 冒泡排序：

给定一个数组，让数组升序 / 降序排序
此处以升序为例：

• 代码①：

public static void bubbleSort(int[] array){
	for (int k = 0; k < array.length-1; k++) {
		for (int i = 0; i < array.length-1-k; i++) {
			if(array[i] > array[i+1]){
			int tmp = array[i];
			array[i] = array[i+1];
			array[i+1] = tmp;
			}
		}
	}
}
public static void main(String[] args) {
	int[] array = {9,12,8,6,10};
	bubbleSort(array);
	System.out.println(Arrays.toString(array));
}

画图解析：

思考：
若数组开始就是按照顺序排列的，比如：{ 1，2，3，4，5，6，7，8，20，6 }，这样的情况，再去按照上述代码进行比较就没有意义了
若比较一趟后就发现已经有序了，就没必要再进行剩下的比较，直接结束比较即可，故有优化版代码如下：

• 代码② (优化版)：

每一趟结束后，都检查是否有序，若某一趟结束后有序了，那么就不需要接下来的比较

public static void bubbleSort(int[] array){
	for (int k = 0; k < array.length-1; k++) {
		boolean flag = false;  //false代表未发生交换
		for (int i = 0; i < array.length-1-k; i++) {
			if(array[i] > array[i+1]){
				int tmp = array[i];
				array[i] = array[i+1];
				array[i+1] = tmp;
				flag = true;
			}
		}
		if(flag == false){
			break;
	}
}

• 代码③

Java内置排序方法，比冒泡排序更高效

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

8.数组逆序：

给定一个数组，将里面的元素逆序排列

思路：设定两个下标，分别指向第一个元素和最后一个元素，交换两个位置的元素，然后让前一个下标自增，后一个下标自减，循环继续即

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

9.数组数字排列：

给定一个整型数组，将所有的偶数放在数组前半部分，所有的奇数放在数组半部分

例如：{ 1，2，3，4 }
排列后：{ 2，4，1，4 }

思路：设定两个下标，分别指向第一个元素和最后一个元素，用下标1 从左往右，找到第一个奇数，用下标2 从右往左，找到第1个偶数，然后交换两位置的元素，依次循环即可

public static void numSort(int[] array){
	int left = 0;
	int right = array.length-1;
	while(left < right){
		while(left < right && array[left] % 2 ==0){
			//偶数
			left++;
		}
		//left 遇到奇数
		while(left < right && array[right] % 2 !=0){
			//奇数
			right--;
		}
		//right 遇到偶数
		if(left < right){
			int tmp = array[left];
			array[left] = array[right];
			array[right] = tmp;
		}
	}
}
public static void main(String[] args) {
	int[] array = {2,3,1,6,7};
	numSort(array);
	System.out.println(Arrays.toString(array));
}

输出结果：2,6,1,3,7

欢迎大家一起讨论~