Java從菜鳥到精通（2）

比較子
== 相等於  ！= 不等於  < 小於 > 大於 <= 小於等於
>= 大於等於
注意：
    1.比較子的結果都是boolean型，也就是要麼是true

，要麼是false
    2.比較子“==”不能誤寫成“=”

邏輯運算子
&  AND（與）   false&true    false
|  OR（或）    false|true    true
^  XOR（異或） true^false    true
!  Not(非)     ！true         false
&& AND（短路）  false&&true  false
|| OR(短路)    false||true   true

&和&&的特點：
&：無論左邊是true是false，右邊都運算。
&&：當左邊為false時，右邊不運算。
|：兩邊都參與運算
||：當左邊為true,右邊不運算
<<:其實就是乘以2的移動的位元次冪
>>:就是除以2的移動的位元次冪
6.語句
程式流程式控制制
    1.判斷結構
        1.if語句
    三元運算：變數=（條件運算式）？運算式1：運算式2；

（好處：可以簡化if else代碼。弊端：因為是一個運算子，所以

運算完必須有一個結果）
    2.選擇結構
        1.switch語句
            格式：
            switch(運算式){
            case 取值1：
            default：
                }
    switch特點：
        a.語句選擇的類型只有四種：byte、short、

int、char；
        b.case之間與default沒有順序。先執行第一個

case，沒有匹配的case執行default；
        c.結束switch語句有兩種情況：遇到Break，執

行到switch語句結束；
        d.如果匹配的case或者default沒有對應的

break，那麼程式會繼續向下執行，運行可以執行的語句，直到遇

到break或者switch結尾結束。
    3.迴圈結構
        1.while （條件運算式） {執行語句}
        2.do{ 執行語句；}while（條件運算式）；
   do while 特點是條件無論是否滿足，迴圈體至少被執行一次

。
        3.for
    for(int i=0;i<5;i++){
               for(int j=i;j<=5;j++){
                System.out.print(" ");
                }
               for(int k=0;k<i;k++){
                System.out.print("* ");

                }
                System.out.println();
            }
7.函數
函數的定義：函數就是定義在類中的具有特定功能的一段獨立小

程式。
函數也稱為方法。

函數的格式：
修飾符  傳回值類型 函數名（參數類型 形參）{
    執行語句；
    return 傳回值；
}
傳回值類型：函數運行後的結果的資料類型。
參數類型：是形式參數的資料類型。
形式參數：是一個變數，用於儲存調用函數時傳遞給函數的實際

參數。
實際參數：傳遞給形式參數的具體數值。
return：用於結束函數。
傳回值：該值會返回給調用者。

函數的特點：
1、定義函數可以將功能代碼進行封裝。
2、便於對該功能進行複用。
3、函數只能被調用才會被執行。
4、對於函數沒有具體傳回值的情況，傳回值類型用關鍵字Void表

示，那麼該函數中的return語句如果在最後一行可以省略不寫
注意：1.函數中只能調用函數，不可以在函數內部定義函數。
      2.定義函數時，函數的結果應該返回給調用者，交由調用

者處理。

函數的重載（overload）
重載的概念
在同一個類中，允許存在一個以上的同名函數，只要它們的參數

個數或者參數類型不同即可。
重載的特點：
與傳回值類型無關，只看參數列表。
重載的好處：
方便於閱讀，最佳化了程式設計。
重載樣本：
//返回兩個整數的和
int add(int x,int y){return x+y;}
//返回三個整數的和
int add(int x,int y,int z){return x+y+z;}
//返回兩個小數的和
double add(double x,double y){return x+y;}
 
什麼時候用重載？
當定義的功能相同，但參與運算的未知內容部同。那麼，這時就

定義一個函數名稱以表示起功能，方便閱讀，而通過參數列表的

不同來區分多個同名函數。

8.數組
數組的定義
概念：同一種類型資料的集合。其實數組就是一個容器。
數組的好處：可以自動給數組中的元素從0開始編號，方便操作這

些元素。
格式1：
元素類型[] 數組名=new 元素類型[元素個數或數組長度]；
格式2：
元素類型[] 數組名=new 元素類型[] {元素，元素，……}
Java程式在運行時，需要在記憶體中的分配空間，為了提高運算效

率，有對空間進行了不同地區的劃分，因為每一片地區都有特定

的處理資料方式和記憶體管理方式。

棧記憶體：
用於儲存局部變數，當資料使用完，所佔空間會自動釋放。

堆記憶體：
1、數組和對象，通過new建立的執行個體都存放在堆記憶體中
2、每一個實體都有記憶體位址值
3、實體中的變數都有預設初始化值
4、實體不在被使用，會在不確定的時間內被記憶體回收行程回收

boolean 預設值時False
方法區：
本地方法區：
寄存器：

數組的操作：以擷取數組中的元素最常見。通常會用到遍曆。

int[] arr=new int[3];
for(int x=0;i<3;x++){syso(arr[x]);}//用For迴圈用完就消失

了。

數組中有一個屬性可以直接擷取到數組元素個數。length
使用方法：數組名稱.length   就能拿到數組的長度。

