Java——循環應用

循環練習

練習一：計算1~100之間奇數和的運算

/*
計算1~100之間奇數和的運算
思路：1、需要定義一個變量來初始化和並記錄和，sum
           2、計算1~100之間的數需要使用for循環來控制相加的次數
           3、需要判斷1~100之間的奇數
           4、將奇數的和進行相加,sum = sum + i
           5、打印出循環後相加的值
*/
public class LoopTest{
         public static void main(String[] args){
                   //定義一個變量來記錄和
                   int sum = 0;
                   //使用for循環來遍歷1~100之間的數
                   for(int i=1;i<=100;i++){
                            //判斷1~100之間的數哪些是奇數
                            if(i%2==1){
                                     //將判斷後的奇數值進行相加
                                     sum += i;
                            }
                   }
                   //打印出最後累計的和
                   System.out.println(sum);
         }
}

運行結果：

練習二：計算水仙花數：三位數：100~999，比如1*1*1+2*2*2+3*3*3=123，找出有這種特性的數

/*
需求：找出水仙花數：三位數：100~999，比如1*1*1+2*2*2+3*3*3=123，找出有這種特性的數
思路：1、定義三個變量分別記錄個位，十位，百位上的數
           2、使用for循環來遍歷100~999之間的數
           3、將數進行拆分，需要用到除法、取模的運算
           4、判斷個位、十位、百位三個數的立方相加是否是這個數的本身，如果是這個數就是水仙花數
           5、打印出這些數
*/
public class LoopTest_1{
         public static void main(String[] args){
                   //定義個位數的變量
                   int ge = 0;
                   //定義十位數的變量
                   int shi = 0;
                   //定義百位數的變量
                   int bai = 0;
                   //使用for循環來遍歷100~999之間的數
                   for(int i=100;i<=999;i++){
                            //拆分百位上的數
                            bai = i / 100;
                            //拆分十位上的數
                            shi = i / 10 % 10;
                            //拆分個位數
                            ge = i % 10;
                            //判斷該數是否符合要求比如1*1*1+2*2*2+3*3*3=123
                            if(ge*ge*ge+shi*shi*shi+bai*bai*bai == i){
                                     System.out.println(i);
                            }
                   }
         }
}

運行結果：

練習三：打印出大寫字母和小寫字母

/*
需求：打印大寫字母和小寫字母
思路：利用ASCII編碼表來進行打印
         1、定義兩個變量來記錄字母a和A
         2、利用for循環來控制打印的次數
         3、打印出數字對應得字母
         4、每一次循環這個字符都要加一次
*/
public class LoopTest_2{
         public static void main(String[] args){
                   //定義兩個變量來記錄字母a和A
                   char daXie = 'A';
                   char xiaoXie = 'a';
                   //利用for循環來控制打印的次數
                   for(int i=0;i<26;i++){
                            System.out.println(xiaoXie+"  "+daXie);
                            xiaoXie++;
                            daXie++;
                   }
         }
}

練習四：打印九九乘法表

/*
需求：打印九九乘法表
思路：1、九九乘法表需要九行，每列加一個運算，需要for循環嵌套去實現
           2、外層循環控制行數，一共九行，for(int i=1;i<=9;i++)
           3、內層循環控制每行的個數，比如1*2=2,2*2=4可以把循環寫成for(int j=1;j<=2;j++)
                    它的第一個數字是逐漸遞增的，可以發現外層循環的變量i也是逐漸遞增的，第二個數字每一次
                    循環後都是不變的，所以可以把第一個數字定義成變量i，第二個就是循環後的變量j，他們兩個
                   相乘即可,內層循環可以寫成for(int j=1;j<=i;j++)
           4、使用輸出語句打印出循環後效果，System.out.print(j+"*"+i+"="+j*i);
*/
public class LoopTest_3{
         public static void main(String[] args){
                   print99(8);
         }
         public static void print99(int k){
                   //for循環嵌套進行遍歷,外層循環控制行數
                   for(int i=1;i<=k;i++){
                            //內層循環控制每行的個數
                            for(int j=1;j<=i;j++){
                                     //輸出兩個數相乘的效果
                                     System.out.print(j+"*"+i+"="+j*i+"   ");
                            }
                            //每次內層循環結束進行換行
                            System.out.println();
                   }
         }
}

char類型和int類型可以相互轉換

/*
char類型可以和int類型轉換
*/
public class CharIntDemo{
         public static void main(String[] args){
                   char c = 'a';
                   int i = c + 1;
                   System.out.println(i);
                   char c1 = (char)6;
                   System.out.println(c1);
         }
}

