基本知識點

文件名必須和類型一致，類名首字母要大寫，例如：MyClass

註釋-Commonts

Java 註釋（Java Comments），單行註釋 //，在 // 至當前行行位之間的內容，都會被忽略
多行註釋：/*被註釋的內容 */，

變量-Variables

String 存儲文本，例如 "hello"，用雙引號包含值
char 存儲單個字符（character），例如 "B"，用雙硬漢包含值
int 存儲沒有小數點的整數，例如 "123" "-123"
float 存儲浮點數，有小數點的，例如 "19.99" "-19.99"
boolean 存儲布爾值，有兩個狀態： true 或 false
聲明變量的語法：type variable = value; ，例如：
- String name = "Michael;"
- boolean myBool = true;
- float myFloatNum = 5.99f; // floating point number
- 同時聲明多個同類型的變量 int x =5, y = 6;
必須使用惟一名稱標識全部Java變量，這些惟一名稱稱爲標識符（identifiers）。變量名有一些規範：
- 變量名能夠包含字母、數字、下劃線、$符號
- 變量名能夠 $、_、字母開頭
- 變量名建議小寫字母開頭，不能包含空格
- 「保留字」不能做爲變量名

數據類型-Data Types

數據類型分爲兩組：html

原始數據類型（Primitive data types）：byte, short, int, long, float, double, boolean and char
數字
- Integer types 整形數字，沒有小數點
  - byte 字節 = 8 bit 位，-128 to 127，例：byte myNum = 100;
  - short = 2 bytes -32,768 to 32,767，例：short myNum = 5000;
  - int = 4 bytes，int 類型是咱們首選的數字類型，例：int myNum = 100000;
  - long = 8 bytes，應該要以 L 結尾，例：long myNum = 15000000000L;
- Floating point types 浮點數類型
  - float = 4 bytes，應該要以 f 結尾，例：float myNum = 5.75f;
  - double = 8 bytes，在大多數計算中使用double更安全，應該要以 d 結尾，例：double myNum = 19.99d;
boolean = 1 byte 存儲值只能是 true or false，例：boolean isJavaFun = true;
char = 2 bytes 存儲單個字符（character）或字母（letter），char 值必須用單引號括起來例，char myGrade = 'B';
String 類型的值必須是以雙引號括起來，例：String greeting = "Hello World";
非原始數據類型（Non-primitive data types）：例如 String, Arrays and Classes
非原始數據類型稱爲「引用類型」，由於他們引用「objects」。它們和原始數據類型的區別在：
- 原始類型是 Java 中預約義的。非原始類型是由程序員定義的（除了 String）。
- 非基本類型可用於調用方法來執行某些操做，而基本類型不行。
- 基本類型始終有值，而非基本類型能夠爲 null。
- 基本類型以小寫字母開頭，而非基本類型以大寫開頭。
- 非基本類型包含 String,Arrays,Classes,Interface,etc

泛型

泛型是Java SE 1.5 的新特性，泛型的本質是參數化類型，也就是說所操做的數據類型被指定爲一個參數。這種參數類型能夠用在類、接口和方法的建立中，分別稱爲泛型類、泛型接口、泛型方法。java

public class Box<T> {
    private T object;

    public void set(T object) { this.object = object; }
    public T get() { return object; }
}

建立一個Box對象，帶泛型參數，獲取對象的時候就不須要強制轉換android

Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();

總結下泛型的好處就是：省去了強制轉換，能夠在編譯時候檢查類型安全，能夠用在類，方法，接口上程序員

下來講說泛型通配符T，E，K，V區別

這些全都屬於java泛型的通配符，剛開始我看到這麼多通配符，一下暈了，這幾個其實沒什麼區別，只不過是一個約定好的代碼，也就是說express

使用大寫字母 A,B,C,D......X,Y,Z 定義的，就都是泛型，把 T 換成 A 也同樣，這裏 T 只是名字上的意義而已編程

? 表示不肯定的java類型
T (type) 表示具體的一個java類型
K V (key value) 分別表明 java 鍵值中的 Key Value
E (element) 表明 Element

參考：api

簡書JAVA泛型通配符T，E，K，V區別，T以及Class<T>，Class<?>的區別

