什么是數(shù)組

數(shù)組是一種數(shù)據(jù)結(jié)構(gòu),用來存儲同一類型的集合.
數(shù)組中的每一個數(shù)據(jù)稱之為數(shù)組元素，數(shù)組中的元素以索引來表示其存放的位置，索引從0開始.

數(shù)組的定義

第一種方式：類型[] 數(shù)組名; 如 int[] nums; **
第二種方式：類型 數(shù)組名[]; 如 int nums[];**
大多數(shù)Java程序員喜歡使用第一種風(fēng)格,因為它把數(shù)據(jù)類型int[],和變量名num分開了.

數(shù)組的初始化

Java中數(shù)組必先初始化后才能使用.
初始化就是給數(shù)組元素分配內(nèi)存，并為每個元素賦初始值。

初始化數(shù)組的兩種方式：
- 靜態(tài)初始化:
語法格式:類型[] 數(shù)組名 = new 數(shù)組類型[]{元素1,元素2,元素3,...元素n};
簡化語法：類型[] 數(shù)組名 = {元素1,元素2,元素3...元素n};
- 動態(tài)初始化:
如果我們事先不知道數(shù)組里存儲哪些數(shù)據(jù)，只知道需要存儲數(shù)據(jù)的個數(shù)，此時可以使用動態(tài)初始化方式。
動態(tài)初始化：初始化時由我們指定數(shù)組的長度，系統(tǒng)自動為數(shù)組元素分配初始值。
格式：類型[] 數(shù)組名 = new 數(shù)組類型[數(shù)組長度];

不同數(shù)據(jù)類型的初始值.png

//數(shù)組初始化
public class InitDemo {
    public static void main(String[] args) {
        //靜態(tài)初始化
        int[] num = new int[] { 1, 2, 3, 4, 5 };
        int[] num1 = { 1, 2, 3, 4, 5 };//簡單寫法
        //只知道要存放數(shù)據(jù)的個數(shù),不知道具體內(nèi)容--動態(tài)初始化
        int[] num2 = new int[5];//不同數(shù)據(jù)的動態(tài)初始化會有不同的初始值
    }
}

注意:無論，以哪種方式初始化數(shù)組，一旦初始化完成，數(shù)組的長度就固定了，不能改變，除非重新初始化。也就是說數(shù)組是定長的。如果需要經(jīng)常擴(kuò)展數(shù)組的大小,應(yīng)該使用另一種數(shù)據(jù)結(jié)構(gòu)--數(shù)組列表(ArrayList).

數(shù)組初始化內(nèi)存分析

數(shù)組初始化內(nèi)存分析.png

一維數(shù)組內(nèi)存分析

簡單數(shù)組排序算法

- 冒泡排序(Bubble Sort)：
思路：對未排序的各元素從頭到尾依次比較相鄰的兩個元素大小關(guān)系，若大于則交換位置，經(jīng)過第一輪比較排序后可得出最大值，然后使用同樣的方法把剩下的元素逐個比較即可。
如果一共有N個元素，那么一共要進(jìn)行N-1輪比較，第M輪要進(jìn)行N-M次比較。

import java.util.Arrays;
//冒泡排序 -- 升序為例
public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] num = { 13, 6, 2, 1, 4, 7, 8, 9 };
        bubbleSort(num);
        System.out.println(Arrays.toString(num));
        Arrays.binarySearch(num, 5);
    }

    private static void bubbleSort(int[] a) {
        //1.確定比較次數(shù),N個元素,就要比較N - 1次
        for (int time = 1; time <= a.length - 1; time++) {
            //2.每次都是從最低位(索引為0處)開始,進(jìn)行相鄰的數(shù)值比較,第一輪出最大值
            //類似于水里冒泡泡,每次都是水底開始,大的氣泡先浮上來
            for (int index = 0; index < a.length - time; index++) {
                if (a[index] > a[index + 1]) {
                    int temp = a[index];
                    a[index] = a[index + 1];
                    a[index + 1] = temp;
                }
            }
        }

    }
}

- 選擇排序(Selection Sort)：
基本思路：選擇某個索引位置的元素，然后和后面元素依次比較，若大于則交換位置，經(jīng)過第一輪比較排序后可得出最小值，然后使用同樣的方法把剩下的元素逐個比較即可。
第一輪會選出最小值，第二輪會選出第二小的值，直到最后。
選擇排序每一輪只進(jìn)行一次交換，相對于冒泡排序效率高一些。

