1、Java語言語法規則和文件格式；
第一個Java程序：
/**
第一個Java程序：
控制台輸出Hello world！
*/
public class Test{
//訪問修飾符 class關鍵詞用於聲明類使用 后面跟類名
public static void main(String args[]){//程序的入口，主函數main方法；
System.out.println(“Hello world!”);// 輸出語句
}
}
Java語言區分大小寫；
public 為訪問修飾符；
class關鍵詞，用於聲明類；
/**/ 多行注釋；注釋掉內容不被程序視為可執行內容；
//單行注釋；
一條語句結束，需要通過“;” 分號結束，表示這條語句已經結束；
Java語言可以通過空格或者換行符、制表符等將其分隔開.
文件格式：一個Java程序，需要有類的聲明，一般一個.java 文件中只有一個類；但是，也可以有多個class存在，此時主意：一個.java文件中，只能存在一個public 修飾的類，即：一個java文件名，應該與這個文件中public 修飾的類名相同；一個java文件中只能存在一個public 修飾的類；
2、程序的入口主函數（主方法）；
在java中主函數main方法，語句格式如下：public static void main(String args[]){}
主函數只能存在於public修飾的類中；否則無法執行該主方法；如果放到其他沒有被public修飾的類中，沒語法錯誤，但是無法執行。
3、變量的聲明和賦值；
變量主要用於數據的存儲，需先聲明再使用；
1、全局變量：聲明在類中，方法外，多個方法可同時使用,也被稱作“屬性”、類變量、成員變量等；可以不賦初始值；全局變量可以在類型前面加訪問修飾符，來控制該變量被訪問的范圍：
例如：
private int i=100;
pulic String str=“”;
protected short t;
2、局部變量：聲明在方法中，供當前方法使用； 聲明是必須賦值或者使用時必須有賦值操作；
例如：
字節型：byte b=99;
短整型：int i=11;
整型： short t=5;
長整型：long l=1898989;
字符串變量：String str=“HELLO”;
浮點型：單精度：float f=1.78;
浮點型：雙精度：double d=1.7878787878;
布爾類型： boolean b=true;
字符型：char c=‘A’;
4、Java中數據類型的分類；
Java中可以分為兩大類數據類型：
1、基本數據類型：
整型：
字節型（8位）： byte -128到127之間的任意整數
短整型（16位）： short -32768~32767之間的任意整數
整型（32位）：int -2^31到2^31-1之間的任意整數
長整型（64位）：long -2^63到2^63-1之間的任意整數
浮點型：
單精度（32位）：float 32位單精度浮點數 根據IEEE754-1985標准
雙精度（64位）：double
布爾類型： boolean （true/false）
字符型(16位)：char
2、引用數據類型：引用類型的內存單元中只存放對象的地址，而對象本身存貯在內存堆中，只是簡單的引用對象的地址。非基本數據類型變量，都是引用數據類型；
（1）類class 例如：Object類 Date類
（2）接口interface
（3）數組array
5、基本數據類型之間的轉換；
在Java中有如下幾種轉換方式：
1、隱式轉換（亦稱自動類型轉換）：系統默認將其轉換為我們需要的數據類型；
轉換規則：從存儲范圍小的類型到存儲范圍大的類型。
具體規則為：byte→short(char)→int→long→float→double
也就是說 short類型的變量可以自動轉換為 int 類型
例如：short t=10，10默認為int類型；
注意：在java中，整數默認為int類型，小數默認為double類型；
2、強制轉換：在變量前加小括號，寫轉換類型，將其強制轉換為指定類型；強制類型轉換，也稱顯式類型轉換，是指必須書寫代碼才能完成的類型轉換。
該類類型轉換很可能存在精度的損失，所以必須書寫相應的代碼，並且能夠忍受該種損失時才進行該類型的轉換。
轉換規則:從存儲范圍大的類型到存儲范圍小的類型。
具體規則為：double→float→long→int→short(char)→byte
語法格式為：(轉換到的類型)需要轉換的值
例如：
(1)byte<- short<-int<-long(這里表示賦值方向)例如：
int i=10；short t=(short)i;
float f=(float)10.123;
long l=10; int i2=(int) l; short t2=(short) l;
(2) double->float;（double賦值給float類型）
float/double->（byte/short/int/long）例如：
float f=(float)10.123; float f=10.123f;
double d=10.123;int i3=(int) d;short t3=(short) d;long l2=(long) d; byte b=(byte) d;
（3）(byte/short/int/long/float/double)->char
char c='A';
c=(char) i;
特殊情況下：通過某些JavaAPI相關方法實現類型轉換(不是基本數據類型之間的轉換了)
例如：
double dRes=Double.valueOf("10.89");
6、關鍵字、標識符和常量用法；
1.關鍵字（詞）：是java中特有的詞語，是電腦語言（這里我們指Java）里事先定義的，有特別意義的標識符，有時又叫保留字，還有特別意義的變量。
例如：
abstract 抽象類或方法
assert 用來查找內部程序錯誤
break 跳出一個switch或循環
byte 8位整數類型
case switch的一個分支
catch 捕獲異常的try塊子句
2.標識符
（1）由字母、數字、_下划線，或者$美元符號組成；
（2）不能以數字開頭；
（3）區分大小寫，長度無限制，但是要見名知意；
（4）不能是Java關鍵字或者保留字；
例如：
合法：Person 、 user_name、 _userName、$abc_123、userProject
非法：2Username、#Test、class 、void、pulic
p.s.類、方法、屬性（變量）、常量命名規則：
類名：開頭字母必須大寫，后面每個單詞首字母也大寫，其他小寫字母；
方法名：開頭字母小寫、后面每個單詞首字母大寫；
常量：所有字母大寫；
3.常量：例如：當我們在項目中定義一個性別標識時，如男性:SEX_MEN="1" ，在我們使用時，永遠不會修改這個數據，此時我們可以認為它就是常量；定義常量后，不 會被修改；（注意：之聲明在類中作為全局變量使用）例如：
public static final String SEX_MAN="0";
7、運算符、表達式；
例如：
int i=6，j，k，m，n;
j = +i; //取原值，即j=6
k = -i; //取負值，即k=-6
m = i++; //先m=i,再i=i+1，即m=6，i=7
m = ++i; //先i=i+1,再m=i，即i=7，m=7
n = j--; //先n=j,再j=j-1，即n=6，j=5
n = --j; //先j=j-1,再n=j，即j=5，n=5;
p.s. ++/-- 在前時，則先運算再取值；在后時，則先取值再運算。
8、條件判斷語句： if語句和switch語句；
(1)if語句結構
(2)switch流程控制語句結構：
主意：switch只能實現等值條件判斷；而且表達式類型只能是int、char、byte類型變量；其中break表示退出當前判斷的執行體；如果再循環中表示退出整個循環；
例如：
（3）三元運算符
語法為：條件表達式？表達式1：表達式2。
說明：問號前面的位置是判斷的條件，判斷結果為bool型，為true時調用表達式1，為false時調用表達式2。
例如：A>B ? 100 :200;
9、循環語句結構；
（1）for循環流程控制
p.s. for循環中另有此種循環方式: for (循環變量類型 循環變量名稱 : 要被遍歷的對象) 循環體,例如：
(2)while循環流程控制
(3)do…while循環流程
p.s. do...while循環與while循環的區別是do…while的循環主體至少運行一次。
10、字符串的定義和使用；
Java中String聲明字符串兩種方法及它們的區別 :
方法1：String msg = “Hello”；
直接賦值。該方法執行后會自動將字符串“Hello”保存在字符串池中。則第二次使用直接賦值時，先檢測字符串池中是否已存在“Hello”，如果存在，則將堆地址賦給引用。
Public class StringDemo{
String msg1 = “Hello”；
String msg2 = “Hello”；
}
執行后使得msg1與msg2的指向的地址是相同的。即內存中只有一個Hello的值。被兩個引用所指向。String類采用了共享的設計模式。
方法2：String msg =new String（“Hello”）；
構造方法賦值。該方法執行后，會開辟兩個內存空間（耗費資源），msg會指向其中的一個，而另一個沒有引用指向，就會成為垃圾內存被清理掉。使用構造方法聲明的“Hello”不會自動保存到字符串池中，不能共享。
Public class StringDemo{
String msg1 = new String（“Hello”）；
String msg2 = new String（“Hello”）；
}
執行后，雖然內容一樣，但是存放的地址是不一樣的。他不會自動保存在字符串內存池中。
總結：綜上所述，直接賦值及構造方法賦值，因保存到字符串池有差異，導致是否可以共享亦有差異，效果如下：
String str1=“weight”;
String str2=“weight”;
String str3=new String (“weight”);
System.out.println(str1==str2);//true
System.out.println(str2==str3);//false
字符串常用方法：
1、charCodeAt方法返回一個整數，代表指定位置字符的Unicode編碼。 strObj.charCodeAt(index) 說明： index將被處理字符的從零開始計數的編號。有效值為0到字符串長度減1的數字。 如果指定位置沒有字符，將返回NaN。 例如： var str = "ABC"; str.charCodeAt(0); 結果：65 2、fromCharCode方法從一些Unicode字符串中返回一個字符串。 String.fromCharCode([code1[,code2...]]) 說明： code1，code2...是要轉換為字符串的Unicode字符串序列。如果沒有參數，結果為空字符串。 例如： String.fromCharCode(65,66,112); 結果：ABp 3、charAt方法返回指定索引位置處的字符。如果超出有效范圍的索引值返回空字符串。 strObj.charAt(index) 說明： index想得到的字符的基於零的索引。有效值是0與字符串長度減一之間的值。 例如： var str = "ABC"; str.charAt(1); 結果：B 4、slice方法返回字符串的片段。 strObj.slice(start[,end]) 說明： start下標從0開始的strObj指定部分其實索引。如果start為負，將它作為length+start處理，此處length為字符串的長度。 end小標從0開始的strObj指定部分結束索引。如果end為負，將它作為length+end處理，此處length為字符串的長度。 例如： 012345 var str = "ABCDEF"; str.slice(2,4); 結果：CD 5、substring方法返回位於String對象中指定位置的子字符串。 strObj.substring(start,end) 說明： start指明子字符串的起始位置，該索引從0開始起算。 end指明子字符串的結束位置，該索引從0開始起算。 substring方法使用start和end兩者中的較小值作為子字符串的起始點。如果start或end為NaN或者為負數，那么將其替換為0。 例如： 012345 var str = "ABCDEF"; str.substring(2,4); // 或 str.substring(4,2); 結果：CD 6、substr方法返回一個從指定位置開始的指定長度的子字符串。 strObj.substr(start[,length]) 說明： start所需的子字符串的起始位置。字符串中的第一個字符的索引為0。 length在返回的子字符串中應包括的字符個數。 例如： 012345 var str = "ABCDEF"; str.substr(2,4); 結果：CDEF 7、indexOf方法放回String對象內第一次出現子字符串位置。如果沒有找到子字符串，則返回-1。 strObj.indexOf(substr[,startIndex]) 說明： substr要在String對象中查找的子字符串。 startIndex該整數值指出在String對象內開始查找的索引。如果省略，則從字符串的開始處查找。 例如： 01234567 var str = "ABCDECDF"; str.indexOf("CD"，1); // 由1位置從左向右查找 123... 結果：2 8、lastIndexOf方法返回String對象中字符串最后出現的位置。如果沒有匹配到子字符串，則返回-1。 strObj.lastIndexOf(substr[,startindex]) 說明： substr要在String對象內查找的子字符串。 startindex該整數值指出在String對象內進行查找的開始索引位置。如果省略，則查找從字符串的末尾開始。 例如： 01234567 var str = "ABCDECDF"; str.lastIndexOf("CD",6); // 由6位置從右向左查找 ...456 結果：5 9、search方法返回與正則表達式查找內容匹配的第一個字符串的位置。 strObj.search(reExp) 說明： reExp包含正則表達式模式和可用標志的正則表達式對象。 例如： var str = "ABCDECDF"; str.search("CD"); // 或 str.search(/CD/i); 結果：2 10、concat方法返回字符串值，該值包含了兩個或多個提供的字符串的連接。 str.concat([string1[,string2...]]) 說明： string1，string2要和所有其他指定的字符串進行連接的String對象或文字。 例如： var str = "ABCDEF"; str.concat("ABCDEF","ABC"); 結果：ABCDEFABCDEFABC 11、將一個字符串分割為子字符串，然后將結果作為字符串數組返回。 strObj.split([separator[,limit]]) 說明： separator字符串或 正則表達式 對象，它標識了分隔字符串時使用的是一個還是多個字符。如果忽略該選項，返回包含整個字符串的單一元素數組。 limit該值用來限制返回數組中的元素個數。 例如： var str = "AA BB CC DD EE FF"; alert(str.split(" "，3)); 結果： AA,BB,CC 12、toLowerCase方法返回一個字符串，該字符串中的字母被轉換成小寫。 例如： var str = "ABCabc"; str.toLowerCase(); 結果：abcabc 13、toUpperCase方法返回一個字符串，該字符串中的所有字母都被轉換為大寫字母。 例如： var str = "ABCabc"; str.toUpperCase(); 結果：ABCABC
11、數組的定義和使用；
數組的定義和使用：
1.數組：它是一個變量，用於存儲相同數據類型的一組數據；
2.建立java數組需要以下三個步驟：
聲明數組
創建數組空間
初始化數組元素
3.數組的聲明方式：
(1)數據類型 變量名[];
(2)數據類型[] 變量名;
例如：char s[]; char[] s;
Object p[]; Object[] p;
注意：
為數組開辟內存空間，在創建數組空間時必須為它指明數組的長度。
一個數組是一個對象，所以用new來創建數組
語法格式為：數組名 = new 數組元素類型[數組元素的個數]；
例如：
int[] MyIntArray;
MyIntArray =new int[4];
MyIntArray[0]=0;
MyIntArray[1]=1;
MyIntArray[2]=2;
MyIntArray[3]=3;
也可以在創建數組空間的時候，同時將初值給出來，例如：
int[] myIntArray={1,2,3,4};
存儲空間的分配等價於使用new
有上面描述得知：java中數組長度不可變；
基本數據類型的數組元素會自動初始化成“空”值（對於數值，空值就是零；對於char，它是null；而對於boolean，它卻是false）。
多維數組的定義和使用：
1. 定義方式：type 維數 arrayName；
例如：int [][] intArray；int[][][] a2；
2. 分配內存空間: 有兩種方法：
a.直接為每一維分配空間：
如：int[][] a = new int[2][3]；
b.分別為每一維分配空間：
如：int[][] a = new int[2][ ]；
a[0] = new int[4];
a[1] = new int[3];
p.s.Java中多維數組被看作數組的數組。例如二維數組為一個特殊的一維數組，其每個元素又是一個一維數組。
如：int[][] a = new int[2][3]；
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
3.多維數組（這里我們針對二維數組舉例）初始化有兩種方式：
例如：
（1）int[][] a = new int[2][3]； 先定義后再賦值；
（2）int a[][] = {{2,3,6}, {1,5}, {3,4}}; 定義時直接賦值；
關於java數組的常用操作方法
1. 聲明一個數組
1 String[] arr1 = new String[5];
2 String[] arr2 = {"a","b","c", "d", "e"};
3 String[] arr3= new String[]{"a","b","c","d","e"};
2. 輸出一個數組
1 int[] arr = { 1, 2, 3, 4, 5 };
2 String arrString = Arrays.toString(arr);
3
4 // 直接輸出，為內存地址
5 System.out.println(arr);
6 // [I@139a55
7
8 System.out.println(arrString );
9 // [1, 2, 3, 4, 5]
3. 檢查一個數組是否包含某值
1 String[] arr= { "a", "b", "c", "d", "e" };
2 boolean b = Arrays.asList(arr).contains("a");
3 System.out.println(b);
4 // true
4. 連接兩個數組
1 //使用Apache Commons Lang library
2
3 1 int[] arr1 = { 1, 2, 3, 4, 5 };
4 2 int[] arr2= { 6, 7, 8, 9, 10 };
5 3 int[] combArr = ArrayUtils.addAll(arr1 , arr2);
// System.arraycopy()
1 static String[] concat(String[] a, String[] b) { 2 String[] c = new String[a.length + b.length]; 3 System.arraycopy(a, 0, c, 0, a.length); 4 System.arraycopy(b, 0, c, a.length, b.length); 5 return c; 6 }
1 //Arrays.copyOf()
2
3 public static int[] concat(int[] first, int[] second) {
4 int[] result = Arrays.copyOf(first, first.length + second.length);
5 System.arraycopy(second, 0, result, first.length, second.length);
6 return result;
7 }
5. 逆向輸出一個數組
1 // Apache Commons Lang library
2
3 int[] arr= { 1, 2, 3, 4, 5 };
4 ArrayUtils.reverse(intArray);
5 System.out.println(Arrays.toString(intArray));
6 //[5, 4, 3, 2, 1]
1 int[] arr = { 1, 2, 3, 4, 5 };
2 int[] revArr = new int[arr.length];
3 for(int i = 0; i < arr.length; i++){
4 revArr[i] = arr[arr.length - i -1];
5 }
6 System.out.println(Arrays.toString(revArr));
7
8 //[5, 4, 3, 2, 1]
6. 移除數組中的元素
1 // Apache common lang
2
3 int[] arr= { 1, 2, 3, 4, 5 };
4 int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
5 System.out.println(Arrays.toString(removed))
p.s. 《java基礎梳理-朝花夕拾》系列由何東飛根據自己工作幾年以來對java的理解梳理而成，筆者閑暇時將持續更新，有不對的地方請各位指教。QQ:983489147