天天看點
傳回

Java基礎之（十二）：數組

記錄了一些數組的筆記，還有一種冒泡排序算法，數組的一種：稀疏數組

數組

數組概述

定義

數組是相同類型資料的有序集合。

數組描述的是相同類型的若幹資料，按照一定的先後次序排列組合而成。

其中，每一個資料稱作一個數組元素，每個數組元素可以通過一個下标來通路它們。

數組聲明建立

  • 首先必須聲明數組變量，才能在程式中使用數組。下面是聲明數組變量的文法： 
dataType[] arrayRefVar;//首選的方法
或
dataType arrayRefVar[];//效果相同，但不是首選方法
  • Java語言使用new操作符來建立數組，文法如下： 
dataType[] arrayRefVar = new dataType[arraySize];
  • 數組的元素是通過索引通路的，數組索引從0開始。
  • 擷取數組長度：

    arrays.length

源碼

public static void main(String[] args) {
    //變量的類型 變量的名字 = 變量的值;
    //數組類型
    int[] nums;//1.定義
    //int nums2[];
    //2.建立一個數組
    nums = new int[10];//這裡面可以存放10個int類型的數字
    //3.給數組元素指派
    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;
    //System.out.println(nums[9]);
    //計算所有元素的和
    int sum = 0;
    //擷取數組長度：arrays.length
    for (int i = 0; i < nums.length; i++) {
        sum = sum + nums[i];
    }
    System.out.println("總和為：" + sum);
}

Java記憶體

  1. 堆
    • 存放new的對象和數組
    • 可以被所有的線程共享，不會存放别的對象引用
  2. 棧
    • 存放基本變量類型（會包含這個基本類型的具體資料）
    • 引用對象的變量

  3. 方法區

    可以被所有的線程共享

    包含了所有的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;
  • 數組的預設初始化
    • 數組是引用類型，它的元素相當于類的執行個體變量，是以數組一經配置設定空間，其中的每個元素也被按照執行個體變量的方式被隐式初始化。 
public static void main(String[] args) {
    //靜态初始化:建立 + 指派
    int[] a ={1,2,3,4,5,6,7,8};
    System.out.println(a[3]);

    //動态初始化:包含預設初始化
    int[] b = new int[10];
    b[0] = 10;
    b[1] = 10;
    System.out.println(b[0]);
    System.out.println(b[1]);
    System.out.println(b[2]);
    System.out.println(b[3]);
}

數組的四個基本特點

  • 其長度是确定的。數組一旦被建立，它的大小就是不可以改變的。
  • 其元素必須是相同類型，不允許出現混合類型。
  • 數組中的元素可以是任何資料類型，包括基本類型和引用類型。
  • 數組變量屬引用類型，數組也可以看成是對象，數組中的每個元素相當于該對象的成員變量。數組本身就是對象，Java中對象是在堆中的，是以數組無論儲存原始類型還是其他對象類型，數組對象本身是在堆中的。

數組邊界

  • 下标的合法區間：[0,length-1],如果越界就會報錯； 
public static void main(String[] args){
    int[] a = new int[2];
    System.out.println(a[2]);
}
  • **ArraylndexOutOfBoundsException: 數組下标越界異常!
  • 小結：
    • 數組是相同資料類型（資料類型可以為任意類型）的有序集合
    • 數組也是對象。數組元素相當于對象的成員變量
    • 數組的長度是确定的，不可變的。如果越界，則報：ArraylndexOutOfBounds

數組使用

  • 普通的for循環：

例子：

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

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


    //查找最大元素
    int max = arrays[0];
    
    for (int i = 0; i < arrays.length; i++) {
        if (arrays[i]>max){
            max=arrays[i];
        }
    }
    System.out.println("max="+max);
}
  • For-Each循環:用來列印一些結果 
//列印數組元素
public static void printArray(int[] arrays){
    for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i]+" ");
    }
}
  • 數組作方法入參：一些函數操作 
public static int[] reverse(int[] arrays)
  • 數組作傳回值 
//反轉數組
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;
}

源碼：

public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5};
    //增強for循環：沒有下标
    //for (int array : arrays) {
    //
    //}

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

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

//反轉數組
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;
}

多元數組

  • 多元數組可以看成是數組的數組，比如二維數組就是一個特殊的一維數組，其每一個元素都是一個一維數組。
Java基礎之（十二）：數組
  • 二維數組 
int a[][] = new int[2][5];
  • 解析：以上二維數組可以看成一個兩行五列的數組。 
