摘要：參考資料程序設計北大唐大仕零基礎學語言浙大翁愷面向對象程序設計語言浙大翁愷在里面搜索可以查看和修改快捷鍵自動補全代碼格式化簡介歷史與一起發展萬維網所有信息用鏈接連接起來靜態網頁動態網頁的出現年開發工具包語法增加廣泛動態編譯腳本

Java程序設計 - 北大 - 唐大仕

零基礎學Java語言 - 浙大 - 翁愷

面向對象程序設計——Java語言 - 浙大 - 翁愷

在preference里面, 搜索keys, 可以查看和修改快捷鍵

Content Assist, 自動補全

Format, 代碼格式化

Java 與 Internet 一起發展

www, 萬維網, 所有信息用鏈接連接起來

Java, 靜態網頁 -> 動態網頁

Java的出現, 1995年, SUN, Stanford University Network, JDK 1.0

JDK, Java Development Kit, Java開發工具包

1995, JDK 1.0
1998, JDK 1.2, Java2
2000, JDK 1.3
2002, JDK 1.4, assert, logging, re
2004, JDK 1.5, 語法增加
2006, JDK 1.6, 廣泛, Compiler API(動態編譯), 腳本語言支持, WebService支持
2010, Oracle并購SUN
2011, JDK 1.7, 帶資源的try, 重拋異常
2014, JDK 1.8, 大改進, lambda表達式

注: 從 JDK 1.5 之后, JDK 1.x 也被稱為 JDK x, 如 JDK 1.8 也被叫做 Java 8

Java的推動力

JCP, Java Community Process, 社區

JSR, Java Specification Requests, 規范

Java SE, J2SE, Java 2 Platform Standard Edition, 標準版, 桌面引用

Jave EE, J2EE, Java 2 Platform Enterprise Edition, 企業版, Web應用

Java ME, J2ME, Micro Edition, 微型版, 嵌入式設備

跨平臺, 安全穩定(不易內存溢出), 支持多線程, 豐富的類庫

純的面向對象, 變量和方法都在對象里面

與 C++ 的區別

無直接指針, 自動內存管理

基本數據類型長度固定

不使用頭文件

不支持宏

無多重繼承(使用接口)

沒有(放在類外面的)全局變量

沒有 GOTO

打開 Eclipse, 然后左上角 File --- New --- Java Project, 輸入工程名 javanote --- Finish

在 Package Explorer 中展開 javanote --- 右鍵 src --- New --- Class, 在 Name 中輸入 Main (首字母大寫), 這之后我們會在 Package Explorer 中看到新增的 Main.java

編寫 Main.java

package javanote;

public class Main{
    public static void main(String args[]) {
        System.out.println("hello world");
    }
}

運行

進入新建文件夾 ./javanote, 然后新建源程序文件 Main.java, 注意文件名和 public class 后面的類名一致

public class Main {
    // 注意 String[] args 不能省略
    public static void main(String[] args){
        System.out.println("hello world");
    }
}

編譯, 將會得到 Main.class 目標文件(obj), 字節碼 bytecode, 擴展名 class .它不是實際機器的最終執行代碼

# c 代表 compiler
$ javac Main.java
$ ls
Main.class  Main.java

運行

# 注意不是 java Main.class
java Main

通過 JVM 讀取并處理 class 文件, 最終轉化成 CPU 的指令. JVM for Win/Unix/ 模擬了一個操作系統/接口

Java Virtual Machine, Java虛擬機

源程序(.java 后綴) ---javac--- 字節碼(bytecode, .class 后綴) ---java--- 在 JVM 上運行

JVM 規定了虛擬的CPU和內存, 包含以下內容: 寄存器集, 類文件結構, 堆棧, 垃圾收集堆, 內存區域

Code Security, 代碼安全性檢測

Garbage Collection, 垃圾回收, 自動管理內存

Java 程序不能依賴于垃圾回收的時間或者順序

