JavaSE-數組

數組

數組是一個最簡單的數據結構

數組概述

數組時相同類型數據的有序集合

數組描述的是相同類型的若干個數據，按照一定的先後次序排列組合而成

其中每一個數據稱做一個數組元素，每個數組元素可以通過一個下標來訪問他們

數組聲明創建

首先必須先聲明數組變量，才能在程序中使用數組。

dataType[] arrayRefVar;		//首選方法

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

Java語言使用new操作符創建數組，語法如下：

dataType[] arrayRefVar = new dataType[arraySize];

public static void main(String[] args) {

        // 聲明數組
        int[] nums;     //定義，Java中建議在類型後面添加中括號代表數組
        int nums2[];    //c、c++類型定義數組的方式

        //創建數組
        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;
        nums[9] = 10;

        int sum = 0;
        for (int i =0; i < nums.length; i++){
            sum += nums[i];

        }
        System.out.println("總和爲：" + sum);

    }

靜態初始化

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;

數組默認初始化

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

public static void main(String[] args) {
        //靜態初始化：創建+賦值
        int[] a = {1, 2, 3, 4, 5};     //一旦定義不可改變
        System.out.println(a[0]);

        //動態初始化:聲明數組時並未直接進行賦值
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
        System.out.println(b[1]);


        //默認初始化：數組是一個引用類型，數組一經聲明都會有默認初始值，一旦被實例化分配內存空間後都會隱式賦值
    }

數組的四個基本特點

• 數組一旦被創建它的大小就是不可以改變的
• 數組中的元素必須是相同類型，不能出現其他類型
• 數組中的元素可以是任何數據類型，包括八大基本類型和引用類型（比如類的實例化對象）
• 數組變量屬於引用類型，數組也可以看成是對象，數組中的每個元素相當於該對象的成員變量。數組對象存在於堆中

數組邊界

數組的下標爲[0, length-1]，如果越界會報 ArrayIndexOutOfBoundsException 數組下標異常

數組小結

• 數組是相同數據類型（數據類型可以爲任何類型）的有序集合
• 數組也是對象。數組元素相當於對象的成員變量
• 數組一旦被創建，其長度是確定的。

數組使用

for-each循環遍歷數組

   //JDK1.5  沒有下標  數組中的每一個元素 : 數組
        //直接遍歷數組
        for (int array : arrays) {
           System.out.println(array);

        }

數組作爲參數&&返回值

public static void main(String[] args) {

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

     
        int[] result = reverseArray(arrays);
        printArray(result);

    }
    //反轉數組: 數組作爲返回值
    public static int[] reverseArray(int[] array){
        int[] result = new int[array.length];

        //反轉操作
        for (int i = 0, j=result.length - 1; i < array.length; i++,j--) {
            result[j] = array[i];
        }


        return result;
    }

    //打印數組元素：數組作爲傳遞給方法
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "   ");
        }
    }

多維數組

多爲數組可以看成是數組的數組，比如二維數組就是一個特殊的一維數組，該二維數組中的每個元素都是一個一維數組。

二維數組

2行5列的數組

int a[][] = new int[2][5];

Arrays類

操作數組的類

Arrays.toString()

public static void main(String[] args) {

        int[] a = {1, 2, 3, 4, 5, 6, 47, 365, 456746, 234, 234234, 785};

        System.out.println(a);      //打印值爲數組對象的hashcode

        System.out.println(Arrays.toString(a));     //打印正常數組

        printArray(a);

        System.out.println("===================數組排序===================");

        Arrays.sort(a);     //對數組進行升序排序

        System.out.println(Arrays.toString(a));
    }

    //打印數組
    public static void printArray(int[] a){
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i == a.length - 1){
                System.out.print(a[i]);
            }else {
                System.out.print(a[i] + ", ");
            }

        }
        System.out.println("]");
    }

稀疏數組

壓縮數組便於保存

package com.Zh1z3ven.array;

public class ArrayDemo08 {
    public static void main(String[] args) {

        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();
        }

        //轉爲細數數組
        //獲取有效值的個數
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; 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] + "\t");



        }

        //讀取稀疏數組
        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();
        }
    }
}