java實現四則運算

阿新 • • 發佈：2020-09-18

1、定義

相同資料型別的有序集合
其中，每一個數據稱作為一個數組元素，每個陣列元素可以通過一個下標來訪問他們

2、陣列的宣告、建立、初始化

2.1、宣告

語法：
- 陣列型別[] 陣列名;（首選）
- 陣列型別陣列名[];
```
//示例
int[] intNums;

double doubleNums[];
```

2.2、建立

使用new操作符建立陣列
語法：陣列型別[] 陣列名 = new 陣列型別[陣列長度];
```
//示例
int[] intNums = new int[8];
```

2.3、初始化

預設初始化
- 陣列是引用型別，一經建立，也就是分配空間後，其中的每個元素會被隱式地初始化，有預設值

靜態初始化

語法：陣列型別[] 陣列名 = {陣列元素,陣列元素,陣列元素......};

//基本資料型別陣列
int[] intNums = {1,2,3};

//Dog類
public class Dog {
  String name;

  public Dog(String name) {
    this.name = name;
   }
}
//引用型別陣列
Dog[] dogs = {new Dog("豆包"),new Dog("旺財")};

動態初始化
- 語法：
  - 陣列型別[] 陣列名 = new 陣列型別[陣列長度];
  - 陣列名[下標索引] = 值；
```
int[] intNums = new int[3];
 
intNums[0] = 1;
intNums[1] = 2;
intNums[2] = 3;
```

2.4、從記憶體分析陣列宣告、建立、初始化的過程

簡單認識Java記憶體
- 堆記憶體
  - 存放new的物件和陣列
  - 可以被所有的執行緒共享
- 棧記憶體
  - 存放基本變數型別（會包含這個基本物件型別的數值）
  - 引用物件的變數（會存放這個變數存放在堆記憶體的地址）
- 方法區
  - 包含了所有的class和static變數
  - 可以被所有的執行緒共享
過程畫圖分析如下

3、二維陣列

一維陣列中的每一個數據元素分別又是一個數組

宣告、建立、初始化的語法和以為陣列一樣，但是多了一個[]

//動態初始化
int[][] arrays = new int[2][3];
arrays[0][0] = 1;
arrays[0][1] = 2;
arrays[0][2] = 3;
arrays[1][0] = 4;
arrays[1][1] = 5;
arrays[1][2] = 6;

//靜態初始化
int[][] arrays = {{1,2,3},{4,5,6}};

4、陣列特點

陣列長度確定，一旦被建立，其大小不可以被改變，下標的合法取值範圍[0,length-1]

如果越界，就會報ArrayIndexOutOfBoundsException異常
陣列中的元素可以是基本資料型別，也可以是引用型別，但必須是同一種類型
陣列也是物件，陣列中的元素相當於物件的成員變數

5、Arrays類常用方法

5.1、toString()

