摘要：變量聲明變量變量名規(guī)則字母開頭，由字母或數(shù)字構成的序列，中的字母包括或者某種語言中代表字母的任何字符，數(shù)字包括或者某種語言中代表數(shù)字的任何字符。刪除原始字符串頭部和尾部空格。中斷控制流程，使用在和循環(huán)中，用于提前中斷循環(huán)。

《Java核心技術 卷Ⅰ》 第3章 Java 的基本程序設計結構

類命名：CamelCase 駝峰命名法，以及必須是字母開頭，后面跟字母和數(shù)字的任意組合；

源代碼文件名：必須與公共類的名字相同（包括大小寫）；

Java中的函數(shù)：都是屬于某個類的方法（而不是稱為成員函數(shù)）；

Java通用語法：object.method(parameters)；

Java使用雙引號分隔字符串；

println輸出后會換行，而print輸出后不換行；

注釋方法：

單行：code; //comment；

多行：/* comment */,不可嵌套使用；

文檔：使用方式如下

/**
 * This is a document comment
 * @from Core Java Chapter 3
 */

8種基本類型(primitive type)：

4種整形：byte,short,int,long；

2種浮點型：float,double；

Unicode編碼字符單元：char；

真值：boolean；

Java沒有無符號類型。

如果需要數(shù)值計算不含任何誤差，應使用BigDecimal或BigInteger類；

NaN不能用 == 來判斷。

聲明變量：type name;

變量名規(guī)則：字母開頭，由字母或數(shù)字構成的序列，Java中的字母包括"A"~"Z"、"a"~"z"、"_"、"$"或者某種語言中代表字母的任何Unicode字符，數(shù)字包括"0"~"9"或者某種語言中代表數(shù)字的任何Unicode字符。

變量名大小寫敏感，長度沒有限制；

可以在一行聲明多個變量，但不提倡；

變量聲明盡可能靠近變量第一次使用的地方；

final關鍵字指示常量，表示只能被賦值一次，常量常用全大寫；

static final關鍵字指示類常量，一個類中的多個方法使用，const雖然是保留字，但是目前并沒有使用；

基礎運算符：+、-、*、/、%;

整數(shù)被0除會產生異常，浮點數(shù)被0除會得到無窮大或NaN結果；

自增自減：++、--，注意在其他表達式中前綴和后綴的區(qū)別，簡易多帶帶使用，以免產生困惑和問題；

關系（比較）運算符以及邏輯運算符：沒有什么特殊的，略；

三元操作符： condition ? exp1(true) : exp2(false);

位運算符：處理整數(shù)，與(&)、或(|)、非(~)、異或(^)、左移(<<)、右移(>>)，在位模式下工作, >>>邏輯右移用0填充高位，>>>算數(shù)右移用符號位填充高位。其中需要注意的是，移位操作右邊的操作數(shù)，也就是移位位數(shù)值在運算前需要進行模數(shù)據(jù)位數(shù)的計算，int類型 1 << 35 和 1 << 3 的結果相同；

數(shù)學函數(shù)：Math.method(x).

合法轉換基本原則：從低字節(jié)類型向高字節(jié)類型轉換；

特殊情況：int(4字節(jié))、long(8字節(jié))轉float(8字節(jié))仍有可能有精度損失，long(8字節(jié))轉double(16字節(jié))也可能有精度損失，但int轉double沒有精度損失；

以上是自動完成的類型轉換；

強制類型轉換(cast)：(type) var，注意轉換如果超出范圍則會截斷產生另一個合法的值;

舍入運算：Math.ground(x)，注意返回的是long；

暫時只記錄一些常用的，以下優(yōu)先級遞減。

除特殊說明，結合性（即在遇到相同優(yōu)先級運算符時計算的順序）默認從左向右。

方法調用

一元運算符：!,~(位非),++,--,+(正),-(負)，強轉，new，從右到左

乘、除、求余數(shù)

加、減

移位

大于(等于)、小于(等于)

相等、不等

位與

位異或

位或

邏輯與

邏輯或

三元運算符，從右到左

帶有賦值(=)操作的操作符，比如+=,-=,...，從右到左

當自己寫代碼時拿不準優(yōu)先級的時候，省事點加括號就完事了。

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };
Size s = Size.MEDIUM; //賦值為null則表示沒有設置任何值

Java沒有內置的字符串類型，而是在標準Java類庫中提供了一個預定義類String，每個用雙引號括起來的字符串都是String類的一個實例。