運行結果：

數組方法練習（把功能寫進方法中）

練習一：數組遍歷打印，比如打印[55,66,77,88,99]

/*
需求：打印出數組[55,66,77,88,99]
思路：1、定義出方法，ergodic()，返回值類型：void，參數列表：給我一個數組arr
           2、先打印出數組格式的左邊括號[，System.out.print("[");
           3、利用for循環進行遍歷數組，for(int i=0;i<arr.length;i++)
           4、判斷數組是否遍歷到最後一個元素if(i==arr.length-1)，
                    就打印出最後沒有逗號的那一個元素System.out.println(arr[i]+"]");
                    否則就打印其他元素不換行加逗號System.out.print(arr[i]+"，");
           5、在主方法中定義出這個數組，並調用這個數組
*/
public class ArrayMethodTest{
         public static void main(String[] args){
                   //5、在主方法中定義出這個數組，並調用這個數組
                   int[] arr = {55,66,77,88,99};
                   ergodic(arr);
         }
         //1、定義出方法
         public static void ergodic(int[] arr){
                   //2、先打印出數組格式的左邊括號[
                   System.out.print("[");
                   //3、利用for循環進行遍歷數組
                   for(int i=0;i<arr.length;i++){
                            //4、判斷數組是否遍歷到最後一個元素
                            if(i==arr.length-1){
                                     System.out.println(arr[i]+"]");
                            }else{
                                     System.out.print(arr[i]+"，");
                            }
                   }
         }
}

練習一：數組的逆序（將數組的元素進行逆向置換）

/*
需求：數組的逆序（將數組的元素進行逆向置換）
思路：1、將功能定義在方法內，displace()，返回值值類型：void，參數列表：給我一個數組int[] arr
           2、使用for循環對數組進行遍歷，for(int min = arr[0],int max = arr[arr.length-1];min > min;min++,max--)
           3、將數據進行置換，需要用到第三方變量來記錄其中一個角標的值
           4、定義出打印數組的功能
           5、在主方法中定義一個數組，調用該方法
*/
public class ArrayMethodTest_1{
         public static void main(String[] args){
                   int[] arr = {1,2,3,4,5};
                   displace(arr);
                   ergodic(arr);
         }
         //1、將功能定義在方法內，displace()
         public static void displace(int[] arr){
                   //2、使用for循環對數組進行遍歷
                   for(int min = 0,max = arr.length-1;max > min;min++,max--){
                            //3、將數據進行置換，需要用到第三方變量來記錄其中一個角標的值
                            int temp = arr[min];
                            arr[min] = arr[max];
                            arr[max] = temp;
                   }
         }
         //4、定義出打印數組的功能
         //1、定義出方法
         public static void ergodic(int[] arr){
                   //2、先打印出數組格式的左邊括號[
                   System.out.print("[");
                   //3、利用for循環進行遍歷數組
                   for(int i=0;i<arr.length;i++){
                            //4、判斷數組是否遍歷到最後一個元素
                            if(i==arr.length-1){
                                     System.out.println(arr[i]+"]");
                            }else{
                                     System.out.print(arr[i]+"，");
                            }
                   }
         }
}

練習二：數組的選擇排序

/*
需求：數組的選擇排序
思路：1、定義一個方法selectSort()，返回值類型：void，參數列表：數組int[] arr
           2、採用循環嵌套的方式，對數組進行遍歷，外層循環走一次for(int i=0;i<arr.length.i++)，
              內層循環走一遍for(int j = i+1;j<arr.length;j++),這時也就可以理解爲第一個角標走一次，
              其他角標依次走一遍
           3、進行大小判斷，角標小的就放到索引爲0的角標上if(arr[i]>arr[j]),進行位置的替換
           4、給一個數組在主方法中調用這個方法
*/
public class ArrayMethodTest_2{
         public static void main(String[] args){
                   //4、給一個數組在主方法中調用這個方法
                   int[] arr = {45,78,69,35,85,25};
                   selectSort(arr);
                   ergodic(arr);
         }
         //1、定義一個方法selectSort()
         public static void selectSort(int[] arr){
                   //2、採用循環嵌套的方式，對數組進行遍歷
                   for(int i=0;i<arr.length;i++){
                            for(int j = i+1;j<arr.length;j++){
                                     //3、進行大小判斷
                                     if(arr[i]>arr[j]){
                                               //進行位置的替換
                                               int temp = arr[i];
                                               arr[i] = arr[j];
                                              arr[j] = temp;
                                     }
                            }
                   }
         }
         //打印數組的功能
         //1、定義出方法
         public static void ergodic(int[] arr){
                   //2、先打印出數組格式的左邊括號[
                   System.out.print("[");
                   //3、利用for循環進行遍歷數組
                   for(int i=0;i<arr.length;i++){
                            //4、判斷數組是否遍歷到最後一個元素
                            if(i==arr.length-1){
                                     System.out.println(arr[i]+"]");
                            }else{
                                     System.out.print(arr[i]+"，");
                            }
                   }
         }
}

