JAVA的基本程式設計結構（下）

• 字串
  • Java沒有內建的字串型別，而是在標準Java類庫中提供了一個預定義類，叫做 String。

  • String e="";    //an empty String
    String greeting="hello";  //每個雙引號括起來的字串都是String類的一個例項

  • 子串

    • String 類的substring方法可以從一個較大的字串提取出一個子串。String substring(int beginIndex,int endIndex)

    • String greeting="Hello";
      String s=greeting.substring(0,3);    //從0開始計數，直到3為止，但不包含3   結果：s="Hel";

    • substring有一個優點：容易計運算元串的長度。s.substring(a,b)的長度為b-a 例如，子串"Hel"的長度為3-0=3

  • 拼接（+號拼接兩個字串）

    • String a="Hello ";     String b="World!";
      String c=a+b;      //結果 c="Hello World!"; 

    • 當一個字串與一個非字串的值進行拼接時，後者會轉換成字串

      • int age=13;      String rating="PG"+age;    //結果  rating="PG13";

      • 這種特性通常用在輸出語句中。例如：System.out.println("The answer is"+answer);

    • 如果需要把多個字串放在一起，用一個界定符分隔，使用靜態join方法。

      • String all=String.join("/","S","M","L","XL");   //結果 all="S / M / L / XL";  

    • Java11,提供 一個repeat方法

      • String repeated="Hello".repeat(3);   //結果  repeated="HelloHelloHello";

  • 不可變字串
    • String 類沒有提供修改字串中某個字元的方法，可以提取想要保留的子串，再與希望替換的字元拼接

      • greeting=greeting.substring(0,3)+"p!";    //結果 greeting="HelP!"

    • 由於不能修改Java字串中的單個字元，所以在Java文件中將String類物件稱為是不可變的。

      • 不可變字串有一個優點，編譯器可以讓字串共享。

  • 檢測字串是否相等  boolean equals(Object other)

    • s.equals(t)  //s與t可以是字串變數，也可以字串字面量  例如：s.equals("hello")    

    • 不區分大小寫，檢測兩個字串是否相等。使用 boolean equalsIgnoreCase(String other)

      • "Hello".equalsIgnoreCase("hello");

    • 使用 == 運算子檢測兩個字串是否相等時，注意兩個字串是否存放在同一個位置上。

      • + 或 substring等操作得到的字串並不共享，不可以使用==運算子檢測

  • 空串與Null串

    • String str="";　　//空串有自己的串長度（0）和內容（空）
      if(str.length()==0) 或  if(str.equals(""))    //檢查一個字串是否為空　　　　　　

    • String str=null; //表示目前沒有任何物件與該變數關聯
      if(str==null)  或  if(str !=null && str.length()!=0)    //檢查一個字串是否為null

  • 碼點與程式碼單元

    • Java字串有char值序列組成，char資料型別是一個採用UTF-16編碼表示Unicode碼點的程式碼單元

    • String greeting="Hello";
      int n=greeting.length();   //length()方法返回採用UTF-16編碼表示給定字串所需要的程式碼單元數量
      int cpCount=greeting.codePointCount(0,greeting.length());  //int codePointCount(int startIndex,int endInex)
                                                                   實際的長度，即碼點數量

    • char charAt(int index) 將返回位置index的程式碼單元，index 介於 0 ~ length() - 1 之間

      • char first=greeting.charAt(0);  //結果 first="H";  注：除非對底層的程式碼單元感興趣，否則不需要呼叫這個方法

  • String API（Application Programming Interface，應用程式設計介面）

    • API是一些預先定義的函式，用來提供應用程式與開發人員基於某軟體或硬體得以訪問的一組例程，而又無需訪問原始碼，或理解內部工作機制的細節。

    • Java 中的 String 類包含了50多個方法，例如：

      • String join(CharSequence delimiter,CharSequence...elements)； //返回一個新字串，用給定的定界符連線所有元素

      • CharSequence是一種介面型別，所有字串都屬於這個介面。一個 CharSequence形參(parameter),完全可以傳入 String型別的實參(argument）　　

  • 閱讀聯機API文件

    • 在標準庫中有幾千個類，方法數量驚人。因此，學會使用聯機 API文件，從中可以查閱標準類庫中的所有類和方法。

      • 可以從Oracle下載 API文件，也可以在瀏覽器訪問 http://docs.oracle.com/javase/8/docs/api 線上檢視
  • 　構建字串（StringBuilder 類）

    • StringBuilder builder=new StringBuilder();   //構建一個空的字串構建器
      builder.append(ch);　　//新增內容，呼叫append方法
      String commpletedString=builder.toString();  //呼叫toString方法，將得到一個String物件，其中包含了構建器中字元的字元序列。

    • StringBuilder 類的前身是StringBuffer，它的效率稍有些低，但允許採用多執行緒的方式新增或刪除字元。通常字串編輯操作都在單個執行緒中執行。

• 輸入與輸出

  • 讀取輸入

    • import java.util.*;  //Scanner 類定義在 java.util包中。當使用的類不是定義在基本 java.lang包中時，都要使用import指令匯入相應的包。
      ...
      Scanner in=new Scanner(System.in);  //構造一個與"標準輸入流" System.in關聯的 Scanner物件
      System.out.println("What is you name? ");
      String name=in.nextLine();    //nextLine 方法讀取一行輸入
      String firstName=in.next();    //讀取一個單詞，以空白符作為分隔符
      System.out.println("How old are you? ");
      int num=in.nextInt();    //讀取一個整數

    • 由於輸入是可見的，Scanner類不適用於從控制檯讀取密碼

      • Console cons=System.console();   //Java6 特別引入了Console類來實現這個目的
        String username=cons.readLine("User name：");  
        char[] passwd=cons.readPassword("Password：");  //為了安全起見，返回的密碼存放在一個字元陣列中，而不是字串中。

  • 格式化輸出

    • double x=10000.0/3.0;
      System.out.print(x);    //將以x的型別所允許的最大非0數位個數列印輸出x   如果希望顯示美元，美分數，這就會有問題  
      System.out.printf("%8.2f",x);  //包括8個字元，精度為小數點後2個字元。會列印一個前導的空格和7個字元，如：3333.33

    • 可以為 printf 提供多個引數，例如：

      • System.out.printf("Hello,%s.Next year,you'll be %d",name,age); //結果 Hello,changm.Next year,you'll be 23

      • %格式說明符會用相應的引數替換，%緊跟著的轉換符指示要格式化的數值型別

      • 用於 printf 的轉換符

        轉換符	型別	示例	轉換符	型別	示例
        d	十進位制整數	159	s	字串	Hello
        x	十六進位制整數	9f	c	字元	H
        o	八進位制整數	237	b	布林	true
        f	定點浮點數	15.9	h	雜湊碼	42628b2
        e	指數浮點數	1.59e+0.1	tx 或 Tx	日期時間（T 強制大寫）	已經過時，應當改為使用 java.time類
        g	通用浮點數(e和f中 較短的一個)	—	%	百分號	%
        a	十六進位制浮點數	0x1.fccdp3	n	與平臺有關的行分隔符	—

  • 檔案輸入與輸出

    • 　　要想讀取一個檔案，需要構造一個Scanner物件

      • Scanner in=new Scanner(Path.of("myfile.txt"),StandardCharsets.UTF_8);    //Path.of 方法是Java11中加入的方法

    • • 如果檔名中包含反斜槓符號，就要在每個反斜槓之前再加一個額外的反斜槓轉義：”c:\\mydirectory\\myfile.txt“

    • 要想寫入一個檔案，需要構造一個PrintWriter物件

      • PrintWriter out=new PrintWriter("myfile.txt",StandardCharsets.UTF_8);   //如果檔案不存在，建立該檔案。可以像輸出到

                                                                                       System.out一樣使用print、println以及printf命令

    • 啟動目錄是命令直譯器的當前目錄

      • String dir=System.getProperty("user.dir");  //獲取啟動目錄的位置

    • 如果用一個不存在的檔案構造Scanner，或者用一個無法建立的檔名構造PrintWriter，就會產生異常。Java編譯器認為這些異常比”被零除“異常更嚴重

      • public static void main(String[] args) throws IOException{      //在main方法中用throws子句標記

• 控制流程

  • 與任何程式設計語言一樣，Java使用條件語句和迴圈結構確定控制流程

  • 塊作用域（一對大括號括起來的若干條Java語句）

    • public static void main(String [] args){
        int n;
        {
           int n;  //Error——不能在巢狀的兩個塊中宣告同名的變數
        }    
      }

  • 條件語句

    • if(條件語句)Java語句1
      if(條件語句)語句語句1 else Java語句2       //條件語句為true,執行Java語句1；否則執行Java語句2
      if(條件語句){
        Java語句1     
      }else{
        Java語句2
      }
      if(條件語句1){                //哪個條件語句為ture，執行哪個塊裡面的Java語句。條件語句都為false，執行Java語句4
        Java語句1
      }else if(條件語句2){
        Java語句2
      }else if(條件語句3){
        Java語句3
      }else{
        Java語句4
      }

  • 迴圈

    • while(條件語句)Java語句
      while(條件語句){
          Java語句        //條件語句為true，while迴圈執行Java語句；否則，條件語句為false,while迴圈一次也不執行
      }
      do{
          Java語句        //先執行Java語句，再檢測條件語句。如果為true，重複執行Java語句，直到條件語句為false為止
      }while(條件語句);

  • 確定迴圈

    • for迴圈語句是支援迭代的一種通用結構，由一個計數器或類似的變數控制迭代次數，每次迭代後這個變數將會更新

    • for(int i=1;i<=10;i++) //第1部分通常是對計數器初始化；第2部分給出每次新一輪迴圈執行前要檢測的迴圈條件；第3部分指定如何更新計數器  
        System.out.println(i);   //for迴圈語句的3個部分應該對同一個計數器變數進行初始化、檢測和更新

    • 在迴圈中，檢測兩個浮點數是否相等需要格外小心。

    • for(double i=1;i!=10;i+=0.1) {   //由於舍入的誤差，可能永遠達不到精確的最終值          
           System.out.println(i);      //因為0.1無法精確地用二進位制表示
      }

    • int i;              
      for(i=1;i<=10;i++){  //for語句中第1部分宣告的變數，其作用域只擴充套件到這個for迴圈體的末尾
         ...               //若希望在for迴圈體外使用迴圈體計數器的最終值，需要在這個迴圈體外宣告變數
      }

  • 多重選擇：switch語句

    • @SuppressWarnings("fallthrough")//如果沒有break；就會執行下一個case分支，有可能觸發多個case分支。加入註解，就不會對這個方法生成警告了
      switch (choice) {       
      case 1:         //switch語句將從與選項值匹配的case標籤開始執行，break；跳出switch語句   
              Java語句
      break;      
      case 2:
              Java語句
      break;
      default:     //沒有相匹配的case標籤，而有default子句，執行default
      break;
      }   //註解是為編譯器或處理Java原始檔或類檔案的工具提供資訊的一種機制           

    • case標籤可以是：

      • 型別為 char、byte、short 或 int 的常量表示式

      • 列舉變數

      • Java7開始，還可以是字串字面量

  • 中斷控制流程的語句

    • break；也可以用於退出迴圈語句

    • 跳出多重巢狀的迴圈語句

      • read_data:while (. . .) {   //建立一個標籤並放在需要跳出的最外層迴圈之前，且緊跟一個冒號
            . . .
            for (. . .) {
                . . .
                if(n<0)
                break read_data;   //可以將該標籤跳出迴圈的形式應用到任何語句     
                        
                . . .
            }
        }

      • continue；越過當前迴圈體的剩餘部分，跳到迴圈首部

• 大數

  • 基本的整數和浮點數精度不能夠滿足要求，使用Java.math包中兩個類：BigInteger 和 BigDecimal

  • BigInteger a=BigInteger.valueOf(100);  //BigInteger類實現任意精度的整數運算，valueOf方法可以將普通的數值轉換為大數
    BigInteger reallyBig=new BigInteger("22221548456466416");  //對於更大的數，可以使用一個帶字串引數的構造器
    BigInteger c=a.add(b);    //c=a+b
    BigInteger d=c.multiply(b.add(BigInteger.valueOf(2)));  //d=c*(b+2) 
    

• 陣列

  • 陣列是一種資料結構，用來儲存同一型別值的集合

  • int []b=new int[100];  //宣告並初始化了一個可以儲存100個整數的陣列。一旦建立了陣列，就不能再改變它的長度。（可以改變單個的陣列元素）
                           若程式執行中需要經常擴充套件陣列的大小，就使用另一種資料結構——陣列列表（array list） 

  • 建立陣列物件並同時提供初始值的簡寫形式

  • int []smallPrimes= {2,3,5,7,11,17};  //不需要使用new，不用指定長度

• 訪問陣列元素　　

  • 迴圈在陣列中填入元素

  • int []a=new int[100];  
    for(int i=0;i<100;i++) {
        a[i]=i;
    }

  • 建立一個陣列時，所有元素都初始化為0。boolean陣列的元素會初始化為false。物件陣列的元素則初始化為一個特殊值null，表示這些元素還（未）存放      任何物件
  • 可以使用array.length獲得陣列中的元素個數

  • for(int i=9;i<a.length;i++)     //如果建立了一個100個元素的陣列，並且訪問元素a[100](或在0~99之外的任何下標) 
        System.out.println(a[i]);     就會引發"array index out of bounds"異常

• for each迴圈
  • 可以用來依次處理陣列（或其他元素集合）中的每個元素，而不必考慮指定下標

  • for(資料型別 變數：資料物件)     //增強的for迴圈的語句格式
    for(int element:a)    //它定義一個變數用於暫存集合中的每一個元素，並執行相應的語句，
                                     該集合表示式必須是一個陣列或是實現了Iterable介面的類物件（例如 ArrayList）
    System.out.println(element); //列印a的每一個元素（迴圈a中的每一個元素）

  • 使用傳統的for迴圈也可以獲得同樣的效果

  • for(int i=0;i<a.length;i++)     //註釋：for each迴圈語句的迴圈變數將會遍歷陣列中的每個元素，而不是下標值     
        System.out.println(a[i]);

  • Arrays類的 toString方法也可以列印陣列中的所有值

  • System.out.println(Arrays.toString(a));  //返回一個包含陣列元素的字串   結果,"[2,3,5,7,11,13]"

• 陣列拷貝

  • 將一個陣列變數拷貝到另一個陣列變數

  • int[] luckyNumbers=smallPrimes;
    luckyNumbers[5]=12;    //結果，smallPrimes[5]=12;

  • 將一個陣列的所有值拷貝到一個新的陣列中去，使用 Arrays類的 copyOf方法

  • int[] copiedLuckyNumbers=Arrays.copyOf(luckyNumbers,luckyNumbers.length);
    //第二個引數是新陣列的長度。這個方法通常用來增加陣列的大小
    luckyNumbers=Arrays.copyOf(luckyNumbers,2*luckyNumbers.length); //如果陣列元素是數值型，那麼額外的元素將被賦值為0；如果陣列元素
    是布林型，則將賦值為false。相反，如果長度小於原始陣列的長度，則只拷貝當前的值  

• 陣列排序

  • 對數值型陣列進行排序，可以使用 Arrays類中的 sort方法

  • int[] a={1,6,2,8,3,9};  
    Arrays.sort(a);   //這個方法使用了優化的快速排序（QuickSort）演算法。該演算法對於大多數資料集合來說都是效率比較高的 

• 多維陣列

  • 多維陣列將使用多個下標訪問陣列元素，它適用於表示表格或更加複雜的排列形式

  • double[] [] balances;  //宣告一個二維陣列（也成為矩陣） 
    balances=new double[10][6];  //陣列進行初始化之前不能使用
    int[][] magicSquare={  //直接宣告並初始化，就可以不呼叫new
         {16,3,2,13},
         {5,10,11,8},  //陣列初始化後，就可以利用兩個中括號訪問各個元素，例如,magicSquare[i][j] 
         {9,6,7,12}
    };

  • for each迴圈語句不能自動處理二維陣列的每一個元素。需要使用兩個巢狀的迴圈

  • for(double[] row:a){    //他會迴圈處理行，而這些行本身就是一維陣列
        for(double value:row){
            System.out.println(value);
        }
    }           

     

  • 想要快速的列印一個二維陣列的資料元素列表，可以呼叫：

  • System.out.println(Arrays.deepToString(a));  //輸除格式為:[[16,3,2,13],[5,10,11,8],[9,6,7,12]]

• 不規則陣列

  • Java實際上沒有多維陣列，只有一維陣列。多維陣列被解釋為"陣列的陣列"。

  • 表示式 balances[i]引用第i個子陣列，也就是表格第 i行。它本身也是一個陣列，balances[i][j]引用這個陣列的第 j個元素

  • doublep[] temp=balances[i];   //由於可以單獨地訪問陣列的某一行，所以可以讓兩行交換 
    balances[i]=balances[i+1]; 
    balances[i+1]=temp;