【狂神說Java】Java零基礎學習視頻--筆記一

[ 狂神說B站]  https://www.bilibili.com/video/BV12J41137hu 

java特性和優勢

簡單性、面向對象、可移植性、高能性、分布式、動態性、多線程、安全性、健壯性。

Java基本語法

標識符注意點

1. 所有的標識符都應該以字母(A-Z 或者a-z) ,美元符($)、或者下划線( )開始

2. 首字符之后可以是字母(A-Z 或者a-z) ,美元符($) 、下划線(或數字的任何字符組合

3. 不能使用關鍵字作為變量名或方法名。

4. 標識符是大小寫敏感的

5. 可以使用中文命名，但是一般不建議這樣去使用，也不建議使用拼音,很Low

數據類型

強類型語言

要求變量的使用要嚴格符合規定，所有變量都必須先定義后才能使用

弱類型語言

1. Java的數據類型分為兩大類 基本類型(primitive type) 引用類型(reference type)

2. 浮點數拓展?銀行業務怎么 表示?錢(BigDecimal數學工具類) //float(double) 有限 離散 舍入誤差，大約接近但不等於

3.  

什么是字節

1. 位(bit) :是計算機內部數據儲存的最小單位，11001100是一 個八位二進制數。

2. 字節(byte) :是計算機中數據處理的基本單位，習慣上用大寫B來表示,

3. 1B (byte,字節) = 8bit (位)

4. 字符:是指計算機中使用的字母、數字、字和符號

類型轉換

由於Java是強類型語言，所以要進行有些運算的時候的，需要用到類型轉換。

• 低-------------------------------> 高 byte, short,char-> int -> long-> float -> double

• 運算中，不同類型的數據先轉化為同一類型，然后進行運算。

  • 強制類型轉換

    高-->低

  • 自動類型轉換

    低-->高

注意點:

1. 不能對布爾值進行轉換

2. 不能把對象類型轉換為不相干的類型

3. 在把高容量轉換到低容量的時候，強制轉換

4. 轉換的時候可能存在內存溢出，或者精度問題!

變量

1. 變量是什么:就是可以變化的量!

2. Java是一種強類型語言,每個變量都必須聲明其類型。

3. Java變量是程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域。

   type varName [=value] [{,varName[=value]}] ;
   //數據類型變量名 =值;可以使用逗號隔開來聲明多個同類型變量。

4. 注意事項:

• 每個變量都有類型，類型可以是基本類型，也可以是引用類型。

• 變量名必須是合法的標識符。

• 變量聲明是一條完整的語句，因此每一個聲明都必須以分號結束

public class demo01 {
    //類變量static
    static double salary = 2500;
    //屬性:變量
    //實例變量:從屬於對象;如果不自行初始化，這個類型的默認值 0.0
    //布爾值:默認是false
    //除了基本類型，其余的默認值都是nulL;
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部變量;必須聲明和初始化值
        int i=10;
        System.out. println(i);
        //變量類型變量名字 = new Demo08();
        demo01 demo01 = new demo01();
        System. out. println(demo01.age);
        System. out . println(demo01. name);
        //類變量static
        System.out. println(salary);
   }
    //其他方法
    public void add(){
   }
}

常量

常量(Constant)： 初始化(initialize)后不能再改變值!不會變動的值。

所謂常量可以理解成一種特殊的變量,它的值被設定后,在程序運行過程中不允許被改變.

final常量名=值;
final double PI=3.14;

常量名一般使用大寫字符。

變量的命名規范

1. 所有變量、方法、類名：見名知義 類成員變量:首字母小寫和駝峰原則: monthSalary 局部變量:首字母小寫和駝峰原則 常量:大寫字母和下划線: MAX_ VALUE 類名:首字母大寫和駝峰原則: Man, GoodMan 方法名:首字母小寫和駝峰原則: run(), runRun()

2. 類成員變量:首字母小寫和駝峰原則: monthSalary

3. 局部變量:首字母小寫和駝峰原則

4. 常量:大寫字母和下划線: MAX_ VALUE

5. 類名:首字母大寫和駝峰原則: Man, GoodMan

6. 方法名:首字母小寫和駝峰原則: run(), runRun()

運算法

1. 算術運算符

   short+bety+long+int-->存在long為long，否則結果為int

   存在double則為double

