Java語言是面向對象的：
爲了簡單起見，Java語言只支持類之間的單繼承，但支持接口之間的多繼承，並支持類與接口之間的實現機制（關鍵字爲implements）。Java語言全面支持動態綁定，而C++語言只對虛函數使用動態綁定。總之，Java語言是一個純的面向對象程序設計語言。
類名：
對於所有的類來說，類名的首字母應該大寫。如果類名由若干單詞組成，那麼每個單詞的首字母應該大寫，例如 MyFirstJavaClass。
方法名：
所有的方法名都應該以小寫字母開頭。如果方法名含有若干單詞，則後面的每個單詞首字母大寫。
Java修飾符
像其他語言一樣，Java可以使用修飾符來修飾類中方法和屬性。主要有兩類修飾符：
訪問控制修飾符 : default, public , protected, private
非訪問控制修飾符 : final, abstract, strictfp
關鍵字 描述
abstract 抽象方法，抽象類的修飾符
assert 斷言條件是否滿足
boolean 布爾數據類型
break 跳出循環或者label代碼段
byte 8-bit 有符號數據類型
case switch語句的一個條件
catch 和try搭配捕捉異常信息
char 16-bit Unicode字符數據類型
class 定義類
const 未使用
continue 不執行循環體剩餘部分
default switch語句中的默認分支
do 循環語句，循環體至少會執行一次
double 64-bit雙精度浮點數
else if條件不成立時執行的分支
enum 枚舉類型
extends 表示一個類是另一個類的子類
final 表示一個值在初始化之後就不能再改變了
表示方法不能被重寫，或者一個類不能有子類
finally 爲了完成執行的代碼而設計的，主要是爲了程序的健壯性和完整性，無論有沒有異常發生都執行代碼。
float 32-bit單精度浮點數
for for循環語句
goto 未使用
if 條件語句
implements 表示一個類實現了接口
import 導入類
instanceof 測試一個對象是否是某個類的實例
int 32位整型數
interface 接口，一種抽象的類型，僅有方法和常量的定義
long 64位整型數
native 表示方法用非java代碼實現
new 分配新的類實例
package 一系列相關類組成一個包
private 表示私有字段，或者方法等，只能從類內部訪問
protected 表示字段只能通過類或者其子類訪問
子類或者在同一個包內的其他類
public 表示共有屬性或者方法
return 方法返回值
short 16位數字
static 表示在類級別定義，所有實例共享的
strictfp 浮點數比較使用嚴格的規則
super 表示基類
switch 選擇語句
synchronized 表示同一時間只能由一個線程訪問的代碼塊
this 表示調用當前實例
或者調用另一個構造函數
throw 拋出異常
throws 定義方法可能拋出的異常
transient 修飾不要序列化的字段
try 表示代碼塊要做異常處理或者和finally配合表示是否拋出異常都執行finally中的代碼
void 標記方法不返回任何值
volatile 標記字段可能會被多個線程同時訪問，而不做同步
while while循環
接口
在Java中，接口可理解爲對象間相互通信的協議。接口在繼承中扮演着很重要的角色。
接口只定義派生要用到的方法，但是方法的具體實現完全取決於派生類。
一個類可以包含以下類型變量：
局部變量：在方法、構造方法或者語句塊中定義的變量被稱爲局部變量。變量聲明和初始化都是在方法中，方法結束後，變量就會自動銷燬。
成員變量：成員變量是定義在類中，方法體之外的變量。這種變量在創建對象的時候實例化。成員變量可以被類中方法、構造方法和特定類的語句塊訪問。
類變量：類變量也聲明在類中，方法體之外，但必須聲明爲static類型。
創建對象
對象是根據類創建的。在Java中，使用關鍵字new來創建一個新的對象。創建對象需要以下三步：
• 聲明：聲明一個對象，包括對象名稱和對象類型。
• 實例化：使用關鍵字new來創建一個對象。
• 初始化：使用new創建對象時，會調用構造方法初始化對象。
例如：Puppy myPuppy = new Puppy( “tommy” );
Java語言支持的變量類型有：
• 類變量：獨立於方法之外的變量，用 static 修飾。
• 無論一個類創建了多少個對象，類只擁有類變量的一份拷貝。
• 靜態變量儲存在靜態存儲區。經常被聲明爲常量，很少單獨使用static聲明變量。
• 靜態變量在程序開始時創建，在程序結束時銷燬。
• 與實例變量具有相似的可見性。但爲了對類的使用者可見，大多數靜態變量聲明爲public類型。
• 默認值和實例變量相似。數值型變量默認值是0，布爾型默認值是false，引用類型默認值是null。變量的值可以在聲明的時候指定，也可以在構造方法中指定。此外，靜態變量還可以在靜態語句塊中初始化。
• 實例變量：獨立於方法之外的變量，不過沒有 static 修飾。
• 實例變量具有默認值。數值型變量的默認值是0，布爾型變量的默認值是false，引用類型變量的默認值是null。變量的值可以在聲明時指定，也可以在構造方法中指定；
• 實例變量可以直接通過變量名訪問。但在靜態方法以及其他類中，就應該使用完全限定名：ObejectReference.VariableName。
• 局部變量：類的方法中的變量。
• 局部變量是在棧上分配的。
• 局部變量沒有默認值，所以局部變量被聲明後，必須經過初始化，纔可以使用。
public class Variable{
static int allClicks=0; // 類變量
String str=”hello world”; // 實例變量
public void method(){
int i =0; // 局部變量
}
}
訪問控制
| 修飾符 | 當前類 | 同一包內 | 子孫類 | 其他包 |
|---|---|---|---|---|
| public | Y | Y | Y | Y |
| protected | Y | Y | Y | N |
| default | Y | Y | N | N |
| private | Y | N | N | N |
聲明爲私有訪問類型的變量只能通過類中公共的 getter 方法被外部類訪問。
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
Logger 類中的 format 變量爲私有變量，所以其他類不能直接得到和設置該變量的值。爲了使其他類能夠操作該變量，定義了兩個 public 方法：getFormat() （返回 format的值）和 setFormat(String)（設置 format 的值）
protected 訪問修飾符不能修飾類和接口，方法和成員變量能夠聲明爲 protected，但是接口的成員變量和成員方法不能聲明爲 protected。
訪問控制和繼承
請注意以下方法繼承的規則：
• 父類中聲明爲 public 的方法在子類中也必須爲 public。
• 父類中聲明爲 protected 的方法在子類中要麼聲明爲 protected，要麼聲明爲 public，不能聲明爲 private。
• 父類中聲明爲 private 的方法，不能夠被繼承。
final 修飾符
1、final 變量：
final 變量能被顯式地初始化並且只能初始化一次。被聲明爲 final 的對象的引用不能指向不同的對象。但是final對象裏的數據可以被改變。也就是說final對象的引用不能改變，但是裏面的值可以改變。
final修飾符通常和static修飾符一起使用來創建類常量。
final int value = 10;
// 下面是聲明常量的實例
public static final int BOXWIDTH = 6;
static final String TITLE = “Manager”;
2、final 方法
類中的 final 方法可以被子類繼承，但是不能被子類修改。
聲明 final 方法的主要目的是防止該方法的內容被修改。
public class Test{
public final void changeName(){
// 方法體
}
}
3、final 類
final 類不能被繼承，沒有類能夠繼承 final 類的任何特性。
abstract 修飾符
1、抽象類：
抽象類不能用來實例化對象，聲明抽象類的唯一目的是爲了將來對該類進行擴充。
一個類不能同時被abstract和final修飾。如果一個類包含抽象方法，那麼該類一定要聲明爲抽象類，否則將出現編譯錯誤。
抽象類可以包含抽象方法和非抽象方法。
abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}
2、抽象方法
抽象方法是一種沒有任何實現的方法，該方法的具體實現由子類提供。
抽象方法不能被聲明成final和static。
任何繼承抽象類的子類必須實現父類的所有抽象方法，除非該子類也是抽象類。
如果一個類包含若干個抽象方法，那麼該類必須聲明爲抽象類。抽象類可以不包含抽象方法。
抽象方法的聲明以分號結尾，例如：public abstract sample();。
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//實現抽象方法
void m(){
………
}
}
JAVA的類有2種訪問權限: public、默認。
而方法和變量有4種：public、默認、protected、private。
public 意味着任何地方的其他類都能訪問。
默認則是同一個包的類可以訪問。
protected 表示同一個包的類可以訪問，其他的包的該類的子類也可以訪問。
private 表示只有自己類能訪問。
instanceof 運算符
該運算符用於操作對象實例，檢查該對象是否是一個特定類型（類類型或接口類型）。
instanceof運算符使用格式如下：
( Object reference variable ) instanceof (class/interface type)
如果運算符左側變量所指的對象，是操作符右側類或接口(class/interface)的一個對象，那麼結果爲真。
如果被比較的對象兼容於右側類型,該運算符仍然返回true。
Java增強 for循環
Java 增強 for 循環語法格式如下:
for(聲明語句 : 表達式)
{
//代碼句子
}
聲明語句：聲明新的局部變量，該變量的類型必須和數組元素的類型匹配。其作用域限定在循環語句塊，其值與此時數組元素的值相等。
表達式：表達式是要訪問的數組名，或者是返回值爲數組的方法。
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(“,”);
}
String [] names ={“James”, “Larry”, “Tom”, “Lacy”};
for( String name : names ) {
System.out.print( name );
System.out.print(“,”);
}
}
}
break 關鍵字
break 主要
continue 關鍵字
continue 適用於任何循環控制結構中。作用是讓程序立刻跳轉到下一次循環的迭代。
在 for 循環中，continue 語句使程序立即跳轉到更新語句。
在 while 或者 do…while 循環中，程序立即跳轉到布爾表達式的判斷語句。
Java Number & Math 類
一般地，當需要使用數字的時候，我們通常使用內置數據類型，如：byte、int、long、double 等。
int a = 5000;
float b = 13.65f;
byte c = 0x4a;
然而，在實際開發過程中，我們經常會遇到需要使用對象，而不是內置數據類型的情形。爲了解決這個問題，Java 語言爲每一個內置數據類型提供了對應的包裝類。
所有的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類 Number 的子類。
這種由編譯器特別支持的包裝稱爲裝箱，所以當內置數據類型被當作對象使用的時候，編譯器會把內置類型裝箱爲包裝類。相似的，編譯器也可以把一個對象拆箱爲內置類型。Number類屬於 java.lang包。
public class Test{
public static void main(String args[]){
Integer x = 5;
x = x + 10;
System.out.println(x);
}
}
當 x 被賦爲整型值時，由於x是一個對象，所以編譯器要對x進行裝箱。然後，爲了使x能進行加運算，所以要對x進行拆箱。裝箱就是自動將基本數據類型轉換爲包裝器類型；拆箱就是自動將包裝器類型轉換爲基本數據類型。
Java Math 類
Java 的 Math 包含了用於執行基本數學運算的屬性和方法，如初等指數、對數、平方根和三角函數。
Math 的方法都被定義爲 static 形式，通過 Math 類可以在主函數中直接調用。
Number & Math 類方法
下面的表中列出的是 Number & Math 類常用的一些方法：
xxxValue()：將 Number 對象轉換爲xxx數據類型的值並返回。
compareTo()：將number對象與參數比較。
equals()：判斷number對象是否與參數相等。
valueOf()：返回一個 Number 對象指定的內置數據類型
toString()：以字符串形式返回值。
parseInt()：將字符串解析爲int類型。
abs()：返回參數的絕對值。
ceil()：對整形變量向左取整，返回類型爲double型。
floor()：對整型變量向右取整。返回類型爲double類型。
rint()：返回與參數最接近的整數。返回類型爲double。
round()：返回一個最接近的int、long型值。
min()：返回兩個參數中的最小值。
max()：返回兩個參數中的最大值。
exp()：返回自然數底數e的參數次方。
log()：返回參數的自然數底數的對數值。
pow()：返回第一個參數的第二個參數次方。
sqrt()：求參數的算術平方根。
sin()：求指定double類型參數的正弦值。
cos()：求指定double類型參數的餘弦值。
tan()：求指定double類型參數的正切值。
asin()：求指定double類型參數的反正弦值。
acos()：求指定double類型參數的反餘弦值。
atan()：求指定double類型參數的反正切值。
atan2()：將笛卡爾座標轉換爲極座標，並返回極座標的角度值。
toDegrees()：將參數轉化爲角度。
toRadians()：將角度轉換爲弧度。
random()：返回一個隨機數。
Java Character 類
Character類用於對單個字符進行操作。
Character類在對象中包裝一個基本類型 char 的值
Character 方法
下面是Character類的方法：
序號 方法與描述
1 isLetter()：是否是一個字母
2 isDigit()：是否是一個數字字符
3 isWhitespace()：是否是一個空格
4 isUpperCase()：是否是大寫字母
5 isLowerCase()：是否是小寫字母
6 toUpperCase()：指定字母的大寫形式
7 toLowerCase()：指定字母的小寫形式
8 toString()：返回字符的字符串形式，字符串的長度僅爲1
Java String 類
字符串廣泛應用在Java 編程中，在 Java 中字符串屬於對象，Java 提供了 String 類來創建和操作字符串。
創建字符串
創建字符串最簡單的方式如下:
String greeting = “菜鳥教程”;
在代碼中遇到字符串常量時，這裏的值是 “菜鳥教程”“，編譯器會使用該值創建一個 String 對象。
和其它對象一樣，可以使用關鍵字和構造方法來創建 String 對象。
String 類有 11 種構造方法，這些方法提供不同的參數來初始化字符串，比如提供一個字符數組參數:
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { ‘r’, ‘u’, ‘n’, ‘o’, ‘o’, ‘b’};
String helloString = new String(helloArray);
System.out.println( helloString );
}
}
注意:String 類是不可改變的，所以你一旦創建了 String 對象，那它的值就無法改變了（詳看筆記部分解析）。
如果需要對字符串做很多修改，那麼應該選擇使用 StringBuffer & StringBuilder 類。
連接字符串
String 類提供了連接兩個字符串的方法：
string1.concat(string2);
返回 string2 連接 string1 的新字符串。也可以對字符串常量使用 concat() 方法，如：
“我的名字是 “.concat(“Runoob”);
更常用的是使用’+’操作符來連接字符串，如：
“Hello,” + ” runoob” + “!”
創建格式化字符串
我們知道輸出格式化數字可以使用 printf() 和 format() 方法。
String 類使用靜態方法 format() 返回一個String 對象而不是 PrintStream 對象。
String 類的靜態方法 format() 能用來創建可複用的格式化字符串，而不僅僅是用於一次打印輸出。
如下所示：
System.out.printf(“浮點型變量的的值爲 ” +
“%f, 整型變量的值爲 ” +
” %d, 字符串變量的值爲 ” +
“is %s”, floatVar, intVar, stringVar);
String 方法
1 char charAt(int index)：返回指定索引處的 char 值。
2 int compareTo(Object o)：把這個字符串和另一個對象比較。
3 int compareTo(String anotherString)：按字典順序比較兩個字符串。
4 int compareToIgnoreCase(String str)：按字典順序比較兩個字符串，不考慮大小寫。
5 String concat(String str)：將指定字符串連接到此字符串的結尾。
6 boolean contentEquals(StringBuffer sb)：當且僅當字符串與指定的StringButter有相同順序的字符時候返回真。
7 static String copyValueOf(char[] data)：返回指定數組中表示該字符序列的 String。
8 static String copyValueOf(char[] data, int offset, int count)：返回指定數組中表示該字符序列的 String。
9 boolean endsWith(String suffix)：測試此字符串是否以指定的後綴結束。
10 boolean equals(Object anObject)：將此字符串與指定的對象比較。
11 boolean equalsIgnoreCase(String anotherString)
將此 String 與另一個 String 比較，不考慮大小寫。
12 byte[] getBytes()
使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
13 byte[] getBytes(String charsetName)
使用指定的字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
將字符從此字符串複製到目標字符數組。
15 int hashCode()
返回此字符串的哈希碼。
16 int indexOf(int ch)
返回指定字符在此字符串中第一次出現處的索引。
17 int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
18 int indexOf(String str)
返回指定子字符串在此字符串中第一次出現處的索引。
19 int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
20 String intern()
返回字符串對象的規範化表示形式。
21 int lastIndexOf(int ch)
返回指定字符在此字符串中最後一次出現處的索引。
22 int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。
23 int lastIndexOf(String str)
返回指定子字符串在此字符串中最右邊出現處的索引。
24 int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。
25 int length()
返回此字符串的長度。
26 boolean matches(String regex)
告知此字符串是否匹配給定的正則表達式。
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
測試兩個字符串區域是否相等。
28 boolean regionMatches(int toffset, String other, int ooffset, int len)
測試兩個字符串區域是否相等。
29 String replace(char oldChar, char newChar)
返回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 得到的。
30 String replaceAll(String regex, String replacement
使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。
31 String replaceFirst(String regex, String replacement)
使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
32 String[] split(String regex)
根據給定正則表達式的匹配拆分此字符串。
33 String[] split(String regex, int limit)
根據匹配給定的正則表達式來拆分此字符串。
34 boolean startsWith(String prefix)
測試此字符串是否以指定的前綴開始。
35 boolean startsWith(String prefix, int toffset)
測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
36 CharSequence subSequence(int beginIndex, int endIndex)
返回一個新的字符序列，它是此序列的一個子序列。
37 String substring(int beginIndex)
返回一個新的字符串，它是此字符串的一個子字符串。
38 String substring(int beginIndex, int endIndex)
返回一個新字符串，它是此字符串的一個子字符串。
39 char[] toCharArray()
將此字符串轉換爲一個新的字符數組。
40 String toLowerCase()
使用默認語言環境的規則將此 String 中的所有字符都轉換爲小寫。
41 String toLowerCase(Locale locale)
使用給定 Locale 的規則將此 String 中的所有字符都轉換爲小寫。
42 String toString()
返回此對象本身（它已經是一個字符串！）。
43 String toUpperCase()
使用默認語言環境的規則將此 String 中的所有字符都轉換爲大寫。
44 String toUpperCase(Locale locale)
使用給定 Locale 的規則將此 String 中的所有字符都轉換爲大寫。
45 String trim()
返回字符串的副本，忽略前導空白和尾部空白。
46 static String valueOf(primitive data type x)
返回給定data type類型x參數的字符串表示形式。
Java StringBuffer和StringBuilder類
當對字符串進行修改的時候，需要使用 StringBuffer 和 StringBuilder 類。
和 String 類不同的是，StringBuffer 和 StringBuilder 類的對象能夠被多次的修改，並且不產生新的未使用對象。
StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不同在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。
由於 StringBuilder 相較於 StringBuffer 有速度優勢，所以多數情況下建議使用 StringBuilder 類。然而在應用程序要求線程安全的情況下，則必須使用 StringBuffer 類。
StringBuffer 方法
1 public StringBuffer append(String s)
將指定的字符串追加到此字符序列。
2 public StringBuffer reverse()
將此字符序列用其反轉形式取代。
3 public delete(int start, int end)
移除此序列的子字符串中的字符。
4 public insert(int offset, int i)
將 int 參數的字符串表示形式插入此序列中。
5 replace(int start, int end, String str)
使用給定 String 中的字符替換此序列的子字符串中的字符。
其他的和String 類的方法類似：
Java 數組
聲明數組變量
首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法：
dataType[] arrayRefVar; // 首選的方法
或 dataType arrayRefVar[]; // 效果相同，但不是首選方法
創建數組
Java語言使用new操作符來創建數組，語法如下：
arrayRefVar = new dataType[arraySize];
上面的語法語句做了兩件事：
• 一、使用 dataType[arraySize] 創建了一個數組。
• 二、把新創建的數組的引用賦值給變量 arrayRefVar。
數組變量的聲明，和創建數組可以用一條語句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
另外，你還可以使用如下的方式創建數組。
dataType[] arrayRefVar = {value0, value1, …, valuek};
foreach 循環
JDK 1.5 引進了一種新的循環類型，被稱爲 foreach 循環或者加強型循環，它能在不使用下標的情況下遍歷數組。
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有數組元素
for (double element: myList) {
System.out.println(element);
}
}
}
數組作爲函數的參數
數組可以作爲參數傳遞給方法。
例如，下面的例子就是一個打印 int 數組中元素的方法:
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + ” “);
}
}
printArray(new int[]{3, 1, 2, 6, 4, 2});
數組作爲函數的返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j–) {
result[j] = list[i];
}
return result;
}
多維數組
多維數組可以看成是數組的數組，比如二維數組就是一個特殊的一維數組，其每一個元素都是一個一維數組：String str[][] = new String[3][4];
多維數組的動態初始化（以二維數組爲例）
1. 直接爲每一維分配空間，格式如下：
type arrayName = new typ[arraylenght1][arraylenght2];
type 可以爲基本數據類型和複合數據類型，arraylenght1 和 arraylenght2 必須爲正整數，arraylenght1 爲行數，arraylenght2 爲列數。
int a[][] = new int[2][3];
2. 從最高維開始，分別爲每一維分配空間，例如：
String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String(“Good”);
s[0][1] = new String(“Luck”);
s[1][0] = new String(“to”);
s[1][1] = new String(“you”);
s[1][2] = new String(“!”);
多維數組的引用（以二維數組爲例）
對二維數組中的每個元素，引用方式爲 arrayName[index1][index2]，
num[1][0];
Arrays 類
java.util.Arrays 類能方便地操作數組，它提供的所有方法都是靜態的。
具有以下功能：
• 給數組賦值：通過 fill 方法。
• 對數組排序：通過 sort 方法,按升序。
• 比較數組：通過 equals 方法比較數組中元素值是否相等。
• 查找數組元素：通過 binarySearch 方法能對排序好的數組進行二分查找法操作。
序號 方法和說明
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。如果查找值包含在數組中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。
2 public static boolean equals(long[] a, long[] a2)
如果兩個指定的 long 型數組彼此相等，則返回 true。如果兩個數組包含相同數量的元素，並且兩個數組中的所有相應元素對都是相等的，則認爲這兩個數組是相等的。換句話說，如果兩個數組以相同順序包含相同的元素，則兩個數組是相等的。同樣的方法適用於所有的其他基本數據類型（Byte，short，Int等）。
3 public static void fill(int[] a, int val)
將指定的 int 值分配給指定 int 型數組指定範圍中的每個元素。同樣的方法適用於所有的其他基本數據類型（Byte，short，Int等）。
4 public static void sort(Object[] a)
對指定對象數組根據其元素的自然順序進行升序排列。同樣的方法適用於所有的其他基本數據類型（Byte，short，Int等）。
Java 日期時間
java.util 包提供了 Date 類來封裝當前的日期和時間。 Date 類提供兩個構造函數來實例化 Date 對象。
第一個構造函數使用當前日期和時間來初始化對象。
Date( )
第二個構造函數接收一個參數，該參數是從1970年1月1日起的毫秒數。
Date(long millisec)
Date對象創建以後，可以調用下面的方法。
1 boolean after(Date date)
若當調用此方法的Date對象在指定日期之後返回true,否則返回false。
2 boolean before(Date date)
若當調用此方法的Date對象在指定日期之前返回true,否則返回false。
3 Object clone( )
返回此對象的副本。
4 int compareTo(Date date)
比較當調用此方法的Date對象和指定日期。兩者相等時候返回0。調用對象在指定日期之前則返回負數。調用對象在指定日期之後則返回正數。
5 int compareTo(Object obj)
若obj是Date類型則操作等同於compareTo(Date) 。否則它拋出ClassCastException。
6 boolean equals(Object date)
當調用此方法的Date對象和指定日期相等時候返回true,否則返回false。
7 long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。
8 int hashCode( )
返回此對象的哈希碼值。
9 void setTime(long time)
用自1970年1月1日00:00:00 GMT以後time毫秒數設置時間和日期。
10 String toString( )
轉換Date對象爲String表示形式，並返回該字符串。
獲取當前日期時間
Java中獲取當前日期和時間很簡單，使用 Date 對象的 toString() 方法來打印當前日期和時間，
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// 初始化 Date 對象
Date date = new Date();
// 使用 toString() 函數顯示日期時間
System.out.println(date.toString());
}
}
日期比較
Java使用以下三種方法來比較兩個日期：
• 使用 getTime() 方法獲取兩個日期（自1970年1月1日經歷的毫秒數值），然後比較這兩個值。
• 使用方法 before()，after() 和 equals()。例如，一個月的12號比18號早，則 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
• 使用 compareTo() 方法，它是由 Comparable 接口定義的，Date 類實現了這個接口。
使用 SimpleDateFormat 格式化日期
SimpleDateFormat 是一個以語言環境敏感的方式來格式化和分析日期的類。SimpleDateFormat 允許你選擇任何用戶自定義日期時間格式來運行。例如：
public static void main(String args[]) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat (“E yyyy.MM.dd ‘at’ hh:mm:ss a zzz”);
System.out.println(“Current Date: ” + ft.format(dNow));
}
SimpleDateFormat ft = new SimpleDateFormat (“E yyyy.MM.dd ‘at’ hh:mm:ss a zzz”);
這一行代碼確立了轉換的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是時、分、秒。
注意:有的格式大寫，有的格式小寫，例如 MM 是月份，mm 是分；HH 是 24 小時制，而 hh 是 12 小時制。
日期和時間的格式化編碼
時間模式字符串用來指定時間格式。在此模式中，所有的 ASCII 字母被保留爲模式字母，定義如下：
字母 描述 示例
G 紀元標記 AD
y 四位年份 2001
M 月份 July or 07
d 一個月的日期 10
h A.M./P.M. (1~12)格式小時 12
H 一天中的小時 (0~23) 22
m 分鐘數 30
s 秒數 55
S 毫秒數 234
E 星期幾 Tuesday
D 一年中的日子 360
F 一個月中第幾周的周幾 2 (second Wed. in July)
w 一年中第幾周 40
W 一個月中第幾周 1
a A.M./P.M. 標記 PM
k 一天中的小時(1~24) 24
K A.M./P.M. (0~11)格式小時 10
z 時區 Eastern Standard Time
’ 文字定界符 Delimiter
” 單引號 `
Java 正則表達式
正則表達式定義了字符串的模式。
正則表達式可以用來搜索、編輯或處理文本。
正則表達式並不僅限於某一種語言，但是在每種語言中有細微的差別。
正則表達式實例
一個字符串其實就是一個簡單的正則表達式，例如 Hello World 正則表達式匹配 “Hello World” 字符串。
.（點號）也是一個正則表達式，它匹配任何一個字符如：”a” 或 “1”。
下表列出了一些正則表達式的實例及描述：
正則表達式 描述
this is text
匹配字符串 “this is text”
this\s+is\s+text
匹配單詞 “this” 後面的 \s+ 可以匹配多個空格，之後匹配 is 字符串，再之後 \s+ 匹配多個空格然後再跟上 text 字符串。
^\d+(.\d+)?
^ 定義了以什麼開始
\d+ 匹配一個或多個數字
? 設置括號內的選項是可選的
. 匹配 “.”
可以匹配的實例：”5”, “1.5” 和 “2.21”。
Java 正則表達式和 Perl 的是最爲相似的。
java.util.regex 包主要包括以下三個類：
• Pattern 類：
pattern 對象是一個正則表達式的編譯表示。Pattern 類沒有公共構造方法。要創建一個 Pattern 對象，你必須首先調用其公共靜態編譯方法，它返回一個 Pattern 對象。該方法接受一個正則表達式作爲它的第一個參數。
• Matcher 類：
Matcher 對象是對輸入字符串進行解釋和匹配操作的引擎。與Pattern 類一樣，Matcher 也沒有公共構造方法。你需要調用 Pattern 對象的 matcher 方法來獲得一個 Matcher 對象。
• PatternSyntaxException：
PatternSyntaxException 是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。
捕獲組
捕獲組是把多個字符當一個單獨單元進行處理的方法，它通過對括號內的字符分組來創建。
例如，正則表達式 (dog) 創建了單一分組，組裏包含”d”，”o”，和”g”。
捕獲組是通過從左至右計算其開括號來編號。例如，在表達式（（A）（B（C））），有四個這樣的組：
• ((A)(B(C)))
• (A)
• (B(C))
• (C)
可以通過調用 matcher 對象的 groupCount 方法來查看表達式有多少個分組。groupCount 方法返回一個 int 值，表示matcher對象當前有多個捕獲組。
還有一個特殊的組（group(0)），它總是代表整個表達式。該組不包括在 groupCount 的返回值中。
\
將下一字符標記爲特殊字符、文本、反向引用或八進制轉義符。例如，”n”匹配字符”n”。”\n”匹配換行符。序列”\”匹配”\”，”(“匹配”(“。
^
匹配輸入字符串開始的位置。如果設置了 RegExp 對象的 Multiline 屬性，^ 還會與”\n”或”\r”之後的位置匹配。
*
零次或多次匹配前面的字符或子表達式。例如，zo* 匹配”z”和”zoo”。* 等效於 {0,}。
+
一次或多次匹配前面的字符或子表達式。例如，”zo+”與”zo”和”zoo”匹配，但與”z”不匹配。+ 等效於 {1,}。
?
零次或一次匹配前面的字符或子表達式。例如，”do(es)?”匹配”do”或”does”中的”do”。? 等效於 {0,1}。
{n}
n 是非負整數。正好匹配 n 次。例如，”o{2}”與”Bob”中的”o”不匹配，但與”food”中的兩個”o”匹配。
{n,}
n 是非負整數。至少匹配 n 次。例如，”o{2,}”不匹配”Bob”中的”o”，而匹配”foooood”中的所有 o。”o{1,}”等效於”o+”。”o{0,}”等效於”o*”。
{n,m}
M 和 n 是非負整數，其中 n <= m。匹配至少 n 次，至多 m 次。例如，”o{1,3}”匹配”fooooood”中的頭三個 o。’o{0,1}’ 等效於 ‘o?’。注意：您不能將空格插入逗號和數字之間。
?
當此字符緊隨任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之後時，匹配模式是”非貪心的”。”非貪心的”模式匹配搜索到的、儘可能短的字符串，而默認的”貪心的”模式匹配搜索到的、儘可能長的字符串。例如，在字符串”oooo”中，”o+?”只匹配單個”o”，而”o+”匹配所有”o”。
.
匹配除”\r\n”之外的任何單個字符。若要匹配包括”\r\n”在內的任意字符，請使用諸如”[\s\S]”之類的模式。
(pattern)
匹配 pattern 並捕獲該匹配的子表達式。可以使用
(?:pattern)
匹配 pattern 但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，不存儲供以後使用的匹配。這對於用”or”字符 (|) 組合模式部件的情況很有用。例如，’industr(?:y|ies) 是比 ‘industry|industries’ 更經濟的表達式。
(?=pattern)
執行正向預測先行搜索的子表達式，該表達式匹配處於匹配 pattern 的字符串的起始點的字符串。它是一個非捕獲匹配，即不能捕獲供以後使用的匹配。例如，’Windows (?=95|98|NT|2000)’ 匹配”Windows 2000”中的”Windows”，但不匹配”Windows 3.1”中的”Windows”。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配之後，而不是在組成預測先行的字符後。
(?!pattern)
執行反向預測先行搜索的子表達式，該表達式匹配不處於匹配 pattern 的字符串的起始點的搜索字符串。它是一個非捕獲匹配，即不能捕獲供以後使用的匹配。例如，’Windows (?!95|98|NT|2000)’ 匹配”Windows 3.1”中的 “Windows”，但不匹配”Windows 2000”中的”Windows”。預測先行不佔用字符，即發生匹配後，下一匹配的搜索緊隨上一匹配之後，而不是在組成預測先行的字符後。
x|y
匹配 x 或 y。例如，’z|food’ 匹配”z”或”food”。’(z|f)ood’ 匹配”zood”或”food”。
[xyz]
字符集。匹配包含的任一字符。例如，”[abc]”匹配”plain”中的”a”。
[^xyz]
反向字符集。匹配未包含的任何字符。例如，”[^abc]”匹配”plain”中”p”，”l”，”i”，”n”。
[a-z]
字符範圍。匹配指定範圍內的任何字符。例如，”[a-z]”匹配”a”到”z”範圍內的任何小寫字母。
[^a-z]
反向範圍字符。匹配不在指定的範圍內的任何字符。例如，”[^a-z]”匹配任何不在”a”到”z”範圍內的任何字符。
\b
匹配一個字邊界，即字與空格間的位置。例如，”er\b”匹配”never”中的”er”，但不匹配”verb”中的”er”。
\B
非字邊界匹配。”er\B”匹配”verb”中的”er”，但不匹配”never”中的”er”。
\cx
匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回車符。x 的值必須在 A-Z 或 a-z 之間。如果不是這樣，則假定 c 就是”c”字符本身。
\d
數字字符匹配。等效於 [0-9]。
\D
非數字字符匹配。等效於 [^0-9]。
\f
換頁符匹配。等效於 \x0c 和 \cL。
\n
換行符匹配。等效於 \x0a 和 \cJ。
\r
匹配一個回車符。等效於 \x0d 和 \cM。
\s
匹配任何空白字符，包括空格、製表符、換頁符等。與 [ \f\n\r\t\v] 等效。
\S
匹配任何非空白字符。與 [^ \f\n\r\t\v] 等效。
\t
製表符匹配。與 \x09 和 \cI 等效。
\v
垂直製表符匹配。與 \x0b 和 \cK 等效。
\w
匹配任何字類字符，包括下劃線。與”[A-Za-z0-9_]”等效。
\W
與任何非單詞字符匹配。與”[^A-Za-z0-9_]”等效。
\xn
匹配 n，此處的 n 是一個十六進制轉義碼。十六進制轉義碼必須正好是兩位數長。例如，”\x41”匹配”A”。”\x041”與”\x04”&”1”等效。允許在正則表達式中使用 ASCII 代碼。
\num
匹配 num，此處的 num 是一個正整數。到捕獲匹配的反向引用。例如，”(.)\1”匹配兩個連續的相同字符。
\n
標識一個八進制轉義碼或反向引用。如果 \n 前面至少有 n 個捕獲子表達式，那麼 n 是反向引用。否則，如果 n 是八進制數 (0-7)，那麼 n 是八進制轉義碼。
\nm
標識一個八進制轉義碼或反向引用。如果 \nm 前面至少有 nm 個捕獲子表達式，那麼 nm 是反向引用。如果 \nm 前面至少有 n 個捕獲，則 n 是反向引用，後面跟有字符 m。如果兩種前面的情況都不存在，則 \nm 匹配八進制值 nm，其中 n 和 m 是八進制數字 (0-7)。
\nml
當 n 是八進制數 (0-3)，m 和 l 是八進制數 (0-7) 時，匹配八進制轉義碼 nml。
\un
匹配 n，其中 n 是以四位十六進制數表示的 Unicode 字符。例如，\u00A9 匹配版權符號 (©)。
Java 方法
在前面幾個章節中我們經常使用到 System.out.println()，那麼它是什麼呢？
• println() 是一個方法。
• System 是系統類。
• out 是標準輸出對象。
這句話的用法是調用系統類 System 中的標準輸出對象 out 中的方法 println()。
命令行參數的使用
有時候你希望運行一個程序時候再傳遞給它消息。這要靠傳遞命令行參數給main()函數實現。
命令行參數是在執行程序時候緊跟在程序名字後面的信息。
import java.util.Scanner;
public class CommandLine {
public static void main(String[] args) {
// TODO Auto-generated method stub
int M=100;
String[] s=new String[M];
System.out.println(“input:”);
Scanner sc=new Scanner(System.in);
for(int i=0;i