擷取數組中的最大值，以及最小值
1.擷取最大值
思路：1，擷取最值，需要進行比較。每一次比較都會有一個較大

的值，因為該值不確定，通過一個變數進行臨時儲存。2，讓數組

中的每一個元素都和這個變數中的值進行比較。如果大於了變數

中的值，就用該變數記錄較大的值。3，當所有的元素都比較完成

，那麼該變數中儲存的就是數組中的最大值了。

步驟：1，定義變數，初始化為數組中任意一個元素即可。
      2，通過迴圈語句對數組進行遍曆。
      3，在變數過程中定義判斷條件，如果遍曆到得元素比變數

中的元素打，就賦值給變數。

需要定義一個功能來完成。以便提高複用性。
1，明確結果，數組中的最大元素 int。
2，未知內容：一個數組。int[]。

public class Test{
  public static void main(String [] args){
    int [] arr={1,2,3,4,5,8,6};
    int max=getMax(arr);
    syso(max);
}
    public static int getMax(int [] arr){
     int max=arr[0];
    for(int  x=1;x<arr.length;x++){
          if(arr[x]>max)
            max=arr[x];
    }
    return max;

}
}

擷取最大值的另一種方式。
可不可以將臨時變數初始化為0呢？可以。這種方式，其實是在初

始化為數組中任意一個下標。
public class Test{
  public static void main(String [] args){
    int [] arr={1,2,3,4,5,8,6};
    int max=getMax(arr);
    syso(max);
}
    public static int getMax(int [] arr){
     int max=0;
    for(int  x=1;x<arr.length;x++){
          if(arr[x]>arr[max])
            max=x;
    }
    return arr[max];

}
}

2，擷取最小值。
public class Test{
  public static void main(String [] args){
    int [] arr={1,2,3,4,5,8,6};
    int min=getMax(arr);
    syso(min);
}
    public static int getMin(int [] arr){
     int min=0;
    for(int  x=1;x<arr.length;x++){
          if(arr[x]<arr[max])
            max=x;
    }
    return min[max];

}
}

對給定數組進行排序：
內迴圈結束一次，最值出現在第一個下標位置上。
class ArrayTest{

  public static void main(String [] args){
    int [] arr{5,45,8,8,4,3,5,7};
    //在排序前列印；
    printArray(arr);
    //排序
    selectSort(arr);
    //在排序後列印；
    printArray(arr);
    }

 public static void selsectSort(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]){
          int temp=arr[x];
            arr[x]=arr[y];
            arr[y]=temp;
            //第二種方法，把這個封裝起來調用
            swap(arr,x,y);
        }
        }

    }
    }

    public static void printArray(int [] arr){
    System.out.print("[");
    for(int x=0;x<arr.length;x++){
        if(x!=arr.length-1)
            syso(arr[x]+", ");
        else
            syso(arr[x]+"]");
    }
        }
}

冒泡排序：
public static void 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]){
                int temp=arr[y];
                arr[y]=arr[y+1];
                arr[y+1]=temp;
            //第二種方法封裝調用
            swap(arr,y,y+1);
            }
        }
    }

}

從上面可以得出：無論什麼排序，都需要對滿足條件的元素進行

位置置換。所以可以把這部分相同的代碼提取出來，單獨封裝成

一個函數。
public static void swap(int [] arr,int a,int b){
     int temp=arr[a];
     arr[a]=arr[b];
     arr[b]=temp;
   }

進位轉換：
class ArrayTest5{
    public static void main(String [] args){
        toBin(6);
System.out.println(Integer.toBinaryString(60));//找出六十

對應的二進位
    }
//十進位轉換成二進位
    public static void toBin(int num){
    StringBuffer sbf=new StringBuffer();
    while(num>0){
        sbf.append(num%2);
        num=num/2;

    }
    System.out.println(sbf.reverse());
    }
//十進位轉換成十六進位
    public static void toHex(int num){
     /*
    int n1=num & 15;
    n1-10+'a';
    int temp=num>>>4;
    temp=num&15;
    */
    StringBuffer sbf=new StringBuffer();
    for(int x=0;x<8;x++){
     int temp=num&15;
    if(temp>9){
//    Syso((char)(temp-10+'A'));
    sbf.append((char)(temp-10+'A'));
    else
    sbf.append(temp);
    num=num>>>4;
    }
    syso(sbf.reverse());
    }
    
    }

}

查表法進行十六進位轉換
/*
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
查表法：將所有的元素臨時儲存起來，建立對應關係。
每一次&15後的值作為索引去查建立好的表。就可以找對應的元素

。這樣比 -10+‘a’簡單的多。

可以通過數組的形式來定義。

下面的結果是反著的，想要正過來，可以通過StringBuffer的

reverse功能實現。也可以通過數組來完成儲存。
*/
public class Test{

    public static void main(String [] args){
    toHex(60);
    }
    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;
    //syso(chs[temp]);
    arr[--pos]=chs[temp];
    num=num>>>4;

    }}

     //儲存資料的arr數組遍曆
    for(int x=pos;x<arr.length;x++){
    syso(arr[x]+", ");

    }
    }
}