day-10

陣列
相同型別資料的有序集合
每一個資料成為一個陣列元素，可以通過下標來訪問他們
陣列的下標是從0開始的

陣列宣告建立：
首先必須宣告陣列變數
java語言使用new來運算元組
陣列元素通過索引來訪問，陣列索引從0開始
獲取陣列長度

public class ArrayDemo01 {
    public static void main(String[] args) {
        //變數的型別 變數的名字 =變數的值
        int[] nums;//定義
        nums=new int[11];//這裡面可以存放十個int型別的數字，建立一個陣列
        //給陣列元素賦值
        nums[0]=0;
        nums[1]=10;
        nums[2]=20;
        nums[3]=30;
        nums[4]=40;
        nums[5]=50;
        nums[6]=60;
        nums[7]=70;
        nums[8]=80;
        nums[9]=90;
        nums[10]=100;
        System.out.println(nums[8]);

        //計算所有元素的和
        int sums =0;
        for (int i = 0; i < nums.length; i++) {
            sums =sums +nums[i];
        }
        System.out.println(sums);
    }
}

記憶體分析

三種初始化
靜態初始化
動態初始化
預設初始化：陣列是引用型別，他的元素相當於類的例項變數，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化

public class ArrayDemo02 {
    public static void main(String[] args) {
        //靜態初始化 建立+賦值
        int[] a={1,2,3,4,5,};
        System.out.println(a[1]);

        //動態初始化 ：包含預設初始化
        int[] b= new int[10];
        b[0]=11;
        b[1]=22;
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
        System.out.println(b[4]);
    }
}

陣列的基本特點：
陣列的長度是確定，如果越界會報錯：AyyayIndexOutOfBoundsException
陣列元素必須是相同型別
陣列物件屬於引用型別，陣列也可以看成物件
陣列物件本身是在堆中的

陣列的使用

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays ={1,2,3,4,5,6,7};
        //列印所有的陣列元素
        for (int i = 0; i <arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("==================");
        //計算所有元素的總和
        int sum =0;
        for (int i = 0; i <arrays.length; i++) {
            sum =sum+arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("====================");
        //查詢最大元素
        int max =arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i]>max){
                max =arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        //增強型
        for (int array : arrays) {
            System.out.println(array);
        }
        printArray(arrays);
        System.out.println("================");
        int[] reverse =reverse((arrays));
        printArray(reverse);
    }
    //反轉陣列
    public static int[] reverse(int[] arrays) {
        int[]result =new int[arrays.length];
        //反轉的操作
        for (int i = 0, j=result.length-1;i < arrays.length; i++,j--) {
            result[j]=arrays[i];
        }
        return result;
    }
    //列印陣列元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i] + "");

        }
    }
}

多維陣列
可以看成陣列的陣列

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][]arrays={{1,2},{2,3},{3,4},{4,5}};
        System.out.println(arrays[1][0]);
        System.out.println(arrays[2][0]);
        printArray(arrays);
        System.out.println("================");
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }
        }
    }
    //列印陣列元素
    public static void printArray(int[][] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i] + "");
        }
    }
}

Arrays類
陣列的工具類java.util.Ayyays

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a ={1,2,3,44124,525,23};
        System.out.println(a);
        //列印陣列元素Arrays.toString(a)
        System.out.println(Arrays.toString(a));
        System.out.println("===========================");
        printArray(a);
    }
    public  static void printArray(int[]a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.println("[");
            }
            if (i == a.length - 1) {
                System.out.println("]");
            } else {
                System.out.println(a[i] + ",");
            }
        }
    }
}

fill方法：給陣列進行賦值
sort方法：對陣列進行排序
equal方法：比較陣列元素值是都相等
binarySerach方法;對拍好的陣列進行二分法分析

 Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));
**氣泡排序**

```java
import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a ={1,2,3,1312,12,414324,33};
        int[] sort =sort(a);
        System.out.println(Arrays.toString(sort));
    }
    //氣泡排序
    //比較陣列中兩個相鄰的元素，如果第一個比第二個大，就交換位置
    //每次比較，都會產生一個最大或者最小的數字
    //下一輪則可以少一次排序
    //一次迴圈，直到結束
    public static int[] sort(int[]array){
        int temp =0;//臨時變數
        //外層迴圈，判斷要走多少次
        for (int i = 0; i < array.length; i++) {
            //內層迴圈，比較陣列中兩個相鄰的元素，如果第一個比第二個大，就交換位置
            for (int j = 0; j < array.length-1; j++) {
                if (array[j + 1] > array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
            
        }
        return array;
    }
}