java byte轉int_java基礎知識

1 寫在前面

JVM + 核心類庫 = JRE + 編譯器等開發工具 = JDK

Java環境變量的配置 : 計算機 -> 屬性-> 進階系統設定 -> 系統變量 -> 建立系統變量

JAVA_HOME : 選擇Java工具包的bin目錄的上一級目錄

Path : %JAVA_HOME%bin

Java程式開發三步驟 : 編寫, 編譯, 運作

編譯 : javac.exe 編譯器 運作 : java.exe 解釋器

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

// 先 javac HelloWorld.java, 再 java HelloWorld
           

2 辨別符的概念及規則

• 辨別符 : 在程式中,我們自己定義的内容; 比如類, 方法, 變量的 名字 都稱為辨別符
• 命名規則 :

  硬性要求

  • 辨別符可以包含

    英文字母26個(區分大小寫),0-9數字,$(美元符号) 和 _(下劃線)

  • 辨別符不能以數字開頭
  • 辨別符不能是已有的關鍵字

• 命名規範 :

  軟性建議

  • 類名規範 : 首字母大寫, 後面每個單詞首字母大寫 (大駝峰式)
  • 變量名規範 : 首字母小寫, 後面每個單詞首字母大寫 (小駝峰式)
  • 方法名規範 : 同變量名規範

3 常量

定義 : 是指在Java程式運作期間固定不變的資料

| 類型 | 含義 | 資料舉例 | | ---------- | ---------------------------------------- | ---------------- | | 整數常量 | 所有的整數 | 0, 1 , 5, -5 | | 浮點數常量 | 所有的小數 | 1.4 , 0.0, -4.9 | | 字元常量 | 單引号引起來的,隻能寫一個字元,必須有内容 | 'a', ‘好’ | | 字元串常量 | 雙引号引起來的,可以寫多個, 可以不寫 | 'aaaaa', 'Hello’ | | 布爾常量 | 兩個值 | true, fasle | | 空常量 | 一個值; 空常量不能直接用來列印輸出 | null |

