------- android教育訓練 、 java教育訓練 、期待與您交流！ ----------
今天的内容主要是數組的特點和對數組的常見操作
一維數組
概念：數組就是存儲同一種資料類型的集合，是一個容器，它可以對容器内的資料從0開始，進行編号，用于封裝這些資料，是一個實體。
格式：
元素類型[] 數組名 = new 元素類型[元素個數或者數組的長度]；
元素類型[] 數組名 = {元素1，元素2......}；
數組其實還有其他的形式，但上面兩種最常用，對于其他格式，這裡不在贅述。
引入兩個記憶體的知識點：棧記憶體和堆記憶體。
棧記憶體：存儲局部變量，資料使用完畢後，會自動釋放。
堆記憶體：記憶體每一個實體，數組和對象都在對記憶體中。
堆記憶體的特點：1，記憶體位址值；
2，預設初始化值，int：0，float型：0.0f，double型：0.0，
boolean型：false；
3，垃圾回收機制：不定時自動回收。
二維數組
概念：
其實就是将數組作為元素存到數組當中，構成的數組稱為二維數組。
格式：
格式一：int[][] arr= new int[5][6];
代表這個數組中有5個一維數組，每一個一位數組中有6個元素，我們要表示某一個元素在數組中的位置可以寫成：arr[0][1]，這代表的是0角标上的一維數組1角标上的元素。
格式二：int[][] arr= new int[5][];
格式三：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
格式三是直接把一維數組中的元素都初始化了。
數組中的常見操作
周遊：擷取數組中的元素通常都會用到周遊。
數組中有一個屬性，可以直接擷取到數組中的元素個數：length，使用方式：數組名稱.length。
但凡有數組通常都會用到for循環。
class ArrayDemo
{
public static void main(String[] args)
{
int[] arr ={2,3,4,5,6,6,7,8,9,88};
printArray(arr);//列印出來的結果是[2,3,4,5,6,6,7,8,9,88]。
}
//定義功能用于列印數組中的元素。元素間用逗号隔開。
public static void printArray(int[] 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.println();//換行。
}
}
運作的結果：
擷取數組中的最大值和最小值：
擷取最值需要進行比較。每一比較都會有一個較大或者較小的值，因為該值不确定，可以通過一個變量進行臨時存儲讓數組中的每一個元素都和這個值進行比較，當我們要擷取最大值時，如果在數組中周遊到的值大于變量中的值，就用改變量記錄較大的值；當所有的元素都比較完成，變量中存儲的就是數組中的最大值，擷取最小值同理。
其實我們将這個變量定義成數組的一個角标，或者這個角标上所對應的值都可以，我選擇其中一種方法，直接将變量定義成數組0角标上的值。
/*
需求：擷取數組中的最大最小值
*/
class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr ={2,1,3,6,4,7,9,6};
int max = getMax(arr);
int min = getMin(arr);
System.out.println("min="+min);
System.out.println("max="+max);
}
public static int getMax(int[] arr)
{
int max = arr[0];//定義一個變量，并将數組中0角标的值賦給這個變量。
for(int x = 1;x<arr.length;x++)
{
if(max<arr[x])
max=arr[x];//比較後，将較大的值賦給max變量。
}
return max;
}
public static int getMin(int[] arr)
{
int min = arr[0];//定義一個變量，并将數組中0角标的值賦給這個變量。
for(int x = 1;x<arr.length;x++)
{
if(min>arr[x])
min =arr[x];//比較後，将較小的值賦給min變量。
}
return arr[min];
}
}
運作後的結果：
數組中的選擇排序和冒泡排序：
選擇排序：選擇一個位置和其他位置比較，在選擇下一個位置和剩下的位置比較，内循環結束一次最值出現在頭角标位置上。
我們用下邊的一個例子來說明，這是我們要進行選擇排序的數組：【49 38 65 97 76 13 27 49】
第一次排序後 13 【38 65 97 76 49 27 49】
第二次排序後 13 27 【65 97 76 49 38 49】
第三次排序後 13 27 38 【97 76 49 65 49】
第四次排序後 13 27 38 49 【49 97 65 76】
第五次排序後 13 27 38 49 49 【97 97 76】
第六次排序後 13 27 38 49 49 76 【76 97】
第七次排序後 13 27 38 49 49 76 76【 97】
這樣就比較直覺了，很明顯是嵌套循環尖朝下的結構，是以我們可以改變内循環的初始化值，讓初始化值随着外循環變化。
冒泡排序：數組中相鄰的兩個元素進行比較，如果符合條件，換位，第一圈比較完後，最值出現在最後一位，第二圈比完後，最值出現在倒數第二位......，循環比較，除了每次比較完的最後一個，因為那一個已經是之前進行比較的一組的最值了，下次不需要在納入比較的範圍之内。
學的時候就在想為什麼要叫冒泡排序，原來是因為随着循環的對這些數進行位置置換，最值會慢慢的浮出來，是以才叫冒泡的吧。
下面是冒泡排序和選擇排序的代碼：
/*
需求：對數組進行選擇排序和冒泡排序。上邊已經詳細的說過這兩個排序，是以在代碼裡就不寫思路和步驟了。
*/
class ArraySort
{
public static void main(String[] args)
{
int[] arr = {12,345,21,3,13,34,2,1};
printArray(arr);//偷個懶，周遊數組前邊已經寫了方法，這裡直接用吧,在這列印排序前的數組。
//int[] arr1 = selectSort(arr);//選擇排序驗證了，沒有問題。
int[] arr1 = bubbleSort(arr);
printArray(arr1);
}
//選擇排序
public static int[] selectSort(int[] arr){
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
return arr;
}
//冒泡排序
public static int[] bubbleSort(int[] arr){
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)//-x：每次比較完，都會一個确定的值不用再參加下一次比較；-1：是為了防止角标越界。
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
return arr;
}
public static void swap(int[] arr,int x,int y)//這個是位置置換功能。
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
｝
運作的結果：
數組的查找操作：
折半查找：首先一定要保證要進行查找的數組是有序的，先定義兩個變量，一個指派為0角标，作為最小值，一個指派為最後一個角标，作為最大值 再定義一個變量，存儲最小值與最大值的一半，也就是數組的中間位置，然後将已知的值與中間位置元素的值進行比較，如果比中間元素的值大，則将最小值指派為中間值加1，繼續取最小值與最大值的中間值元素與已知元素進行比較，如果比中間元素的值小，則将最大值指派為中間值減1，繼續取最小值與最大值的中間值元素與已知元素進行比較，如果比較到最後最小值已經大于最大值了，說明這個元素在數組中不存在，這時我們傳回-1。
代碼如下：我把兩個方法都寫進去，其實都是差不多的。
/*
折半查找
*/
class ArrayBinarySearch
{
public static void main(String[] args)
{
int[] arr = {3,11,23,34,45,56,76,87};//注意，這個數組一定要是有序的。
int num = binarySearch(arr,23);
System.out.println("num="+num);
}
public static int binarySearch(int[] arr,int key)
{
//方法一
/*
int min,max,mid;
max = arr.length-1;
min = 0;
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;
*/
//方法二
int min,max,mid;
min = 0;
max = arr.length-1;
while(min<=max)
{
mid = (max+min)/2;
if(key>arr[mid])
min = mid+1;
else if(key<arr[mid])
max = mid-1;
else
return mid;
}
return -1;//如果我們要把一個數插入到數組中，把這裡改成return min;就可以了。
}
}
運作後的結果：
進制轉換：
直接上查表法吧：将所有的元素臨時存儲起來，建立對應關系，将每次做完&運算的值(&的值根據你要轉換的進制而定，&15是轉16進制，&7是轉8進制，&1是轉二進制)作為索引去查表，就可以查到對應的元素，然後再将這個值右移(位數由你要轉的進制而定，16進制4位，8進制3位，2進制1位)。下面是代碼：
/*
查表法十進制----十六進制
*/
class ToHexDemo
{
public static void main(String[] args)
{
toHexCha(45,15,4);
}
public static void toHexCha(int num,int yushu,int weiyi)
{
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 & yuShu;
System.out.print(chs[temp]);
num = num>>>weiyi;
}
*/
//方法二 StringBuilder容器
/*StringBuilder sb = new StringBuilder();
for(int x=0;x<8;x++)
{
int temp = num & yushu;
num = num>>>weiyi;
sb.append(chs[temp]);
}
System.out.println(sb.reverse());
*/
//方法三 存到數組中
char[] arr = new char[8];
int pos = arr.length-1;//arr.length;
while(num!=0)
{
int temp = num & yushu;
num = num>>>weiyi;
arr[pos--] = chs[temp];//arr[--pos];
}
for(int x=pos+1;x<arr.length;x++)//x=pos;
{
System.out.print(arr[x]);
}
}
}
運作結果是：
以上就是今天的所有内容！