------<a href="http://www.itheima.com" target="_blank" rel="external nofollow" target="blank">Java教育訓練、Android教育訓練、iOS教育訓練、.Net教育訓練</a>、期待與您交流！ -------
A、基本概念
定義：同一個類型資料的集合，其實數組就是一個容器。
數組的好處：可以自動給數組中的元素從0開始編号，友善操作這些元素。
格式1：
元素類型[ ] 數組名= new 元素類型[ 元素個數或數組長度]
示例：int [ ]arr = new int[3 ]也可以寫成：int arr [] = new int[3 ]，但一般都按規範來寫。
定義一個可以存儲3個整數的容器。
int [ ]x = new int[ 3 ];
格式2：
元素類型[ ] 數組名=new 元素類型[ ] { 元素，元素，……}；
示例： int [ ] arr = new int[ ] {3,5,1,7 };
也可簡化為：int [ ]arr = { 3,5,1,7 };
B、記憶體結構
前言：java程式在運作時，需要在記憶體中配置設定空間。為了提高運算效率，有對空間進行了不同區域的劃分，因為每一片區域都有特定的處理資料的方式和記憶體管理方式。
棧記憶體：用于存儲局部變量，當資料使用完畢後，所占的空間會被自動釋放。
堆記憶體：
*數組和對象，通過new建立的執行個體都存放在堆記憶體中。
*每一個實體都有記憶體位址值
*實體中的變量都有預設的初始化值（例int：0；boolean：false；double：0.0）
*實體不在被使用，會在不确定的使勁按内被垃圾回收器回收
另：除了以上兩個記憶體區外，還有方法區、本地方法區、寄存器
執行個體：
classArrayDemo
{
public static void main(String[] args)
{
int[] arr = new int[3];
arr=null;
System.out.println(arr[3]);
}
}
在沒有arr=null;運作時給出錯誤提示：
Array indexout of bounds exception：3：操作數組時，通路到了數組中不存在的角标。
在有arr=null;運作時給出錯誤提示：
Null pointerexception：空指針異常，當引用沒有任何指向值為null的情況，該引用還在用語操作實體。
C 1、數組的常見操作——周遊
擷取數組中的元素,通常會用到周遊
classArrayDemo2
{
public static void main(String[] args)
for(int x=0; x<arr.length; x++)
{
int[] arr = new int[]{ 3，6，5，1，8，9，67};
System.out.println(“arr[“+x+”]=”+arr[x]+”;”);
}
}
總結：數組中有一個屬性可以直接擷取到數組元素的個數:length
使用方式：”數組名稱.length”
上面的程式在或許列印元素的取值範圍時就有用到。
練習：用于列印數組中的元素int[]arr={ 3，6，5，1，8，9，67};，元素間用逗号隔開
classArrayDemo2
{
public static void main(String[] args)
{
int[]arr={ 3，6，5，1，8，9，67}
printArray(arr)；
}
public static void printArray([ ]arr)
{
System.out.print(“[”)
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
System.out.print(arr[x] + ”,”);
else
System.out.println(arr[x] + ”]”);
}
}
}
注：再列印數組時，如果直接用“System.out.print(arr)”來進行列印，那麼得到的會是該數組空間的16進制的記憶體位址值。
練習題：
給定一個數組{5，1，6，4，2，8，9}
1、 擷取該數組中的最大值和最小值。
思路：
a、擷取最值需要進行比較，每一次比較都會有一個較大的值，因為該值不确定，通過一個變量進行臨時存儲。
b、讓數組中的每一個元素都和這個變量中的值進行比較，如果大于了變量中的值，就用該變量記錄較大值。
c、當所有的元素都比較完成，那麼該變量中儲存的值就是數組中的最大值了
步驟：
a、 定義變量，初始化數組中的任意一個元素即可，
b、 通過循環語句對數組進行周遊
c、 在變量過程中定義判斷條件，如果周遊到的元素比變量中的元素大，就指派給該變量：
需要定義一個功能來完成，以便提高複用性。
a、 明确結果，數組中的最大元素 int類型
b、 未知内容：一個數組，int[ ]
publicstatic int getMax(int[ ] arr)
{
int max=arr[ 0 ];
for(intx=1;x<arr.length;x++)
{
if(arr[x]>max)
max = arr[ x ];
}
returnmax;
}
publicstatic void main(String[ ] args)
{
int[ ] arr={5，1，6，4，2，8，9}};
int max = getMax(arr)；
System.out.println(“max=”+max);
}
擷取最大值的另外一種方式。
可不可以将臨時變量max初始化為0呢？可以，這種方式，其實是在初始化為數組中任意一個角标。
及：
publicstatic int getMax(int[ ] arr)
{
int max= 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max = x ;
}
returnarr [max] ;
}
publicstatic void main(String[ ] args)
{
int[ ] arr={5，1，6，4，2，8，9}};
int max = getMax(arr)；
System.out.println(“max=”+max);
}
擷取最小值：(同理)
publicstatic int getMin(int[ ] arr)
{
int min =0
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
returnarr[min];
}
publicstatic void main(String[ ] args)
{
int[ ] arr={5，1，6，4，2，8，9}};
int max = getMax(arr)；
int min = getMin(arr)
System.out.println(“max=”+max);
System.out.println(“min=”+min);
}
C2、數組的常見操作——排序
Array.sort(arr); ——java中已經定義好的一種排序方式，開發中，對數組排序，要使用該句代碼！
a、選擇排序
執行個體：對數組{5，1，6，4，2，8，9}進行排序。
class ArrayTest1
{
publicstatic void selectsort (int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(inty=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
inttemp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
publicstatic void main(String[] args)
{
int[]arr={5,1,6,4,2,8,9};
printArray(arr);
selectsort(arr);
printArray(arr);
}
publicstatic void printArray(int[]arr)
{
System.out.print("[");
for(intx=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}
總結:内循環結束一次，最值出現在頭角标位置上
b、冒泡排序
定義：相鄰的兩個元素進行比較，如果符合條件，換位。
特點：第一圈排序後，最值出現了最後位。
class BubbleSort
{
publicstatic void bubbleSort(int[] arr)
{
for(int x=0;x<arr.length-1 ; x++)
{
for(int y=0;y<arr.length-x-1 ;y++ )
{
if(arr[y]>arr[y+1])
{
inttemp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
publicstatic void printArray(int[]arr)
{
System.out.print("[");
for(intx=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
publicstatic void main(String[] args)
{
int[]arr={5,1,6,4,2,8,9};
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
}
c、排序——換位置功能的提取
引言：發現無論是什麼排序，都需要對滿足條件的元素進行位置的置換，是以可以把這部分相同的代碼提取出來，單獨封裝成為一個函數！
public static void swap(int[] arr,int a,int b)
{
inttemp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
在上面b中的程式中，可以直接運作swap（arr）；
D、數組——查找
定義功能，擷取key第一次出現在數組中的位置，如果傳回是 -1，那麼代表該key值在數組中不存在
執行個體：
class Index
{
publicstatic void main(String[] args)
{
int[]arr={3,1,5,4,2,9};
intindex=getIndex(arr,2);
System.out.println("index="+index);
}
publicstatic int getIndex(int[]arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
{
returnx;
}
}
return-1;
}
}
是以，如果在上面的程式的arr數組中出現了兩個2，那麼index輸出的将是第一次2出現的角标值
折半查找
可以提高效率，但是必須要保證該數組是有序的數組。
classHalfSearch
{
public static int halfSearch(int[] arr,intkey)
{
int min,mid,max;
min=0;
max=arr.length-1;
mid=(max+min)/2;
while ( arr[mid]!=key)
{
if (key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
if (min>max)
return -1;
mid=(max+min)/2;
}
return mid;
}
public static void main(String[] args)
{
int[] arr={2,4,5,7,19,32,45};
int index=halfSearch(arr,55);
System.out.println("index="+index);
}
}
折半的第二種方式：
classHalfSearch2
{
public static int halfSearch_2(int[]arr,intkey)
{
int min =0,max=arr.length-1,mid;
while (min<=max)
{
mid=(min+max)>>1;//等價于mid=（max+min）/2
if (key>arr[mid])
min=mid+1;
else if (key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
public static void main(String[] args)
{
int[] arr={2,4,5,7,19,32,45};
int index=halfSearch_2(arr,55);
System.out.println("index="+index);
}
}
練習題1：有一個有序的數組，想要将一個元素插入到該數組中，還要保證數組是有序的，如何擷取該元素在數組中的位置 {2,4,5,7,19,32,45}
classHalfPractice
{
publicstatic int halfSearch_2(int[]arr,int key)
{
int min =0,max=arr.length-1,mid;
while (min<=max)
{
mid=(min+max)>>1;
if(key>arr[mid])
min=mid+1;
else if (key<arr[mid])
max=mid-1;
else
return mid;
}
return min;
}
public static void main(String[] args)
{
int[] arr={2,4,5,7,19,32,45};
int index=halfSearch_2(arr,8);
System.out.println("index="+index);
}
}
就是在最後傳回時将halfSearch2中的return-1改成了return min，此時的min就是8應該所在的位置！
練習題2：十進制轉二進制
classArrayTests
{
public static void tobin(int num)
{
while (num>0)
{
System.out.print(num%2);
num=num/2;
}
}
public static void main(String[] args)
{
tobin(6);
}
}
最後的輸出結果是011，将顯示的結果反過來就是110就是6的2進制數！
練習題3：十進制轉十六進制
class ArrayTest16
{
public static void toHex(int num)
{
for (int x=0;x<8 ;x++ )
{
int temp=num&15;
if (temp>9)
System.out.println((char)(temp-10+'A'));
else
System.out.println(temp);
num= num>>> 4;
}
}
public static void main(String[] args)
{
toHex(60);
}
}
查表法:十進制轉十六進制
将所有的元素臨時存儲起來，建立對應關系，每一次&15的值都作為引索去查建立好的表，就可以找對應得元素。這比-10+‘a’簡單的多
這個表可以通過數組的形式來定義。
分析：
0 1 2 3 4 5 6 7 8 9 A B C D E F——十六進制
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15——角标
classChecktoHex
{
public static void main(String[] args)
{
toHex(60);
}
publicstatic void toHex(int num)
{
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
for(int x=0;x<8;x++)
{
int temp=num&15;
System.out.println(chs[temp]);
num=num>>>4;
}
}
發現終于出結果了，但是結果是反着的，想要正過來，可以通過StringBufferreverse功能來完成，但是這個工具還沒有學習，是以可以使用已經學過的容器，數組來完成反轉存儲
classChecktoHex
{
public static void toHex(int num)
{
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
char[] arr=new char [8];
int pos=arr.length;
while (num!=0)
{
int temp=num & 15;
arr[--pos] = chs[temp];
num = num >>> 4;
}
System.out.println("pos="+pos);
for (int x=pos;x<arr.length ;x++)
{
System.out.print(arr[x]+",");
}
}
public static void main(String[] args)
{
toHex(60);
}
}
同理:編寫十轉二的查表法程式
class ChecktoBin
{
public static void toBin(int num)
{
char[] chs={'0','1'};
char[] arr=new char [32];
int pos=arr.length;
while (num!=0)
{
int temp=num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
//System.out.println("pos="+pos);
for (int x=pos;x<arr.length ;x++)
{
System.out.print(arr[x]+",");
}
}
public static void main(String[] args)
{
toBin(-6);
}
}
由于通過查表法轉二進制和十六進制有很多的相似之處，是以，我們可以從裡面提取出一些共同的部分定義其功能！
classTranslation
{
if(num==0)
{
System.out.println(0);
return;
}
public static void main(String[] args)
{
toOct(32);
}
public static void toBin(int num)
{
trans(num,1,1);
}
public static void toOct(int num)
{
trans(num,7,3);
}
public static void toHex(int num)
{
trans(num,15,4);
}
public static void trans(int num,int base,intoffset)
{
char[] chs={'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
char[] arr=new char[32];
int pos=arr.length;
while (num!=0)
{
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for (int x=pos;x<arr.length ;x++)
{
System.out.print(arr[x]);
}
}
}
F、數組中的數組
——二維數組
格式1：int[ ] [ ] arr = new int[3][2];
l 定義了名稱為arr的二維數組
l 二維數組中有3個一維數組
l 每一個以為數組中有兩個元素
l 一維數組的名稱分别為arr[0],arr[1], arr[2]
l 給第一個一維數組中角标為1的位指派78，寫法是：arr[0][1]=78;
格式2：int[ ] [ ] arr = new int[3][ ];
l 二維數組中都是3個一維數組
l 每個一維數組都是預設初始化值null
l 可以對這三個一維數組分别進行初始化
l int[ ] [] arr = new int[3][ ];
arr[0]=new int[3];
arr[1]=new int[1];
arr[2]=new int[2];
System.out.println(arr.length);//列印的是二維數組的長度
System.out.println(arr.length);//列印的是二維數組中第一個一維數組的長度
格式3：int[][]arr={{3,5,1,7},{2,3,5,7},{6,1,8,2}}
了解應用，如果上面數組表示一個公司三個銷售團隊每個季度的銷售額度，那麼求該公司一年的總銷售額度？
分析:把所有的數都要加一邊，是以要周遊，先周遊二維數組，再周遊二維數組中一維數組的每一個元素，是以有：
class PlanarArray
{
publicstatic void main(String[] args)
{
int[][]arr={{3,5,1,7},{2,3,5,7},{6,1,8,2}};
intsum=0;
for(int x=0;x<arr.length ;x++)
{
for(int y=0;y<arr[x].length;y++)
{
sum=sum+arr[x][y];
}
}
System.out.println("sum="+sum);
}
}
補充知識：
一維數組的表現形式：
int[] x; int x[];————兩種
int[][]y; int[] y[]; int y[][];————三種
練習：給出數組int[]x,y[];請問下面那一個是正确的？
分析：
int[] x,y[];——這個表達式等價于：
int[] x;int [] y[];
a． x[0]=y; error
b． y[0]=x; yes
c． y[0][0]=x; error
d． x[0][0]=y; error
e． y[0][0]=x[0]; yes
f． x=y error
Summary: []定義在類型當中[]是跟着類型走的，在類型當中[]對他們都有效，而[]跟着字母走那麼隻對單個字母有效！
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)