技術標籤：Java基礎java

陣列

1.陣列

1.1.陣列的概念

• 陣列是引用型別，陣列元素可以是基本資料型別也可以是引用資料型別
• 其實是個容器，是一組 相同型別的資料的容器；
• 陣列元素指的就是陣列種的數值

1.1.陣列特性

1，陣列長度一旦確定不能改變

2, 陣列的索引從 0 開始；

3，陣列的記憶體空間是連續的；訪問陣列非常

2.1.陣列初始化3種

 	/**
     * 陣列的初始化方式
     */
    public static void method1() {
        int a;
        //宣告一個數組 資料型別[] 陣列名
//        int[] arr; //等價與 int arr[]
 

        //1,第一種陣列初始化, 陣列的長度為 6
        int[] arr = new int[6];

        //2,第2種初始化
        int[] arr2 = {67, 90, 78, 99}; // 0-3

        // 3，第3種初始化
        int[] arr3 = new int[]{67, 78, 99, 55};
    }

2.2.陣列的使用

1，陣列元素賦值

/**
     * 給陣列元素賦值和取值
     */
    public static void method2() {
        double[] stuScores =
 
 new double[10];
        //1,如何求陣列長度
        System.out.println("陣列長度" + stuScores.length);
        //2,取出陣列元素的值 索引號 0-（陣列長度-1）
        System.out.println(stuScores[0]);
        //3，給陣列元素賦值
        stuScores[0] = 98;
        System.out.println(stuScores[0]);
        //依次給陣列元素賦值
        for (int i = 0; i <
 
 stuScores.length; i++) {
            stuScores[i] = Math.random() * 100;
        }
        //迴圈遍歷所有的陣列元素
        for (int i = 0; i < stuScores.length; i++) {
            System.out.println(stuScores[i]);
        }
    }

2,使用陣列的計算均值，最值

 /**
     * 使用陣列得到學生成績的 平均值 最值
     */
    public static void method3() {
        Scanner sc = new Scanner(System.in);
        System.out.println("請錄入學生人數：");
        int stuNum = sc.nextInt();
        //此陣列用來存放學生成績
        int[] scores = new int[stuNum];
        int sum = 0;
        for (int i = 0; i < stuNum; i++) {
            int score = (int) (Math.random() * 100);
            scores[i] = score;
            sum += scores[i];
            System.out.println("第" + (i + 1) + "個學生成績是：" + score);
        }
        System.out.println("總的成績：" + sum);
        System.out.println("平均成績：" + sum / stuNum);
        // 得到最大值 ,最小值；先假設第一個就是最大值，迴圈進行比較
        int maxScore = scores[0], maxIndex = 0;
        int minScore = scores[0], minIndex = 0;
        for (int i = 1; i < scores.length; i++) {
            if (maxScore < scores[i]) {
                maxScore = scores[i];
                maxIndex = i;
            }
            if (minScore > scores[i]) {
                minScore = scores[i];
                minIndex = i;
            }
        }
        System.out.println("最高成績為 " + maxScore + "索引值是 " + maxIndex);
        System.out.println("最低成績為 " + minScore + "索引值是 " + minIndex);
    }

3,陣列的拷貝,引用的直接賦值和值的拷貝

/**
     * 陣列的拷貝
     */
    public static void method4() {
        int[] arr1 = {34, 56, 78, 99};
        // 直接把arr1的引用賦值給arr2 ，引用的直接拷貝
        /*int[] arr2 = arr1;
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        //改變陣列arr1的陣列元素值
        arr1[1] = 69;
        System.out.println(arr2[1]);*/
        //陣列元素值的拷貝
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        arr1[1] = 69;
        System.out.println(arr2[1]);
    }