Strings

String Length，例：String txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";int len = txt.length();
toUpperCase()、toLowerCase() 方法，將值變爲全大寫、全小寫
indexOs() 返回在字符串中第一次出現的索引位置，和 Python 同樣，也是從 0 開始的；
+ 操做符能夠字符串鏈接（concatenation）；
concat() 方法也能夠 concatenate 兩個字符串：System.out.println(firstName.concat(lastName));，將 "20"+10，結果是「2010「，字符串類型；

Math

Math.random() 返回 0(inclusive) to 1 (exclusive) 範圍的值，0≤x<1

If...Else

if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

栗子：數組

int time = 22;
if (time < 10) {
  System.out.println("Good morning.");
} else if (time < 20) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}

三元運算符（Ternary Operator）安全

variable = (condition) ? expressionTrue : expressionFalse;

栗子：app

int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";

Switch

switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

break; 語句要記得寫，否則一直往下執行，直到遇到 break;
default 語句是用來當沒有匹配條件時執行的，它不須要 break

While 循環

while (condition) {
  // code block to be executed
}

Do/While 循環是上面那種寫法的一個變體（variant）。這個循環是在檢查條件以前，就會直接執行一次代碼！而後判斷條件，執行循環。

do {
  // code block to be executed
}
while (condition);

For 循環

for (statement 1; statement 2; statement 3) {
  // code block to be executed
}

最早執行初始化步驟。能夠聲明一種類型，但可初始化一個或多個循環控制變量，也能夠是空語句。
而後，檢測布爾表達式的值。若是爲 true，循環體被執行。若是爲false，循環終止，開始執行循環體後面的語句。
執行一次循環後，更新循環控制變量。
再次檢測布爾表達式。循環執行上面的過程

For-Each 循環

for (type variable 聲明語句: arrayname 數組名) {
  // code block to be executed
}

栗子：

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
  System.out.println(i);
}

Arrays 數組

Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value. 數組用於在單個變量中存儲多個值，而不是爲每一個值聲明單獨的變量。

栗子：

// 用變量類型+方括號（square brackets）
String[] cars;
// 在大括號內（inside curly braces）放入值
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

數組元素的操做：

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars[0]); // 輸出首個元素
cars[0]="Opel"; // 修改首個元素值
System.out.println(cars.length); // 數組的長度，這裏不用調用方法
// 數組的循環
for (int i=0;i < cars.length; i++){
  System.out.println(cars[i]);
}
// for-each 循環
for (String i : cars){
  System.out.println(i);
}

多維數組（Multidimensional Arrays）

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
int x = myNumbers[1][2];
System.out.println(x); // Outputs 7

Exceptions

try {
  //  Block of code to try
}
catch(Exception e) {
  //  Block of code to handle errors
}

栗子🌰：

public class MyClass {
  public static void main(String[] args) {
    try {
      int[] myNumbers = {1, 2, 3};
      System.out.println(myNumbers[10]);
    } catch (Exception e) {
      System.out.println("Something went wrong.");
    } finally {
      System.out.println("The 'try catch' is finished.");
    }
  }
}

finally 語句，不論上面結果如何，最終都要執行；

throw 關鍵字可讓你建立一個自定義的 error：

public class MyClass {
  static void checkAge(int age) { 
    if (age < 18) {
      throw new ArithmeticException("Access denied - You must be at least 18 years old."); 
    }
    else {
      System.out.println("Access granted - You are old enough!"); 
    }
  } 

  public static void main(String[] args) { 
    checkAge(15); // Set age to 15 (which is below 18...)
  } 
}

Methods 方法

一個方法就是一個代碼塊，它在被調用時運行。

public class MyClass {
  static void myMethod() {
    // code to be executed
  }
}

myMethod 方法名；
void 表示這個方法沒有返回值；
static 表示這個方法屬於 MyClass 這個類，不是 MyClass 類的對象。

方法參數

public class MyClass {
  static void myMethod(String fname) {
    System.out.println(fname + " Refsnes");
  }

