Java学习笔记Day5 数组

数组的使用

• For循环遍历
• For-Each循环
• 数组做方法入参
• 数组做返回值

public class Demo03 {
	public static void main(String[] args) {
		int[] arrays = {1,2,3,4,5,};

		//打印数组全部元素
		for (int i = 0; i < arrays.length; i++) {
			System.out.println(arrays[i]);
		}
		System.out.println("=================");
		//计算数组元素总和
		int sum = 0;
		for (int i = 0; i < arrays.length; i++){
			sum += arrays[i];
		}
		System.out.println(sum);
		System.out.println("==============");
		//查找数组最大元素
		int max = arrays[0];
		for (int i = 1; i < arrays.length; i++){
			if(arrays[i] > max){
				max = arrays[i];
			}
		}
		System.out.println(max);
	}
}

public class Demo04 {
	public static void main(String[] args) {
		int[] arrays = {1,2,3,4,5,};
		//JDK1.5,没有下标
//		for (int array : arrays) {
//			System.out.println(array);
//		}
		//printArray(arrays);

		int[] reverseArrays = reverse(arrays);
		printArray(reverseArrays);
	}

	//打印数组元素
	public static void printArray(int[] arrays){
		for (int i = 0; i < arrays.length; i++) {
			System.out.print(arrays[i]+"\t");
		}
	}

	//反转数组
	public static int[] reverse(int[] arrays){
		int[] result = new int[arrays.length];
		//反转操作
		for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
			result[j] = arrays[i];
		}
		return result;
	}
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组。

二维数组：

int a[][] = new a[2][5]

以上二维数组a可以看成一个两行五列的数组

public class Demo05 {
	public static void main(String[] args) {
		//[4][2]
		/*
		  1,2  arrays[0]
		  2,3  arrays[1]
		  3,4  arrays[2]
		  4,5  arrays[3]
		 */
		int[][] arrays = {{1,2},{2,3},{3,4},{4,5},};
		//System.out.println(arrays[0][1]);
		for (int i = 0; i < arrays.length; i++) {
			for (int j = 0; j < arrays[i].length; j++) {
				System.out.println(arrays[i][j]);
			}
		}
	}
}

Arrays 类

• 数组的工具类：java.util.Arrays
• 由于数组对象本身并没有什么方法可供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作。
• Arrays类中的方法都是statics修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用。
• 具有以下常用功能
  • 给数组赋值：通过fill方法。
  • 对数组排序：通过sort方法，按升序。
  • 比较数组：通过equals方法比较数组中元素值是否相等。
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。（先通过sort方法对数组进行排序，否则结果是未定义的）

import java.util.Arrays;

public class Demo06 {
	public static void main(String[] args) {
		int[] a = {1,2,3,4,123,45,76,};
		System.out.println(a); //[I@1b6d3586

		//打印数组元素 Arrays.toString
		//System.out.println(Arrays.toString(a));
		//printArray(a);

		Arrays.sort(a);//数组排序
		System.out.println(Arrays.toString(a));

		Arrays.fill(a,2,4,0);//数组填充
		System.out.println(Arrays.toString(a));
	}
	public static void printArray(int[] a){
		for (int i = 0; i < a.length; i++) {
			if(i==0){
				System.out.print("[");
			}
			if(i==a.length-1){
				System.out.print(a[i]+"]");
			}else {
				System.out.print(a[i] + ", ");
			}
		}
	}
}

冒泡排序

冒泡排序是最为出名的排序算法之一，总共有八大排序！（直接插入排序、希尔排序、直接排序、堆排序、冒泡排序、快速排序、归并排序、基数排序）

冒泡排序总共两层循环，外层冒泡轮数，里层依次比较。

冒泡排序的时间复杂度为O（n2）

使用时考虑如何优化。

import java.util.Arrays;

public class Demo07 {
	public static void main(String[] args) {
		int[] arrays = {2,5,1,23,7,};
		int[] newArrays = sort(arrays);
		System.out.println(Arrays.toString(newArrays));

	}
	//冒泡排序
	/*
	1.比较数组中两个相邻的元素，如果前一个数比后一个数大，就交换位置；
	2.每一次比较都会产生一个最大或最小的数字；
	3.下一轮则可以少一次排序；
	4.依次循环，直到结束。
	 */
	public static int[] sort(int[] arrays){
		int temp = 0;
		//外层循环，判断这个要走多少次(比较轮数:n-1轮)
		for (int i = 0; i < arrays.length-1; i++){

			boolean flag = false;//通过flag标识位减少没有意义的比较

			//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置(每一轮比较次数：n-1-i)
			for (int j = 0; j < arrays.length-1-i ; j++) {
				if (arrays[j+1]<arrays[j]){
					temp = arrays[j+1];
					arrays[j+1]=arrays[j];
					arrays[j]=temp;
					flag = true;
				}
			}
			if (flag == false){
				//break;
			}
		}
		return arrays;
	}
}

稀疏数组

假设要编写五子棋游戏，有存盘退出和续上盘功能。棋盘上未落子区域记为0，黑棋记为1，白棋记为2。数据化，该二位数组的很多默认值为0，因此记录了很多没有意义的数据。因此提出了稀疏数组。

概念：

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方式是：
  • 记录数组一共有几行几列，有多少个不同值
  • 把具有不同值的元素、行和列及值记录在一个小规模的数组中，从而缩小程序的规模
• 下图中：左边为原始数组，右边是稀疏数组

import java.util.Arrays;

public class Demo08 {
	public static void main(String[] args) {
		//稀疏数组
		//创建一个二维数组 11*11 0:没有棋子 1：黑棋 2：白

		int[][] array1 = new int[11][11];
		array1[1][2] = 1;
		array1[2][3] = 2;
		//输出原始数组
		System.out.println("输出原始数组");
		for (int[] ints : array1) {  //for-each遍历
			for (int anInt : ints) {
				System.out.print(anInt + "\t");
			}
			System.out.println();

		}
		System.out.println("============================================");

		//转换为稀疏数组保存
		//获取有效值的个数
		int sum = 0;
		for (int[] ints : array1) {
			for (int anInt : ints) {
				if (anInt!=0){
					sum++;
				}
			}
		}
		System.out.println("有效值个数:"+sum);

		//创建一个稀疏数组的数组	
		int[][] array2 = new int[sum+1][3];
		array2[0][0]=11;
		array2[0][1]=11;
		array2[0][2]=2;

		//遍历二维数组，将非零的值存放在稀疏数组中
		int count = 0;
		for (int i = 0; i < array1.length; i++) {
			for (int j = 0; j < array1[i].length; j++) {
				if (array1[i][j]!=0){
					count++;
					array2[count][0] = i;
					array2[count][1] = j;
					array2[count][2] = array1[i][j];
				}
			}
		}
		//输出稀疏数组
		System.out.println("稀疏数组：");
		for (int[] ints : array2) {
			for (int anInt : ints) {
				System.out.print(anInt+"\t");
			}
			System.out.println();
		}
		System.out.println("========================");
		System.out.println("还原：");
		//读取稀疏数组
		int[][] array3 = new int[array2[0][0]][array2[0][1]];
		//给其中的元素还原值
		for (int i = 1; i < array2.length; i++) {
			array3[array2[i][0]][array2[i][1]]=array2[i][2];
		}
		//打印
		for (int[] ints : array3) {
			for (int anInt : ints) {
				System.out.print(anInt+"\t");
			}
			System.out.println();
		}
	}
}