System.out.println(5);
System.out.println(5.0);
System.out.println('5');
System.out.println("admin);
           

4 資料基本類型

Java資料類型分為兩大類 : 基本資料類型 和 引用資料類型

基本資料類型 : 整數, 浮點數, 字元, 布爾這四大類 又可分為八種

引用資料類型 : 字元串, 類, 數組, 接口, Lambda

| 資料類型 | 關鍵字 | 記憶體占用 | 取值範圍 | | ------------ | ------- | ------------- | ------------------------ | | 位元組型 | byte | 1個位元組 | -128 ~127 | | 短整型 | short | 2 個位元組 | -32768 ~ 32767 | | 整型 | int | 4個位元組(預設) | -2的31次方 ~ 2的31次方-1 | | 長整型 | long | 8個位元組 | -2的63次方 ~ 2的63次方-1 | | 單精度浮點數 | float | 4個位元組 | 1.4013E-45 ~ 3.4028E+38 | | 雙精度浮點數 | double | 8個位元組 | 4.9E-324~1.7977E+308 | | 字元 | char | 2個位元組 | 0-65535 | | 布爾 | boolean | 1個位元組 | true, false |

注意事項 :

1. 字元串不是基本類型, 而是引用類型
2. 浮點型可能是一個近似值, 并非精确的值
3. 資料範圍與位元組數不一定相關, 例如float資料範圍比long更加廣泛,但是float是4個位元組,long是8個位元組
4. 浮點數當中預設類型是double,如果一定要使用float類型, 需要加上一個字尾F, 推薦使用大寫字母字尾
5. 如果是整數, 預設是int類型, 如果一定要使用long類型, 需要加上一個字尾F, 推薦使用大寫字母字尾

5 變量

定義 : 在程式運作期間可以變化的量稱為變量

Java中要求一個變量每次隻能儲存一個資料, 且必須要明确儲存變量的資料類型

變量定義的格式包括三個要素： 資料類型 、 變量名 、 資料值 。

資料類型 變量名稱 = 資料值; // 建立了一個變量,并将資料值指派給變量

注意事項 :

1. 如果建立多個變量, 變量之間的名稱不可以重複
2. 對于float和long類型來說, 字母字尾F和L不要丢掉
3. 如果使用byte或者short類型的變量, 那麼右側的資料值不能超過左側類型的範圍
4. 沒有進行指派的變量, 不能直接使用; 一定要指派之後, 才能使用
5. 變量的使用不能超過作用域的範圍[作用域: 從定義變量的一行開始, 一直到直接所屬的大括号為止]

6 資料類型轉換

自動類型轉化 -- 隐式轉換

将取值小的範圍自動提升為取值範圍大的類型, 比如:一個int類型與byte位元組類型相加運算是int類型

public static void main(String[] args){
        int i = 1;
        byte b = 2;
        // byte x = b + i; // 報錯 
        // int類型和byte類型運算，結果是int類型 
        int j = b + i; 
        System.out.println(j);
}
           

同樣道理當一個 int 類型變量和一個double 變量運算時，int 類型将會自動提升為 double 類型進行運算。

public static void main(String[] args) {
    int i = 1; 
    double d = 2.5; 
    //int類型和double類型運算，結果是double類型 
    // int類型會提升為double類型
    double e = d+i;
    System.out.println(e);
 }
           

轉換規則 :範圍小的類型向 範圍大的類型提升; byte, short ,char 運算時直接提升為 int

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

強制類型轉換 -- 顯式轉換

将 1.5 指派到 int 類型變量會發生什麼? 産生編譯失敗, 肯定無法指派

int i = 1.5
// // 錯誤 double 類型記憶體8個位元組， int 類型記憶體4個位元組。 1.5 是 double 類型，取值範圍大于 int 。可以了解為 double 是8 升的水壺， int 是4升的水壺，不能把大水壺中的水直接放進小水壺去。 想要指派成功，隻有通過強制類型轉換，将 double 類型強制轉換成 int 類型才能指派。
           

強制類型轉換：将取值範圍大的類型 強制轉換成 取值範圍小的類型 。 比較而言，自動轉換是Java自動執行的，而強制轉換需要我們自己手動執行。

轉換格式 : 資料類型 (範圍小) 變量名 (範圍小) = (資料類型 -- 範圍小) 被轉資料值(範圍大);

int i = (int) 1.5;

public static void main(String[] args) { 
    //short類型變量，記憶體中2個位元組 
    short s = 1;
    /*出現編譯失敗 s和1做運算的時候，1是int類型，s會被提升為int類型 s+1後的結果是int類型，将結果在指派會short類型時發生錯誤 short記憶體2個位元組，int類型4個位元組 必須将int強制轉成short才能完成指派 */
    s = s + 1;//編譯失敗 
    s = (short) (s+1);//編譯成功 
}
           

注意事項 :

1. 強制類型轉換一般不推薦使用, 有可能發生精度損失, 資料溢出

7 ASCII編碼表

public static void main(String[] args){
    // 字元類型變量
    char c = 'a';
    int i = 1;
    // 字元類型和int類型計算
    System.out.println(c+i);  //輸出結果為98
}
           

| 字元 | 數值 | | :--- | :--- | | 0 | 48 | | 9 | 57 | | A | 65 | | Z | 90 | | a | 97 | | z | 122 |

在char類型和int類型計算的過程中，char類型的字元先查詢編碼表，得到97，再和1求和，結果為98。 char類型提升 為了int類型。char類型記憶體2個位元組，int類型記憶體4個位元組。

8 運算符

算數運算符

| 算數運算符包括： | | | :--------------- | :--------------------------- | | + | 加法運算，字元串連接配接運算 | | - | 減法運算 | | * | 乘法運算 | | / | 除法運算 | | % | 取模運算，兩個數字相除取餘數 | | ++、— | 自增自減運算 |

Java中, 整數使用以上運算符 ,無論怎麼計算, 也不會得到小數

public static void main(String[] args) { 
    int i = 1234;
    System.out.println(i/1000*1000);//計算結果是1000
}
           

一切基本資料類型與 String字元串用 + 都是拼接形成新的 字元串

自增運算符 : ++

自減運算符 : --

使用格式 : 寫在變量名稱之前, 字尾寫在變量名稱之後, 例如: ++num, 也可以num++

使用方式 :

​ 單獨使用 : ++num, num++ 沒有任何差別

​ 混合使用 :

​ A - 如果是前++ ,那麼變量立刻馬上+1,然後拿着結果使用 [先加後用]

​ B - 如果是後++,那麼使用變量本來的數值,然後再讓變量+1 [先用後加]

注意事項 : 隻有變量才能使用自增, 自減運算符; 常量不可改變, 是以不能用

指派運算符

| 指派運算符包括： | | | :--------------- | :----- | | = | 等于号 | | += | 加等于 | | -= | 減等于 | | *= | 乘等于 | | %= | 取模等 | | /= | 除等于 |

指派運算符 : 就是将符号左邊的值, 賦給左邊的變量

public static void main(String[] args){ 
    int i = 5; 
    i+=5;//計算方式 i=i+5 變量i先加5，再指派變量i 
    System.out.println(i); //輸出結果是10
}
           

比較運算符

| 比較運算符包括： | | | :--------------- | :----------------------------------------------------------- | | == | 比較符号兩邊資料是否相等，相等結果是true。 | | > | 比較符号左邊的資料是否大于右邊的資料，如果大于結果是true。 | | < | 比較符号左邊的資料是否小于右邊的資料，如果小于結果是true。 | | >= | 比較符号左邊的資料是否大于或者等于右邊的資料，如果小于結果是true。 | | <= | 比較符号左邊的資料是否小于或者等于右邊的資料，如果小于結果是true。 | | != | 不等于符号 ，如果符号兩邊的資料不相等，結果是true。 |

比較運算符 : 兩個資料之間比較的運算, 運算結果都是布爾值 true 或者 false

邏輯運算符

| 邏輯運算符包括： | | | :--------------- | :----------------------------------------------------------- | | && 短路與 | 1. 兩邊都是true，結果是true 2. 一邊是false，結果是false 短路特點：符号左邊是false，右邊不再運算 [全真為真] | | ！ 取反 | 1. ! true 結果是false 2. ! false結果是true | | || 短路或 | 1. 兩邊都是false，結果是false 2. 一邊是true，結果是true 短路特點： 符号左邊是true，右邊不再運算。 [一真為真] |

三元運算符

運算法則 : 資料類型 變量名 = 布爾類型表達式 ? 結果1 : 結果2

當布爾類型表達式值為true, 取結果1指派給變量 ; 否則即當布爾類型表達式值為false, 取結果2指派給變量;

9 JDK的JShell的簡單使用

當我們編寫的代碼非常少的時候, 而又不願意編寫類, main方法, 也不願意去編譯和運作,就要使用JShell指令

在cmd當中 輸入 jshell進入,,,,,,,輸入 /exit 退出指令

編譯器的的優化 :

• 對于 byte/short/char 三種類型來說, 如果右側指派的數值沒有超過範圍, 那麼javac編譯器将會自動隐含地(強轉)為我們補上一個(byte)(short)(char); 如果右側超過了左側的範圍, 那麼直接編譯報錯
• 在給變量指派的時候, 如果右側的表達式當中全都是常量, 沒有任何變量, 那麼編譯器javac 将會直接将若幹個常量表達式計算得到結果; short = 5 + 8; // 等号右邊全都是常量, 沒有任何變量參與運算編譯之後, 得到的.class 位元組碼檔案當中相當于[直接就是] : short result = 13;右側的常量結果數值, 沒有超過左側範圍, 是以正确; 這稱之為"編譯器的常量優化"

10 流程控制

順序結構

在一個程式執行的過程中，各條語句的執行順序對程式的結果是有直接影響的。也就是說，程式的流程對運作結果 有直接的影響。是以，我們必須清楚每條語句的執行流程。而且，很多時候我們要通過控制語句的執行順序來實作 我們要完成的功能。

public static void main(String[] args){
//順序執行，根據編寫的順序，從上到下運作
System.out.println(1);
System.out.println(2);
System.out.println(3);
}
           

判斷語句

if

if(關系表達式)｛
語句體;
｝



public static void main(String[] args){
    System.out.println("開始");
    // 定義兩個變量
    int a = 10;
    int b = 20;
    //變量使用if判斷
    if (a == b){
    System.out.println("a等于b");
    }
    int c = 10;
    if(a == c){
    System.out.println("a等于c");
    }
    System.out.println("結束");
｝
           

執行流程 :

1. 首先判斷關系表達式看其結果是true還是false
2. 如果是true就執行語句體
3. 如果是false就不執行語句體

if.....else

if(關系表達式) {
語句體1;
}else {
語句體2;
}
           

執行流程 :

1. 首先判斷關系表達式看其結果是true還是false
2. 如果是true就執行語句體1
3. 如果是false就執行語句體2

if ....else if ...else

if (判斷條件1) {
執行語句1;
} else if (判斷條件2) {
執行語句2;
}
...
}else if (判斷條件n) {
執行語句n;
} else {
執行語句n+1;
}
           

執行流程 :

1. 首先判斷關系表達式1看其結果是true還是false
2. 如果是true就執行語句體1
3. 如果是false就繼續判斷關系表達式2看其結果是true還是false
4. 如果是true就執行語句體2
5. 如果是false就繼續判斷關系表達式…看其結果是true還是false
6. …
7. 如果沒有任何關系表達式為true，就執行語句體n+1。

public static void main(String[] args) {
    // x和y的關系滿足如下：
    // x>=3 y = 2x + 1;
    //‐1<=x<3 y = 2x;
    // x<=‐1 y = 2x – 1;
    // 根據給定的x的值，計算出y的值并輸出。
    // 定義變量
    int x = 5;
    int y;
    if (x>= 3) {
    y = 2 * x + 1;
    } else if (x >= ‐1 && x < 3) {
    y = 2 * x;
    } else {
    y = 2 * x ‐ 1;
    }
    System.out.println("y的值是："+y);
}
           

選擇語句

switch(表達式) {
    case 常量值1:
    語句體1;
    break;
    case 常量值2:
    語句體2;
    break;
    ...
    default:
    語句體n+1;
    break;
}
           

執行流程 :

1. 首先計算出表達式的值
2. 其次，和case依次比較，一旦有對應的值，就會執行相應的語句，在執行的過程中，遇到break就會結 束。
3. 最後，如果所有的case都和表達式的值不比對，就會執行default語句體部分，然後程式結束掉。

public static void main(String[] args) {
    //定義變量，判斷是星期幾
    int weekday = 6;
    //switch語句實作選擇
    switch(weekday) {
    case 1:
    System.out.println("星期一");
    break;
    case 2:
    System.out.println("星期二");
    break;
    case 3:
    System.out.println("星期三");
    break;
    case 4:
    System.out.println("星期四");
    break;
    case 5:
    System.out.println("星期五");
    break;
    case 6:
    System.out.println("星期六");
    break;
    case 7:
    System.out.println("星期日");
    break;
    default:
    System.out.println("你輸入的數字有誤");
    break;
    }
}
           

switch語句中, 表達式的資料類型 ,可以是byte, short, int ,char ,enum(枚舉), 還可以是字元串

循環語句

循環語句可以在滿足循環條件的情況下, 反複執行某一段代碼, 這段被重複執行的代碼被稱為循環體語句, 當反複執行這個循環體時, 需要在合适的時候把循環判斷條件修改為false, 進而結束循環, 否則循環将一直執行下去, 形成死循環

for循環語句表達式

for(初始化表達式①; 布爾表達式②; 步進表達式④){
    循環體③
}
           

執行流程 :

執行順序：①②③④>②③④>②③④…②不滿足為止。

①負責完成循環變量初始化

②負責判斷是否滿足循環條件，不滿足則跳出循環

③具體執行的語句

④循環後，循環條件所涉及變量的變化情況

public static void main(String[] args) {
    //定義變量從0開始，循環條件為<10
    for(int x = 0; x < 10; x++) {
    System.out.println("HelloWorld"+x);
    }
}
循環練習：使用循環，計算1-100之間的偶數和
public static void main(String[] args) {
    //1.定義一個初始化變量,記錄累加求和,初始值為0
    int sum = 0;
    //2.利用for循環擷取1‐100之間的數字
    for (int i = 1; i <= 100; i++) {
    //3.判斷擷取的數組是奇數還是偶數
        if(i % 2==0){
        //4.如果是偶數就累加求和
        sum += i;
        }
    }
    //5.循環結束之後,列印累加結果
    System.out.println("sum:"+sum);
}
           

do.......while循環表達式

初始化表達式①
do{
循環體③
步進表達式④
}while(布爾表達式②);


輸出10次HelloWorld
public static void main(String[] args) {
    int x=1;
    do {
    System.out.println("HelloWorld");
    x++;
    }while(x<=10);
}
           

do...while循環的特點：無條件執行一次循環體，即使我們将循環條件直接寫成false，也依然會循環一次。這樣的 循環具有一定的風險性，是以初學者不建議使用do...while循環。

跳出語句

break : 終止swtich或者循環

public static void main(String[] args) {
     for (int i = 1; i<=10; i++) {
     //需求:列印完兩次HelloWorld之後結束循環
     if(i == 3){
     break;
     }
     System.out.println("HelloWorld"+i);
     }
 }
           

continue : 結束本次循環, 繼續下一次的循環

public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
    //需求:不列印第三次HelloWorld
    if(i == 3){
    continue;
    }
    System.out.println("HelloWorld"+i);
    }
}
           