  public static void main(String[] args) {
    myMethod("Liam");
    myMethod("Jenny");
    myMethod("Anja");
  }
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes

方法返回值

public class MyClass {
  static int myMethod(int x, int y) {
    return x + y;
  }

  public static void main(String[] args) {
    System.out.println(myMethod(5, 3));
  }
}
// Outputs 8 (5 + 3)

Java Classes 類

類和對象 Classes and Objects

Java 是一個 OOP 語言（object-oriented programming），面向對象編程。

對象具備屬性（attributes）和方法（methods）。

建立對象：

public class MyClass {
  int x = 5; // 這裏的 x 就是 MyClass 的 attribute，也叫 fields

  public static void main(String[] args) {
    MyClass myObj1 = new MyClass();  // Object 1
    MyClass myObj2 = new MyClass();  // Object 2
    myObj2.x = 25;
    System.out.println(myObj1.x);  // Outputs 5
    System.out.println(myObj2.x);  // Outputs 25
  }
}

發如今當前定義的類中，就已經能夠用這個類建立對象了；
類名首字母就要大寫啦，它是非原始類型的數據類型；
類名要和文件名一致；
兩個類文件在同一級目錄下，直接能夠調用另外一個類建立對象，不像 Python 還須要 import 模塊；
建立多個對象時，及時一個對象的屬性值修改了，不會影響到其餘對象的屬性值；

final 關鍵字：若是你不像類屬性在後面被修改，可使用 final 關鍵字聲明屬性

public class MyClass {
  final int x = 10;
  public static void main(String[] args) {
    MyClass myObj = new MyClass();
    myObj.x = 25; // will generate an error: cannot assign a value to a final variable
    System.out.println(myObj.x); 
  }
}

會報錯：Error:(8, 14) java: 沒法爲最終變量x分配值
final 關鍵字在你想要讓一個變量老是存儲一樣的值（也就是值不變）時，頗有用；
final 被叫作修飾符（modifier）；

Methods 方法

public class MyClass {
  static void myMethod() {
    System.out.println("Hello World!");
  }

  public static void main(String[] args) {
    myMethod(); // 沒有建立對象，就能夠調用方法，static 的功勞
  }
}

Static or Public

static 方法能夠不用建立類的對象就能夠被調用，不像 public 方法（只能經過建立對象來調用）

栗子🌰：

public class MyClass {
  // Static method
  static void myStaticMethod() {
    System.out.println("Static methods can be called without creating objects");
  }

  // Public method
  public void myPublicMethod() {
    System.out.println("Public methods must be called by creating objects");
  }

  // Main method
  public static void main(String[ ] args) {
    myStaticMethod(); // Call the static method
    // myPublicMethod(); This would compile an error

    MyClass myObj = new MyClass(); // Create an object of MyClass
    myObj.myPublicMethod(); // Call the public method on the object
  }
}

Constructors 構造器

構造器是 Java 中的特殊方法，用來初始化對象。當經過類建立一個對象的時候，構造器就被調用了。它被用來設置對象屬性的初始值。

public class Car {
  int modelYear;
  String modelName;

  public Car(int year, String name) {
    modelYear = year;
    modelName = name;
  }