2. a++、++a

   int b = a++; //執行完這行代碼后， 先給b賦值，再自增
   int c = ++a; ////執行完這行代碼前， 先自增，再給b賦值
   ​

3. 位運算符

   <<、>>效率極快

4. 字符串連接符+

   System . out .println("" +a+b);//""先和a拼接，在和b拼接，a+b不進行算術運算
   System . out. println(a+b+"");//a+b先進行算術運算，在和""拼接
   ​

包機制

1. 為了更好地組織類，Java 提供了包機制，用於區別類名的命名空間。

2. 包語句的語法格式為:

   package pkg1[. pkg2[. pk...]];

3. 一般利用公司域名倒置作為包名;

4. 為了能夠使用某一個包的成員，我們需要在Java程序中明確導入該包。使用"import"語句可 完成此功能

   import package1[. package..].(classname |*);

Java Doc

1. javadoc命令是用來生成自己API文檔的

2. 參數信息

   • @author作者名

   • @version 版本號

   • @since 指明需要最早使用的jdk版本

   • @param參數名

   • @return 返回值情況

   • @throws 異常拋出情況

Java流程控制

Scanner對象

1. 之前我們學的基本語法中我們並沒有實現程序和人的交互，但是Java給我們提供了這樣一個工具類,我們可以獲取用戶的輸入。java.util.Scanner 是Java5的新特征，我們可以通過Scanner類來獲取用戶的輸入。

2. 基本語法:

   Scanner S = new Scanner( System. in);

3. 通過Scanner類的next()與nextLine()方法獲取輸入的字符串，在讀取前我們一般需要使用hasNext()與hasNextLine()判斷是否還有輸入的數據。

   • next()和hasNext()

     public class Demo02_Scanner {
         public static void main(String[] args) {
             //創建一個掃描器對象，用於接收鍵盤數據
             Scanner scanner = new Scanner(System.in);
             System.out.println("使用next方式接收: ");
             //判斷用戶有沒有輸入字符串
             if (scanner.hasNext()){
                 //使用next方式接收
                 String str = scanner.next();//程序會等待輸入內容，不輸入會卡在這里
                 System.out.println("輸出的內容為: "+str);
            }
             //凡是屬於IO流的類如果不關閉會一直占用資源.要養成好習慣用完就關掉
             scanner.close();
        }
     }

   • nextLine()和hasNextLine()

     public class Demo02_Scanner {
         public static void main(String[] args) {
             Scanner scanner = new Scanner(System.in);
             System.out.println("使用nextLine方式接收: ");
             //判斷是否還有輸入
             if (scanner.hasNextLine()) {
                 String str = scanner.nextLine();
                 System.out.println("輸出的內容為: " + str);
            }
             scanner.close();
        }
     }

   • next():

     • 一定要讀取到有效字符后才可以結束輸入。

     • 對輸入有效字符之前遇到的空白，next() 方法會自動將其去掉。

     • 只有輸入有效字符后才將其后面輸入的空白作為分隔符或者結束符。

     • next() 不能得到帶有空格的字符串。

   • nextLine():

     • 以Enter為結束符,也就是說nextLine()方法返回的是輸入回車之前的所有字符。

     • 可以獲得空白。

4. 使用語法

   public class Demo02_Scanner {
       public static void main(String[] args) {
     Scanner scanner = new Scanner(System. in);
       System.out.println("請輸入數據: ");
     String str = scanner.nextLine( );
     System.out .println( "輸出的內容為: "+str);
     scanner.close();
      }
   }

5. 其他hasNextInt()和hasNextFloat()

   public class Demo03_Scanner {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
           //從鍵盤接收數據
           int i = 0;
           float f = 0.0f;
           System.out.println("請輸入整數: ");
           if (scanner.hasNextInt()) {
               i = scanner.nextInt();
               System.out.println("整數數據: " + i);
          } else {
               System.out.println("輸入的不是整數數據! ");
          }
           System.out.println("請輸入小數: ");
           if (scanner.hasNextFloat()) {
               f = scanner.nextFloat();
               System.out.println("小數數據: " + f);
          } else {
               System.out.println("輸入的不是小數數據! ");
          }
           scanner.close();
      }
   }

6. 輸入多個數字，並求其總和與平均數

