【JAVA数组的定义与使用】（二）练习+二维数组

🌠个人主页 : @赶路人- -
🌌个人格言 :

要努力成为梧桐，让喜鹊在这里栖息。
要努力成为大海，让百川在这里聚积。

use,v.使用，用途 [jus] program,n.程序 [ˈproʊgræm]

4.数组练习

4.1数组转字符串

import java.util.Arrays

int[] arr = {1,2,3,4,5,6};

String newArr = Arrays.toString(arr);
System.out.println(newArr);
//System.out.println(Arrays.toString(arr));

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

Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法.
想查看包的具体实现代码，可以将鼠标放到代码打印的Arrays.toString上，ctrl+鼠标左键就可以进入jar包查看方法源代码了。

实现一个自己版本的数组转字符串

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5,6};
	System.out.println(toString(arr));
}
public static String toString(int[] arr) {
	String ret = "[";
	for (int i = 0; i < arr.length; i++) {
		// 借助 String += 进行拼接字符串
		ret += arr[i];
		// 除了最后一个元素之外, 其他元素后面都要加上 ", "
		if (i != arr.length - 1) {
			ret += ", ";
		}
	}
	ret += "]";
	return ret;
}

4.2数组拷贝

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

arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));

// 拷贝某个范围.
int[] newArr = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));

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

实现自己版本的拷贝数组

public static int[] copyOf(int[] arr) {
	int[] ret = new int[arr.length];
	for (int i = 0; i < arr.length; i++) {
		ret[i] = arr[i];
	}
	return ret;
}

4.3找数组中的最大元素

给定一个整型数组, 找到其中的最大元素 (找最小元素同理)

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5,6};
	System.out.println(max(arr));
}
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;
}
// 执行结果
6

类似于 “打擂台” 这样的过程. 其中 max 变量作为 擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对手.

4.4求数组中元素的平均值

给定一个整型数组, 求平均值

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5,6};
	System.out.println(avg(arr));
}
public static double avg(int[] arr) {
	int sum = 0;
	for (int x : arr) {
		sum += x;
	}
	return (double)sum / (double)arr.length;
	//注意这里要用double类型，聪明的你一想就懂为啥的。
}
// 执行结果
3.5

! 结果要用 double 来表示.

4.5查找数组中指定元素（顺序查找）

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.

public static void main(String[] args) {
	int[] arr = {1,2,3,10,5,6};
	System.out.println(find(arr, 10));
}
public static int find(int[] arr, int toFind) {
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == toFind) {
		return i;
		}
	}
	return -1; // 表示没有找到
}
// 执行结果
3

4.6查找数组中指定元素（二分查找）

针对有序数组, 可以使用更高效的二分查找.
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否
则就去右边找.

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5,6};
	System.out.println(binarySearch(arr, 6));
}
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;
}
// 执行结果
5

4.7检查数组的有序性

给定一个整型数组, 判断是否该数组是有序的(升序)

public static void main(String[] args) {
	int[] arr = {1,2,3,10,5,6};
	System.out.println(isSorted(arr));
}
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;
}

4.8数组排序（冒泡排序）

给定一个数组, 让数组升序 (降序) 排序.
算法思路
每次尝试找到当前待排序区间中最小(或最大)的元素, 放到数组最前面(或最后面).

public static void main(String[] args) {
     int[] arr = {9, 5, 2, 7};
     bubbleSort(arr);
     System.out.println(Arrays.toString(arr));
 }
 public static void bubbleSort(int[] arr) {
     // [0, bound) 构成了一个前闭后开区间, 表示已排序区间
     // [bound, length) 构成了一个前闭后开区间, 表示待排序区间
     // 每循环一次, 就找到一个合适大小的元素, 已排序区间就增大1.
     for (int bound = 0; bound < arr.length; bound++) {
         for (int cur = arr.length - 1; cur > bound; cur--) {
             if (arr[cur - 1] > arr[cur]) {
                 int tmp = arr[cur - 1];
                 arr[cur - 1] = arr[cur];
                 arr[cur] = tmp;
             }
         }
     } // end for
 } // end bubbleSort
// 执行结果
[2, 5, 7, 9]

冒泡排序性能较低. Java 中内置了更高效的排序算法

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

4.9数组逆序

给定一个数组, 将里面的元素逆序排列
思路
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.

public static void main(String[] args) {
	int[] arr = {1, 2, 3, 4};
	reverse(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--;
	}
}

4.10数组数字排列

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

例如
{1, 2, 3, 4}
调整后得到
{4, 2, 3, 1}

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

 public static void main(String[] args) {
     int[] arr = {1, 2, 3, 4, 5, 6};
     transform(arr);
     System.out.println(Arrays.toString(arr));
 }
 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;
     }
 }

5.二维数组

Java中的一维数组和二维数组在使用和声明上有一些区别：

声明方式：

一维数组的声明方式为 type[] arrayName; 或者 type arrayName[];，例如：int[] array1;
或者 int array2[];。 二维数组的声明方式为 type[][] arrayName;，例如：int[][]array2D;。

元素个数：

一维数组是一个线性集合，包含一系列元素。 二维数组是一系列一维数组的集合，每个一维数组本身也是一个数组。 

存储结构：

一维数组是一个连续的内存块，所有元素都存储在同一个维度中。
二维数组实际上是一个一维数组的数组，每个一维数组可以有不同的长度。Java的二维数组是一个数组的数组，每个数组元素都是一维数组。
访问方式：

一维数组的元素通过单个索引来访问，例如：array[index];。
二维数组的元素通过两个索引来访问，分别是行索引和列索引，例如：array[rowIndex][columnIndex];。 

初始化：

一维数组可以通过静态初始化或动态初始化来赋值。 
二维数组也可以通过静态初始化或动态初始化，需要为每个一维数组指定长度。

示例：

// 一维数组的声明和初始化
int[] array1D = new int[5]; // 动态初始化，长度为5的一维数组
int[] array1DInitialized = {1, 2, 3, 4, 5}; // 静态初始化

// 二维数组的声明和初始化
int[][] array2D = new int[3][2]; // 动态初始化，3行2列的二维数组
int[][] array2DInitialized = {{1, 2}, {3, 4}, {5, 6}}; // 静态初始化

总的来说，一维数组是一列数据的集合，而二维数组是多行多列的数据表格，可以看作是一维数组的数组。

除了上面提到的区别外，二维数组还有一些特点：

• 多维度：二维数组可以有多个维度，例如三维数组、四维数组等，每增加一个维度，就相当于在前一个维度的基础上再嵌套一个数组。
• 行列长度可变：Java中二维数组的行长度可以是可变的，即每个一维数组的长度可以不同。这使得二维数组可以表示不规则的数据表格，每行的列数可以不同。
• 矩阵运算：二维数组常用于表示矩阵，进行矩阵运算，如矩阵相加、矩阵相乘等。
• 图像处理：在图像处理中，常用二维数组表示图像的像素点，通过操作二维数组可以实现图像的处理和编辑。
• 空间复杂度：二维数组的存储空间通常比较大，尤其是在需要大量数据存储时，因为它是一个数组的数组，需要额外的空间来存储数组的引用以及每个数组的元素。
• 内存连续性：在内存中，二维数组的各个元素并不一定是连续存储的，尤其是在数组的长度不规则时，每个一维数组可能被存储在不同的内存位置上。

总的来说，二维数组是一种多维的数据结构，适用于表示表格、矩阵等具有行列结构的数据，并且具有灵活性和广泛的应用领域。