  public static void main(String[] args) {
    Car myCar = new Car(1969, "Mustang");
    System.out.println(myCar.modelYear + " " + myCar.modelName);
  }
}

// Outputs 1969 Mustang

構造器的名字必須和類名相同，它不能有返回值（相似 void）；
全部的類都有構造器。若是你沒建立， Java 會自動建立。

修飾符 Modifiers

修飾符分爲兩種：

1.訪問修飾符控制訪問等級
- default( 缺省 ) 在同一包內可見，使用對象：類、接口、變量、方法
- public 對全部類可見，使用對象：類、接口、變量、方法
- private 「私有」，在同一類內可見，使用對象：變量、方法。注意：不能修飾類。私有訪問修飾符是最嚴格的訪問級別！被聲明爲 private 的方法、變量和構造方法只能被所屬類訪問，而且類和接口不能聲明爲 private。聲明爲私有訪問類型的變量只能經過類中公共的 getter 方法被外部類訪問
- protected 對同一包內的類和全部子類可見。使用對象：變量、方法。注意：不能修飾類。
2.非訪問修飾符不控制訪問等級，可是提供其餘功能
- final 用來修飾類、方法、變量，final 修飾的類不能被繼承，修飾的方法不能被繼承類從新定義，修飾的變量爲「常量」，不可修改。
- static 用來修飾類方法和類變量，類方法、類變量屬於類而不是一個對象。對類變量和方法的訪問能夠直接使用 classname.variablename 和 classname.methodname 的方式訪問。
- abstract 修飾符，用來建立抽象類和抽象方法，抽象方法沒有方法體，抽象方法只能在抽象類中，不然會報錯；可是抽象類中定義非抽象方法是不會報錯的；
- synchronized 和 volatile 修飾符，主要用於線程的編程；

Encapsulation 封裝

爲了實現封裝：

聲明屬性/變量時，使用 private 修飾符（在同一類內可見）；
提供 public setter 和 getter 方法來獲取和修改 private 變量；

栗子：

/* 文件名: EncapTest.java */
public class EncapTest{
   private String name;
   private int age;
   
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
    public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
}

this 關鍵字用來指向當前的對象；

Packages 包

Java 的包是用來將相關類分組的，能夠把它看作是一個文件夾。

包的做用：

把功能類似或相關的類或接口組織在同一個包中，方便類的查找和使用。
如同文件夾同樣，包也採用了樹形目錄的存儲方式。同一個包中的類名字是不一樣的，不一樣的包中的類的名字是能夠相同的，當同時調用兩個不一樣包中相同類名的類時，應該加上包名加以區別。所以，包能夠避免名字衝突。
包也限定了訪問權限，擁有包訪問權限的類才能訪問某個包中的類。

Java 使用包（package）這種機制是爲了防止命名衝突，訪問控制，提供搜索和定位類（class）、接口、枚舉（enumerations）和註釋（annotation）等。

Java 包分爲兩類：

內置包（Built-in Packages），來自 Java API 的包；
用戶自定義的包；

Built-in Packages

// 語法
import package.name.Class; // Import a single class 
import package.name.*; // Import the whole package

引入一個類

import java.util.Scanner;

java.util 是一個 package，Scanner 是它的一個類；

引入一個包

import java.util.*;

自定義包

使用 package 關鍵字：

package mypack;

注意：類文件中能夠包含任意數量的 import 聲明。import 聲明必須在包聲明以後，類聲明以前

繼承 Inheritance

subclass(child) 子類
superclass(parent) 超類/父類

爲了繼承某個類，使用 extends 關鍵字。

class Vehicle {
  protected String brand = "Ford";         // Vehicle attribute
  public void honk() {                     // Vehicle method
    System.out.println("Tuut, tuut!");
  }
}

class Car extends Vehicle {
  private String modelName = "Mustang";    // Car attribute
  public static void main(String[] args) {

    // Create a myCar object
    Car myCar = new Car();

    // Call the honk() method (from the Vehicle class) on the myCar object
    myCar.honk();

    // Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class
    System.out.println(myCar.brand + " " + myCar.modelName); 
  }
}

Vehicle 中使用了一個 protected 修飾符，若是使用了 private 修飾符，那麼 Car 類是沒法獲取 brand 屬性的；

Polymorphism 多態

同一個事件發生在不一樣的對象上會產生不一樣的結果。

多態存在的三個必要條件

繼承
重寫
父類引用指向子類對象

class Animal {
  public void animalSound() {
    System.out.println("The animal makes a sound");
  }
}

class Pig extends Animal { 
// 繼承自 Animal
// 重寫了 animalSoud 方法
  public void animalSound() {
    System.out.println("The pig says: wee wee");
  }
}

class Dog extends Animal {
  public void animalSound() {
    System.out.println("The dog says: bow wow");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Animal myAnimal = new Animal();  // Create a Animal object
    // 父類 指向 子類
    // Parent p = new Child();
    Animal myPig = new Pig();  // Create a Pig object
    Animal myDog = new Dog();  // Create a Dog object

    myAnimal.animalSound();
    myPig.animalSound();
    myDog.animalSound();
  }
}

重寫（override）的規則：
- 參數列表必須徹底與被重寫方法的相同；
- 返回類型必須徹底與被重寫方法的返回類型相同；
- 訪問權限不能比父類中被重寫的方法的訪問權限更低。例如：若是父類的一個方法被聲明爲public，那麼在子類中重寫該方法就不能聲明爲protected。
- 父類的成員方法只能被它的子類重寫。
- 聲明爲final的方法不能被重寫。
- 聲明爲static的方法不能被重寫，可是可以被再次聲明
- 子類和父類在同一個包中，那麼子類能夠重寫父類全部方法，除了聲明爲private和final的方法
- 構造方法不能被重寫。
重載（overload）：重載(overloading) 是在一個類裏面，方法名字相同，而參數不一樣。返回類型能夠相同也能夠不一樣。每一個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。最經常使用的地方就是構造器的重載
- 當使用多態方式調用方法時，首先檢查父類中是否有該方法，若是沒有，則編譯錯誤；若是有，再去調用子類的同名方法。
多態的好處：可使程序有良好的擴展，並能夠對全部類的對象進行通用處理

Interface 接口

一個 Interface 是一個抽象類，用來將一些 empty bodies 的方法組織在一塊兒。

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

接口類必須被其餘類以關鍵字 implements 實現，接口方法由「實現」類提供：

// interface
interface Animal {
  public void animalSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface
class Pig implements Animal {
  public void animalSound() {
    // The body of animalSound() is provided here
    System.out.println("The pig says: wee wee");
  }
  public void sleep() {
    // The body of sleep() is provided here
    System.out.println("Zzz");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    Pig myPig = new Pig();  // Create a Pig object
    myPig.animalSound();
    myPig.sleep();
  }
}

關於接口的注意點：

接口類不能用於建立對象；
接口方法不能擁有方法體；
接口的實現類，必須重寫它全部的方法；
接口方法默認是 abstract 和 public 修飾符；
接口屬性默認是public static 和final
一個接口不能包含一個構造器（由於它不能用來建立對象）

Java不支持「多重繼承」（一個類只能從一個超類繼承）。可是，它能夠經過接口實現，由於該類能夠實現多個接口。注意：要實現多個接口，請使用逗號分隔它們（請參閱下面的示例）。

interface FirstInterface {
  public void myMethod(); // interface method
}

interface SecondInterface {
  public void myOtherMethod(); // interface method
}

// DemoClass "implements" FirstInterface and SecondInterface
class DemoClass implements FirstInterface, SecondInterface {
  public void myMethod() {
    System.out.println("Some text..");
  }
  public void myOtherMethod() {
    System.out.println("Some other text...");
  }
}

class MyMainClass {
  public static void main(String[] args) {
    DemoClass myObj = new DemoClass();
    myObj.myMethod();
    myObj.myOtherMethod();
  }
}

抽象類和接口的區別：

抽象類中的方法能夠有方法體，就是能實現方法的具體功能，可是接口中的方法不行。
抽象類中的成員變量能夠是各類類型的，而接口中的成員變量只能是 public static final 類型的。
接口中不能含有靜態代碼塊以及靜態方法(用 static 修飾的方法)，而抽象類是能夠有靜態代碼塊和靜態方法。
一個類只能繼承一個抽象類，而一個類卻能夠實現多個接口。

接口與類的區別：

接口不能用於實例化對象。
接口沒有構造方法。
接口中全部的方法必須是抽象方法。
接口不能包含成員變量，除了 static 和 final 變量。
接口不是被類繼承了，而是要被類實現。
接口支持多繼承。

Enums 枚舉類

枚舉是一個特殊的「類」，它表示一組常量（不變的變量，如 final 變量）。

enum Level {
  LOW, // 常量用逗號隔開，必須用大寫字母
  MEDIUM,
  HIGH
}

Level myVar = Level.MEDIUM; // 獲取枚舉的常量值

myVar 類型就是 Level，不是 String

循環：

for (Level myVar : Level.values()) {
  System.out.println(myVar);
}

User Input 用戶輸入

Scanner 類用於獲取用戶輸入，它在 java.util 包中。

nextBoolean() 從用戶獲取 boolean 值
nextByte() 從用戶獲取一個字節的值
nextDouble
nextFload
nextInt()
nextLine()
nextLong()
nextShort()

栗子🌰：

import java.util.Scanner;

class MyClass {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);