import java.util.Scanner;
​
public class Demo04_Scanner {
    public static void main(String[] args) {
        //我們可以輸入多個數字，並求其總和與平均數，每輸入一個數字用回車確認，通過輸入非數字來結束輸入並輸出執行結果:
        Scanner scanner = new Scanner(System.in);
        double sum = 0;
        int m = 0;
        //通過循環判斷是否還有輸入，並在里面對每-次進行求和和統計
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m=m+1; //m++
            sum=sum+x;
            System.out.println("你輸入了第"+m+"個數據，然后當前結果sum=" +sum) ;
       }
        System.out.println(m + "個數的和為" + sum);
        System.out.println(m +"個數的平均值是" + (sum / m));
        scanner.close();
   }
}

switch多選擇結構

1. 多選擇結構還有一個實現方式就是switch case語句。

2. switch case語句判斷一個變量與一系列值中某個值是否相等,每個值稱為一個分支。

3. switch 語句中的變量類型可以是:

   • byte、short, int 或者char.

   • 從JavaSE7開始，switch支持字符串String類型了

     • 字符的本質是數字

     • java文件

     public class Demo05_Switch {
         public static void main(String[] args) {
             String name = "狂神";
             switch (name){
                 case "秦疆":
                     System.out.println("秦疆");
                     break;
                 case "狂神":
                      System.out.println("狂神");
                      break;
                 default :
                     System.out.println("弄啥嘞! ");
            }
        }
     }
     ​

     • class文件（hashCode()）

       //
       // Source code recreated from a .class file by IntelliJ IDEA
       // (powered by Fernflower decompiler)
       //
       ​
       package com.base;
       ​
       public class Demo05_Switch {
          public Demo05_Switch() {
          }
       ​
          public static void main(String[] args) {
              String name = "狂神";
              byte var3 = -1;
              switch(name.hashCode()) {
              case 941788:
                  if (name.equals("狂神")) {
                      var3 = 1;
                  }
                  break;
              case 997472:
                  if (name.equals("秦疆")) {
                      var3 = 0;
                  }
              }
       ​
              switch(var3) {
              case 0:
                  System.out.println("秦疆");
                  break;
              case 1:
                  System.out.println("狂神");
                  break;
              default:
                  System.out.println("弄啥嘞! ");
              }
       ​
          }
       }

   • 同時case標簽必須為字符串常量或字面量。

增強for循環

1. 這里我們先只是見一面，做個了解，之后數組我們重點使用

2. Java5引入了一種主要用於數組或集合的增強型for循環。

3. Java增強for循環語法格式如下:

   for(聲明語句:表達式)
   {
   //代碼句子
   }

   • 聲明語句:聲明新的局部變量，該變量的類型必須和數組元素的類型匹配。其作用域限定在循 環語句塊，其值與此時數組元素的值相等。

   • 表達式:表達式是要訪問的數組名,或者是返回值為數組的方法。

public class Demo06_Foreach {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50}; //定義了一個數組
        //遍歷數組的元素
        for (int x: numbers){
            System.out.println(x);
       }
   }
}

break continue

1. break在任何循環語句的主體部分，均可用break控制循環的流程。break用於強行退出循環，不執行循環中剩余的語句。(break語句也在switch語句中使用)

2. continue語句用在循環語句體中，用於終止某次循環過程，即跳過循環體中尚未執行的語句,接着進行下一次是否執行循環的判定。

3. 關於goto關鍵字 goto關鍵字很早就在程序設計語言中出現。盡管goto仍是Java的- 個保留字，但並未在語言中得到正式使用; Java沒有goto。然而，在break和continue這兩個關鍵字的身上，我們仍然能看出一些goto的影子——帶標簽的break和continue.

   • "標簽" 是指后面跟一個冒號的標識符，例如: label:

   • 對Java來說唯一 用到標簽的地方是在循環語句之前。 而在循環之前設置標簽的唯一理由是:我們希望在其中嵌套另一個循環，由於break和continue關鍵字通常只中斷當前循環，但若隨同標簽使用，它們就會中斷到存在標簽的地方。

public class Demo07_Label {
    public static void main(String[] args) {
        //打101- 150之問所有的質數
        int count = 0;
        //不建議使用!
        outer:for (int i = 101;i < 150;i++){
            for (int j = 2; j < i/2;j++){
                if (i %j== 0){
                    continue outer;
               }
           }
            System.out.print(i+" ");
       }
   }
}

方法

何謂方法?

