1.定義函數首先明確函數需要返回什麼結果，即返回值類型，其次明確函數運算過程中需要參與的未知變量，即形式參數類型和個數。定義函數只需完成需要的功能即可，不需要打印返回結果，需要對返回值進行打印還是比
較等運算是函數調用者的事，不要在函數定義時完成額外的功能，依需求而定。
java虛擬機運行時，把內存劃分爲5塊區域：棧、堆、方法區、本地方法區、寄存器。
基本數據類型int x=5;直接在棧內存中開闢一塊內存空間，把變量名和值5存進去；
引用數據類型int [ ] y=new int [3];在棧內存中開闢一塊空間，把數組名y存進去，通過new在堆內存中開闢一個連續的3塊內存空間，把首元素的空間的地址賦值給y,如0X63DE，形成指向關係。
棧內存的特點：用於存儲局部變量，當數據使用完時，所佔內存自動釋放；
堆內存的特點：1.必須有至少一塊棧內存指向它，否則就是垃圾內存
2.堆中的元素都有初始化值
3.成爲垃圾內存後，會在不確定的時間內被垃圾回收器回收
3.數組的常用操作：獲取數組中的元素，數組的遍歷，獲取數組中的最大值、最小值(用一個變量存貯數組中的任一個元素，在遍歷數組時，用其動態存儲與當前獲取元素的比較後的最大值，注意這個變量初始化可以是數組中的任意一個元素值，也可以是0，但此時變量用於存儲數組的下標)
4.數組的排序：選擇排序法、冒泡排序法 Array.sort(arr)
選擇排序：從第一個數開始，依次與後面的所有數進行比較，再拿第二個數依次與後面的數進行比較；
冒泡排序：拿第一個數與第二個數比較，再拿第二個數與第三個數比較，依次比較兩個相鄰的數。
這兩種排序的效率都不高，效率高的是希爾排序。
因爲在堆內存中交換數據比較耗資源，高效率的方法是在棧內存中用一個變量存儲需要交換的數，當一次循環結束後，再在棧內存中交換數據，這樣每循環一次只發生一次堆數據交換。
/*------------------------------------------------------------*/
5.數組排序
選擇排序法，從數組的第一個元素開始，依次與後面的元素比較，前者>後者，二者值交換，所以內循環進行一次，最小值出現在最前面
public static void selectSort(int [] arr){
for (int x=0;x<arr.length-1 ;x++ ){ //這裏應該是減1的，防止下標越界，但奇怪不減1竟然正常運行,
//因爲當x=arr.length時,內循環y=x+1=arr.length,不滿足 //y<arr.length,
for (int y=x+1;y<arr.length ;y++ ){ //所以跳出循環，就不會發生下標越界了
if (arr[x]>arr[y]) { //這個其實還是好理解的，外循環控制着當前比較着後 //面至少還有一個數,
//所以外循環從0到arr.length-1
int temp=arr[x]; //內循環控制從外循環的當前循環後緊接着的1位即 //x+1開始，
arr[x]=arr[y]; //直到最後1位,依次和和外循環當前的數比較
arr[y]=temp;
}
}
}
}
//遍歷數組並打印
public static void printArr(int [] arr){
System.out.print("[");
for (int i=0;i<arr.length ;i++ ){
if (i!=arr.length-1)
System.out.print(+arr[i]+",");
else
System.out.println(arr[i]+"]");
}
}
冒泡排序法：從數組前兩個數開始比較，如果前者>後者，二者交換順序，然後從第二個數開始，第二個數與第三個數比較，依次滾動向前，比較相鄰的兩個數，循環一次後，最大數出現在最右端。
public static void bubbleSort(int [] arr){
for (int x=0;x<arr.length-1 ;x++ ){
for (int y=0;y<arr.length-1-x;y++ ){ //這裏減一防止下面出現下標越界，減x是進行一次內循 //環最大的數就到了最右邊
//需要參與比較的數就少一個
if (arr[y]>arr[y+1]){
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
}
class ArraySort1{
public static void main (String [] args){
int [] arr={34,66,2,6,10,7};
selectSort(arr);
printArr(arr);
bubbleSort(arr);
printArr(arr);
}
選擇排序法是每次固定一個數作爲參照物，依次和後面的比較,走過後不再回頭
冒泡排序法是每次比較相鄰的兩個數，兩個兩個比較，一遍過後從頭再來，只是，比較的範圍從右端一點點向左移
共同點，外循環一樣，都要保證下標<arr.length-1,內循環通過一個判斷交換值，（再次聯想到交換兩個數值得三種方法）
/*------------------------------------------------------------*/
6.數組查找
遍歷查找（查找一個數在數組中第一次出現的位置）
class ArraySearch1{
public static void main (String [] args){
int [] arr={4,7,2,67,2,32,90};
System.out.println(getIndex(arr,2));
}
public static int getIndex(int [] arr,int value){
for (int i=0;i<arr.length ;i++ ){
if (value==arr[i]) //i=0,滿足i<arr.length,判斷是否value=arr[i],如果不等，加1繼續循環
return i; //如果相等，則返回i,return是函數結束的標誌，返回i後函數結束
} //如果直到i=arr.length,仍然沒有value=arr[i],則跳出for循環，繼續執行
return -1; //下面語句 注意，return-1不能寫在for循環中
}
}
/*------------------------------------------------------------*/
折半查找比遍歷查找效率要高一點
//先把數組按升序排列，找出中間的數與指定的數比較，如果中間的數比指定的數小，則縮小查找範圍
//再在剩下的範圍中折中查找，依次循環，直到找到這個數或者查找範圍的區間的下標交叉時，程序結束
class ArraySearch2{
public static void main (String [] args){
int [] arr={1,2,4,5,7,8,9};
int index=halfSearch(arr,9);
System.out.println("index="+index);
int index2=halfSearch_2(arr,5);
System.out.println("index="+index2);
}
public static int halfSearch(int [] arr,int value){
int min,max,mid;
min=0; //小角標
max=arr.length-1; //大角標
mid=(min+max) >>1; //區間一半處的角標
while (value!=arr[mid]){ //當要找的數不等於中間角標時，一直縮小範圍循環比較
if (arr[mid]<value) //要找的數大於中間角標的數，就縮小區間，在右半邊區間中找
min=mid+1;
else if (arr[mid]>value) //要找的數小於中間角標的數，就縮小區間，在左半邊區間中找
max=mid-1;
if (min>max) //如果小角標移到大角標的右邊了，說明要找的數不在數組中
return -1;
mid=(min+max)>>1; //角標每移動一次，就折半一次
}
return mid;
}
/*------------------------------------------------------------*/
//折半查找第二種循環邏輯
public static int halfSearch_2(int [] arr,int value){
int min,max,mid;
min=0;
max=arr.length;
mid=(min+max) >>1;
while (min<max) { //當小角標一直在大角標左邊時，還需要循環
if (value>arr[mid])
min=mid+1;
else if (value<arr[mid])
max=mid-1;
else
return mid;
mid=(min+max)>>1;
}
return -1;
}
}
/*------------------------------------------------------------*/
需求：已知一個排過序的數組，當把一個數插入數組中後，仍然使數組按順序排列，找出這個數的位置。
分析：這是折半查找的一個應用，當數組中存在與要插入的數相等時，返回該數的下標，當不存在時，返回 arr[min]的下標min
class ArraySearch3{
public static void main (String [] args){
int []arr={1,2,4,5,6,8,10,13};
int index=halfSearchApp(arr,3);
System.out.println(index);
}
public static int halfSearchApp(int [] arr,int value){
int min,max,mid;
min=0;
max=arr.length-1;
mid=(min+max)>>1;
while (min<max){
if(value>arr[mid])
min=mid+1;
else if(value<arr[mid])
max=mid-1;
else
return mid;
mid=(min+max)>>1;
}
return min;
}
}
7.進制轉換（優化後的代碼）
public class Test{
public static void main(String []args){
toBin(6);
toBin(-6);
toOct(60);
toHex(60);
}
}
//十進制轉換爲二進制
public static void toBin(int sum){
trans(num,1,1);
}
//十進制轉換爲八進制
public static void toOct(int sum){
trans(num,7,3);
}
//十進制轉換爲十六進制
public static void toHex(int sum){
trans(num,15,4);
}
//進制轉換提取出的通用代碼
public static void trans(int num,int base,int offset){
//如果是0，直接打印並結束
if (num==0) {
System.out.println(0);
return;
}
//定義查表用的數組
char [] chg={'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; //取num最低base位
arr[--pos]=chg[temp]; //查表後存儲到arr中
num=num >>>offset; //num無符號右移offset位
}
//遍歷，打印
for (int x=pos;x<arr.length;x++){ //從pos開始打印，避免前面出現0
System.out.print(arr[x]);
}
System.out.println(); //換行
}
}