GC 是完全自動的, 不能被強制執行, 程序員最多只能用 System.gc()來建議執行垃圾回收器回收內存, 但是具體的回收時間, 是不可知的。當對象的引用變量被賦值為 null, 可能被當成垃圾

GC 自動回收內存, 程序員不需要要無法精確控制回收過程, 也就是說只有 new, 沒有 delete

系統級線程會跟蹤存儲空間的分配情況

JVM 空閑時, 檢查和釋放那些可以釋放的空間

在具體運行的時候, Java需要一個運行環境, 即 JRE

JRE = JVM + API(Lib)

JRE 運行程序時的三項主要功能

加載代碼(class loader), 校驗代碼(bytecode verifier), 執行代碼(runtime interpreter, 因此虛擬機有時候也簡單稱為一個解釋器)

小結: Java運行環境(JRE) 首先由虛擬機 JVM 來裝載程序, 然后調用相應的指令來執行

平臺無關: 把 class 文件放到不同的系統, 虛擬機可以執行, 不需要重新編譯

JDK = JRE + Tools (編譯工具 javac, 打包工具 jar, 調試工具 jdb, 執行器 java, 文檔生成器 javadoc)

JRE = JVM + API

開發程序需要 JDK, 如果只是運行程序則 JRE 夠了

類, class, 是抽象的具有共同屬性和行為的集合

類 = 屬性(變量, 字段, field) + 行為(函數, 方法, method)

對象, object, 對象實例, instance, 一個實體, 一塊可以標識的存儲區域

三大特征: 封裝, 繼承, 多態

類型: Application(應用程序), Applet(小應用, 嵌入到HTML)

Application 的基本結構

package javanote;

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

// 一個文件可以有多個 class, 但是只能有一個 public class, 且與文件同名
// main 方法必須是 public static
// main 方法是一個特殊的方法, 它是程序運行的入口
// main 還可用于測試, 直接運行該類的時候會調用 main, 如果是其他類調用這個類的方法, 則不會運行 main
// package, 包, 文件路徑
// import, 導入其他的類

輸入 Scanner, 輸出 System.out.print()

package javanote;

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main{
    public static void main(String args[]) {
        try {
            // 注意, 如果輸入的不是整數, 而是小數/字符串, 則會報錯. 因此需要try...catch...
            Scanner in = new Scanner(System.in);
            int a = in.nextInt();
            System.out.println(a);
        }
        catch (InputMismatchException e) {
            // TODO: handle exception
        }
    }
}

整數型

byte, 1 字節

short, 2 字節

int, 4 字節

long, 8 字節

Java 中沒有 無符號數

實數, 浮點數

float, 4 字節

double, 8 字節, 浮點數默認是 double

邏輯型

boolean, 1 bit, true/false

Java 中不可以用 if(1) 或 if(0), 也不能 if( a = 5 )

boolean 不能比較大小, 不能進行算術運算

2 + true           // error
true + true        // error, 就算換成 boolean a, b; 然后 a + b; 仍然是error
true > false       // error
1 > false          // error
true == 6;         // error
a == b > false     // error, ==, != 優先級低, 先做 b > false, 這里也會出錯
( a == b ) > false // error, 類似于 true > false 的error

邏輯運算的 !, &&, || 只能用于 boolean, 作用到其他類型上面會出錯, 這點也和 C 不一樣

字符型

char, 2 字節, 統一使用 Unicode 編碼, 跨平臺

強制類型轉換

double a = 10.3;
int b = (int)a;
int c = (int) (10/3.0);
// (10/3.0)要加括號, 因為(int)是單目運算, 優先級高

基本數據類型, 變量在棧. 復制變量的時候，復制的是值.

非基本數據類型, 引用類型, 在堆, 變量只是引用, 類似于指針, 只能指向特定對象, 不能亂指, 復制變量的時候，復制的是引用

