Java4——數組

一、 一維數組

（一）、一維數組的聲明

類型 名稱[] 或 類型[] 名稱

   		   int a[];
	   	   int[] a1;
		   double  b[];
		   Mydate[] c;  //對象數組

（二）、一維數組初始化

動態初始化：數組聲明且爲數組元素分配空間與賦值的操作分開進行。聲明時就定義數組容量。

int [] ii=new int[4];//聲明一個能放4個int類型數據的數組。 

靜態初始化：在定義數組的同時就爲數組元素分配空間並賦值。

int [] ii=new int[]{1,2,3,4};//聲明瞭存放{1，2，3，4}的數組

（三）、數組元素的引用

1. 定義並用運算符new爲之分配空間後，纔可以引用數組中的每個元素
2. 數組元素的引用方式：數組名[數組元素下標]
3. 數組元素下標可以是：整型常量、整型表達式。如a[3] , b[i] , c[6*i];
4. 數組元素下標從0開始，長度爲n的數組合法下標取值範圍: 0 —>n-1；如int a[]=new int[3];
5. 可引用的數組元素爲a[0]、a[1]、a[2] 每個數組都有一個屬性length指明它的長度，例如：a.length
6. 指明數組a的長度(元素個數) 數組一旦初始化，其長度是不可變的

（四）、數組元素的默認初始化

數組是引用類型，它的元素相當於類的成員變量，因此數組一經分配空間，其中的每個元素也被按照成員變量同樣的方式被隱式初始化。
使用動態初始化時，數組有默認值
數字的默認值是0、對象的默認值是null

二、多維數組

即每個一維數組中的元素都是數組。

1. 格式1（動態初始化）：int[][] arr = new int[3][2];
2. 格式2（動態初始化）：int[][] arr = new
   int[3][]; ps:int[][]arr = new int[][3]; //非法
3. 格式3（靜態初始化）：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

注意特殊寫法情況：int[] x,y[]; x是一維數組，y是二維數組。
Java中多維數組不必都是規則矩陣形式
數不能給數組賦值，數組不能給數賦值

靜態：
int [] ii=new int [][]{{1,2},{3,4}};

聲明：int[] x,y[];  以下選項允許通過編譯的是：
a )   x[0] = y;  //no, x[0]是一個數，y是一個二維數組
b)    y[0] = x; //yes， y[0]就是一維數組，x是一維數組
c)    y[0][0] = x;//no， y[0][0] 是一個數字，x是一維數組
d)    x[0][0] = y;//no， x[0][0] 不存在，x是一維數組，沒有第二維
e)    y[0][0] = x[0];//yes， y[0][0] 是一個數字， x[0]是一個數
f)    x = y; //no， x是一維數組，y是一個二維數組
一維數組：int[] x  或者int x[]   
二維數組：int[][] y 或者  int[] y[]  或者 int  y[][]

三、數組中涉及的常見算法

1.求數組元素的最大值、最小值、總和、平均數

public class test1 
{
	public static void main(String[] args)
	{
		int [] a=new int []{4,7,8,2};
		int i=0;
		int max=a[0];
		int min=a[0];				//min=數組的第一個元素即可，不能等於0.當然，定義這個數的時候必須要在定義數組之後
		double sum=0;				//因爲後面會用sum來存放一個除法結果，所以爲了保留小數部分定義爲double型的
		for(i=0;i<a.length;i++)
		{
			if(a[i]>max)
			{
				max=a[i];			//每次比較結果較大的放在max中，最後循環完max中就存放了最大的一組數據
			}
			if(a[i]<min)
			{
				min=a[i];
			}
			sum+=a[i];
		}
		System.out.println("max="+max);
		System.out.println("min="+min);
		System.out.println("arry="+sum/a.length);
	}
}

2.數組的複製、反轉

public class test1 
{
	public static void main(String[] args)
	{
		int [] a=new int []{4,7,8,2};
//		int [] m=a;這個不是數組的複製，而是數組的賦值。
		int [] copy=new int [4];		//新數組的長度必須與被複制數組的長度相同。
		int [] turn=new int [4];
		int i=0;
		int k=0;
		for(i=0;i<a.length ;i++)//複製
		{
			copy[i]=a[i];
		}
		for(i=3;i>=0;i--)//反轉，a數組的最後一個賦值給turn的第0個
		{
			turn[k]=a[i];
			k++;
		}
		for(i=0;i<a.length ;i++)
		{
			System.out.println(a[i]);
		}
		for(i=0;i<a.length ;i++)
		{
			System.out.println(copy[i]);
		}
		for(i=0;i<a.length ;i++)
		{
			System.out.println(turn[i]);
		}
	}
}
結果：
4 7 8 2
4 7 8 2
2 8 7 4

3.數組元素的排序

1. 插入排序
   直接插入排序、折半插入排序、Shell排序

2. 交換排序
   冒泡排序、快速排序（或分區交換排序）
   冒泡排序思想：
   相鄰兩元素進行比較，如有需要則進行交換，每完成一次循環就將最大元素排在最後（如從小到大排序），下一次循環是將其它的數進行類似操作。
   輪次是數組次數減1

public class test1 
{
	public static void main(String[] args)
	{
		int [] a=new int []{4,7,8,2};
		int i=0;
		int k=0;
		int temp=0;
		for(i=0;i<a.length-1 ;i++)//循環輪次,數值爲數組長度-1
			for(k=0;k<a.length-1-i;k++)//每一輪的數字對比，
				if(a[k]>a[k+1])//相鄰元素，前面的大於後面的則令前後交換。正序和倒序不同的地方。
				{
					temp=a[k];
					a[k]=a[k+1];
					a[k+1]=temp;
				}
		for(i=0;i<a.length ;i++)
		{System.out.println(a[i]);}
	}
}

3. 選擇排序
   簡單選擇排序、堆排序

4. 歸併排序

5. 基數排序