    System.out.println("Enter name, age and salary");

    // String input
    String name = myObj.nextLine();

    // Numerical input
    int age = myObj.nextInt();
    double salary = myObj.nextDouble();

    // Output input by user
    System.out.println("Name: " + name); 
    System.out.println("Age: " + age); 
    System.out.println("Salary: " + salary); 
  }
}

Data and Time 日期和時間

Java 沒有內置的 Date 類，能夠經過引入 java.time 包來使用。這個包包含許多日期和時間類，例如：

Class	描述
`LocalDate`	表示日期，year,month,day(yyyy-MM-dd)
`LocalTime`	表示時間，hour,minute,second and microsecond(HH-mm-se-zzz)
`LocalDateTime`	表示日期和時間 (yyyy-MM-dd-HH-mm-ss.zzz)
`DateTimeFormatter`	用於顯示和解析日期時間對象的Formatter

Current Date /當前時間 Current Time 顯示當前日期

import java.time.LocalDate; // import the LocalDate class 引入 LocalDate  類
import java.time.LocalTime; // import the LocalTime class
public class MyClass { 
  public static void main(String[] args) { 
    // 當前日期
    LocalDate myObj = LocalDate.now(); // Create a date object 能夠看到，這裏建立對象沒有使用 new 關鍵字
    System.out.println(myObj); // Display the current date
	//2018-12-28
	
	// 當前時間
    LocalTime myObj = LocalTime.now();
    System.out.println(myObj);
    // 15:34:46.622
	// 能夠看到，這裏的時間格式並非很好看

   // 顯示當前日期和時間
   LocalDateTime myDateTime = LocalDateTime.now();
   // 2018-12-28T15:36:56.581

	// 格式化日期和時間 ★★★
	// 1  now 方法建立時間日期對象
	LocalDateTime myDateObj = LocalDateTime.now(); 
    System.out.println("Before formatting: " + myDateObj); 
    // 2 建立格式化器對象
    DateTimeFormatter myFormatObj = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss"); 
	// 3 時間日期對象調用格式化器
    String formattedDate = myDateObj.format(myFormatObj); 
    System.out.println("After formatting: " + formattedDate); 
  } 
}

