Java學習——陣列&稀疏陣列

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

陣列

陣列概述

陣列宣告建立

當訪問的陣列下標超過陣列最大下標值是，會報錯java.lang.ArrayIndexOutOfBoundsException: 下標越界
靜態初始化: 建立+賦值

int[] a = {1,2,3,4,5,6,};
但是動態初始化裡沒賦值時都有預設值0
以記憶體角度講，棧包含堆，堆立面是陣列，數組裡面每一個下標都有一個空間放值。

陣列使用

For-Each迴圈
陣列作方法入參
陣列作返回值

多維陣列

二維陣列

Arrays 類

關於陣列的工具類

例：Arrays.sort(); //陣列升序排序

氣泡排序

public class ArrayDemo05 {
     public static void main(String[] args) {
 
         int[] a = {6541, 8496, 456, 4, 1, 516, 84, 64};
 
         int[] sort = sort(a);
         System.out.println(Arrays.toString(sort));
 
     }
 
     //氣泡排序
     public static int[] sort(int[] arrays) {
 
          
//臨時變數，交換時用
         int temp = 0;
         //外層迴圈，判斷要走多少次
         for (int i = 0; i < arrays.length - 1; i++) {
 
             boolean flag = false; //通過flag標識位減少沒有意義的比較,減
             
             //內層迴圈，比價判斷兩個數，如果第一個數，比第二個數打
             //，則交換位置。
             for (int j = 0; j < arrays.length -1 - i; j++) {
                  
if (arrays[j + 1] > arrays[j]) {
                     temp = arrays[j];
                     arrays[j] = arrays[j + 1];
                     arrays[j + 1] = temp;
                     flag = true;
                 }
             }
             if(flag = false){
                 break;
             }
         }
         return arrays;
     }}

稀疏陣列

package com.wang.array;
 
 import com.sun.org.apache.xpath.internal.SourceTree;
 
 /**
  * ArrayDemo06
  *
  * @auther WANG
  * @date 2020/8/8 23:01
  */
 public class ArrayDemo06 {
     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();
         }
 
         //1.轉換為稀疏陣列儲存
         //獲取有效值的個數
         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);
 
         //2.建立一個稀疏陣列
         int[][] array2 = new int[sum+1][3];
 
         array2[0][0] = 11;
         array2[0][1] = 11;
         array2[0][2] = sum;
 
         //3.遍歷二維陣列，將非零的值，存放在稀疏陣列中
         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");
         }
 
         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();
 
         }
 
     }
 }