学习笔记十三：Java之数组

只有创造，才是真正的享受，只有拚搏，才是充实的生活。

本讲内容：数组

数组是Java中的对象，它用来存储多个相同类型的基本数据类型或者对象引用。

一、声明数组
数组是通过说明它将要保存的元素类型来声明的，元素类型可以是对象或者基本类型。类型后面的方括号可以在写在标识符的前面，也可以写在后面。推荐写在前面。int[ ] a      int a[ ]

二、 一维数组

1、int[] a;   //声明,没有初始化

2、int[] a=new int[5];   //声明并初始化为默认值,int型为0

3、 int[] a={1,2,3,4,5};   //声明并初始化为给定值

4、 int[] a;   a=new int[5];  //正确，声明与初始化分开

5、int[] a; a={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用，如3

6、 int a[];a[0]=1; a[1]=2;   //错误,因为数组没有初始化,不能赋值

三、二维数组

1、 int[][] a;  //声明,没有初始化

2、 int[][] a=new int[2][3];    //声明并初始化为默认值,int型为0

3、 int[][] a={{1,2},{2,3},{3,4}};   //声明并初始化为给定值 
     int[][] a={{1,2},{2,3},{3,4,5}};   //没有错,数组空间不是连续分配的，所以不要求每一维的大小相同

4、 int[][] a=new int[2][];
     a[0]=new int[3];  //a[0]其实就是一个数组
     a[1]=new int[4];  //每一维的大小可以不一样;

5、int[][] a=new int[][]{{1,2},{2,3},{3,4,5}};   //同(3)  

     int[] a=new int[5]{{1,2},{2,3},{3,4,5}};  //错误,如果提供了数组初始化操作，则不能定义维表达式

     int[][] a=new int[2][];
     a[0]={1,2,3,4,5};   //错误,数组常量只能在初始化操作中使用

6、int[][] a=new int[2][];
     a[0][1]=1;   //错误,第二维没有初始化,不能赋值,java.lang.NullPointerException异常

总结: 1.二维就是数组的数组,里面的数组大小不要求一样
        2.不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化

四、初始化分类

1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。int[] a=new int[2]

下面我们通过例子讲解

1、一维数组：

<span style="font-size:18px;"><span style="font-size:18px;">public class T19 {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int arr[]=new int[5];
		int sum=0;
		for(int i=0;i<5;i++){
			System.out.println("请输入第"+(i+1)+"学生成绩");
			arr[i]=in.nextInt();
			sum+=arr[i];
		}
		System.out.println("这5个人的平均分为"+sum/5);
	}
}</span></span>

2、规则二维数组：

<span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[][] a={{1,2},{3,4},{5,6}};
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.println(a[i][j]);
			}
		}
	}
}</span>

打印：1 2 3 4 5 6

3、不规则二维数组：

<span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[][] a={{1,2},{3,4,5},{6,7,8,9}};
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.println(a[i][j]);
			}
		}
	}
}</span>

打印：1 2 3 4 5 6 7 8 9

 

4、打印图形

<span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int[][] arr=new int[4][6];
		
		arr[1][2]=1;
		arr[2][1]=2;
		arr[2][3]=3;
		
		//先访问行再访问列
		for(int i=0;i<4;i++){//行
			for(int j=0;j<6;j++){//列
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}</span>

<span style="font-size:18px;">0 0 0 0 0 0 
0 0 1 0 0 0 
0 2 0 3 0 0 
0 0 0 0 0 0 </span>

五、数组排序

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。

1、快速排序法

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a={7,3,6,9,4};
		Arrays.sort(a);
		for(int i :a){//<span style="color: rgb(51, 51, 51); font-family: Helvetica, Tahoma, Arial, sans-serif; font-size: 14px; line-height: 24px; background-color: rgb(245, 245, 245);">遍历整个集合</span>
			System.out.println(i);
		}
	}
}</span></span>

2、冒泡法  比较相邻的俩个数，把小的数放在前面

冒泡排序是稳定性排序方法。比较适合参加排序序列的数据量较小的情况，这种方法是排序时间效率最低的一种。

总共进行 1 + 2 + 3 + 4 + . . . + n-1 = n(n-1) /2次

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a={7,3,6,9,4};
		bubbleSort(a);
		for(int i :a){
			System.out.println(i);
		}
	}
	public static int[] bubbleSort(int[] a){
		for(int i=0;i<a.length-1;i++){//a.length=5  走几次，一次确定一个数，一共有a.length-1次
			for(int j=i+1;j<a.length;j++){
				if(a[i]>a[j]){
					int temp;
					temp=a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
		}
		return a;
	}
}</span></span>

3、选择排序算法（选择最小的一个数与第一个数交换）

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a={7,3,6,9,4};
		selectSort(a);
		for(int i :a){
			System.out.println(i);
		}
	}
	public static int[] selectSort(int[] a){
		for(int i=0;i<a.length-1;i++){
			int min=i;
			for(int j=i+1;j<a.length;j++){
				if(a[min]>a[j]){
					min=j;
				}
			}
			if(min!=i){
				int temp=a[i];
				a[i]=a[min];
				a[min]=temp;
			}
		}
		return a;
	}
}</span></span>

<span style="font-size:18px;"><span style="font-size:18px;">import java.util.*;

