新手初學(xué)Java數(shù)組

更新時(shí)間：2021年07月07日 11:52:23 作者：Prpr君

數(shù)組是相同類型數(shù)據(jù)的有序集合數(shù)組描述的是相同類型的若干個(gè)數(shù)據(jù),按照一定的先后次序排列組合而成。其中,每一個(gè)數(shù)據(jù)稱作一個(gè)數(shù)組元素,每個(gè)數(shù)組元素可以通過一個(gè)下標(biāo)來訪問它們數(shù)組的聲明創(chuàng)建

什么是數(shù)組

數(shù)組是相同類型數(shù)據(jù)的有序集合
數(shù)組描述的是相同類型的若干個(gè)數(shù)據(jù),按照一定的先后次序排列組合而成。
其中,每一個(gè)數(shù)據(jù)稱作一個(gè)數(shù)組元素,每個(gè)數(shù)組元素可以通過一個(gè)下標(biāo)來訪問它們

數(shù)組的聲明創(chuàng)建

首先必須聲明數(shù)組變量，才能在程序中使用數(shù)組。下面是聲明數(shù)組變量的語法:

dataType[] array;//例： int[] nums; 推薦使用這種寫法
或者
dataType array[];//例： int nums[];

使用new來創(chuàng)建數(shù)組的語法:

dataType[] array = new dataType[arraySize]//例 int[] nums = new int[10];

數(shù)組的元素是通過索引訪問的，數(shù)組索引從0開始。

獲取數(shù)組的長度：array.length

練習(xí)：用循環(huán)給數(shù)組賦值1到10，并輸出數(shù)組的總和

public static void main(String[] args) {
        //創(chuàng)建一個(gè)數(shù)組
        int[] array = new int[10];
        //sum為總和
        int sum = 0;
        //循環(huán)給數(shù)組賦值
        for (int i = 1;i<=array.length;i++){
            array[i-1] = i;
        }
        //循環(huán)遍歷數(shù)組，把每位加到sum計(jì)算總和
        for (int j = 0;j<array.length;j++){
            sum = sum + array[j];
        }
        System.out.println("數(shù)組總和為:"+sum);
    }

內(nèi)存分析：

結(jié)合以上練習(xí)和這張簡單的內(nèi)存分析思維導(dǎo)圖來簡單分析一下數(shù)組是如何生成在java內(nèi)存的？

三種初始化狀態(tài)

靜態(tài)初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1)}//Man是類名

動(dòng)態(tài)初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

數(shù)組的默認(rèn)初始化

動(dòng)態(tài)初始化包含了默認(rèn)初始化。數(shù)組是引用類型，它的元素相當(dāng)于類的實(shí)例變量，因此數(shù)組一經(jīng)分配空間，其中的每個(gè)元素也被按照實(shí)例變量同樣的方式被隱式初始化。

int[] a = new int[2];//可以理解為一但通過new實(shí)例化了，數(shù)組的每個(gè)元素也同樣的被實(shí)例化位默認(rèn)值存在堆的空間里

數(shù)組的四個(gè)基本特點(diǎn)

其長度是確定的。數(shù)組一旦被創(chuàng)建，它的大小就是不可以改變的。
其元素必須是相同類型,不允許出現(xiàn)混合類型。
數(shù)組中的元素可以是任何數(shù)據(jù)類型，包括基本類型和引用類型。
數(shù)組變量屬引用類型，數(shù)組也可以看成是對(duì)象，數(shù)組中的每個(gè)元素相當(dāng)于該對(duì)象的成員變量。數(shù)組本身就是對(duì)象，Java中對(duì)象是在堆中的，因此數(shù)組無論保存原始類型還是其他對(duì)象類型，數(shù)組對(duì)象本身是在堆中的。

數(shù)組的使用

For-Each循環(huán)

public static void main(String[] args) {
        int[] arrays = {1,3,5,7,9};
        //JDK1.5以上可以使用，但是沒有下標(biāo)
        for (int array : arrays) {
            System.out.println(array);
        }
    }

數(shù)組作方法入?yún)?/p>

public static void main(String[] args) {
        int[] arrays = {2,4,6,8,10};
        printArray(reverse(arrays));//輸出10 8 6 4 2
    }
    //打印數(shù)組元素
    public static void printArray(int[] arrays){
        for(int i = 0; i < arrays.length; i++){
            System.out.print(arrays[i]+" ");
        }
    }

