數值概述

• 陣列是相同型別資料的有序集合

• 陣列描述的是相同型別的若干個資料結構，按照一定的先後次序排列組合而成

• 其中，每一個數據稱作一個數組元素，每個陣列元素可以通過一個下標來訪問他們。

陣列宣告建立

陣列宣告

• 首先必須宣告陣列變數，才能在程式中使用陣列。

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

• Java語言使用new操作符來建立陣列

dataType arrayRefvar = new dataType[arraySize];

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

• 獲取陣列長度

arrays.length

記憶體分析

三種初始化

• 靜態初始化

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;

• 陣列的預設初始化

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

陣列使用

• For- Each 迴圈

int[] arrays ={1,2,3,4,5}
//列印全部的陣列元素
for(int i=0;i<arrays.length;i++){
  System.out.println(i);
}
//計算所有元素的和
int sum=0;
for(int i=0;i<arrays.length;i++){
  sum=sum+arrays[i];
}
System.out.println(sum);
 

int[] arrays={1,2,3,4,5}
//列印全部的陣列元素
for(int arrays : arrays){
  System.out.println(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 rusult;
}

多維陣列

• 多維陣列可以看成是陣列的陣列

int[][] ={{},{},{}};

Arrays 類

java.util.Arrats

import java.util.Arrays;
​
public class ArraysDemo01 {
  public static void main(String[] args) {
    int[] arrays={123,243,124,521,213,123,342};
    System.out.println(arrays);
    //列印陣列  Arrays.toString
    System.out.println(Arrays.toString(arrays));
    //排序 Arrays.sort() 升序
    Arrays.sort(arrays);
    System.out.println(Arrays.toString(arrays));
    //填充 Arrays.fill(arrays ,2,4, 0)  --> 將0賦值給arrays中的2~4
    Arrays.fill(arrays,2,4,0);
    System.out.println(Arrays.toString(arrays));
   }
}
​

氣泡排序

1. 比較陣列中兩個相鄰的元素，如果第一個數要比第二個數大，我們交換他們位置

2. 每一次比較，都會產生出一個最大，或最小的數字

3. 下一輪，可以少一次排序

4. 依次迴圈，直到結束

int[] arrays={1,3,5,1,6,3};
int temp=0;
for(int i = 0; i<arrays.length-1;i++){
  //外層迴圈，判斷我們要走多少次
  for(int j = 0; j<arrays.length-1-i;j++){
    //內層迴圈，比較兩個數，根據條件判斷位置，則交換位置
    if(array[j+1]>arrays[j]){
      temp=arrays[j];
      arrays[j]=arrays[j+1];
      arrays[j+1]=temp;
     }
   }
}

稀疏陣列

• 大部分為0，或大部分全部為同一值

• 稀疏陣列的處理方式

1. 記錄陣列一共有幾行幾列，有多少個不同值

2. 把具有不同值的元素和行列及值記錄在一個小規模的陣列中，從而縮小程式的規模

package base.base.base;
​
public class ArraysDemo03 {
  public static void main(String[] args) {
    //1.建立一個二維陣列 11*11 0：沒棋，1：黑棋，2：白棋
    int [][] array1 = new int[11][11];
    array1[2][1]=1;
    array1[6][1]=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[] ints: array1) {
      for (int anInt: ints){
        if (anInt!=0){
          sum++;
         }
       }
     }
    System.out.println("有效值的個數："+sum);
    //2.建立一個稀疏陣列的陣列
    //遍歷二維陣列，將稀疏矩陣值存放到稀疏陣列中
    int count = 0;
    int [][]array2 = new int[sum+1][3];
    array2[0][0]=11;
    array2[0][1]=11;
    array2[0][2]=sum;
    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[] ints:array2
       ) {
      for (int anInt:ints
         ) {
        System.out.print(anInt+"\t");
       }
      System.out.println();
     }
    //3.還原稀疏陣列
    int[][] array3=new int[array2[0][0]][array2[0][0]];
    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();
     }
​
   }
}
​