public class T {
	public static void main(String[] args) {
		//打印系统时间
		Calendar cal=Calendar.getInstance();
		System.out.println("排序前时间："+cal.getTime());
		//Math.random()让程序随机产生一个0～1
		int t=(int)(Math.random()*100);
		System.out.println(t);
		System.out.println("排序后时间："+cal.getTime());
	}
}</span></span>

<span style="font-size:18px;"><span style="font-size:18px;">排序前时间：Sat Dec 27 21:42:20 CST 2014
58
排序后时间：Sat Dec 27 21:42:20 CST 2014
</span></span>

4、插入排序法（比选择排序快）

把n个等排序的元素看成一个有序列表和一个无序列表，开始时有序列表只有一个元素，无序列表有n-1个元素，排序过程中每次从无序列表中拿出一个数与有序列表比较，将它插入有序列表中使之成为新的有序列表。

<span style="font-size:18px;"><span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int len=8;
		int[] arr=new int[len];
		for(int i=0;i<len;i++){
			int t=(int)(Math.random()*100);
			arr[i]=t;
		}
		
		InsertSort is=new InsertSort();
		is.sort(arr);
		
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

class InsertSort{
	public void sort(int arr[]) {
		for(int i=1;i<arr.length;i++){
			int insertVal=arr[i];
			int index=i-1;
			while(index>=0&&insertVal<arr[index]){
				arr[index+1]=arr[index];
				index--;
			}
			arr[index+1]=insertVal;
		}
	}
}
</span></span>

5、快速排序法（比上面的快百倍）

以中间一直二分开比较

<span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int len=8;
		int[] arr=new int[len];
		for(int i=0;i<len;i++){
			int t=(int)(Math.random()*100);
			arr[i]=t;
		}
		
		QuickSort is=new QuickSort();
		is.sort(0,arr.length-1,arr);
		
		for(int i=0;i<len;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

class QuickSort{
	public void sort(int left,int right,int[] arr) {
		int l=left;
		int r=right;
		int pivot=arr[(left+right)/2];
		int temp=0;
		while(l<r){
			while(arr[l]<pivot) l++;
			while(arr[r]>pivot) r--;
			if(l>=r) break;
			
			temp=arr[l];
			arr[l]=arr[r];
			arr[r]=temp;
			
			if(arr[l]==pivot) --r;
			if(arr[r]==pivot) ++l;
		}
		if(l==r){
			l++;
			r--;
		}
		if(left<r) sort(left,r,arr);
		if(right>l) sort(l,right,arr);
	}
}
</span>

六、数组Arraysr的重要方法

Arrays.sort()	排序
clone()	复制数组：限制：全部复制，无法部分的复制。
Arrays.fill（ a1, value ）	a1是一个数组变量，value是一个a1中元素数据类型的值，作用：填充a1数组中的每个元素都是value
Arrays.fill(a, fromIndex, toIndex, val)	第一个参数指操作的数组，第二个和第三个指在该数组的某个区域插入第四个参数，第二个参数指起始元素下标（包含该下标），第三个参数指结束下标（不包含该下标）
Arrays.binarySearch()	找出某个数的下标值，缺点：数组必须已经过了排序，否则结果无法预料
Arrays.toString()	显示数组数据

例如：

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a=new int[5];
		Arrays.fill(a,3);
		for(int i :a){
			System.out.println(i);
		}
	}
}</span></span>

打印：3 3 3 3 3

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a=new int[5];
		Arrays.fill(a,3);
		Arrays.fill(a, 1,3,1);
		for(int i :a){
			System.out.println(i);
		}
	}
}	</span></span>

打印：3 1 1 3 3

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a=new int[5];
		int[] b;
		Arrays.fill(a, 2);
		b=a.clone();
		for(int i :b){
			System.out.println(i);
		}
	}
}</span></span>

打印：2 2 2 2 2

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a = { 1, 2, 4, 5, 3 };
		Arrays.sort(a);
		System.out.println(Arrays.binarySearch(a, 5));
	}
}</span></span>

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-family: Arial;font-size:18px; line-height: 26px;">打印：4</span></span></span>

<span style="font-size:18px;"><span style="font-size:18px;">public class Text {
	public static void main(String[] args) {
		int[] a = { 1, 5, 6, 7, 3, 1 };
		System.out.println(Arrays.toString(a));
	}
}</span></span>

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-family: Arial;font-size:18px; line-height: 26px; white-space: pre;">打印：</span>[1, 5, 6, 7, 3, 1]</span></span>

七、二分法查找

<span style="font-size:18px;">public class T {
	public static void main(String[] args) {
		int[] arr={2,3,6,89,4};
		BinaryFind bf=new BinaryFind();
		bf.find(0,arr.length-1,3,arr);
	}
}

class BinaryFind{
	public void find(int leftIndex,int rightIndex,int val,int[] arr) {
		//首先找到中间的数
		int midIndex=(rightIndex+leftIndex)/2;
		int midVal=arr[midIndex];
		
		if(rightIndex>=leftIndex){
	
		if(midVal>val){
			//在arr左边数中找
			find(leftIndex,midIndex-1,val,arr);
		}else if(midVal<val){
			find(midIndex+1,rightIndex,val,arr);
		}else if(midVal==val){
			System.out.println("找到下标"+midIndex);
			}
		}
	}
}</span>

<span style="font-size:18px;">找到下标1</span>

本讲就到这里，Take your time and enjoy it