1. System.out.println(), 那么它是什么呢?

2. Java方法是語句的集合，它們在一起執行一個功能。

   • 方法是解決一類問題的步驟的有序組合

   • 方法包含於類或對象中

   • 方法在程序中被創建， 在其他地方被引用

3. 設計方法的原則:方法的本意是功能塊，就是實現某個功能的語句塊的集合。我們設計方法的時候，最好保持方法的原子性，就是一個方法只完成1個功能，這樣利於我們后期的擴展。

4. 回顧：方法的命名規則?

方法的定義

1. Java的方法類似於其它語言的函數，是-段用來完成特定功能的代碼片段，一般情況下，定義一個方法包含以下語法:

   • 方法包含一個方法頭和一個方法體。下面是一個方法的所有部分:

   • 修飾符：修飾符,這是可選的，告訴編譯器如何調用該方法。定義了該方法的訪問類型。

   • 返回值類型:方法可能會返回值。returnValueType 是方法返回值的數據類型。有些方法執行所需的操作，但沒有返回值。在這種情況下，returnValueType 是關鍵字void。

   • 方法名:是方法的實際名稱。方法名和參數表共同構成方法簽名。

   • 參數類型:參數像是一個占位符。當方法被調用時，傳遞值給參數。這個值被稱為實參或變量。參數列表是指方法的參數類型、順序和參數的個數。參數是可選的，方法可以不包含任何參數。

     • 形式參數:在方法被調用時用於接收外界輸入的數據。

     • 實參:調用方法時實際傳給方法的數據。

   • 方法體:方法體包含具體的語句，定義該方法的功能。

     修飾符 返回值 類型 方法名(參數類型參數名){
      方法體
      return返回值; 
     }
     ​

方法調用

1. 調用方法:對象名.方法名(實參列表)

2. Java支持兩種調用方法的方式，根據方法是否返回值來選擇。

   • 當方法返回一個值的時候，方法調用通常被當做一個值。例如: int larger = max(30，40);

   • 如果方法返回值是void,方法調用一定是一條語句。 System. out. println( "Hello, kuangshen!");

3. 課后拓展了解：值傳遞（Java）和引用傳遞

方法的重載

1. 重載就是在一個類中，有相同的函數名稱，但形參不同的函數。

2. 方法的重載的規則:

   • 方法名稱必須相同。

   • 參數列表必須不同(個數不同、或類型不同、參數排列順序不同等)。

   • 方法的返回類型可以相同也可以不相同。

   • 僅僅返回類型不同不足以成為方法的重載。

3. 實現理論:

   方法名稱相同時,編譯器會根據調用方法的參數個數、參數類型等去逐個匹配，以選擇對應的方法，如果匹配失敗，則編譯器報錯。

命令行傳參

有時候你希望運行一個程序時候再傳遞給它消息。這要靠傳遞命令行參數給main()函數實現。

public class CommandLine {
 public static void main(String args[]){
  for(int i=0; i<args.length; i++){
   System. out. println("args["+ i + "]:"+ args[i]);
  }
 }
}

可變參數

1. JDK 1.5開始，Java支持傳遞同類型的可變參數（不定項）給一個方法。

2. 在方法聲明中，在指定參數類型后加一個省略號(..)。

3. 一個方法中只能指定一個可變參數，它必須是方法的最后一個參數。任何普通的參數必須在它之前聲明。

public class Demo08 {
    public static void main(String args[]) {
        //調用可變參數的方法
        printMax(15,22.0,36,25.3);
        printMax(new double[]{1, 2, 3});//本質為數組
​
   }
    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
       }
        double result = numbers[0];
        //排序!
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
           }
       }
        System.out.println("The max value is " + result);
   }
}

遞歸（能不用就不用）

1. 遞歸就是: A方法調用A方法!就是自己調用自己

2. 利用遞歸可以用簡單的程序來解決一些復雜的問題。 它通常把一個大型復雜的問題層層轉化為-個與原問題相似的規模較小的問題來求解，遞歸策略只需少量的程序就可描述出解題過程所需要的多次重復計算，大大地減少了程序的代碼量。遞歸的能力在於用有限的語句來定義對象的無限集合。

3. 遞歸結構包括兩個部分:

   • 遞歸頭：什么時候不調用自身方法。如果沒有頭，將陷入死循環。

   • 遞歸體：什么時候需要調用自身方法。

