java中Arrays类，冒泡排序和稀疏数组

Arrays类

数组的工具类：java.util.Arrays
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用对象来调用。
具有以下常用功能：
给数组赋值：通过fill方法
对数组排序：sort方法
比较数组：equals方法比较元素值是否相等
查找数组元素：通过binarySearch方法堆排序好的数组进行二分查找法操作。

例题：用方法输出数组和直接输出数组

import java.util.Arrays;
public class ArraryDemo06 {
	public static void main(String[] args) {
		int[] a = {1,2,3,4,9090,1234,127222};
		System.out.println(a);//[I@75a1cd57
		//数组排序
		Arrays.sort(a);
		//打印数组元素Arrays.toString
		System.out.println(Arrays.toString(a));
		printArray(a);
		
		//将指定的字节值分配给指定字节数组的每个元素
		//a要填充的数组
		//val要存储在数组的所有元素中的值
		//Arrays.fill(a, 0);
		Arrays.fill(a, 2,4,0);//2-4之间的数被0填充
		System.out.println(Arrays.toString(a));
		//数组中所有元素值变为0
	}
	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]+", ");
			}
		}
	}
}

冒泡排序

练习题：

//冒泡排序
	//1.比较数组中两个相邻的元素，如果第一个数比第二个数大，则交换他们的位置
	//2.每一次比较，都会产生出一个最大，或者最小的数字
	//3.下一轮则可以少一次排序
	//4.依次循环，直到结束
public class ArraryDemo07 {
	public static void main(String[] args) {
		int[] a= {1,2,4,5,6,78,2,2,2,34,56};
		int[] sort = sort(a);
		//调用完我们自己写的排序方法以后，返回一个排序后的数据
		System.out.println(Arrays.toString(sort));
	}	
	public static int[] sort(int[] array) {
		//临时变量
		int temp=0;
		//外层循环，判断我们这个要走多少次
		for(int i=0;i<array.length-1;i++) {
		//内层循环，比较判断两个数，如果第一个数大于第二个数，				    则交换位置。
		for(int j=0;j<array.length-1-i;j++) {
			if(array[j]>array[j+1]) {
				temp=array[j];
				array[j]=array[j+1];
				array[j+1]=temp;
			}
		}
	}
	return array;
	}	
}

稀疏数组

数组下标从0开始。

稀疏数组练习题：

//冒泡排序
	//1.比较数组中两个相邻的元素，如果第一个数比第二个数大，则交换他们的位置
	//2.每一次比较，都会产生出一个最大，或者最小的数字
	//3.下一轮则可以少一次排序
	//4.依次循环，直到结束
public class ArraryDemo08 {
	public static void main(String[] args) {
		//1.创建二维数组 11 * 11  0:没有棋子 1：黑棋 2：白旗
		int[][] array1 = new int[11][11];
		array1[1][2]=1;
		array1[2][3]=2;
		//输出原始数组
		System.out.println("输出原始数组：");
		//for(元素类型 循环变量：集合)
		for(int[] ints:array1) {
			for(int anInt : ints) {
				System.out.print(anInt+"  ");
			}
			System.out.println();
		}
		System.out.println("====================");
		
		//转换为稀疏数组
		//获取有效值的个数
		int sum=0;
		for(int i=0;i<11;i++) {
			for(int j=0;j<11;j++) {
				if(array1[i][j]!=0) {
					sum++;
				}
			}
		}
		System.out.println("有效值的个数为："+sum);
				
		//2.创建稀疏数组的数组
		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 i=0;i<array2.length;i++) {
			System.out.println(array2[i][0]+"\t"+array2[i][1]
					+"\t"+array2[i][2]);
		}	
		System.out.println("=================");
		System.out.println("还原:");		
		//1.读取稀疏数组
		int[][] array3 = new int[array2[0][0]][array2[0][1]];
		//2.给其中的元素还原值
		for(int i=1; i<array2.length;i++) {
			array3[array2[i][0]][array2[i][0]]=array2[i][2];
		}
		//3.打印稀疏数组
		System.out.println("输出还原数组：");
		for(int[] ints:array1) {
			for(int anInt : ints) {
				System.out.print(anInt+"  ");
			}
			System.out.println();
		}
	}	
}