String emptyString = "";
String greeting = "Hello";

String s = greeting.substring(0, 3);

substring方法的兩個參數(shù)是：

想要復制的第一個位置（從0開始）

不想復制的第一個位置（從0開始）

兩個參數(shù)相減就是子串的長度。

String name = "FirstName" + "LastName";
String age = 24 + "years old";
String person = String.join(",", name, age[, ...]);
// person is "FirstName LastName,24 years old[, ...]"

一個字符串與一個非字符串拼接時，后者轉換成字符串（任何一個Java對象都可以轉換成字符串，可能指的是Class.toString()）。

String類沒有提供修改字符的方法，編譯器可以讓字符串共享以提高效率。

"Hello".equals(greeting) //區(qū)分大小寫
"Hello".equalsIgnoreCase("hello") //不區(qū)分大小寫

一定不要使用==來解決這個問題，它只能確定字符串是否在同一位置，而不是他們具有相同的字符內容。

如果虛擬機始終將相同字符串共享，那就可以使用==，但實際上只有字符串常量是共享的，+和substring等操作產生的結果并不是共享的。

""是長度為0的字符串，如果要檢查字符串是否為空串：

str.length() == 0
str.equals("")

Null串指的是String變量存放null，表示目前沒有任何對象與該變量關聯(lián)：

str == null

檢查字符串既不是null串也不是空串：

str != null && str.length() != 0

只列出一般常用到的

int compareTo(String other)：按照字典順序，字符串在other之前就返回負數(shù)，位于other之后則為正數(shù)，相等返回0。

new String(int[] codePoints, int offset, int count：僅了解，用數(shù)組中從offset開始的count個碼點構造字符串。

boolean equals(Object other)

boolean equalsIgnoreCase(String other)

boolean startsWith(String prefix)：如果以prefix為開頭，返回true。

boolean endsWith(String suffix)：如果以suffix為結尾，返回true。

int indexOf(String str)：返回與字符串str匹配的第一個子串的開始位置，如果不存在則返回-1。

int length()

String replace(CharSequence oldString, CharSequence newString)：用newString代替原始字符串中所有oldString，可用String或StringBuilder作為參數(shù)。

String substring(int beginlndex, int endlndex)

String toLowerCase()

String toUpperCase()

String trim()：刪除原始字符串頭部和尾部空格。

String join(CharSequence delimiter, CharSequence... elements)

CharSequence類型的參數(shù)，這是一種接口類型，所有字符串都屬于這個接口。

當需要用許多較短字符串構成字符串時，使用String的拼接方式效率會比較低，每次連接都會產生一個新的String對象，耗時也浪費空間，使用StringBuilder類可以避免這個問題。

StringBuilder builder = new StringBuilder();
builder.append(ch);
builder.append(str);
String string = builder.toString();

StringBuilder類的前身是StringBuffer，效率稍低但是允許多線程方式添加或刪除字符，如果只是在單線程中編輯，則應該用StringBuilder替代它，兩個類的API相同。

int length()

StringBuilder appencl(String str or char c)

void setCharAt(int i, char c)：將第i個代碼單元設置為c。

StringBuilder insert(int offset,String str or char c)：在offset位置插入一個串或單元并返回this。

StringBuilder delete(lnt startindex,int endlndex)：刪除偏移量從startIndex到endIndex-1的代碼單元并返回this。

String toString()：返回內容相同的字符串。

首先在程序的最開始添上：

import java.util.*

Scanner類定義在java.util包中，當使用的類不是定義在基本java.lang包中時，一定要import指示將相應包加載。

Scanner in = new Scanner(System.in);
System.out.print("Qusetion:");
String answer = in.nextLine();

nextLine方法獲取的是一個輸入行，只想讀取一個單詞（以空白符作為分隔符），機會調用：

String answer = in.next();

讀取一個數(shù)：

int number = in.nextInt();
double weight = in.nextDouble();

boolean hasNext()：檢查輸入中是否還有其他單詞。

boolean hasNextInt()

boolean hasNextDouble()

如果想讀取一個輸入不可見的密碼，使用Console類：

Console cons = System.console();
String username = cons.readLine("User name:");
char[] password = cons.readPassword("Password:");

安全起見，在完成密碼處理不再使用password后，應使用填充值覆蓋數(shù)組元素。

double x = 10000.0/3.0;
System.out.print(x);
// 3333.3333333333335
System.out.printf("%8.2f", x);
// 8個字符寬度和小數(shù)點后兩個字符的精度打印x，也就是打印一個空格和7個字符
// 3333.33
System.out.printf("Hello %s, you are %d.", name, age);

d：十進制整數(shù)

x：十六進制整數(shù)

f：定點浮點數(shù)

e：指數(shù)浮點數(shù)

s：字符串

c：字符

b：布爾

%：百分號

使用靜態(tài)的String.format方法創(chuàng)建一個格式化字符串，而不打印輸出：

String str = Stirng.format("Hello %s, you are %d.", name, age);

文件讀?。?/p>

Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");
// Scanner(File f)
// static Path get(String pathname)：根據(jù)給定路徑名構造一個Path
// 然后使用前面介紹的Scanner的方法進行文件讀取

如果文件名（包括其路徑，比如C:dir)，中有反斜杠，則要在每個反斜杠前再加一個額外的反斜杠（因為反斜杠是作為轉義字符的存在，在字符串中要表示則必須用）。

