JAVA中有哪些練習案例

這篇文章給大家分享的是有關JAVA中有哪些練習案例的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

/*
    定義方法,實現數組的遍歷
    遍歷中,輸出結果  [11,33,565,66,78,89]
    int[] arr = {3,4,45,7};
    結果包含字符串, [  ]  ,
    實現步驟:
      1. 定義方法實現數組的遍歷
      2. 先打印[ 中括號
      3. 遍歷數組
        輸出數組的元素和逗號
        判斷是否遍歷到了數組的最后一個元素,如果是最后一個元素,輸出]中括號
*/
public class ArrayMethodTest{
    public static void main(String[] args){
        int[] arr = {11,44,55,33,66};
        printArray(arr);
        
        int[] arr2 = {22,88,99,33,66};
        printArray(arr2);
        
    }
    /*
       定義方法,實現功能
       返回值: void
       方法參數: 數組
    */
    public static void printArray(int[] arr){
        //輸出一半中括號,不要換行打印
        System.out.print("[");
        //數組進行遍歷
        for(int i = 0 ; i < arr.length ; i++){
            //判斷遍歷到的元素,是不是數組的最后一個元素
            //如何判斷 循環變量 到達 length-1
            if( i == arr.length-1 ){
                //輸出數組的元素和]
                System.out.print(arr[i]+"]");
            }else{
            //不是數組的最后一個元素,輸出數組元素和逗號
             System.out.print(arr[i]+",");
            }
        }
        System.out.println();
    }
}







/*
   數組的逆序:
     數組中的元素,進行位置上的交換
     逆序 不等于 反向遍歷
     就是數組中最遠的兩個索引,進行位置交換,實現數組的逆序
     使用的是數組的指針思想,就是變量,思想,可以隨時變換索引
     反轉 reverse
     實現步驟:
       1. 定義方法,實現數組的逆序
       2. 遍歷數組
         實現數組的最遠索引換位置
         使用臨時的第三方變量
*/
public class ArrayMethodTest_1{
    public static void main(String[] args){
        int[] arr = {3,5,7,1,0,9,-2};
        //調用數組的逆序方法
        reverse(arr);
        //看到數組的元素,遍歷
        printArray(arr);
    }
    
    /*
       定義方法,實現數組的逆序
       返回值: 沒有返回值
       參數:   數組就是參數
    */
    public static void reverse(int[] arr){
        //利用循環,實現數組遍歷,遍歷過程中,最遠端換位
        //for的第一項,定義2個變量, 最后,兩個變量++ --
        for( int min = 0 , max = arr.length-1 ; min < max ; min++,max--){
            //對數組中的元素,進行位置交換
            //min索引和max索引的元素交換
            //定義變量,保存min索引
            int temp = arr[min];
            //max索引上的元素,賦值給min索引
            arr[min] = arr[max];
            //臨時變量,保存的數據,賦值到max索引上
            arr[max] = temp;
        }
    }
    
    /*
       定義方法,實現功能
       返回值: void
       方法參數: 數組
    */
    public static void printArray(int[] arr){
        //輸出一半中括號,不要換行打印
        System.out.print("[");
        //數組進行遍歷
        for(int i = 0 ; i < arr.length ; i++){
            //判斷遍歷到的元素,是不是數組的最后一個元素
            //如何判斷 循環變量 到達 length-1
            if( i == arr.length-1 ){
                //輸出數組的元素和]
                System.out.print(arr[i]+"]");
            }else{
            //不是數組的最后一個元素,輸出數組元素和逗號
             System.out.print(arr[i]+",");
            }
        }
        System.out.println();
    }
}