public static void main(String[] args) {
        //[4][2]
        /*
        1,2    array[0]
        2,3    array[1]
        3,4    array[2]
        4,5    array[3]
        */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        //System.out.println(array[0]);

        //printArray(array[0]);
       // System.out.println(array[0][0]);

        //System.out.println(array.length);
        //System.out.println(array[0].length);

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

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

Arrays類

  • Arrays類中的方法都是static修飾的靜态方法，在使用的時候可以直接使用類名進行調用，而“不用”使用對象來調用（注意：是“不用”而不是“不能”）
  • 具有以下常用功能：
    • 給數組指派：通過 file 方法。
    • 對數組排序：通過 sort 方法，按升序。
    • 比較數組：通過 equals 方法比較數組中元素值是否相等。
    • 查找數組元素：通過 binarySearch 方法能對排序好的數組進行二分查找法操作。
  • Arrays.toString ：列印數組元素 
//列印數組元素Arrays.toString
System.out.println(Arrays.toString(a));java
//[1, 2, 3, 4, 5, 43, 45345, 433, 435]
  • Arrays.sort : 對數組進行排序 ： 升序java 
Arrays.sort(a);//數組進行排序 : 升序
System.out.println(Arrays.toString(a));
  • Arrays.fill : 對數組進行填充 
Arrays.fill(a,0);//将a中元素都指派為0
System.out.println(Arrays.toString(a));
           
Arrays.fill(a,2,4,0);//将a中2~4之間的元素填充為0
System.out.println(Arrays.toString(a));
           
import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,43,45345,433,435};

        System.out.println(a);//[I@16b98e56

        //列印數組元素Arrays.toString
        System.out.println(Arrays.toString(a));
        //[1, 2, 3, 4, 5, 43, 45345, 433, 435]

        //printArray(a);
        Arrays.sort(a);//數組進行排序 : 升序
        System.out.println(Arrays.toString(a));
        //[1, 2, 3, 4, 5, 43, 433, 435, 45345]

        Arrays.fill(a,2,4,0);//将a中2~4之間的元素填充為0
        System.out.println(Arrays.toString(a));
        //[1, 2, 0, 0, 5, 43, 433, 435, 45345]
        
        Arrays.fill(a,0);//将a中元素都指派為0
        System.out.println(Arrays.toString(a));
        //[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("[");
            }
            System.out.print(a[i]);
            if (i<a.length-1){
                System.out.print(", ");
            }else{
                System.out.print("]");
            }
        }
    }
}

一個例子：冒泡排序

兩層循環：外層冒泡輪數，裡層依次比較

時間複雜度為O(n2)。

import java.util.Arrays;

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

        int[] a ={1,4,22,5,6,11,23,44,56};
        int[] sort = sort(a);//調用完我們自己寫的排序方法以後，傳回一個排序後的數組
        System.out.println(Arrays.toString(sort));
    }

    //冒泡排序
    //1.比較數組中，兩個相鄰的元素，如果第一個數比第二個數大，我們就交換它們的位置
    //2.每一次比較，都會産生出一個最大，或者最小的數字；
    //3.下一輪，則可以少一次排序！
    //4.依次循環，知道結束！
    
    public static int[] sort(int[] array){
        //臨時變量
        int temp = 0;
        //外層循環，判斷我們這個要走多少步
        for (int i = 0; i < array.length-1; i++) {
            //内層循環，比較判斷兩個數，如果第一個數比第二個數大，則交換位置

            for (int j = 0; j < array.length-1; j++) {
                if(array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }       
        return array;
    }    
}

數組擴充：稀疏數組

需求：編寫五子棋遊戲中，有存盤退出和續上盤的功能。

使用二維數組記錄棋盤

分析問題：因為該二維數組的很多值是預設值0，是以記錄了很多沒有意義的資料。

解決：稀疏數組

稀疏數組介紹

  • 當一個數組中大部分元素為0，或者為同一值的數組時，可以使用稀疏數組來儲存該數組。
  • 稀疏數組的處理方式是:
    • 記錄數組一共有幾行幾列，有多少個不同值
    • 把具有不同值的元素和行列及值記錄在一個小規模的數組中，進而縮小程式的規模
  • 如下表：上邊是原始資料，下邊是稀疏數組
22 15
11 17
-6
39
91
28
行 列 值
[0] 6 7 8
[1] 3
[2]
[3] 1
[4] 5
[5] 2
[6]
[7] 4
[8] 
public static void main(String[] args) {
        //建立一個二維數組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();
        }
        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("稀疏數組:");
        System.out.println("行\t列\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("================");
        System.out.println("還原後：");
        //1.讀取稀疏數組
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.給其中的元素還原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.列印
        System.out.println("輸出還原的數組");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("================");
    }
上一篇: [Docker]核心概念
下一篇: [Shell]date擷取指定日期的後幾天