JAVA的數組①

java的數組
數組的定義:
數組就是一個容器 容器中存放了一組數據 這組數據的類型時相同的
數組的存放規則:
是以角標來存放 並且下標從0開始
數組的聲明規範:
數據類型 變量名 = 初值;
數據類型 指的就是數組中存放的數據的類型
兩種格式:
1:
元素類型[] 數組名 = new 元素類型[元素個數或數組長度];
2:
元素類型[] 數組名 = new 元素類型[]{所有的元素};

數組就相當於在堆內存中開闢了一塊連續的空間
堆內存
堆內存的特點:
1.有初始值 默認爲0
2.有內存地址
3.也有垃圾回收機制
int[] array保存了堆內存的收地址

數組的遍歷
基本上只要有數組的問題 就離不開數組的遍歷
遍歷: 打印出數組中所有的元素

int array[] = new int[] {1,4,2,3};
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]);
    }

結果

1423

數組中元素的反轉
反轉就是把元素中的位置進行交換
但是編寫一個函數 是不能進行元素交換的
因爲堆內存和棧內存是兩個不同的空間
數組的排序
1.冒泡排序
核心: 相鄰兩個數比較大小 交換位置
我們先寫一下交換看一下
原數: 3 2 5 1
第一趟交換
2 3 5 1
2 3 5 1
2 3 1 5 // 確定一個數(最大值 最後面)
第二趟交換
2 3 1 5
2 1 3 5 // 再次確定一個數
第三趟交換
1 2 3 5 // 確定最後一個數
因爲第一次確定了最後一個數 所以第二次的交換不需要和最後一個數相比 同理 最後一趟交換只需要比一次
int array = int[]{3,2,5,1}

public static void sort(int[] array){
    for (int i = 0; i < array.length - 1; i++){
        for(int j = 0; j < array.length - 1 - i; j++){
            if(array[j] > array[j + 1]){
            int temp = array[j];
            array[j] = array[j + 1]
            array[j+1] = temp;
            }
        }
    }
}

結果

[1 , 2, 3, 5]

當輸入一個0的數組的時候 輸出的結果和數組的角標爲0時 時衝突的所以i < array.length要寫成i < array.length - 1
內循環 - 1 可以避免數組越界
又因爲每一趟比較都會確定一個數 下一趟比較就會少比較一次
因爲i是同樣遞增的 所以j < array.length - 1可以寫成j < array.length - 1 - i可以讓運算更加快 運算負荷小

2選擇排序
核心: 選擇一個數和下一個數相比較 換位(一般選第0個數)
寫一下交換
原數[3,2,5,1]
第一趟交換
2 3 5 1
2 3 5 1
1 3 5 2 //確定一個數(最小的數 最前面)
第二趟交換
1 3 5 2
1 2 5 3
第三趟交換
1 2 3 5
因爲每一次比較都會確定一個數 所以接下來的每一趟比較都會少一次
代碼

int[] array = new int[]{3,2,5,1}
    for(int i = 0; i < array.length - 1; i++){
        for(int j = 1 + i; j < array.length; j++){
            if (array[j] < array[i]){
                int temp = array[j];
                array[j] = array[i];
                array[i] = temp;

        }
    }
}

結果

[1, 2, 3, 5]

因爲array[0]不用和array[0]比較所以內循環的j要從1開始
因爲每趟比較後確定一個數 所以內循環要加上i

折半查找
前提: 必須要有個有序的數組
因爲如果不是有序的數組 折半沒有意義
代碼

int[] array = new int[]{1,3,5,6.9,22]
int min = 0;
int max = array.length - 1;
int mid = (max + min) / 2;
int key = 9;
while(key !=array[mid]){
      if(key > array[mid]){
        min = mid + 1;
    } else if(key < array[mid]){
        max = mid - 1;
    }
    mid = (max + min) / 2;
    if (min > max){
        mid = -1;
        break;
    }
}

結果

4

如果查找的是一個數組裏不存在的數 就會造成死循環
所以要在第二次折半操作之後加上條件if (min > max)
當最小值大於最大值的時候停止循環並且輸出-1 因爲數組裏的角標是不能爲-1的 就是說當輸出-1的時候 表示數組裏沒有這個數

二維數組
定義: 二維空間是多個一維空間組成的
同樣二維數組是多個一維數組組成的 而且是多個相同類型的一維數組
聲明方式
1
int [][] array = new int [2][3];
意思是有2個一維數組 並且每個一維數組裏面有8個元素

2

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

意思是有3個一維數組 並且每個一維數組有4個元素
和聲明方式1不同的是它表明了所有一維數組中的元素
在二維數組中array.length表明的是二維數組的長度 也就是有幾個一維數組
我們來遍歷一下聲明方式2的二維數組
代碼

for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array[i].length; i++){
        System.out.print(array[i][j] + " ");
    }
    System.out.println();
}

結果

1 2 3 4
2 3 1 4
3 5 1 2

其中array[i].length聲明的是二維數組中第i個一位數組的長度