死循環 : 也就是循環中的條件永遠為true，死循環的是永不結束的循環。例如：while(true){}

嵌套循環

所謂嵌套循環，是指一個循環的循環體是另一個循環。比如for循環裡面還有一個for循環，就是嵌套循環。總共的循環次數=外循環次數*内循環次數

外循環一次, 内循環多次

for(初始化表達式①; 循環條件②; 步進表達式⑦) {
    for(初始化表達式③; 循環條件④; 步進表達式⑥) {
        執行語句⑤;
    }
}
           

11 開發工具 Intellij IDEA

IDEA是一個專門針對java的內建開發工具(IDE), 由java語言編寫, 是以, 需要有JRE運作環境并配置好環境變量; 他可以極大的提升我們的開發效率, 可以自動編譯, 檢查錯誤

項目Project --> 子產品Module --> 包 Packpage

IDE的 HelloWorld 在子產品的src目錄下 建立 java class,寫上 psvm 快捷生成 main()

IDE的基本設定 : 更改自動補全為 Alt+/

IDEA常用快捷鍵

| 快捷鍵 | 功能 | | -------------------- | -------------------------------------- | |

Alt+Enter

| 導入包, 自動修正代碼 | |

Ctrl+Y

| 删除光标所在行 | |

Ctrl+D

