Java 程序流程控制----數組

一. 順序結構

程序由上至下逐行執行，沒有判斷和跳轉

二. 分支結構

根據條件，選擇性地執行某段代碼
如：if—else 或 switch

int i = 2;

if(i % 2 == 0){
    System.out.println("Even");
}else{
    System.out.println("Odd");
}

int score = 0;
if (score == 100){
    System.out.println("Execellent");
}else if(score>80 && score<=99){
    System.out.println("Great");
}else if(score>=60 && score<=80){
    System.out.println("OK");
}else{
    System.out.println("Work harder");
}

int i = 1;

String str = "a";

switch(str){    
    case "a":
        System.out.println("Monday");
        break;
    case "b":
        System.out.println("Tuesday");
        break;
    default:
        System.out.println("Unknown");
        break;
}

switch(i){
    case (1):
        System.out.println("Monday");
        break;
    default:
        System.out.println("Unknown");
        break;
}

三. 循環結構

根據循環條件，重複性執行某段代碼
如：while， do----while ，for

for

for(int i=0; i<5; i++){//初始化表達式；布爾值測試表達式；更改表達式
    System.out.println("Hello");
}

//3的倍數，輸出foo；5的倍數，輸出biz；7的倍數輸出baz；15的倍數，輸出foobiz等
for(int i=1; i <=150; i++){
    String str = "";
    str += i;
    if(i % 3 == 0){
	str += "foo";
    }	
    if(i % 5 == 0){
        str += "biz";
    } 
    if(i % 7 == 0){
        str += "baz";
    }
    System.out.println();
}

for(int i=100; i<=999; i++){
    int m = i/100;//得到百位數
    int n = (i - 100*m)/10;// 得到十位數
    int k = i - 100*m - 10*n;//得到個位數
    int res = m*m*m + n*n*n + k*k*k
    if(res == i){//判斷是否是水仙花數
        System.out.println(i);
    }
}

while

int i = 1;
while(i<=100){
    // 獲取變量i<=100的判斷結果，是true還是false，
    //如果是true則執行while括號內代碼
    //如果是false就不執行
    System.out,println(i);
    i++;//不斷改變i的值
}

int res = 0;
int i = 1;
while(i<=100){
    if(i % 2 == 0){
	 res += i;
    }
    i++;
}

do…while

int m=1;
do{
    Sytem.out.println(m);
    m++;
}while(m<=100);

無限循環

for(;;){

}

while(true){

}

嵌套循環

在寫嵌套循環的時候，儘量保證外層循環的次數小於內層循環次數

for(int i=1; i<=9; i++){
    for(int j=1; j<=9; j++){
    System.out.print(i + "*" + j "=" + (i*j) + "  ");
    }
    System.out.println();
}

//1到100之內的質數相加
//比如7，將7分別處以1到7之間的數，如果整除的次數只有兩次，即爲質數
for(int i=1; i<=100; i++){
    int k = 0;
    for(int j=1; j<=i; j++){//循環1到i，用i與1到i之間的數分別取模
        if(i % j == 0){
            k++;
        }
    }

    if(k == 2){
        System.out.println(i);
    }

}

Continue

for(int i=0; i<9; i++){
    if(i % 2 == 0){
        continue;// 結束當前循環，直接進入下一次循環
    }
    System.out.println(i);
}

Return

return並非專門用於結束循環，它的功能是結束一個方法。當一個方法執行到一個return時，這個方法將被結束。

四.數組

一維數組的聲明方式

type var[] 或者 type[] var

一維數組的初始化

數組元素的默認初始化，數組是引用類型，它的元素相當於類的成員變量，因此數組一旦被分配空間，其中的每個元素也被按照成員變量同樣的方式被隱式初始化
數字類型的默認值是0
對象類型的默認值是null

動態初始化
int[] i = new int[4];// 聲明一個能放4個int類型數據的數組

靜態初始化
int[] i = new int[](1,2,3,4);//聲明一個存放了1，2，3，4這四個數的數組

默認初始化
int[] i = new int[4];
System.out.println(i[2]);//結果是0

數組元素的引用

String[] str = new String[]("c", "a", "b");//數組內的元素都有一個下標，從0開始
System.out.println(str[1]);
Syete.out.println(str.length);

多維數組

一維數組中的每一個元素都是一個數組，這樣的數組就是二維數組
int[ ] x,y[ ] --------x爲一維數組，y爲二維數組

靜態化定義方式
int[][] ii = new int[][]{
    {1,2};//第零個元素
    {4,2};//第一個元素
};
動態初始化
//第一維的長度爲2，第二維，即第一維每個元素的長度爲3
int[][] ii = new int[2][3];

int[][] ii = new int[2][];//只定義第一維的長度，第二維默認爲空數組

取值
int[][] ii = new int[4][]{
    {1,2},
    {4,2}
};

System.out.println(ii[1][0]);//結果爲4

int[][] arr = new int[][]{
    {3,8,2},
    {2,7},
    {9,0,1,6}
};

int len = arr.length;//數組的第一維長度
int res = 0;
for(int i=0; i<len; i++){
    int[] arr0 = arr[i];
    int llen = arr0.length;//數組的第二維長度
    for(int j=0; j<=llen; j++){
        res += arr0[j];
    }
}
System.out.println(res);

簡化寫法
for(int  i=0; i<arr.length; i++){
    for(int j=0; j<arr[i].length; j++){
        res += arr[i][j];
    }
}

數組中常見算法

求數組元素的最大值，最小值，總和，平均數

int arr[] = new int[](4,2,7,1,3,5);
int min = arr[0];//假設arr[0]是最小值
int max = arr[0];//假設arr[0]是最大值
for(int i=0; i<arr.length;i++){ 
    if(max<arr[i]){
        max = arr[i];
    }
    System.out.println(max);

    if(min>arr[i]){
        min = arr[i];
    }
    System.out.println(min);
    
}

int arr[] = new int[](4,2,7,1,3,5);
int sum = 0;
for(int i=0; i<arr.length; i++){
    sum += arr[i];
}
System.out.println(sum);
System.out.println(sum/arr.length);

數組的複製，反轉

int arr[] = new int[](4,2,7,1,3,5);
int[] copy = new int[arr.length];
for(int i=0; i<arr.length; i++){ 
    copy[i] = arr[i];
}

int arr[] = new int[](4,2,7,1,3,5);
int k = 0;
int reverse[] = new int[arr.length];
//聲明一個與arr長度一樣的數組，倒序循環arr，正序給reverse賦值
//一個數組的最後一個元素，他的下標等於數組長度減一
for(int i=arr.length - 1; i>=0; i--){
    reverse[k] = arr[i];
    k++;
}

數組的冒泡排序

//第一輪得到一個最大的數
//第二輪得到第二大的數
int[] arr = new int[](4,7,3,1);
int temp = 0;
for(int i=0; i<arr.length - 1; i++){//外層循環是循環輪次，爲數組長度減一	
    for(int j=0; j< arr.length - 1 - i; j++){//每一輪數字進行對比.次數爲數組長度減一減i 
        if(arr[j] > arr[j+1]){
            temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

常見問題