/*
  數組的排序: 一般都是升序排列,元素,小到大的排列
  
  兩種排序的方式
     選擇排序: 數組的每個元素都進行比較
     冒泡排序: 數組中相鄰元素進行比較
     規則: 比較大小,位置交換
*/
public class ArrayMethodTest_2{
    public static void main(String[] args){
        int[] arr = {3,1,4,2,56,7,0};
        //調用選擇排序方法
        //selectSort(arr);
        
        //調用冒泡排序方法
        bubbleSort(arr);
        printArray(arr);
    }
    /*
       定義方法,實現數組的冒泡排序
       返回值: 沒有
        參數:  數組
    */
    public static void bubbleSort(int[] arr){
        for(int i = 0 ; i < arr.length - 1; i++){
            //每次內循環的比較,從0索引開始, 每次都在遞減
            for(int j = 0 ; j < arr.length-i-1; j++){
                //比較的索引,是j和j+1
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
    /*
        定義方法,實現數組的選擇排序
        返回值: 沒有
        參數:  數組
        實現步驟:
          1.嵌套循環實現排序
            外循環,控制的是一共比較了多少次
            內循環,控制的是每次比較了多少個元素
          2. 判斷元素的大小值
            小值,存儲到小的索引
    */
    public static void selectSort(int[] arr){
        for(int i = 0 ; i < arr.length - 1; i++){
            //內循環,是每次都在減少,修改變量的定義
            for(int j = i+1 ; j < arr.length ; j++){
                //數組的元素進行判斷
                if(arr[i] > arr[j]){
                    //數組的換位
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    
    /*
       定義方法,實現功能
       返回值: void
       方法參數: 數組
    */
    public static void printArray(int[] arr){
        //輸出一半中括號,不要換行打印
        System.out.print("[");
        //數組進行遍歷
        for(int i = 0 ; i < arr.length ; i++){
            //判斷遍歷到的元素,是不是數組的最后一個元素
            //如何判斷 循環變量 到達 length-1
            if( i == arr.length-1 ){
                //輸出數組的元素和]
                System.out.print(arr[i]+"]");
            }else{
            //不是數組的最后一個元素,輸出數組元素和逗號
             System.out.print(arr[i]+",");
            }
        }
        System.out.println();
    }
}




/*
   數組的查找功能
     在一個數組中,找一個元素,是否存在于數組中,如果存在,就返回索引
    
     普通查詢:
       找到元素在數組中出現的索引,如果沒有這個 元素,結果就是負數
        
*/
public class ArrayMethodTest_3{
     public static void main(String[] args){
         int[] arr = {1,3,5,7,9,11,15};
         int index = binarySearch(arr,10);
         System.out.println(index);
        
     }
    
     /*
         定義方法,實現,折半查找
         返回值: 索引
         參數: 數組,被找的元素
         實現步驟:
           1. 需要的變量定義
              三個,三個指針
            
           2. 進行循環折半
              可以折半的條件  min <= max
        
           3. 讓被找元素,和中間索引元素進行比較
               元素 > 中間索引  小指針= 中間+1
               元素 < 中間索引  大指針= 中間-1
               元素 == 中間索引  找到了,結束了,返回中間索引
            
            4. 循環結束,無法折半
              元素沒有找到 ,返回-1
     */
     public static int binarySearch(int[] arr, int key){
         //定義三個指針變量
         int min = 0 ;
         int max = arr.length -1 ;
         int mid = 0;
         //循環折半,條件 min<=max
         while( min <= max){
             //公式,計算中間索引
             mid = (min+max)/2;
             //讓被找元素,和中間索引元素進行比較
             if(key > arr[mid]){
                 min = mid + 1;
             }else if (key < arr[mid]){
                 max = mid - 1;
             }else{
                 //找到元素,返回元素索引
                 return mid;
             }
         }
         return -1;
     }
    
    /*
       定義方法,實現數組的普通查詢
       返回值: 索引
       參數:   數組, 被找的元素
    
       實現步驟:
         1. 遍歷數組
         2. 遍歷過程中,使用元素和數組中的元素進行比較
            如果相同,返回元素在數組中的索引
            如果不同,返回負數
    */
    public static int search(int[] arr, int key){
        //遍歷數組
        for(int i = 0 ; i < arr.length ; i++){
            //數組元素,被查找的元素比較
            if(arr[i] == key){
                //返回索引
                return i;
            }
        }
        return -1;
    }
}



/*
    ASCII編碼表演示
    字符Java 數據類型,char
    整數Java 數據類型,int
    
    int 類型和 char 數據類型轉換
    char  兩個字節, int 四個字節
    
    char轉成int類型的時候,類型自動提示,char數據類型,會查詢編碼表,得到整數
    int轉成char類型的時候,強制轉換,會查詢編碼表
    
    char存儲漢字,查詢Unicode編碼表
    
    char可以和int計算,提示為int類型, 內存中兩個字節
    char取值范圍是0-65535, 無符號的數據類型
*/
public class ASCIIDemo{
    public static void main(String[] args){
        char c = 'a';
        int i = c + 1;
        System.out.println(i);
        
        int j = 90;
        char h = (char)j;
        System.out.println(h);
        
        System.out.println( (char)6 );
        
        char k = '你';
        System.out.println(k);
        
        
        char m = -1;
    }
}





/*
   要求:
     計算1-100之間的所有的奇數和
     1+3+5+7...+99
    
     有1個數據,從0變到100  循環 int =0  <= 100  ++
     從0-100,范圍內,找到奇數  數%2==1 奇數
     所有的奇數求和計算
     需要變量,保存奇數的求和
    
     實現步驟:
       1. 程序可以使用到的數據,預先定義好變量
         需要奇數和
       2. 利用循環,讓變量從0變化到100
       3. 判斷變量的變化情況是不是奇數
       4. 如果是奇數,和預先定義好的變量,求和
*/
public class LoopTest{
    public static void main(String[] args){
        // 定義變量,保存求和
        int sum = 0;
        // for循環,循環中的變量, 0-100
        for(int i = 0 ; i <= 100 ; i++){
            //對循環的變量,進行奇數的判斷, %2==1
            if(i % 2 == 1){
                //對奇數求和
                sum += i;
            }
        }
        System.out.println(sum);
        
        //sum = 0;
        
         /*for(int i=1 ; i <=100; i+=2) {
             sum +=i;
         }
        System.out.println(sum);*/
    }
}





/*
   要求: 計算出水仙花數
     三位數 100-999  個位數的立方+十位數的立方+百位數的立方 = 自己本身
     153 = 1*1*1 + 5*5*5 + 3*3*3
     已知三位數  123  獲取出每個數位 利用 除法,取模運算
    
    實現步驟:
     1. 定義變量才存儲 三個數位上的整數
     2. 利用循環,循環中的變量,從100變化到999
     3. 循環中得到三位數,利用算法,拆解成三個單獨數位
     4. 將三個數位立方的求和計算, 計算后的求和,和他自己進行比較判斷
        想同,就是水仙花
*/
public class LoopTest_1{
    public static void main(String[] args){
        //定義三個變量
        int bai = 0;
        int shi = 0;
        int ge = 0 ;
        
        //循環,循環變量從100-999
        for(int i = 100 ; i < 1000 ; i++){
            //對i,進行計算,獲取出三個數位
            //獲取百位
            bai = i / 100;
            //獲取十位
            shi = i / 10 % 10;
            //獲取個位
            ge = i % 10;
            //對三個數位進行立方求和
            if(bai * bai * bai + shi * shi *shi + ge * ge *ge == i){
                System.out.println(i);
            }
        }
    }
}



點擊(此處)折疊或打開
/*
     利用循環,輸出字母包含大寫小寫,52個
     輸出A-Z  a-z
     利用編碼表實現,字母和數字的對應關系
     A-Z  65-90
     a-z  97-122
    
     實現步驟:
       1. 定義變量,保存小寫a,大寫A
       2. 循環26次,輸出定義好的變量
          每次循環,變量++
*/
public class LoopTest_2{
    public static void main(String[] args){
        //定義變量,保存2個字母
        char xiaoXie = 'a';
        char daXie = 'A';
        //定義循環,次數26次
        for(int i = 0 ; i < 26 ;i++){
            //輸出保存字母的變量
            System.out.println(xiaoXie+"  "+daXie);
            daXie++;
            xiaoXie++;
        }
    }
}




/*
    利用嵌套for循環,實現99乘法表示
    實現步驟:
      1. 定義外循環控制行數
      2. 內循環控制個數,個數,每次都在遞增
      3. 循環中輸出,乘法表的格式   1*3=3
*/
public class LoopTest_3{
    public static void main(String[] args){
        print99(6);
    }
    
    public static void print99(int n){
        //定義外循環,循環9次
        for(int i = 1; i <= n; i++){
            //定義內循環,每次遞增,循環條件, <=i
            for(int j = 1; j <= i ;j++){
                //按照標準格式,輸出打印
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

感謝各位的閱讀！關于“JAVA中有哪些練習案例”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！