4，陣列的遍歷

  /**
     * 陣列元素的2種遍歷方式
     */
    public static void method5() {
        int[] arr = {66, 56, 87, 99, 50};
        // 1，普通for迴圈遍歷
      /*  for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
        //2，增強for迴圈遍歷
        for (int b : arr) {
            System.out.println(b);
        }
    }

2.3. Arrays工具類的使用

    /**
     * Arrays是個工具類，裡面封裝的是運算元組相關的方法;
     */
	public static void method6() {
        int[] arr = {66, 56, 87, 99, 50, 2, 1};
        double[] dos = {5.6, 9.8, 2.3};
        int a = 10;
        //1，把陣列元素以字串形式打印出來
        System.out.println(Arrays.toString(arr));
        // 2，對陣列元素進行排序，源陣列發生改變
       /* Arrays.sort(arr);
        System.out.println("============");
        System.out.println(Arrays.toString(arr));*/
        // 3，對陣列進行拷貝，第二個引數newLength代表新陣列的長度，與源陣列不一定相等，如果大於源陣列長度會賦預設值（int是0，double是0.0）
        int[] arr2 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr2));
    }

2.4.多維陣列-二維陣列

1，二維陣列的初始化

    /**
     * 二維陣列的使用，二維數組裡面的陣列元素是一維陣列
     */
    public static void method7() {
        // 6表示有6個一維陣列，每個一維陣列長度為3;
        int[][] arr = new int[6][3];
        //給第二一維陣列的索引為2的陣列元素賦值
        arr[1][2] = 56;

        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        arr2[1] = new int[2];
        arr2[2] = new int[1];

        int[][] arr3 = {{3, 4, 5}, {1, 2}, {1}};
    }

2，二維陣列的使用，錄入多個班級的學生成績

 /**
     * 使用二維陣列儲存多個班級的成績 3  1(20)  2(30)  3(35)
     */
    public static void method8() {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入班級個數：");
        int classNum = sc.nextInt();
        int[][] stuScore = new int[classNum][];
        for (int i = 0; i < stuScore.length; i++) {
            System.out.println("請輸入第" + (i + 1) + "班級人數：");
            int stuNum = sc.nextInt();
            stuScore[i] = new int[stuNum];
        }
        //依次給 每個班的每個學生的成績進行賦值
        for (int i = 0; i < classNum; i++) {
            for (int j = 0; j < stuScore[i].length; j++) {
                stuScore[i][j] = (int) (Math.random() * 100);
            }
        }
        //遍歷每個班 每個學生的成績
        for (int i = 0; i < classNum; i++) {
            System.out.println(Arrays.toString(stuScore[i]));
        }
    }

2.方法

2.1.方法的定義

• 其實實現一個功能的程式碼片段; 封裝到方法中 可以實現程式碼重用

2.2.如何宣告一個方法

1，宣告方法。形參是方法宣告時的引數，實參是實際呼叫時的傳值

/**
     * 方法：其實實現一個功能的程式碼片段; 封裝到方法中 可以實現程式碼重用
     * 許可權修飾符 static不是必須的  void代表方法沒有返回值(有返回值的話要加return關鍵字) 方法名-首字母小寫遵守駝峰標誌（方法引數列表）
     * return 只能返回一個值
     */
    public static int[] sortDescent(int[] sortArr) {
        Arrays.sort(sortArr);
//        System.out.println(Arrays.toString(sortArr));
        int[] newArr = new int[sortArr.length];
        int index = 0;
        for (int i = sortArr.length - 1; i >= 0; i--) { //4,3,2
            newArr[index] = sortArr[i];
            index++;
        }
//        System.out.println(Arrays.toString(newArr));
        return newArr;
    }


 	/**
     * op1,op2 方法形參；add(10, 20)真正呼叫的時候10,20稱為方法的實參
     *
     * @return 把值返回給呼叫者
     */
    public static int add(int op1, int op2) {
        int sum = op1 + op2;
        return sum;
    }

2，使用方法（呼叫方法）

 		//呼叫方法
		sortDescent(aa);
        sortDescent(bb);
        sortDescent(cc);
//        int cc = add(10, 20);
        method2(10, "ss");

3，定義方法（四類）