這里指定了UTF-8字符編碼，要讀取一個文本時要知道它的字符編碼，如果省略字符編碼將會使用運行這個Java程序的機器的“默認編碼”，不同機器可能會有不同的“默認編碼”。

文件寫入：

PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");
// PrintWriter(String fileName)

如果文件不存在，將創(chuàng)建該文件，使用print,printf,println等方法寫入數(shù)據(jù)。

注意，如果直接給Scanner一個字符串參數(shù)，Scanner會把字符串解釋為數(shù)據(jù)而不是文件名。

Scanner in = new Scanner("myfile.txt");
// Scanner會包含10個字符的數(shù)據(jù)，而不是文件數(shù)據(jù)

另外，如果使用一個不存在的文件構造Scanner或者用一個不能被創(chuàng)建的文件名構造一個PrintWriter將會發(fā)生異常，Java編譯器認為這些異常比“被0除”異常更嚴重。

Java的控制流程結構與C和C++的一樣，只有很少的例外，Java沒有goto語句，但break語句可以帶標簽，可以實現(xiàn)從內層循環(huán)跳出的目的。另外還有一種變形的for循環(huán)，類似C#的foreach循環(huán)。

塊，即復合語句，一對大括號括起來的若干Java語句，塊確定了變量的作用域。

{ // block 1
  int i;
  {
    // block 2 這是一個嵌套塊
    int j;
  }
}

但不能在嵌套的兩個塊中聲明同名變量：

{ // block 1
  int i;
  {
    // block 2
    int i; // Error
  }
}

雖然C++中，允許這樣做，內層定義的變量會覆蓋外層定義的變量，有可能導致程序設計出錯，所以Java中不允許這樣做。

if(condition1) { statement1 }
else if(condition2) { statement2 }
else { statement3 }

while(condition) { statement }

如果希望循環(huán)體至少被執(zhí)行一次，則使用：

do { statement }
while(condition);

for(declare; condition; refresh) { statement }
// for語句內部聲明的變量無法在循環(huán)體外部使用

switch(condition)
{
  case 1:
    ...
    break;
  case 2:
    ...
    break;
  ...
  default:
    // no case match
    ...
    break;
}

case標簽可以是：

類型為char、byte、short或int的常量表達式；

switch(grade)
{
  ...
  case 100:
  ...
}

枚舉常量（當使用枚舉常量時，不必在標簽中指明枚舉名）；

Size size = ....;
switch(size)
{
  ...
  case SMALL: //no need to use Size.SMALL
  ...
}

JAVA SE 7 開始可以用字符串字面量。

switch(str)
{
  ...
  case "yes":
  ...
}

break，使用在while和for循環(huán)中，用于提前中斷循環(huán)。

Java提供一個種帶標簽的break語句，用于跳出多重嵌套的循環(huán)語句。

tag:
while(...)
{
  ...
  for(...)
  {
    ...
    if(...)
    {
      break tag;
    }
  }
}
// 在break后會跳出綁定tag的循環(huán)體（在這里也就是while）
// 而不是像普通break只是跳出for

continue，用于跳過本次循環(huán)，進行下一次循環(huán)體的執(zhí)行。

基本的整數(shù)和浮點數(shù)精度不能夠滿足需求，可以使用java.math包中的兩個很有用的類：

BigInteger：任意精度的整數(shù)運算

BigDecimal：任意精度的浮點數(shù)運算