| 複制光标所在行的内容, 插入光标位置下面 | |

Ctrl+Alt+L

| 格式化代碼 | |

Ctrl+/

| 單行注釋, 再按取消注釋 | |

cTRL+Shift+/

| 選中代碼注釋, 多行注釋, 再按取消注釋 | |

Alt+Ins

| 自動生成代碼, toString, get, set等方法 | |

Alt+Shift+上下箭頭

| 移動目前代碼行 |

删除子產品: 選中子產品delete, 或者右鍵

Remove Module

導入子產品 :

File

-->

Project Structure

-->

+

-->

import Module

--> 選擇對應的目錄-->一直next,next

12 方法

定義 : 就是将一個功能抽取出來, 把代碼單獨定義在一個大括号内, 形成一個單獨的功能;當我們需要這個功能的時候,就可以去調用, 這樣既實作了代碼的複用性, 也解決了代碼備援的現象

定義格式 :

修飾符 傳回值類型 方法名 (參數清單) {
    代碼 ...
    return ;
}

public static void main (String[] args) {
    方法體 ...
    return 傳回值;
}
           

解釋 :

• 修飾符 : 目前固定寫法

  public static

• 傳回值類型 : 目前固定寫法

  void

  , 其他傳回值會在後面接觸
• 方法名: 我們定義的方法名 : 滿足辨別符的規範, 用來調用方法
• 參數清單 :方法在運算過程中的未知資料, 調用者調用方法時傳遞
• return : 将方法執行後的結果資料帶給調用者，方法執行到 return ，整體方法運作結束
• 結果 : 方法的傳回值