/**
     * 有引數有返回值
     *
     * @param str1
     * @param a
     * @param b
     * @return
     */
    public static String method4(String str1, int a, double b) {
        return "";
    }

    /**
     * 無引數有返回值,一定要有return關鍵字
     *
     * @return
     */
    public static double method3() {
        System.out.println("");
        double d = 2.2;
        return d;
    }

    /**
     * 有引數無返回值
     *
     * @param op
     * @param str
     */
    public static void method2(int op, String str) {
        System.out.println("執行程式碼邏輯");
    }

    /**
     * 無參無返回值 進行呼叫的時候 method1();
     */
    public static void method1() {
        System.out.println("========");
        System.out.println("========");
        System.out.println("========");
        System.out.println("========");
    }

2.3.方法的過載

2.3.1.什麼是方法過載(overload)

• 方法名相同，引數列表不同（引數個數不同，引數型別不同，引數順序不同）
• 例如Arrays.sort(int[] a) 就是方法的過載

    public static double[] sortDescent(double[] sortArr) {
        return null;
    }

    public static float[] sortDescent(float[] sortArr) {
        return null;
    }

2.4.方法遞迴呼叫

• 方法自己呼叫自己

 /**
     * 斐波那契數列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……
     * @param number
     * @return
     */
    public static int fibonacci(int number) {
        if (number == 1 || number == 0) {
            return number;
        } else {
            return fibonacci(number - 1) + fibonacci(number - 2);
        }
    }

注意點：

​ 遞迴呼叫層次過深 會發生棧空間溢位

3.排序演算法

1，氣泡排序

演算法原理：

​ 將相鄰的兩個元素進行比較，最大的值放在右端。
N個數字要排序完成，總共進行N-1趟排序，每i趟的排序次數為(N-i)次，所以可以用雙重迴圈語句，外層控制迴圈多少趟，內層控制每一趟的迴圈次數。

/**
     * 氣泡排序
     */
    public static void bubbleSort(int[] sort) {
        int temp;
        //外層總共進行了陣列長度-1趟
        for (int i = 0; i < sort.length - 1; i++) {
            for (int s = 0; s < sort.length - 1 - i; s++) {
                if (sort[s] > sort[s + 1]) {
                    temp = sort[s];
                    sort[s] = sort[s + 1];
                    sort[s + 1] = temp;
                }
            }
            System.out.println(Arrays.toString(sort));
        }
    }

2，選擇排序

演算法原理：

​ 從第一個元素開始，分別與後面的元素相比較，找到最小的元素與第一個元素交換位置；從第二個元素開始，分別與後面的元素相比較，找到剩餘元素中最小的元素，與第二個元素交換；重複上述步驟，直到所有的元素都排成由小到大為止。

 /**
     * 選擇排序,每輪迴圈都會找到一個最小值所在的索引
     *
     * @param sort
     */
    public static void selectionSort(int[] sort) {
        int minIndex, temp;
        for (int i = 0; i < sort.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < sort.length; j++) {
                if (sort[minIndex] > sort[j]) {
                    minIndex = j;
                }
            }
            // 互換位置
            if (i != minIndex) {
                temp = sort[i];
                sort[i] = sort[minIndex];
                sort[minIndex] = temp;
            }
            System.out.println(Arrays.toString(sort));
        }
    }

3，插入排序

演算法原理：

​ 將指標指向某個元素，假設該元素左側的元素全部有序，將該元素抽取出來，然後按照從右往左的順序分別與其左邊的元素比較，遇到比其大的元素便將元素右移，直到找到比該元素小的元素或者找到最左面發現其左側的元素都比它大，停止.
此時會出現一個空位，將該元素放入到空位中，此時該元素左側的元素都比它小，右側的元素都比它大；

 /**
     * 插入排序
     * @param sort
     */
    public static void insertSort(int[] sort) {
        int leftIndex, current;
        for (int i = 1; i < sort.length; i++) {
            leftIndex = i - 1;
            current = sort[i];
            while (leftIndex >= 0 && sort[leftIndex] > current) {
                sort[leftIndex + 1] = sort[leftIndex];
                leftIndex--; //
            }
            //插入的索引值
            sort[leftIndex + 1] = current;
            System.out.println(Arrays.toString(sort));
        }
    }