練習三：數組的冒泡排序

/*
需求：數組的冒泡排序
思路：1、定義一個方法bubblesort()，返回值類型，void，參數列表int[] arr
           2、使用for循環對數組進行遍歷，外層循環控制循環的次數for(int i = 0;i<arr.length;i++)
                    冒泡排序是相鄰兩個元素進行比較排序，內循環控制它的兩個相鄰兩個元素的比較循環,如果j的
              索引爲0，相鄰元素的索引就是0+1，j的索引每次循環必須從0索引開始比較，內循環的長度控制就是arr.length-i-1,
              for(int j=0;j<arr.length-i-1;j++)
           3、對元素進行大小判斷if(arr[j]>arr[j+1])，進行位置的置換
           4、在主方法中定義一個數組，調用該方法
*/
public class ArrayMethodTest_3{
         public static void main(String[] args){
                   // 4、在主方法中定義一個數組，調用該方法
                   int[] arr = {15,2,78,65,48,95,48};
                   bubblesort(arr);
                   ergodic(arr);
         }
         //1、定義一個方法bubblesort()
         public static void bubblesort(int[] arr){
                   //2、使用for循環對數組進行遍歷
                   for(int i = 0;i<arr.length;i++){
                            for(int j=0;j<arr.length-i-1;j++){
                                     //3、對元素進行大小判斷
                                     if(arr[j]>arr[j+1]){
                                               //位置置換
                                               int temp = arr[j];
                                               arr[j] = arr[j+1];
                                               arr[j+1] = temp;
                                     }
                            }
                   }
         }
         //打印數組的功能
         //1、定義出方法
         public static void ergodic(int[] arr){
                   //2、先打印出數組格式的左邊括號[
                   System.out.print("[");
                   //3、利用for循環進行遍歷數組
                   for(int i=0;i<arr.length;i++){
                            //4、判斷數組是否遍歷到最後一個元素
                            if(i==arr.length-1){
                                     System.out.println(arr[i]+"]");
                            }else{
                                     System.out.print(arr[i]+"，");
                            }
                   }
         }
}

練習四：折半查找法（前提：必須是有序數組）

/*
折半查找法
思路：1、定義一個方法binarySearch(),返回值類型：int，參數列表：int[] arr,要查找的數int key
           2、定義三個變量（指針）int min = 0,int max = arr.length-1,int mid = 0
           3、循環查找,小指針小於等於大指針while(min<=max)就進行循環查找，小指針大於大指針就說明該數組沒查找的這個數
             返回-1
           4、進行判斷：
                     進行折半操作mid = (min+max)/2
                     如果key>arr[mid],min = mid+1
                     如果key<arr[mid],max = mid-1
                     直到mid==min或者max，說明該值已經找到,返回該索引mid
           5、在主方法中定義數組，調用該方法
*/
public class ArrayMethodTest_4{
         public static void main(String[] args){
                   //5、在主方法中定義數組，調用該方法
                   int[] arr = {1,2,3,4,5,6,7,8,9};
                   int num = binarySearch(arr,5);
                   System.out.println(num);
         }
         //1、定義一個方法binarySearch()
         public static int binarySearch(int[] arr,int key){
                   //2、定義三個變量（指針）
                   //小指針
                   int min = 0;
                   //中間指針
                   int mid = 0;
                   //大指針
                   int max = arr.length-1;
                   //3、循環查找,小指針小於等於大指針while(min<=max)就進行循環查找，小指針大於大指針就說明該數組沒查找的這個數返回-1
                   while(min<=max){
                            // 4、進行判斷
                            mid = (min+max)/2;
                            if(key<arr[mid]){
                                     max = mid - 1;
                            }else if(key>arr[mid]){
                                     min = mid + 1;
                            }else{
                                     return mid;
                            }
                   }
                   return -1;
         }
}