注意事項 :

• 方法的定義位置在類中,在main()外面, 在 main中調用,先後順序無所謂,和調用順序有關
• 傳回值類型, 必須要和 return語句傳回的類型相同, 否則編譯失敗
• 不能用輸出語句調用 void 類型的方法; 因為方法執行後沒得結果,也不列印出任何内容
• 一個方法中可以有多個return語句,但是隻能保證同時隻能有一個被執行, return不能連寫

方法的調用方式:

• 單獨調用, 方法名稱(參數);
• 列印調用, System.out.println(Sum(3,5));
• 指派調用, 資料類型 變量名稱 = Sum(3,5);

方法的有無參數:

有參數: 小括号當中有内容, 當一個方法需要一些資料條件,才能完成任務的時候,就是有參數
例如兩數相加, 必須知道兩個數字各自是多少, 才能相加

無參數: 小括号當中留白, 一個方法不需要任何資料條件, 自己就能獨立完成任務,就是無參數
例如定義一個方法, 列印10次Helloworld
           

有無傳回值

package cn.itcast.day04.demo02;

public class Demo04Return {
    public static void main(String[] args) {
        int num = getSum(10,20);
        System.out.println("傳回值"+ num);
        System.out.println("=============");

        printSum(2,3);
    }

    public static int getSum(int a, int b){
        int res = a + b;
        return res;
    }

