JavaSE03: Arrays工具类的使用及简单数组算法

离散数学终于考完了，接下来终于可以一心学习java了~~

Arrays工具类的使用

**Arrays类是用来操作数组的工具类，包含了用来操作数组（比

如排序和搜索）的各种方法，使用时需要导包java.util.Arrays**

• boolean equals(int[] a,int[] b) 判断两个数组是否相等。

public static void main(String[] args) {
    
    
		int[] a = new int[] {
    
    1,2,3,4};
		int[] b = new int[] {
    
    1,2,3,4};
		System.out.println(Arrays.equals(a, b));
		
	}

运行结果：

• String toString(int[] a) 打印一维数组的信息。

public static void main(String[] args) {
    
    
		int[] a = new int[] {
    
    1,2,3,4};
		System.out.println(Arrays.toString(a));
		
	}

运行结果：

• String toDeepString(int[][] a) 打印二维数组的信息。

public static void main(String[] args) {
    
    
		int[][] a = new int[][] {
    
    {
    
    1,2,3},{
    
    1,2},{
    
    3,4,5}};
		System.out.println(Arrays.deepToString(a));
		
	}

运行结果：
**说明：这个方法较为少用，推荐使用循环打印二维数组，这样的数组会更美观些！ **

• void fill(int[] a,int val) 将指定值填充到数组之中。

public static void main(String[] args) {
    
    
		int[] b = new int[] {
    
    1,2,3,4};
		System.out.println("替换前：" + Arrays.toString(b));
		Arrays.fill(b, 10);
		System.out.println("替换后：" + Arrays.toString(b));
	}

运行结果：

• void sort(int[] a) 对数组从小到大进行排序。

public static void main(String[] args) {
    
    
		int[] b = new int[] {
    
    1,4,3,2};
		System.out.println("排序前：" + Arrays.toString(b));
		Arrays.sort(b);
		System.out.println("排序后：" + Arrays.toString(b));
	}

运行结果：

• int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值

public static void main(String[] args) {
    
    
		int[] b = new int[] {
    
    1,4,3,2};
		Arrays.sort(b);
		System.out.println("排序后：" + Arrays.toString(b));
		System.out.println("查找排序后2的位置： " + Arrays.binarySearch(b, 2));
	}

运行结果：

提示：若使用binarySearch方式的参数中数组为未排序数组，则会返回-2：

public static void main(String[] args) {
    
    
		int[] b = new int[] {
    
    1,4,3,2};
		
		System.out.println("查找排序后3的位置： " + Arrays.binarySearch(b, 3));
	}

运行结果：

对Arrays类一些常用方法的介绍就到此为止了，对该类其他方法感兴趣的小伙伴可以查阅一下API文档多了解了解~~

简单数组算法

数组中常见的算法有：
1. 数组元素的赋值(杨辉三角、回形数等)
2. 求数值型数组中元素的最大值、最小值、平均数、总和等
3. 数组的复制、反转、查找(线性查找、二分法查找)
4. 数组元素的排序算法
接下来就介绍一点简简单单的小东西吧~~

杨辉三角

相信大家高中时期学习二项式都认识了杨辉三角了吧，这里就不作过多介绍，直接上代码：

package deserts.package01;

public class Array02 {
    
    
	public static void main(String[] args) {
    
    
		int[][] yangHui = new int[10][];
		for(int i = 0; i < yangHui.length; i++) {
    
    
			yangHui[i] = new int[i + 1];
		}
		for(int i = 0; i < yangHui.length; i++) {
    
    
			yangHui[i][0] = yangHui[i][yangHui[i].length - 1] = 1;
		}
		for(int i = 2; i < yangHui.length; i++) {
    
    
			for(int j = 1; j < yangHui[i].length - 1; j++) {
    
    
				yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
			}
		}
		for(int i = 0; i < yangHui.length; i++) {
    
    
			for(int j = 0; j < yangHui[i].length; j++) {
    
    
				System.out.print(yangHui[i][j] + "  ");
			}
			System.out.println();
		}
	}
}

一道面试题

利用随机数生成一个整数数组，数组中有10个元素，每个元素的值都在1-30之间，且要求各个数值不能相同。打印该数组。
代码实现：

public class Array03 {
    
    
	public static void main(String[] args) {
    
    
		int[] arr = new int[10];
		for(int i = 0; i < arr.length; i++) {
    
    
			arr[i] = (int)(Math.random()*30+1);
			for(int j = 0; j < i; j++) {
    
    
				if(arr[j] == arr[i]) {
    
    
					i--;//如果相同，i--跳出循环使得赋值失败
					break;
				}
			}
		}
		for(int i = 0; i < arr.length; i++) {
    
    
			System.out.print(arr[i] + " ");
			if(i == 4)
				System.out.println();
		}
	}
}

运行结果：

最后，是简单的冒泡排序

介绍：
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步
   做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
   代码实现：

public class Test02 {
    
    
	public static void main(String[] args) {
    
    
		int[] b = new int[] {
    
    1,4,3,2,9,6,13};
		for(int i = 0; i < b.length - 1; i++) {
    
    
			for(int j = 0; j < b.length - 1; j++) {
    
    
				if(b[j] > b[j + 1]) {
    
    
					int temp = b[j];
					b[j] = b[j + 1];
					b[j + 1] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(b));
	}
}

运行结果：

写在最后

暑假的学习生活明天正式开始，为了养成写博客的习惯，超梦尽量会在每天学习生活结束前写一篇博客来巩固当天的新知识~~所以面向对象的内容会在稍微晚点更新_{每天也会安排学习1}2小时的数据结构，每周预计更新2~3篇算法相关的博客，下一篇介绍的是稀疏数组算法！

我是超梦，期待与你一起变好~~~