《瘋狂Java講義》學習筆記（四）流程控制與數組

1、順序結構

• 順序結構就是程序從上而下逐行地執行，中間沒有任何判斷和跳轉

2、分支結構

• if…else…
• switch
  控制表達式只允許byte、short、char、int、String和枚舉類型

swicth(expression){
    case condition1:{
        statement(s)
        break;
    }
    case condition2:{
        statement(s)
        break;
    }
    ...
    default:{
        statement(s)
    }
}
// 注意每個case中需要帶有break;

3、循環結構

• 循環語句包含的4個部分：

初始化語句init_statement
循環條件test_expression
循環體body_statement
迭代語句iteration_statement

• while

[init_statement]
while(test_expression){
    statement;
    [iteration_statement]
}
例：
int count = 0;
while(count<10){
    System.out.println(count);
    count++;
}

• do…while

// 循環體至少執行一次
[init_statement]
do{
    statement;
    [iteration_statement]
}while(test_expression);
例：
int count = 0;
do{
    System.out.println(count);
    count++;
}while(count<10);

• for循環

for([init_statement];test_expression;[iteration_statement]){
    statement;
}

• 嵌套循環，就是循環中套有循環

for(int i=0;i<5;i++){
    for(int j=0;j<5;j++){
        System.out.println(i+j);
    }
}

4、控制循環結構

• break
  結束當前循環
• break outer

// 結束至指定循環
outer:
for(int i=0;i<5;i++){
    for(int j=0;j<5;j++){
        System.out.println(i+j);
        if(j==1){
            break outer;
        }
    }
}

• continue

// 忽略本次循環
for(int i=0;i<5;i++){
    if(i==2){
        continue;
        System.out.println(i);
    }
}

• continue outer類似break outer
• return 全部退出

5、數組類型

數組用於存儲多個數據，每個數組元素存放一個數據，通常可通過數組元素的索引來訪問數組元素，包括爲數組元素賦值和取出數組元素的值

• 理解數組
  一個數組中，數組元素的類型是唯一的，但子類
  Person[] personArray = new Person[]{new Person(),new Gril()}
  組初始化完成，數組的內存中所佔的空間將被固定下來，即使某個數組元素數據被清空，數組長度不變
  數組也是一種引用類型，int是基本類型，但int[]是引用類型
• 定義數組

String[] strArray(推薦)
String strArray[]

• 數組靜態初始化

初始化時由程序員顯式指定每個數組元素的初始值，由系統決定數組長度
int[] intArray = new int[]{5,6,7,8}
int[] intArray = {5,6,7,8}

• 數組動態初始化

int[] intArray = new int[4];
初始值如下：
整型（byte、short、int和long），初始值是0
浮點（float、double），初始值是0.0
字符（char），初始值是'\u0000'
布爾（boolean），初始值是false
引用類型（類、接口和數組），初始值是null

• 使用數組
  數組下標從0開始，intArray[0]是第一個元素
  可以使用for或foreach遍歷數組
• 內存中的數組
  數組變量只是一個引用，實際的數組對象被存儲在堆（heap）中
  如果引用的對象是局部變量，那麼它被存儲在棧（stack）中
• 二維數組就是每個元素都是一個數組
  String[][] strArray = new String[][]{new String[3],new String[]{"hello"}}
• 操作數組的常用API：
  
  • 查找元素出現索引（要求元素已經升序排序）：
    int Arrays.binarySearch(type[] a,type key)
    如果數組不包含key，則返回負數
  • 在指定範圍查找元素出現索引（要求元素已經升序排序）：
    int Arrays.binarySearch(type[] a,int fromIndex,int toIndex,type key)
  • 複製數組，如果小於原來長度則取前面的元素，如果大於則多出來的補默認值
    type[] Arrays.copyOf(type[] original,int length)
  • 在指定範圍複製數組，與上面類似
    type[] Arrays.copyOfRange(type[] original,int from,int to)
  • 對比數組，如果長度相等且數組元素也一一相同，返回true
    boolean Arrays.equals(type[] a,type[] b)
  • 數組賦值，把數組元素全部複製爲val
    void Arrays.fill(type[] a,type val)
  • 在指定範圍數組賦值
    void Arrays.fill(type[] a,int fromIndex,int toIndex,type val)
  • 排序
    void Arrays.sort(type[] a)
  • 在指定範圍數組排序
    void Arrays.sort(type[] a,int fromIndex,int toIndex)
  • 轉換成字符串，按順序把多個數組元素連綴在一起，多個數組元素使用英文逗號和空格隔開
    String Arrays.toString(type[] a)
• Java8新增操作數組API

int[] arr1 = new int[]{3,-4,25,16,30,18};
// 併發排序，性能更強
Arrays.parallelSort(arr1);
int[] arr2 = new int[]{3,-4,25,16,30,18};
// 前一個元素乘積和後一個元素相乘，第一個元素時乘以1
{1*3=3,3*-4=-12,-12*25=-300,-300*16=-48000,-48000*30=-144000,-144000*18=-2592000}
Arrays.parallelPrefix(arr2,new IntBinaryOperator(){
    public int applyAsInt(int left,int right){
        return left*right;
    }
});
int[] arr3 = new int[5];
// 與索引值相乘
{0,5,10,15,20}
Arrays.parallelSetAll(arr3,new IntUnaryOperator(){
    public int applyAsInt(int operand){
        return operand*5;
    }
});