數組是一種容器, 所有元素有相同的數據類型, 一旦創建, 則不能改變大小. 數組必須用 new 來分配空間, 數組元素默認初始化.

// 注意方括號的位置

// a和b都是數組, 其中 a 未分配空間, b 分配了 4 個 int 的空間
int[] a, b = new int[4];
// c 是數組, d 是 int 變量
int c[], d;

數組是引用類型, 元素個數可以用變量定義,

// 數組是引用類型
int[] a1 = new int[3];
int b = 10;
// 元素個數可以用變量定義, 和c99類似
int[] a2 = new int[b];

// error, 數組是引用類型, 理解為指針, 不能直接給它分配空間, 分配的空間在堆, 必須 new 一塊空間然后指向那里
int a3[5];

如果沒有對數組進行顯式初始化, 則會隱式初始化為 0 或 null, 比 C 安全

// 如果沒有對數組進行顯式初始化, 則會隱式初始化為 0 或 null
int[] a4 = {3, 1, 2};
int[] a5 = new int[]{3, 1, 2};

// 注意, 數組元素會默認初始化, 但是基本數據類型聲明后不會默認初始化
int a;
a++;  // error

與指針的類似之處, 數組變量只是數組的管理者, 而不是擁有者

int[] a = new int[10];
int[] b = a;
b[0] = 5;

// 此時 a[0] 也變成了 5
// a == b 的結果是 true

復制數組, 不能用 b = a, 而需要遍歷, 除此以外還有 a.clone() 和 System.arraycopy(src, int srcPos, dst, int dstPos, int length) 方法

int[] a = {1, 2, 3, 4};
// 方法1, a.clone()
int[] b = a.clone();

int[] c = new int[4];
// 方法2, System.arraycopy()
System.arraycopy(a, 0, c, 0, a.length);

每個數組, 都有一個 .length 屬性, 比 C 安全

int[] a = new int[10];
for( int i = 0; i < a.length; i++ ) {  }

// 也可以這樣遍歷, 因為數組是個 Iterable 對象
for( int n : a ) {  }

二維數組

int[][] a = new int[3][5];
for( int i = 0; i < a.length; i++ ) {
    for( int j = 0; j < a[0].length; j++ ) {
        a[i][j] = i * 5 + j; 
    }
}

// 初始化
int[][] a = {
    {1, 2, 3, 4},
    {1, 2, 3},
}

// 注意最后可以多一個逗號

字符類型 char, 能被單引號包圍, 如 "a", "+", "你", unicode16編碼, 2個字節, 在所有機器上是一致和統一的

字符串, String, 第一個字母大寫, 說明是一個類, 是管理者

String s1 = new String("123");
String s2 = "abc";

// 自動轉換
String s3 = s1 + s2 + 12 + 24;    // "123abc1224"
String s4 = s1 + s2 + (12 + 24);  // "123abc36"

// 注意
String s5 = null;
System.out.println( s5 + "a" ); // nulla

讀取輸入

next --- 相當于 C++ 中的 cin
nextLine --- 相當于 C++ 中的 getline

字符串的操作. 字符串是對象, 對它的所有操作都要通過 . 這個運算符

長度, s.length()

注意要加括號 () , 是字符串的 length() 方法, 和數組的 length 屬性不一樣

而且在調用 .length() 時, s 必須指向一塊字符串, 不能是未初始化區域(null)

訪問字符, s.charAt(index), 注意這是只讀操作, read-only

遍歷, 注意字符串無法使用 for(char ch : s), 因為字符串不是 Iterable 對象

for( int i = 0; i < s.length(); i++ ){
    s.charAt(i);
}

子串, .substring()

// [n:-1]
s.substring(n);
// [n, n + len)
s.substring(n, len);

內容是否相同 .equals()

if( s.equals("Hello") ) {  }

比較大小, .compareTo(), unicode 編碼相減