    public static void printSum(int a,int b){
        int res = a + b;
        System.out.println(res);
    }

}
           

getSum就是有傳回值的方法; printSum就是無傳回值的方法

練習 1 : 定義一個方法, 用來判斷兩個數字是否相同

public class Demo01MethodSame(){

public static void main(String[] args) {
    System.out.println(isSame(10,20))  // false

}

public static boolean isSame(int a,int b){
    boolean same;
    if (a == b){
        same = true;
    }else{
        same = fasle;
    }

    boolean same = a = b?true:fasle;

    boolean same = a==b

    return same;

    return a == b;
}

}
           

練習2 : 定義一個方法, 永安裡列印指定次數的HelloWorld

public class Demo03MethodPrint {

    public static void main(String[] args) {
        printCount(8);
    }

    /*
    三要素
    傳回值類型 : void
    方法名 : printCount
    參數清單 : 到底列印多少次, 告訴我幾次,就列印幾次 次數 int :num
     */

    public static void printCount(int num){
        for (int i = 0; i < num; i++) {
            System.out.println("HelloWorld" + (i+方法1));
        }

    }
}
           

方法定義的三要素 : 傳回值類型, 方法名, 參數清單 [

傳回值類型必須與return傳回的類型相同

]

方法重載

定義 : 同一個類中, 允許重載一個以上的同名方法, 隻要他們的參數清單不同即可, 與修飾符和傳回值類型無關

參數清單 : 個數不同, 資料類型不同, 順序不同

重載方法調用 : JVM通過方法的參數清單, 調用不同的方法

13 數組

定義 : 是一種容器, 可以同時存放多個資料值

特點 :

1. 數組是一種引用資料類型
2. 數組當中的多個資料, 類型必須統一
3. 數組的長度在程式運作期間不可改變

數組的建立 , 也叫做數組的初始化

1. 動态初始化(指定長度) : 在建立數組的時候, 直接指定數組當中的資料元素的個數
2. 靜态初始化(指定内容) : 在建立數組的時候, 不直接指定資料個數多少, 而是直接将具體的資料内容指定

動态初始化數組的格式 : 資料類型[] 數組名稱 = new 資料類型[數組長度];

動态初始化時數組的元素會自動擁有一個預設值, 為 0; 根據數組的類型自動擁有

靜态初始化時數組的元素會其實也會自動擁有一個預設值, 為 0; 隻不過系統馬上将預設值替換為了大括号當中的具體數值

解析含義 :

左側資料類型 : 也就是數組當中儲存的資料, 全都是統一的什麼類型

左側中的括号 : 代表我是一個數組

左側的數組名稱 : 給數組取一個名字

右側中的new : 代表建立數組的動作

右側資料類型 : 必須和左邊的資料類型保持一緻

右側括号中的長度 : 也就是數組當中, 到底可以儲存多少個資料, 是一個int數字

靜态初始化數組的格式 : 資料類型[] 數組名稱 = new 資料類型[]{元素1,元素2,元素3};

省略初始化數組的格式 : 資料類型[] 數組名稱 = {元素1,元素2,元素3};

// 直接列印數組名稱, 得到的是數組對應的, 記憶體位址的哈希值

int[] array = {10,20,30}
System.out.println(array);   // [[email protected] 十六進制
           

數組的通路

索引 : 每一個存儲到數組的元素，都會自動的擁有一個編号，從0開始，到length-1結束, 這個自動編号稱為數組索引(index)，可以通過數組的索引通路到數組中的元素。

格式 : 數組名[索引]

數組的指派 : array[索引] = 具體的數值

Java的記憶體劃分

Java的記憶體需要劃分為五個部分:

1 棧(Stack) : 存放的都是方法中的局部變量, 方法的運作一定要在棧當中; 局部變量: 方法的參數,或者是方法{}内部的變量, 作用域: 一旦超過作用域, 立刻從棧記憶體才能當中消失

2 堆(Heap) : 凡是 new 出來的東西,都在堆當中; 堆記憶體裡面的東西都有一個位址值 : 16 進制, 堆記憶體裡面的資料, 都有預設值; 整數 --> 預設為0; 浮點數 --> 預設為0.0; 字元 --> 預設為'u0000'; 布爾值 --> 預設為false; 引用類型 --> 預設為null