Java數組

數組的定義

1. 數組是相同類型數據的有序集合.

2. 數組描述的是相同類型的若干個數據,按照一定的先后次序排列組合而成。

3. 其中,每一個數據稱作一個數組元素,每個數組元素可以通過一個下標來訪問它們.

數組聲明創建

1. 首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法:

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

2. Java語言使用new操作符來創建數組，語法如下:

   dataType[] arrayRefVar = new dataType[arraySize] ;

3. 數組的元素是通過索引訪問的,數組索引從0開始。

   • 獲取數組長度：arrays . length

int[] nums; //1.聲明-一個數組
nums = new int[10]; //2. 創建一個數組
nums[0] = 1;//3.給數組元素中賦值

內存分析

三種初始化

1. 靜態初始化

   int[] a = {1,2,3};
   Man[] mans = {new Man(1,1) , new Man(2,2)};

2. 動態初始化

   int[] a = new int[2]; 
   a[0]=1;
   a[1]=2;

3. 數組的默認初始化

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

數組的四個基本特點

1. 其長度是確定的。數組一旦被創建，它的大小就是不可以改變的。

2. 其元素必須是相同類型,不允許出現混合類型。

3. 數組中的元素可以是任何數據類型，包括基本類型和引用類型。

4. 數組變量屬引用類型，數組也可以看成是對象，數組中的每個元素相當於該對象的成員變量。

5. 數組本身就是對象，Java中對象是在堆中的，因此數組無論保存原始類型還是其他對象類型,數組對象本身是在堆中的。

小結:

1. 數組是相同數據類型(數據類型可以為任意類型)的有序集合

2. 數組也是對象。數組元素相當於對象的成員變量

3. 數組長度的確定的，不可變的。如果越界，則報: ArrayIndexOutofBounds

數組使用

1. For-Each循環

   public class Demo09_Array {
       public static void main(String[] args) {
           int[] arrays = {1,2,3,4,5};
           //JDK1.5,沒有下標
           for (int array : arrays) {
               System.out.println(array);
          }
      }
   }

2. 數組作方法入參

   public class Demo09_Array {
       public static void main(String[] args) {
           int[] arrays = {1,2,3,4,5};
           printArray(arrays);
      }
       //打印數組元素
       public static void printArray(int[] arrays){
           for (int i = 0; i < arrays.length; i++) {
               System.out.print(arrays[i]+" ");
          }
      }
   }
   ​

3. 數組作返回值

   public class Demo09_Array {
       public static void main(String[] args) {
           int[] arrays = {1,2,3,4,5};
           int[] reverse = reverse( arrays);
           printArray(reverse);
      }
       //反轉數組
       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 printArray(int[] arrays){
           for (int i = 0; i < arrays.length; i++) {
               System.out.print(arrays[i]+" ");
          }
      }
   }

多維數組

1. 多維數組可以看成是數組的數組，比如維數組就是一個特殊的一維數組，其每一個元素都是一個一維數組。

2. 二維數組

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

   • 解析：二維數組a可以看成一個兩行三列的數組。

3. 思考：多維數組的使用?

Arrays類

1. 數組的工具類java.util.Arrays

2. 由於數組對象本身並沒有什么方法可以供我們調用,但API中提供了-一個工具類Arrays供我們使用,從而可以對數據對象進行一些基本的操作。

   查看JDK幫助文檔

3. Arrays類中的方法都是static修飾的靜態方法,在使用的時候可以直接使用類名進行調用,而"不用"使用對象來調用(注意:是"不用"而不是"不能")

   • 具有以下常用功能：

   • 給數組賦值：通過fill方法。

   • 對數組排序：通過sort方法,按升序。

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

   • 比較數組：通過equals方法比較數組中元素值是否相等。

   • 查找數組元素： 通過binarySearch方法能對排序好的數組進行二分查找法操作。

package com.base;
import java.util.Arrays;
public class Demo10_Arrays {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 9090, 31231, 543, 21, 3, 23};
        System.out.println(a); // 數組對象的hashcode [I@4554617c
        //打印數組元素Arrays.tostring
        System.out.println(Arrays.toString(a));
        printArray(a);
   }
 //自己編寫打印數組的方法
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
           }
            if (i == a.length - 1) {
                System.out.print(a[i] + "]");
           } else {
                System.out.print(a[i] + ", ");
           }
       }
   }
}