ofPattern() 方法接受各類值的排序，若是你想要顯示一個不一樣格式的日期時間值，能夠這麼作：

yyyy-MM-dd "1988-09-29"
dd/MM/yyyy "29/09/1988"
dd-MMM-yyyy "29-Sep-1988"
E, MMM dd yyyy "Thu, Sep 29 1988"

更多日期格式，能夠查看：

ArrayList 數組列表

ArrayList 類一個大小可調整（resizeable）的數組（array），這個類位於 java.util 包中。

和內置的數組相比，內置數組的大小是不可變的（若是你要增長 or 刪除數組的元素，你必須新建一個新的數組），而 ArrayList 能夠新增、刪除元素。

栗子：

import java.util.ArrayList; // import the ArrayList class

public class MyClass { 
  public static void main(String[] args) { 
    ArrayList<String> cars = new ArrayList<String>(); // Create an ArrayList object
	// Add Items
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");
    System.out.println(cars);
	// Access an Item
	System.out.println(cars.get(0));
	// Change an Item
	cars.set(0,"VV5"); // return oldValue
	// Remove an Item
	cars.remove(0); // return oldValue
	cars.clear(); // 刪除所有元素
	// Size
	cars.size(); // get how many elements 
	for (String i : cars) {
      System.out.println(i);
    }
    // 或者這麼寫
    for(int i = 0; i < cars.size(); i++){
      System.out.println(cars.get(i));
    }

	// java.util 包中還有一個有用的 `Collections` 類，它包含了 sort() 方法，能夠字母排序或者數字排序
    ArrayList<Integer> myNumbers = new ArrayList<Integer>();
    myNumbers.add(33);
    myNumbers.add(15);
    myNumbers.add(20);
    myNumbers.add(34);
    myNumbers.add(8);
    myNumbers.add(12);

    Collections.sort(myNumbers);  
    // Sort myNumbers，這在 Python 中屬於就地改變的一種排序 in place，由於它直接改變了 myNumbers 這個列表的元素順序

    for (int i : myNumbers) {
      System.out.println(i);
    }
  }
}

