Java陣列宣告建立和使用以及多維陣列、Arrays類、稀疏陣列

油炸蘑菇魚發表於2020-05-23
Java陣列

目錄

陣列概述

  • 陣列是相同型別陣列的有序集合
  • 陣列描述的是相同的型別的若干個資料，按照一定的先後次序排列組合而成
  • 其中，每一個資料稱作一個陣列元素，每個陣列元素可以通過一個下標來訪問它們

陣列宣告建立

首先必須宣告陣列變數，才能在程式中使用陣列。下面是宣告陣列變數的語法：

dataType[] arrayRefVar;//首選的方法
dataType arrayRefVar[];//效果相同，但不是首選方法

java語言使用new操作符來建立陣列，語法如下：

dataType[] arrayRefVar = new dataType[arraySize];

陣列的元素是通過索引訪問的，陣列索引從0開始

獲取陣列長度：arrays.length

public class ArrayDemo01 {
    public static void main(String[] args) {
        //陣列型別 陣列的名字 = 陣列的值;
        int[] nums;//宣告一個陣列
        int nums2[];//也是定義，但不首選
        nums = new int[10];//給宣告的陣列分配空間，建立陣列。這裡面可以存放10個int型別的數字
        //給陣列元素中賦值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;

        System.out.println(nums[9]);//0   不賦值的話，預設值為0
        //計算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum=sum+nums[i];
        }
        System.out.println(sum);//45
    }
}

記憶體分析

java記憶體分析

堆

存放new的物件和陣列

可以被所有執行緒共享，不會存放別的物件引用

棧

存放基本變數型別（會包含這個基本型別的具體數值）

引用物件的變數（會存放這個引用在堆裡面的具體地址）

方法區

可以被所有的執行緒共享

包含了所有的class和static變數

三種初始化

靜態初始化

建立+賦值

int[] a ={1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};//需要先建立相關類

動態初始化

包含預設初始化

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

陣列的預設初始化

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

陣列的四個基本特點

  • 其長度是確定的。陣列一旦被建立，它的大小就是不可以被改變的
  • 其元素必須是相同型別，不巡視出現混合型別
  • 陣列中的元素可以試試任何資料型別，包括基本型別和引用型別
  • 陣列變數屬於引用型別，陣列也可以看成是物件，陣列中的每個元素相當於該物件的成員變數。

陣列本身就是物件，java中物件是在堆中的，因此陣列無論儲存原始型別還是其他物件型別，陣列物件本身是在堆中的。

陣列邊界

下標的合法區間：[0,length-1],如果越界就會報錯；

int [] a = new int[3];
System.out.println(a[3]);//ArrayIndexOutOfBoundsException:陣列下標越界異常

小結：

  • 陣列是相同陣列型別（資料型別可以為任意型別）的有序集合
  • 陣列也是物件。陣列元素相當於物件的成員變數
  • 陣列長度的確定的，不可變的。如果越界，則報：ArrayIndexOutOfBoundsException

陣列使用

陣列基礎使用

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //列印全部陣列元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);//12345
        }
        //計算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];

        }
        System.out.println("sum="+sum);//sum=15
        System.out.println("==================================");
        //查詢最大元素
        int max = arrays[0];

        for (int i = 1; i < arrays.length; i++) {
            if(max<arrays[i]){
                max=arrays[i];
            }
        }
        System.out.println("max="+max);//max=5
    }
}

For Each迴圈和普通for迴圈

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //for-each 沒有下標
        for (int array : arrays) {
            System.out.print(array);//取出每一個值12345
        }

        int[] reverse = reverse(arrays);
        printArray(reverse);//54321
    }

    //列印陣列元素，陣列可以做方法入參
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);//12345
        }
    }

    //反轉陣列
    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;//陣列作為返回值
    }
}

多維陣列

多維陣列可以看成是陣列的陣列，比如二維陣列就是一個特殊的一維陣列，其中每一個元素都是一個一維陣列

二維陣列

int a[][] = new int[2][5];//可以看成一個兩行五列的陣列

遍歷二維陣列

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[][] array = {{1,2,3},{2,3,4},{3,4,5}};//建立二維陣列[3][3]
        /*
        1,2,3     array[0]
        2,3,4     array[1]
        3,4,5     array[2]
         */
        printArray(array[1]);//234
        System.out.println(array[0][2]);//3
        System.out.println(array.length);//3
        System.out.println(array[0].length);//3
        
        //遍歷二維陣列
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);//123 234 345
            }

        }
    }
    //列印陣列元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);//12345
        }
    }
}

Arrays類

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

由於陣列物件本身並沒有什麼方法可以供我們呼叫，但API中提供了一個工具類Arrays供我們使用，從而可以對資料物件進行一些基本操作

Arrays類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫，而“不用”使用物件來呼叫("不用"而不是"不能")

具體以下常用功能：

  • 給陣列賦值：通過fill方法
  • 對陣列排序：通過sort方法，按升序
  • 比較陣列：通過equals方法比較陣列中元素值是否相等
  • 查詢陣列元素：通過binarySearch方法能對排序好的陣列進行二分查詢法操作
package com.shenxiaoyu.array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9090,32311,643,21,3,3,23};
        System.out.println(a);//[I@16d3586
        //列印陣列元素Arrays.toString
        //System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 9090, 32311, 643, 21, 3, 3, 23]
        printArray(a);
        Arrays.sort(a);//陣列進行排序：升序
        System.out.println(Arrays.toString(a));//[1, 2, 3, 3, 3, 4, 21, 23, 643, 9090, 32311]

        Arrays.fill(a,0);//陣列填充
        System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    }
    //列印陣列元素
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+",");
            }
        }
    }

}

稀疏陣列

當一個陣列中大部分為-，或者為同一值的陣列時，可以使用稀疏陣列來儲存該陣列

稀疏陣列的處理方式：

  • 記錄陣列一共有幾行幾列，有多少不同值
  • 把具有不同值的元素和行列及值記錄在一個小規模陣列中，從而縮小程式的規模。
package com.shenxiaoyu.array;

import java.util.jar.JarOutputStream;

public class ArrayDemo07 {
    public static void main(String[] args) {
        //1.建立一個二維陣列 11*11 0：沒有棋子 1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //輸出原始的陣列
        System.out.println("輸出原始的陣列");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        /*
        輸出原始的陣列
        0  0  0  0  0  0  0  0  0  0  0
        0  0  1  0  0  0  0  0  0  0  0
        0  0  0  2  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
         */

        //轉換為稀疏陣列來儲存
        //獲取有效值的個數
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的個數："+sum);

        //建立一個稀疏陣列的陣列
        int[][] array2 = new int[sum+1][3];

        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        //遍歷二維陣列，將非零的值，存放稀疏陣列中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];

                }
            }
        }
        //輸出稀疏陣列
        System.out.println("稀疏陣列");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]
                    +"\t"+array2[i][1]
                    +"\t"+array2[i][2]);
        }
        /*
        有效值的個數：2
        稀疏陣列
        11 11 2
        1  2  1
        2  3  2
         */
        System.out.println("====================================");
        System.out.println("還原");
        //讀取稀疏陣列
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //給其中的元素還原他的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //列印
        System.out.println("輸出還原的陣列");

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        /*
        還原
        輸出還原的陣列
        0  0  0  0  0  0  0  0  0  0  0
        0  0  1  0  0  0  0  0  0  0  0
        0  0  0  2  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
        0  0  0  0  0  0  0  0  0  0  0
         */
    }
}

相關文章