冒泡排序

1. 冒泡排序無疑是最為出名的排序算法之一， 總共有八大排序!

2. 冒泡的代碼還是相當簡單的，兩層循環，外層冒泡輪數，里層依次比較，江湖中人人盡皆知。

3. 我們看到嵌套循環，應該立馬就可以得出這個算法的時間復雜度為0(n2)。

   import java.util.Arrays;
   //1. 比較數組中，兩個相鄰的元素，如果第一個數比第二個數大，我們就交換他們的位置
   //2. 每一次比較，都會產生出一個最大，或者最小的數字;
   //3. 下一輪則可以少一次排序!
   //4. 依次循環，直到結束!
   public class Demo11 {
       public static void main(String[] args) {
           int[] a = {1, 4, 5, 6, 72, 2, 2, 2, 25, 6, 7};
           int[] sort = sort(a); //調用完我們自己寫的排序方法以后，返回一個排序后的數組
           System.out.println(Arrays.toString(sort));
      }
       public static int[] sort(int[] array) {
           //臨時變量
           int temp = 0;
           //外層循環，判斷我們這個要走多少次;
           for (int i = 0; i < array.length - 1; i++) {
               Boolean flag = false;
               //內層循環，比價判斷兩個數，如果第一個數，比第二個數大,則交換位置
               for (int j = 0; j < array.length - 1 - i; j++) {
                   if (array[j + 1] > array[j]) {
                       temp = array[j];
                       array[j] = array[j + 1];
                       array[j + 1] = temp;
                       flag = true;
                  }
              }
               if (flag == false){
                   break;
              }
          }
           return array;
      }
   }

稀疏數組介紹

1. 當一個數組中大部分元素為0,或者為同一-值的數組時，可以使用稀疏數組來保存該數組。

2. 稀疏數組的處理方式是:

   • 記錄數組一共有幾行幾列，有多少個不同值

   • 把具有不同值的元素和行列及值記錄在一個小規模的數組中，從而縮小程序的規模

public class Demo12_Sparse {
    public static void main(String[] args) {
        //創建一個元素的二維數組 11*11 0：沒有棋子 1： 黑棋   2： 白棋
        int chessArry1[][] = new int[11][11];
        chessArry1[1][2] = 1;
        chessArry1[2][3] = 2;
        for (int [] row : chessArry1) {
            for ( int data : row) {
                System.out.printf("%d\t", data);
           }
            System.out.println();
       }
        int[][] paraseArr =  transformSparseArr(chessArry1);
        transformArry(paraseArr);
   }
    //二維數組 轉 稀疏數組
    public static int[][] transformSparseArr( int[][] arry) {
        int sum =0;  // 有效值的個數
        int rowSize = 0;
        //1、計算出有效的個數
        for (int[] row :arry) {
            for ( int data :row) {
                rowSize = row.length;
                if (data != 0) {
                    sum++;
               }
           }
       }
        //創建稀疏數組 並給稀疏數組賦值
        int [][] sparseArr= new int[sum+1][3];
        sparseArr [0][0] = arry.length;
        sparseArr [0][1] = rowSize;
        sparseArr [0][2] = sum;
        //count 計數器 計算放入的有效個數 即第幾個非零數據
        int count = 0;
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < rowSize ; j++) {
                if (arry[i][j] != 0) {
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = arry[i][j];
               }
           }
       }
        // 輸出稀疏數組形式
        System.out.println("===========稀疏數組============");
        for (int i = 0; i < sparseArr.length; i++) {
            // %d 占位符 \t 制表符 \n 換行
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
       }
        System.out.println();
        return sparseArr;
   }
    // 稀疏數組 轉化為 二維數組
    public static int[][] transformArry(int[][] parseArr) {
        int row = parseArr[0][0]; //得到行
        int col = parseArr[0][1]; //得到列
        //數組恢復 並賦值
        int[][] arry = new int[row][col];
        for (int i = 1 ; i < parseArr.length; i++) {
            arry[parseArr[i][0]][parseArr[i][1]] = parseArr[i][2];
       }
        // 輸出
        System.out.println("============二維數組恢復==============");
        for (int [] rows: arry) {
            for (int data : rows) {
                System.out.printf("%d\t", data);
           }
            System.out.println();
       }
        return arry;
   }
}