s1.compareTo(s2);        // unicode 編碼相減

其他操作

int loc = s.indexOf("a");
s.indexOf("a", loc + 1);
s.indexOf("abc");

s.lastIndexOf("a");

s.startsWith(ch);
s.endsWith(ch);
s.trim();            // 去掉兩端空格
s.replace(c1, c2);
s.toLowerCase();
s.toUpperCase();

注意, 字符串本身是不可變的. 以上操作如果返回了字符串, 那這些返回的字符串是新生成的, 而不是修改了原來的字符串.

基本數據類型對應的包裹類型

boolean --- Boolean
byte --- Byte
short --- Short
char --- Character
int --- Integer
long --- Long
float --- Float
double --- Double

基本數據類型 + 更多方法和字段

int a = Integer.MAX_VALUE;        // 2^31 - 1
boolean b = Character.isDigit("a");    // false
char c = Character.toLowerCase("A");    // a

數學類, Math

Math.abs()
Math.round()
Math.random()
Math.pow()

實參類型的寬度(尺寸大小)必須 <= 形參類型的寬度(大小)

比如形參 double 實參 int 是可以的, 但是反過來就不行

true 和 int 無法轉換

方法的每一次運行, 都會產生獨立的本地變量空間, 參數也是本地變量

由于沒有 C 的指針, 也沒有 C++ 的引用 &, 所以一般方法無法實現 swap, 需要使用數組或者對象

類名首字母大寫. 其余的, 首字母小寫

少用下劃線

隨寫隨用，而不是上方統一聲明、分開使用

訪問控制修飾符

其他修飾符

static

不屬于某個實例, 而是屬于整個類的(屬性). static 變量, 相當于該類一個全局變量, 有點像 C 中的 extern 全局變量, 是所有該類的對象實例所共享的. 這樣看來, Java 的類是一個樹的結構, 根結點中存儲著公有信息, 而對象實例是衍生出來的子結點. 也就是說, static 是一個公共的路燈, 只有一盞, 每個人可以去開關路燈. 但是如果你要去關掉某一戶人家里的燈, 就要明確指明他家的門牌號

類就相當于計網中的協議, 比如網絡層協議, 規定了每個數據包應該有什么樣的格式. 而對象則是一個個具體的實際的數據包.

類變量, 相當于協議頭部的一個字段, 所有這個類的對象實例都有相同的頭部信息. 相對的, 成員變量則是數據部分.

static 變量多帶帶劃分一塊存儲空間, 不與具體的對象綁定在一起, 該存儲空間被類的各個對象所共享.

static 變量值在方法區加載一次, 而 非 static 變量在創建對象時會加載很多次, 每次創建都會拷貝一份

static 方法再內存中有專用的代碼段

static 的訪問

static 方法可以訪問 static 變量 (類變量)