使用valueOf方法可以將普通的數(shù)值轉換為大數(shù)值：

BigInteger a = BigInteger.valueOf(100);

算術運算符是add、subtract、divide、multiply，BigInteger還有mod運算：

BigInteger c = a.add(b);
// c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));
// d = c * (b + 2)

以及兩個大數(shù)的比較compareTo，相等返回0，小于返回負，大于返回正。

聲明數(shù)組變量：

int[] a;
int[] b = new int[100];

當然Java中也可以int a[]的聲明方式，看個人喜好吧。

數(shù)組創(chuàng)建時的初始化：

int數(shù)組：所有元素初始化為0

boolean數(shù)組：所有元素初始化為alse

對象數(shù)組：所有元素初始化為null

獲取數(shù)組中的元素個數(shù)使用array.length。

for each 循環(huán)語句的循環(huán)變量將會遍歷數(shù)組中的每個元素，而不需要使用下標值。

for(variable:collection) { statement }

variable：用于暫存集合中的每一個元素，并執(zhí)行相應塊

collection：必須是一個數(shù)組或者實現(xiàn)了Iterable接口的類對象（比如ArrayList）。

for(int element : a)
{
  System.out.println(element);
}

Java中，可以創(chuàng)建數(shù)組對象的同時賦予初始值的寫法：

// 不需要調用new
int[] a = { 2, 3, 5, 7, 11, 13 };
// 初始化一個匿名的數(shù)組
a = new int[] { 17, 19, 23, 31, 37 };
// 這是以下語句的簡寫方式
int[] anonymous = { 17, 19, 23, 31, 37 };
a = anonymous;

Java中允許數(shù)組長度為0，但這與null不同。

數(shù)組變量拷貝：

int[] b = a;
b[0] = 1;

此時a中的第一個元素a[0]的值也會被修改為1。

數(shù)組值拷貝：

int[] c = Arrays.copyOf(a, a.length);
// 第2個參數(shù)是新數(shù)組長度，通常用于增加數(shù)組大小
int[] c = Arrays.copyOf(c, c.length * 2);
// 如果長度小于原始數(shù)組，則只拷貝前面的數(shù)據(jù)元素

如果使用下面這種形式運行一個Java程序：

java Message -g cruel world

則程序中獲取命令行參數(shù)的方法是：

public class Message
{
  public static void main(String[] args)
  {
    // args就是參數(shù)數(shù)組
    System.out.printlf(Arrays.toString(args));
    // [-g, cruel, world]
  }
}

int[] a = new int[1000];
...
Arrays.sort(a);

sort方法使用了優(yōu)化的快速排序算法。

插播一個生成0到n-1之間隨機數(shù)的辦法：

int r = (int) (Math.random() * n);
// Math.random返回一個0-1（不包括1）的隨機浮點數(shù)

static String toString(type[] a)：a為基本數(shù)據(jù)類型數(shù)組（不包括字符串數(shù)組），返回字符串，元素放在中括號內，并用逗號分隔。

static type copyOf(type[] a, int length)

static type copyOfRange(type[] a, int start, int end)

返回與a類型相同的一個數(shù)組，長度為length或end-start

start：起始下標（包含這個值）

end：終止下標（不包含這個值）

static int binarySearch(type[] a, type v)

static int binarySearch(type[] a, int start, int end, type v)

采用二分法查找值v，查找成功則返回相應下標值，否則返回一個負數(shù)值r，-r-1是保持a有序的v應該插入的位置。

static void fi11(type[] a, type v)：將數(shù)組的所有元素設置為v。

static boolean equals(type[] a, type[] b)：數(shù)組大小相同，并且所有對應下標的元素都相等，則返回true。

int[][] magicSquare = 
{
  { 16, 3, 2, 13 },
  { 5, 10, 11, 8 },
  { 9, 6, 7, 12 },
  { 4, 15, 14, 1 }
};
// 訪問元素使用 magicSquare[i][j]

基本命名規(guī)則：駝峰法

三種注釋方式

8種基本數(shù)據(jù)類型

變量聲明以及命名規(guī)則

基本運算符

數(shù)值類型的自動與強制轉換

各運算符優(yōu)先級

枚舉類型

String API

StringBuilder

命令行輸入輸出

文件輸入輸出

控制流程

中斷控制流程

大數(shù)值

數(shù)組以及相關操作

個人靜態(tài)博客：

氣泡的前端日記： https://rheabubbles.github.io