add 方法其實還能夠指定插入的索引位置，這就是利用了 Java 中「重載」的概念，方法名同樣，參數不同-》表現行爲就不同。

參考：

HashMap

HashMap 使用「鍵值對」的方式存儲元素，感受就是和 Python 中的字典一個效果。

import java.util.HashMap;

public class MyClass {
  public static void main(String[] args) {
	// 建立了一個 HashMap  對象，它存儲 String 類型的 鍵，存儲 String 類型的值
    // Create a HashMap object called capitalCities
    HashMap<String, String> capitalCities = new HashMap<String, String>();

    // Add keys and values (Country, City)
    capitalCities.put("England", "London");
    capitalCities.put("Germany", "Berlin");
    capitalCities.put("Norway", "Oslo");
    capitalCities.put("USA", "Washington DC");
    System.out.println(capitalCities); 
	// Access an Item
	capitalCities.get("England");
	//Remove an Item
	capitalCities.remove("England");
	//Remove all 
	capitalCities.clear();
	//HashMap Size
	capitalCities.size();
	//循環，keySet() 只返回 keys
	//values() 只返回 values
	// Print keys and values
	for (String i : capitalCities.keySet()) {
  	  System.out.println("key: " + i + " value: " + capitalCities.get(i));
}
  }
}

Files 文件

使用 File 類建立一個對象，指定文件名或者目錄名：

import java.io.File; 

public class GetFileInfo { 
  public static void main(String[] args) { 
    File myObj = new File("filename.txt");
    // Get file info
    if (myObj.exists()) {
      System.out.println("File name: " + myObj.getName()); 
      System.out.println("Absolute path: " + myObj.getAbsolutePath()); 
      System.out.println("Writeable: " + myObj.canWrite()); 
      System.out.println("Readable " + myObj.canRead()); 
      System.out.println("File size in bytes " + myObj.length());
    } else {
      System.out.println("The file does not exist.");
    }
  } 
}

輸出：

File name: filename.txt
Absolute path: C:\Users\MyName\filename.txt
Writeable: true
Readable: true
File size in bytes: 0

import java.io.FileWriter;   // Import the FileWriter class
import java.io.IOException;  // Import the IOException class to handle errors

public class WriteToFile { 
  public static void main(String[] args) { 
    try { 
      FileWriter myWriter = new FileWriter("filename.txt");
      myWriter.write("Files in Java might be tricky, but it is fun enough!");
      myWriter.close(); //當寫好文件以後，須要關閉
      System.out.println("Successfully wrote to the file.");
    } catch (IOException e) {
      System.out.println("An error occurred.");
      e.printStackTrace();
    } 
  } 
}

輸出：

Successfully wrote to the file.

經常使用方法

System.out.println("Hello World"); 打印信息

FAQ

Java中如何理解父類的引用指向類的對象？

知乎-Java中如何理解父類的引用指向類的對象。。初學者。。？介紹的很棒，多態的妙處！

教程

w3schools-Java Tutorial 雖然是英文版，但仍是比較通俗易懂的，推薦；

Java 複習

基本知識點

註釋-Commonts

變量-Variables

數據類型-Data Types

泛型

下來講說泛型通配符T，E，K，V區別

Strings

Math

If...Else

Switch

While 循環

For 循環

Arrays 數組

Exceptions

Methods 方法

Java Classes 類

類和對象 Classes and Objects

Methods 方法

Constructors 構造器

修飾符 Modifiers

Encapsulation 封裝

Packages 包

繼承 Inheritance

Polymorphism 多態

Interface 接口

Enums 枚舉類

User Input 用戶輸入

Data and Time 日期和時間

Current Date /當前時間 Current Time 顯示當前日期

ArrayList 數組列表

HashMap

Files 文件

經常使用方法

FAQ

Java中如何理解父類的引用指向類的對象？

教程