static 方法不能訪問無 static 前綴的 普通成員變量, 不能訪問實例變量, 也就是不能使用 this 或 super, 調用類方法時, 可以通過 `類名.

普通成員函數 可以訪問 static 變量

可以通過 類名.類變量 訪問類變量, 也可以通過 對象名.類變量 訪問類變量. 同理, 調用類方法時可以用 類名.類方法, 也可以用 類名.類方法

class A{
    static int var = 1;
    public static void main(String args[]){
        A.var++;            // OK, 類名.類變量
        A a = new A();
        a.var++;            // OK, 對象名.類變量
        var++;                // OK, 直接訪問
    }
}

final, 不可改變的, 最終的

類前面加上 final, 表示這個類不能被繼承, 有利于 Java 的優化

方法前面加上 final, 則這個方法不能被子類覆蓋 Override

字段前面加上 final, 能且只能被賦值一次, 然后就不能被改變了. 通常用 static final 表示常量

類 = 字段(成員變量) + 方法(成員函數)

成員變量的生存期 ---> 該對象的生存期, new 開始, GC 收集

成員變量的作用域 ---> 類的內部

構造方法, 構造函數, new 一個新的對象會調用構造方法, 可以重載 overload (參數表不同)

初始化順序

1.new
2.先跳到構造函數(但不進入)
3.調到父類的構造函數(如果有父類)
4.重復3, 一直到最高的父類
5.跳到構造函數外面的 定義初始化
    int price = 80, balance = 0;
6.進入構造函數, 完成構造函數里面的語句
7.回到子類, 進行子類的定義初始化, 再完成子類的構造函數
8.把構造出來的對象交給對象實例 vm 管理

如果有構造方法的重載, 而且如果其中一個要調用另一個構造方法, 那么要借助 this

class Person{
    private int age, id;
    public Person(){
        this(1);// 必須放在最開始, 調用另外一個構造方法
        age = 0;
    }
    public Person(int pid){
        id = pid;
    }
}

析構函數使用的是 finalize() 方法, 但是一般不用去定義, 交給 JVM 就好了

對象是實體, 可以像理解 C++ 的指針一樣理解對象實例

必須 new, 才會分配具體的空間, 每個對象的 id 不同

如果是用另一個對象對其賦值, 則相當于兩個人管理同一個對象實例, 和指針一樣

Student s1 = new Student();
Student s2 = s1;
s1.setAge(5);   // 5
s1.getAge();    // 5
s2.setAge(10);  // s2 更新 age
s1.getAge();    // 10, s1也會修改, 因為兩者指向同一塊區域

安全性

一個對象實例是內存中的一塊區域, 只能通過同類型的引用去訪問, 不能隨便拿一個指針亂指到一個實例(內存區域)

private

是對類的限制, 而不是對對象的限制

同一個類的內部, 該類的不同對象實例之間, 可以互相訪問private.

但是出了這個類，就無法訪問private了。舉例如下

class Lower{
    private int val = 0;

    public void test(){
        Lower a = new Lower();
        Lower b = new Lower();
        // 類的內部, 該類的不同對象實例之間, 可以互相訪問private
        a.val = b.val;
    }
}

class Higher{
    public void test2(){
        Lower l1 = new Lower();
        Lower l2 = new Lower();
        // error, not visible. 超出了Lower類的內部, private字段就變成了不可見
        l1.val = l2.val;
    }
}

private 方法和字段不能繼承

public

default (friendly)

既沒有前綴 public, 也沒有前綴 private, 那么這個成員是 default

那么和它位于同一個包(同一個文件夾)的其他類可以訪問.

注意, 不需要顯式聲明為 default

protected

同一包內的類可見

所有子類可見

繼承關系

父類 public, 子類也必須為 public

父類 protected, 子類 protected, public, private

父類 private 不能夠被繼承

方法重載: 多個方法有著相同的名字, 這些方法的簽名 signature 不同 (參數不同, 或者參數類型不同), 編譯的時候能夠被識別出來

通過方法重載, 可以實現多態

模塊化, 把相關的屬性和方法封裝成為一個類

信息隱蔽, 隱藏類的細節(private), 用戶只能通過受保護的接口訪問某個類

class Person{
    private int age;
    public int getAge(){
        return age;
    }
}

父類(super)和子類(sub, 也作派生類)之間如果有共同的屬性和方法, 就不用再寫第二遍了。可以更好地抽象和分類, 提高代碼的可重用性, 提高可維護性

單繼承, 一個類只能有一個直接父類, 子類自動繼承父類的狀態和行為

繼承的例子 (extends)

class Person{
    int age;
    String name;
}

// 注意關鍵字 extends 表示繼承(擴展)
class Student extends Person{
    String school;
}

// 如果沒有 extends xxx, 那么默認為 extends java.lang.Object 的子類
// 因此所有的類都是直接或間接地繼承了 Object

覆蓋

JDK 1.5 之后引入了 @Override, 表示覆蓋 (修改) 了父類的方法.

可以當做注釋, 同時編譯器會幫你檢查, 如果父類中沒有相同的 方法名 + 參數表, 就會報錯

父類方法 func() 被覆蓋后, 仍然可以用 super.func() 調用父類的方法

重載

方法名相同, 參數表不同. 重載是新的方法.

構造方法是不能繼承的, 因為構造方法是和類名同名的

子類構造的過程中需要用 super 來調用父類的構造方法

例題, 問以下代碼的結果是什么

class Person {
    String name = "";
    public Person(String n) {
        name = n;
    }
}
class Employee extends Person {
    String empID = "";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

結果是編譯報錯, 因為父類 Person 沒有無參數的構造函數, 解決方法

// 方法1, 給父類 Person 增加無參數的構造函數(子類會默認調用)
class Person {
    public Person() {}
}

// 方法2, 子類構造函數中用 super 顯式調用父類已有的構造函數
class Employee extends Person {
    public Employee(String id) {
        super("Bob");// 注意 super 必須放在第一句
        empID = id;
    }
}

子類對象和父類對象的轉換

Student 是一個 Person (子類對象可以被視為父類對象)

Person 不一定是 Student, 具體情況看下面的例子

// 假設 Student extends Person
Person p1 = new Student(); // 編譯正常, 運行正常
Student s1 = (Student) p1; // 編譯正常, 運行正常

Person p2 = new Person();
Student s2 = (Student) p2;
s2.xxx(); // 【編譯正常, 運行錯誤】

與類的繼承沒有關系, 子類和父類可以位于不同的包中

相當于名字空間, 解決同名沖突. 同時包也相同于文件夾(存儲路徑)

另外就是可訪問性, 同一個包中的各個類, 默認是可以互相訪問的

abstract, 抽象

abstract class Person{
    // 含有抽象方法的類必須聲明為抽象類
    // 注意抽象方法是分號;結尾, 而不是花括號
    // 也就是說抽象方法只有聲明, 沒有實現
    abstract void speak();

    void eat() {
        // 抽象類可以有非抽象方法
    }
}

class Student extends Person{
    @Override
    void speak() {
        // 子類 extends 父類后
        // 要么仍然保持 abstract 方法
        // 要么 Override 覆蓋(這里也可以稱為實現)父類的 abstract 方法
    }
}

public class Main{
    public static void main(String args[]) {
        // 錯誤, 抽象類不能被實例化 `instantiate`
        // Person p1 = new Person();

        // 但是抽象類可以用于定義變量
        Person p2 = new Student();
    }
}

interface, 接口, 約定某種特征

interface 是純抽象類, 所有方法都是 abstract, 也就是 C++ 中的純虛類

所有的成員變量都是 public static final (相當于 const 常量)

static 表明它屬于這個類而不是某個具體對象, final 表明它一旦初始化就不會被改變, 是一個編譯時刻已經確定的常量

// 注意直接用 interface 修飾, 不需要 class
interface Flyable{
    // 接口類的所有方法都是 `public abstract`, 不需要顯式寫出
    // public abstract void fly();

    void fly();
}

interface Runnable{
    // 如果使用 static 修飾符, 則表明這是默認實現, 不需要每次 implements 都去實現 run
    // java8 以上的新特性, 但是這就又回到父子繼承了
    static void run() {
    }
}

// implements 多個接口用逗號分隔
class Superman extends Person implements Flyable, Runnable{
    @Override
    public void fly() {
    }
}

class Airplane implements Flyable{
    @Override
    public void fly() {
    }
}

接口可以繼承接口，但是不能繼承(extends)類

接口不能實現接口，只有類能夠實現(implements)接口. 一個類可以實現(implements)多個接口(多繼承), 也就是說, 通過接口可以實現不相關類的相同行為(fly()), 而不需要考慮層次關系(``)

引用類型一共有三大類: 1.類 class, 2.接口 interface, 3.數組

相同的名字表示不同的含義

case1, 編譯時多態, 靜態

重載 Overload, 多個方法同名但參數表不同

p.say();
p.say("Hi");

case2, 運行時多態, 動態

覆蓋 Override, 子類方法覆蓋父類同名方法. 動態綁定 dynamic binding, 也稱為虛方法調用, 運行的時候根據實例對象來調用方法, 舉例如下

class Person{
    void say(){
        System.out.println("hi");
    }
}

class Student extends Person{
    @Override
    void say(){
        System.out.println("hi, I"m a student");
    }
}

public class Main{
    static void func(Person p){
        p.say();
    }

    public static void main(String args[]) {
        Person p = new Person();
        Student s = new Student();
        Person ps = new Student();
        // func() 的參數表說明了我們需要一個 Person 對象
        func(p);
        // 但是我們也可以把 Student 傳進去
        // 這時候不會報錯, 而且會正確調用子類的 say()
        func(s);
        // 更進一步, 如果我們用向上造型, func() 能接受 ps, 且會正確調用子類的 say()
        func(ps);
    }
}

可以被 Override 的方法都可以稱作虛方法, 虛方法不需要特殊的聲明

非 static、final、private 修飾的所有方法都是虛方法

向上造型 upcasting

父類 obj = new 子類();

子類的對象, 可以被當成父類的對象來使用, 可以賦值給父類的變量, 可以傳遞給需要父類對象的函數, 如果一個容器存放的是父類對象, 那么子類對象也可以放進去

// 為什么? 因為繼承了父類, 對外的接口是一樣的

子類的對象可以賦值給父類的變量. 注意, Java 不存在 對象 對 對象 的賦值, 而是讓兩個管理員共同管理一個對象. 類比指針, 不是復制內容, 而是給地址.

有哪些類, 類里面有什么屬性和方法, 類之間的關系(繼承, 關聯), 對象之間發送消息(調用方法)

容器 container, 是放東西的東西, 數組可以看做一種容器, 但是數組的長度一旦確定就無法改變, 而容器一般可以改變其容量

基本數據類型數組 與 對象數組

// 基本數據類型數組, 每一個元素都是基本數據類型
int[] ai = new int[32]; // 每個元素被初始化為0

// String[] 數組, 對象數組, 每一個元素只是一個管理者, 一個指針, 而不是保存實際內容
// 元素初始化為 null, 實際內容還不存在, 需要 for 循環去創建和賦值(指向)
String[] as = new String[10];

容器類

// import java.util.ArrayList;
ArrayList noteList = new ArrayList();

// 用法參考 https://www.w3schools.com/java/java_arraylist.asp
noteList.add( Integer.toString(0) );
noteList.add( "1" );
noteList.get(0);
noteList.set(0, "00");

// import java.util.Collections;
// 排序
Collections.sort(noteList);

noteList.remove(0);
noteList.clear();

// 如果要構建一個數組, 可以調用 toArray() 方法
int size = noteList.size();
String[] mylist = new String[size];
noteList.toArray(mylist);

關系圖

去重

HashSet s = new HashSet();
s.add("first");
s.add("second");
s.add("first");
sysout(s); // [first, second]
s.contains("1"); // false

參考文檔

https://docs.oracle.com/javas...

https://www.tutorialspoint.co...

鍵值映射關系

/*
映射關系
1        penny
5        nickel
10        dime
25        quarter
50        half-dollar
*/
HashMap dollarMap = new HashMap();
dollarMap.put(1, "penny"); // 注意其他容器都是 add, map 是 put
dollarMap.put(5, "nickel");
dollarMap.put(10, "dime");
dollarMap.put(25, "quarter");
dollarMap.put(50, "half");
dollarMap.replace(50, "half-dollar");
dollarMap.containsKey(30); // false
dollarMap.get(30); // null
dollarMap.get(50);