import java.util.Arrays;

//選擇排序--以升序為例
public class SelectionSortDemo {
    public static void main(String[] args) {
        int[] num = { 12, 13, 2, 1, 4, 7, 8, 9 };
        selectionSort(num);
        System.out.println(Arrays.toString(num));
    }

    public static void selectionSort(int[] num) {
        //1.N個數(shù)要進(jìn)行N-1輪
        for (int time = 1; time < num.length; time++) {
            //選擇排序,類似于排隊,找出最矮的,放在第一位,第二矮的放在第二位....
            for (int index = time; index < num.length; index++) {
                if (num[time - 1] > num[index]) {
                    int temp = num[index];
                    num[index] = num[time - 1];
                    num[time - 1] = temp;
                }
            }
        }
    }
}

-二分查找(折半查找)
采用二分法查找時，數(shù)據(jù)需是排好序的
二分查找的基本思想是將n個元素分成大致相等的兩部分，取a[n/2]與x做比較，如果x=a[n/2],則找到x,算法中止；如果x<a[n/2],則只要在數(shù)組a的左半部分繼續(xù)搜索x,如果x>a[n/2],則只要在數(shù)組a的右半部搜索x.
當(dāng)數(shù)據(jù)量很大適宜采用該方法。

例如:猜數(shù)游戲：
猜一個從1到100之間的數(shù)，為了能用最少的次數(shù)猜中，必須從50開始猜。如果你猜的偏小了，那么就能推出那個數(shù)在50到100之間，所以馬上猜75。但如果你猜偏大了，你也能明白哪個說在1到50之間，所以馬上猜25。如此重復(fù)，范圍越來越小，直到猜到為止。

//二分法查找--前提:數(shù)組是有序的,一般都是升序
public class BinarySearchDemo {
    public static void main(String[] args) {
        int[] num = { 1, 3, 5, 7, 9 };
        int ret = binarySearch(num, 5);
        System.out.println(ret);
    }

    private static int binarySearch(int[] num, int key) {
        int low = 0;
        int high = num.length - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;//右移1位,就是除以2,但是效率更高
            int midVal = num[mid];
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid;
        }
        return -1;
    }
}

多維數(shù)組

如果每個變量都是一維數(shù)組，那這個裝多個一維數(shù)組的數(shù)組是什么呢？也就是說現(xiàn)在數(shù)組里還有數(shù)組，此時我們習(xí)慣稱為二維數(shù)組，同理什么是三維數(shù)組呢？
一維數(shù)組:數(shù)組中的每一個元素都是一個值.
二維數(shù)組:數(shù)組在的每一個元素都是一維數(shù)組.
三維數(shù)組:數(shù)組中的每一個元素都是二維數(shù)組.
注意:在Java中沒有真正的多維數(shù)組的概念,我們習(xí)慣稱之為數(shù)組中的數(shù)組.
注意區(qū)分和C/C＋＋中的多維數(shù)組
詳細(xì)可以看這篇文章:http://blog.csdn.net/u012110719/article/details/46288893

二維數(shù)組內(nèi)存分析

二維數(shù)組內(nèi)存分析.png

方法的可變參數(shù)

遇到什么問題

求兩個數(shù)之和，需要一個方法,該方法有兩個參數(shù)，求5個數(shù)之和，需要重載一個方法,該方法有5個參數(shù)，求100個數(shù)之和、1000個數(shù)之和、10000個數(shù)之和，方法的參數(shù)列表會很長很長

我們使用數(shù)組解決了同類型的多參數(shù)問題.但是,調(diào)用者需要先把數(shù)據(jù)封裝到一個數(shù)組中,再傳遞給求和方法.,很不爽!
怎么解決
解決方案:使用方法的可變參數(shù)機(jī)制.
方法的可變參數(shù)其實底層就是數(shù)組.
** 注意:**
1:可變參數(shù)只能運用于方法的參數(shù)中.
2:其本質(zhì)就是數(shù)組,是Java5的一個語法糖.
3:可變參數(shù)必須作為方法的最后一個參數(shù).

//方法的可變參數(shù)
public class AlterArgsDemo {
    public static void main(String[] args) {
        int ret = getSum(1, 2, 3);
        System.out.println(ret);//6
        ret = getSum(1, 2);
        System.out.println(ret);//3
        ret = getSum(1, 2, 3, 4, 5);
        System.out.println(ret);//15
    }

    public static int getSum(int... arr) {
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }
}