語法：Arrays.toString(陣列名)
作用：直接輸出陣列，結果為[I@1540e19d，物件的hashcode，toString()方法可以列印陣列中各個元素

//示例
int[] nums = {6,55,32,178,126,986,467,434,556};
//輸出結果為：原陣列：[6, 55, 32, 178, 126, 986, 467, 434, 556]
System.out.println("原陣列：" + Arrays.toString(nums));

5.2、sort()

語法：Arrays.sort(陣列名)
作用：對陣列進行升序排序

//示例
int[] nums = {6,55,32,178,126,986,467,434,556};

Arrays.sort(nums);
//輸出結果為：排序後的陣列：[6, 32, 55, 126, 178, 434, 467, 556, 986]
System.out.println("排序後的陣列：" + Arrays.toString(nums));

5.3、copyOf()

語法：Arrays.copyOf(陣列名,新陣列的長度)
作用：複製指定的陣列，用0擷取或填充，以達到指定的陣列長度

//示例
int[] nums = {6,55,32,178,126,986,467,434,556};

int[] nums2 = Arrays.copyOf(nums,5);
//輸出結果為：複製後的陣列：[6, 32, 55, 126, 178]
System.out.println("複製後的陣列：" + Arrays.toString(nums2));
int[] nums3 = Arrays.copyOf(nums,15);
//輸出結果為：複製後的陣列：[6, 32, 55, 126, 178, 434, 467, 556, 986, 0, 0, 0, 0, 0, 0]
System.out.println("複製後的陣列：" + Arrays.toString(nums3));

5.4、fill()

語法：Arrays.fill(陣列名)
作用：用0填充所有的陣列元素

//示例
int[] nums = {6,55,32,178,126,986,467,434,556};

Arrays.fill(nums,0);
//輸出結果為：填充後的陣列：[0, 0, 0, 0, 0, 0, 0, 0, 0]
System.out.println("填充後的陣列：" + Arrays.toString(nums));

5.5、equals()

語法：Arrays.equals(陣列1,陣列2)
作用：判斷兩個陣列是否相同，相同的條件為：包含相同數量的元素，並且兩個陣列中對應的每個陣列元素都相等

//示例
int[] i1 = new int[]{1,2,3};
int[] i2 = {1,2,3};
//輸出結果為：true
System.out.println(Arrays.equals(i1,i2));

6、稀疏陣列

在陣列中，若數值為0的元素數目遠遠多於非0元素的數目，並且非0元素分佈沒有規律時，可以用稀疏陣列來儲存該陣列

//建立一個數組，把陣列轉換成稀疏陣列，再把稀疏陣列轉換為原陣列
public class SparseArray {

  public static void main(String[] args) {
    //一、建立一個數組並且輸出
    
    //1、建立一個數組
    int[][] sArray1 = new int[11][11];
    sArray1[1][2] = 1;
    sArray1[2][3] = 2;
    sArray1[10][10] = 11;

    //2、輸出
    System.out.println("原陣列為：");
    for (int[] sInt : sArray1) {
      for (int i : sInt) {
        System.out.print(i + "\t");
       }
      System.out.println();
     }

    //二、把陣列轉換成稀疏陣列輸出
    
    //1、確定稀疏矩陣中有效字元的個數
    int sum = 0;

    for (int i = 0; i <11 ; i++) {
      for (int j = 0; j <11 ; j++) {
        if (sArray1[i][j] != 0){
          sum++;
         }
       }
     }
    System.out.println("有效值的個數為：" + sum);

    /*
    2、建立一個稀疏矩陣
    總共sum + 1行
    第一行存放的是稀疏矩陣的資訊，幾行、幾列、多少個有效字元
    其餘sum行存放的是有效字元的資訊，位於第幾行，第幾列，值為多少
     */
    int[][] sArray2 = new int[sum + 1][3];

    //3、給稀疏矩陣賦值
    //給第一行元素賦值
    sArray2[0][0] = 11;
    sArray2[0][1] = 11;
    sArray2[0][2] = sum;
    /*
    給其餘行賦值
    遍歷二維陣列，將非零的值存放在稀疏矩陣中
    第一層遍歷控制橫座標，總共有多少行
    第二層遍歷控制縱座標，每一行元素的個數
     */
    int count = 0;
    for (int i = 0; i <sArray1.length ; i++) {
      for (int j = 0; j <sArray1[i].length ; j++){
        if (sArray1[i][j] != 0){
          count++;
          //橫座標
          sArray2[count][0] = i;
          //縱座標
          sArray2[count][1] = j;
          //值
          sArray2[count][2] = sArray1[i][j];
         }
       }
     }

    //4、輸出稀疏陣列
    System.out.println();
    System.out.println("稀疏陣列為：");
    for (int i = 0; i <sArray2.length ; i++){
      System.out.println(sArray2[i][0] + "\t" 
                + sArray2[i][1] + "\t" 
                + sArray2[i][2]);
     }

    //三、還原稀疏陣列

    //1、建立一個數組
    int[][] sArray3 = new int[sArray2[0][0]][sArray2[0][1]];

    //2、給其中的元素還原值
    for (int i = 1; i <sArray2.length ; i++) {
      sArray3[sArray2[i][0]][sArray2[i][1]] = sArray2[i][2];
     }

    //3、輸出陣列
    System.out.println();
    System.out.println("還原的陣列為：");
    for (int[] sInt : sArray3) {
      for (int i : sInt) {
        System.out.print(i + "\t");
       }
      System.out.println();
     }
   }
}