數(shù)組作返回值

 public static void main(String[] args) {
        int[] arrays = {2,4,6,8,10};
        //使用for-each遍歷出反轉(zhuǎn)后的數(shù)組
        for(int array : reverse(arrays)){
            System.out.print(array+" ");
        }
    }
    //反轉(zhuǎn)數(shù)組，從數(shù)組最后一個(gè)元素到第一個(gè)元素
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

多維數(shù)組

多維數(shù)組可以看成是數(shù)組的數(shù)組，比如二維數(shù)組就是一個(gè)特殊的一維數(shù)組，其每一個(gè)元素都是一個(gè)一維數(shù)組。

二維數(shù)組

int a[][] = new int[3][2]//可以看作一個(gè)3行2列的數(shù)組來理解

例：創(chuàng)建并打印二維數(shù)組的所有元素

public static void main(String[] args) {
        int[][] arrays = {{1,2},{3,4},{5,6}};
        for (int i = 0; i <arrays.length ; i++) {
            for (int j = 0;j<arrays[i].length;j++){
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }

Arrays類

數(shù)組的工具類java.util.Arrays
由于數(shù)組對(duì)象本身并沒有什么方法可以供我們調(diào)用,但API中提供了一個(gè)工具類Arrays供我們使用,從而可以對(duì)數(shù)據(jù)對(duì)象進(jìn)行一些基本的操作。
Arrays類中的方法都是static修飾的靜態(tài)方法,在使用的時(shí)候可以直接使用類名進(jìn)行調(diào)用,而"不用"使用對(duì)象來調(diào)用(注意:是"不用”而不是"不能")

常用功能:

返回指定數(shù)組的內(nèi)容的字符串表示形式，通過toString方法。

public static void main(String[] args) {
        int[] arrays = {9,5,8,7,100,365,277,25,64};
		System.out.println(Arrays.toString(arrays));
    }

將指定的int值分配給指定的int數(shù)組的每個(gè)元素：通過fill方法。

public static void main(String[] args) {
        int[] arrays = {9,5,8,7,100,365,277,25,64};
        Arrays.fill(arrays,0);//給數(shù)組里面所有元素替換為0
        System.out.println(Arrays.toString(arrays));
        //輸出[0, 0, 0, 0, 0, 0, 0, 0, 0]
        int[] arr = {9,5,8,7,100,365,277,25,64};
//      a - 要填充的數(shù)組
//      fromIndex - 要用指定值填充的第一個(gè)元素（包括）的索引
//      toIndex - 要用指定值填充的最后一個(gè)元素（排除）的索引
//      val - 要存儲(chǔ)在數(shù)組的所有元素中的值
        Arrays.fill(arr,0,5,9);//給數(shù)組里面所有下標(biāo)范圍替換為9
        System.out.println(Arrays.toString(arr));
    }

對(duì)數(shù)組排序:通過sort方法,按升序。

public static void main(String[] args) {
        int[] arrays = {9,5,8,7,100,365,277,25,64};
        Arrays.sort(arrays);//數(shù)組進(jìn)行排序：升序
        System.out.println(Arrays.toString(arrays));
        //輸出[5, 7, 8, 9, 25, 64, 100, 277, 365]
    }

比較數(shù)組:通過equals方法比較數(shù)組中元素值是否相等。

public static void main(String[] args) {
        int[] arrays = {9,5,8,7,100,365,277,25,64};
        int[] arrays2 = {9,5,8,7,100,365,277,25,64};
        boolean flag = Arrays.equals(arrays, arrays2);
        System.out.println("arrays和arrays2中的元素比較結(jié)果："+flag);
    }

冒泡排序

冒泡排序算法的運(yùn)作：

比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。
對(duì)每一對(duì)相鄰元素作同樣的工作，從開始第一對(duì)到結(jié)尾的最后一對(duì)。比較完最后一對(duì)則最后的元素會(huì)是最大的數(shù)。
針對(duì)所有的元素重復(fù)以上的步驟，除了最后一個(gè)。
持續(xù)每次對(duì)越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對(duì)數(shù)字需要比較。

代碼示例：

public static void main(String[] args) {
        int[] arrays = {9,5,8,7,100,365,277,25,64};
        sort(arrays);
    }
    //冒泡排序:比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)的值
    public static void sort(int array[]){
        //temp是臨時(shí)變量，用于比較的值進(jìn)行交換
        int temp = 0;
        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]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

以上代碼通過可以通過斷點(diǎn)Debug發(fā)現(xiàn)，排序過程中，執(zhí)行完最后的排序后，雖然數(shù)據(jù)已全部排序完備，但程序無法判斷是否完成排序

為了解決這一不足，可設(shè)置一個(gè)標(biāo)志位flag來進(jìn)行優(yōu)化，將其初始值設(shè)置為false，表示被排序的表是一個(gè)無序的表，每一次排序開始前設(shè)置flag值為false，在進(jìn)行數(shù)據(jù)交換時(shí)，修改flag為非true。在新一輪排序開始時(shí)，檢查此標(biāo)志，若此標(biāo)志為false，表示上一次沒有做過交換數(shù)據(jù)，則結(jié)束排序；否則進(jìn)行排序；

例:

public static void main(String[] args) {
        int[] arrays = {9,5,8,7,100,365,277,25,64};
        sort(arrays);
    }
    public static void sort(int array[]){
        //temp是臨時(shí)變量，用于比較的值進(jìn)行交換
        int temp = 0;
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag==false){
                break;
            }
        }
        System.out.println(Arrays.toString(array));
    }

稀疏數(shù)組

當(dāng)一個(gè)數(shù)組中大部分元素為0，或者為同一值的數(shù)組時(shí)，可以使用稀疏數(shù)組來保存該數(shù)組。
稀疏數(shù)組的處理方式是:
- 記錄數(shù)組一共有幾行幾列，有多少個(gè)不同值
- 把具有不同值的元素和行列及值記錄在一個(gè)小規(guī)模的數(shù)組中，從而縮小程序的規(guī)模
如下圖：左邊是原始數(shù)組，右邊是稀疏數(shù)組

例：一個(gè)有11行11列的五子棋盤，下了黑子和白字和沒下棋子的地方我們可以用不同數(shù)字表示

（0：無）（1：黑）（2：白）

因?yàn)樵摱S數(shù)組的很多值是默認(rèn)值0，因此記錄了很多沒有意義的數(shù)據(jù)。我們可以用稀疏數(shù)組來優(yōu)化壓縮