3 方法區(Method Area) : 存儲.class 相關資訊, 包含方法的資訊

4 本地方法棧(Native Method Stack) : 與作業系統相關

5 寄存器(pc Register) : 與CPU相關

一個數組的從無到有

兩個數組的記憶體圖

兩個引用指向同一個數組的問題

把 arrayB = arrayA 把arrayA的記憶體位址指派給arrayB

public class Demo05ArraySame {

    public static void main(String[] args) {
        int[] arrayA = new int[3]; // 初始化一個數組

        System.out.println(arrayA); // 位址值
        System.out.println(arrayA[0]);  // 0
        System.out.println(arrayA[1]);  // 0
        System.out.println(arrayA[2]);  // 0

        arrayA[1] = 20;
        arrayA[2] = 30;
        System.out.println(arrayA);  // 位址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]);  // 20
        System.out.println(arrayA[2]);  // 30

        int[] arrayB = arrayA;
        System.out.println(arrayB); // 位址值
        System.out.println(arrayB[0]);  // 0
        System.out.println(arrayB[1]);  // 0
        System.out.println(arrayB[2]);  // 0

        arrayB[1] = 200;
        arrayB[2] = 300;
        System.out.println(arrayB);  // 位址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]);  // 200
        System.out.println(arrayB[2]);  // 300

        System.out.println("=================");
        System.out.println(arrayA[1]);  // 200
        System.out.println(arrayA[2]);  // 300
    }
}
           

操作 arrayA和arrayB, 他們倆其實就是一個數組

空指針異常

所有的引用類型變量, 都可以指派為一個 null 值,但是代表其中什麼都沒有

數組必須進行new初始化才能使用其中的元素

如果隻是指派了一個null,沒有進行new建立,那麼将會發生空指針異常 NullPointerException

數組的長度屬性

每個數組都具有長度，而且是固定的，在程式運作期間不可變,Java中賦予了數組的一個屬性，可以擷取到數組的長度，語句為： 數組名.length ，屬性length的執行結果是數組的長度，int類型結果。由次可以推斷出，數組的最大索引值為 數組名.length-1 。

int[] arrayC = new int[3];
arrayC = new int[5];
System.out.println(arrayC) // 此時并沒有改變數組的長度,而是新建立了一個數組, 改變了arrayC的引用 --> 指向新的數組
           

數組的周遊輸出

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
           

數組擷取最大值元素

public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定義變量，儲存數組中0索引的元素
    int max = arr[0];
    //周遊數組，取出每個元素
    for (int i = 1; i < arr.length; i++) {
        //周遊到的元素和變量max比較
        //如果數組元素大于max
        if (arr[i] > max) {
            //max記錄住大值
            max = arr[i];
        }
    }
    System.out.println("數組最大值是： " + max);
}
           

數組反轉

blic static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    循環中定義變量min=0最小索引
    初始化語句 min=0最小索引,max=arr.length‐1最大索引
    條件判斷  min <= max
    步進表達式  min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
        //利用第三方變量完成數組中的元素交換
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    // 反轉後，周遊數組
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
           

數組作為方法的參數傳遞

數組作為方法的參數傳遞, 傳遞的參數是數組的記憶體位址

public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //調用方法，傳遞數組
    printArray(arr);
}
/*
建立方法，方法接收數組類型的參數
進行數組的周遊
*/
public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
           

數組作為方法的傳回值傳回

數組作為方法的傳回值傳回, 傳回的是數組的記憶體位址

一個方法可有0, 1, 多個參數,但是隻能有0或者1個傳回值, 不能有多個傳回值

如果希望一個方法當中産生多個結果資料傳回, 使用一個數組作為傳回值類型即可

public static void main(String[] args) {
    //調用方法，接收數組的傳回值
    //接收到的是數組的記憶體位址
    int[] res = cal(10,20,30);
    for (int i = 0; i < res.length; i++) {
        System.out.println("總和:"+ res[0]);
        System.out.println("平均數:"+ res[0]);
    }
}
/*
建立方法，傳回值是數組類型
return傳回數組的位址
*/
public static int[] cal(int a,int b,int c) {
    int sum = a+b+c; // 總和
    int avg = sum /3;  // 平均數

    int[] arr = {sum,avg};

    return arr;
}
           

方法的參數為基本資料類型時,傳遞的是資料值; 方法的參數為引用類型時, 傳遞的是位址值

同理, 引用類型作為方法的傳回值時, 傳回的也是位址值