public static void main(String[] args) {
        //1.創(chuàng)建一個(gè)二維數(shù)組array1  有11行11列 (0：無 1：黑 2：白)
        int[][] array1 = new int[11][11];
        //根據(jù)示例圖表示，1在第二行第三列，2在第三行第四列
        array1[1][2] = 1;
        array1[2][3] = 2;
        //輸出原始數(shù)組
        System.out.println("輸出原始數(shù)組");
        for(int[] ints : array1){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("==========================================");
        //2.獲取有效值的個(gè)數(shù)
        int sum = 0;//sum拿來記錄有效個(gè)數(shù)
        //11為二維數(shù)組的行數(shù)
        for (int i = 0; i < 11; i++) {
            //11為二維數(shù)組的列數(shù)
            for (int j = 0; j <11 ; j++) {
                //如果幾行幾列的值不是0,則有效值個(gè)數(shù)+1
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的個(gè)數(shù):"+sum);
        //3.創(chuàng)建一個(gè)代表稀疏數(shù)組的數(shù)組array2
        //sum+1中的+1是第一行要存放總共幾行幾列幾個(gè)有效值的數(shù)據(jù),3列是固定存放行、列、值
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;//總共多少行
        array2[0][1] = 11;//總共多少列
        array2[0][2] = sum;//有效值個(gè)數(shù)
        //4.遍歷二維數(shù)組，將非0的值存放在稀疏數(shù)組中
        int count = 0;//記錄行數(shù)
        for (int i = 0; i < array1.length ; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;//查找到一個(gè)有效值就+1行記錄在稀疏數(shù)組array2中
                    array2[count][0] = i;//橫坐標(biāo)
                    array2[count][1] = j;//縱坐標(biāo)
                    array2[count][2] = array1[i][j];//值
                }
            }
        }
        System.out.println("輸出稀疏數(shù)組");
        System.out.println("行"+"\t"+"列"+"\t"+"值");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                                +array2[i][1]+"\t"
                                +array2[i][2]+"\t");
        }
        System.out.println("==========================================");
        //5.把稀疏數(shù)組array2還原為原始數(shù)組array3
        //稀疏數(shù)組中array2[0][0]和[0][1]固定存放是總共幾行幾列，array2是11行11列
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //給其中的元素還原它的值,注意i要從1開始,因?yàn)閍rray2[0]行存取的是幾行幾列
        for (int i = 1; i < array2.length; i++) {
            //0是int數(shù)組中的默認(rèn)值，所以只需要在有效值的位置還原
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印array3
        System.out.println("輸出還原數(shù)組");
        for(int[] ints : array3){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }

結(jié)果：