Java 基礎語法 - tw511教學網

四、Java基礎語法

Java 運算子

計算機的最基本用途之一就是執行數學運算，作爲一門計算機語言，Java也提供了一套豐富的運算子來操縱變數。我們可以把運算子分成以下幾組：

算術運算子
關係運算符
位運算子
邏輯運算子
賦值運算子
其他運算子

算術運算子

算術運算子用在數學表達式中，它們的作用和在數學中的作用一樣。下表列出了所有的算術運算子。

表格中的範例假設整數變數A的值爲10，變數B的值爲20：

操作符	描述	例子
+	加法 - 相加運算子兩側的值	A + B 等於 30
-	減法 - 左運算元減去右運算元	A – B 等於 -10
*	乘法 - 相乘操作符兩側的值	A * B等於200
/	除法 - 左運算元除以右運算元	B / A等於2
％	取餘 - 左運算元除以右運算元的餘數	B%A等於0
++	自增: 運算元的值增加1	B++ 或 ++B 等於 21（區別詳見下文）
–	自減: 運算元的值減少1	B-- 或 --B 等於 19（區別詳見下文）

下面下麪的簡單範例程式演示了算術運算子。複製並貼上下面下麪的 Java 程式並儲存爲 Test.java 檔案，然後編譯並執行這個程式：

範例

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 檢視  d++ 與 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

執行結果

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

自增自減運算子

自增（++）自減（–）運算子是一種特殊的算術運算子，在算術運算子中需要兩個運算元來進行運算，而自增自減運算子是一個運算元。

字首自增自減法(++a,–a): 先進行自增或者自減運算，再進行表達式運算。
後綴自增自減法(a++,a–): 先進行表達式運算，再進行自增或者自減運算

範例：

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定義一個變數；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增運算子字首運算後a="+a+",x="+x);
        System.out.println("自增運算子後綴運算後b="+b+",y="+y);
    }
}

執行結果：

自增運算子字首運算後a=6，x=12
自增運算子後綴運算後b=6，y=10

關係運算符

下表爲Java支援的關係運算符,表格中的範例整數變數A的值爲10，變數B的值爲20：

運算子	描述	例子
==	檢查如果兩個運算元的值是否相等，如果相等則條件爲真。	（A == B）爲假。
!=	檢查如果兩個運算元的值是否相等，如果值不相等則條件爲真。	(A != B) 爲真。
>	檢查左運算元的值是否大於右運算元的值，如果是那麼條件爲真。	（A> B）爲假。
<	檢查左運算元的值是否小於右運算元的值，如果是那麼條件爲真。	（A <B）爲真。
>=	檢查左運算元的值是否大於或等於右運算元的值，如果是那麼條件爲真。	（A> = B）爲假。
<=	檢查左運算元的值是否小於或等於右運算元的值，如果是那麼條件爲真。	（A <= B）爲真。

下面下麪的簡單範例程式演示了關係運算符。複製並貼上下面下麪的Java程式並儲存爲Test.java檔案，然後編譯並執行這個程式：

範例

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}

執行結果：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

位運算子

Java定義了位運算子，應用於整數型別(int)，長整型(long)，短整型(short)，字元型(char)，和位元組型(byte)等型別。

位運算子作用在所有的位上，並且按位元運算。假設a = 60，b = 13;它們的二進制格式表示將如下：

範例

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位運算子的基本運算，假設整數變數 A 的值爲 60 和變數 B 的值爲 13：

操作符	描述	例子
＆	如果相對應位都是1，則結果爲1，否則爲0	（A＆B），得到12，即0000 1100
\|	如果相對應位都是 0，則結果爲 0，否則爲 1	（A \| B）得到61，即 0011 1101
^	如果相對應位值相同，則結果爲0，否則爲1	（A ^ B）得到49，即 0011 0001
〜	按位元取反運算子翻轉運算元的每一位，即0變成1，1變成0。	（〜A）得到-61，即1100 0011
<<	按位元左移運算子。左運算元按位元左移右運算元指定的位數。	A << 2得到240，即 1111 0000
>>	按位元右移運算子。左運算元按位元右移右運算元指定的位數。	A >> 2得到15即 1111
>>>	按位元右移補零操作符。左運算元的值按右運算元指定的位數右移，移動得到的空位以零填充。	A>>>2得到15即0000 1111

下面下麪的簡單範例程式演示了位運算子。複製並貼上下面下麪的Java程式並儲存爲Test.java檔案，然後編譯並執行這個程式：

範例

public class Test {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
}

執行結果：

a && b = false
a || b = true
!(a && b) = true

邏輯運算子

下表列出了邏輯運算子的基本運算，假設布爾變數A爲真，變數B爲假

操作符	描述	例子
&&	稱爲邏輯與運算子。當且僅當兩個運算元都爲真，條件才爲真。	（A && B）爲假。
\| \|	稱爲邏輯或操作符。如果任何兩個運算元任何一個爲真，條件爲真。	（A \| \| B）爲真。
！	稱爲邏輯非運算子。用來反轉運算元的邏輯狀態。如果條件爲true，則邏輯非運算子將得到false。	！（A && B）爲真。

下面下麪的簡單範例程式演示了邏輯運算子。複製並貼上下面下麪的Java程式並儲存爲Test.java檔案，然後編譯並執行這個程式：

範例

public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }
}

執行結果：

a && b = false
a || b = true
!(a && b) = true

短路邏輯運算子

當使用與邏輯運算子時，在兩個運算元都爲true時，結果才爲true，但是當得到第一個操作爲false時，其結果就必定是false，這時候就不會再判斷第二個操作了。

public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定義一個變數；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路邏輯運算子的結果爲"+b);
        System.out.println("a的結果爲"+a);
    }
}

執行結果爲：

使用短路邏輯運算子的結果爲false
a的結果爲5

賦值運算子

下面下麪是Java語言支援的賦值運算子：

操作符	描述	例子
=	簡單的賦值運算子，將右運算元的值賦給左側運算元	C = A + B將把A + B得到的值賦給C
+ =	加和賦值操作符，它把左運算元和右運算元相加賦值給左運算元	C + = A等價於C = C + A
- =	減和賦值操作符，它把左運算元和右運算元相減賦值給左運算元	C - = A等價於C = C - A
* =	乘和賦值操作符，它把左運算元和右運算元相乘賦值給左運算元	C * = A等價於C = C * A
/ =	除和賦值操作符，它把左運算元和右運算元相除賦值給左運算元	C / = A，C 與 A 同類型時等價於 C = C / A
（％）=	取模和賦值操作符，它把左運算元和右運算元取模後賦值給左運算元	C％= A等價於C = C％A
<< =	左移位賦值運算子	C << = 2等價於C = C << 2
>> =	右移位賦值運算子	C >> = 2等價於C = C >> 2
＆=	按位元與賦值運算子	C＆= 2等價於C = C＆2
^ =	按位元互斥或賦值操作符	C ^ = 2等價於C = C ^ 2
\| =	按位元或賦值操作符	C \| = 2等價於C = C \| 2

面的簡單範例程式演示了賦值運算子。複製並貼上下面下麪的Java程式並儲存爲Test.java檔案，然後編譯並執行這個程式：

範例

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}

執行結果如：

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

條件運算子（?:）

條件運算子也被稱爲三元運算子。該運算子有3個運算元，並且需要判斷布爾表達式的值。該運算子的主要是決定哪個值應該賦值給變數。

variable x = (expression) ? value if true : value if false

範例

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等於 1 成立，則設定 b 爲 20，否則爲 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等於 10 成立，則設定 b 爲 20，否則爲 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

執行結果：

Value of b is : 30
Value of b is : 20

instanceof 運算子

該運算子用於操作物件範例，檢查該物件是否是一個特定型別（類型別或介面型別）。

( Object reference variable ) instanceof  (class/interface type)

如果運算子左側變數所指的物件，是操作符右側類或介面(class/interface)的一個物件，那麼結果爲真,看下面下麪的例子：

範例

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

執行結果

true

Java運算子優先順序

當多個運算子出現在一個表達式中，誰先誰後呢？這就涉及到運算子的優先級別的問題。在一個多運算子的表達式中，運算子優先順序不同會導致最後得出的結果差別甚大。

例如，（1+3）＋（3+2）*2，這個表達式如果按加號最優先計算，答案就是 18，如果按照乘號最優先，答案則是 14。

再如，x = 7 + 3 * 2;這裏x得到13，而不是20，因爲乘法運算子比加法運算子有較高的優先順序，所以先計算3 * 2得到6，然後再加7。

下表中具有最高優先順序的運算子在的表的最上面，最低優先順序的在表的底部。

類別	操作符	關聯性
後綴	() [] . (點操作符)	左到右
一元	expr++ expr–	從左到右
一元	++expr --expr + - ～！	從右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
關係	> >= < <=	左到右
相等	== !=	左到右
按位元與	＆	左到右
按位元互斥或	^	左到右
按位元或	\|	左到右
邏輯與	&&	左到右
邏輯或	\| \|	左到右
條件	？：	從右到左
賦值	= + = - = * = / =％= >> = << =＆= ^ = \| =	從右到左
逗號	，	左到右

Java 分支語句

條件語句可根據不同的條件執行不同的語句。包括if條件語句與switch多分支語句。

分類

if 分支結構
switch 分支結構

if分支結構

第一種格式

if(條件表達式){
執行的程式碼塊；
}

執行流程

[外連圖片轉存失敗,源站可能有防盜鏈機制機製,建議將圖片儲存下來直接上傳(img-Q1v2sAwU-1597371747417)(https://gitee.com/darknightjakt/mapdepot/raw/master/img/20200813105708)]

執行流程說明

首先判斷關係表達式看其結果是true還是false
如果是true就執行語句體
如果是false就不執行語句體

範例

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("開始");
		// 定義兩個變數
		int a = 10;
		int b = 20;

		if (a == b) {
			System.out.println("a等於b");
		}
	
		int c = 10;
		if (a == c) {
			System.out.println("a等於c");
		}
	
		System.out.println("結束");
	}
}

第二種格式

if(條件表達式){
執行的程式碼塊;
}else{
執行的程式碼塊；
}

執行流程

[外連圖片轉存失敗,源站可能有防盜鏈機制機製,建議將圖片儲存下來直接上傳(img-NLiNC2Py-1597371747419)(https://s3.ap-northeast-1.wasabisys.com/img.tw511.com/202008/20200813105709hiyunvkx5wy.jpg)]

執行流程說明

首先判斷關係表達式看其結果是true還是false
如果是true就執行語句體1
如果是false就執行語句體2

範例

public class IfDemo2 {
	public static void main(String[] args) {
		System.out.println("開始");
		// 判斷給定的數據是奇數還是偶數
		// 定義變數
	int a = 100;
		// 給a重新賦值
	a = 99;

	if (a % 2 == 0) {
		System.out.println("a是偶數");
	} else {
		System.out.println("a是奇數");
	}
	
		System.out.println("結束");
	}
}

第三種格式

if(條件表達式){
執行的程式碼塊;
}else if(條件表達式){
執行的程式碼塊;
}…(此處省略N個else if)
else{
執行程式碼塊;
}

執行流程

[外連圖片轉存失敗,源站可能有防盜鏈機制機製,建議將圖片儲存下來直接上傳(img-zRnrGI8N-1597371747421)(https://gitee.com/darknightjakt/mapdepot/raw/master/img/20200813105710)]

執行流程說明

首先判斷關係表達式1看其結果是true還是false
如果是true就執行語句體1
如果是false就繼續判斷關係表達式2看其結果是true還是false
如果是true就執行語句體2
如果是false就繼續判斷關係表達式…看其結果是true還是false
…
如果沒有任何關係表達式爲true，就執行語句體n+1

範例

public class IfDemo3 {
	public static void main(String[] args) {
        
		// 定義變數
		int x = 5;
		int y = 0;
        
		if (x >= 3) {
			y = 2 * x + 1;
		} 
        else if (x >= -1 && x < 3) {
			y = 2 * x;
		} 
        else{
			y = 2 * x - 1;
		}
		
		System.out.println("y的值是："+y);
	}
}

注意事項

1、一旦滿足某個條件表達式，則進入其執行語句塊執行，執行完畢後不會執行其一下的條件語句。
2、如果多個條件表達式之間爲「互斥」關係，多個語句之間可以上下調換順序，一旦是包含關係，要求條件表達式範圍小的寫到範圍大的上邊；

switch分支結構

首先計算出表達式的值
其次，和case依次比較，一旦有對應的值，就會執行相應的語句，在執行的過程中，遇到break就會結束。
最後，如果所有的case都和表達式的值不匹配，就會執行default語句體部分，然後程式結束掉。

執行流程

[外連圖片轉存失敗,源站可能有防盜鏈機制機製,建議將圖片儲存下來直接上傳(img-NdnrZWji-1597371747424)(https://gitee.com/darknightjakt/mapdepot/raw/master/img/20200813105711)]

舉例

public class SwitchDemo {
	public static void main(String[] args) {
		//建立鍵盤錄入物件
		Scanner sc = new Scanner(System.in);
		
		//接收數據
		System.out.println("請輸入一個數字(1-7)：");
		int weekday = sc.nextInt();
		
		//switch語句實現選擇
		switch(weekday) {
		case 1:
			System.out.println("星期一");
			break;
		case 2:
			System.out.println("星期二");
			break;
		case 3:
			System.out.println("星期三");
			break;
		case 4:
			System.out.println("星期四");
			break;
		case 5:
			System.out.println("星期五");
			break;
		case 6:
			System.out.println("星期六");
			break;
		case 7:
			System.out.println("星期日");
			break;
		default:
			System.out.println("你輸入的數位有誤");
			break;
		}
	}
}

注意事項

swich（表達式）中表達式的返回值必須是以下幾種型別之一：

byte，short，char，int，列舉(jdk1.5)，String(jdk1.7)
case子句中的值必須是常數，且所有case子句中的值應是不同的；
default子句是可任選的，當沒有匹配的case時，執行default；
break語句用來在執行完一個case分支後使程式跳出swich語句塊；如果沒有break程式會順序執行到swich結尾；

分支結構和switch分支結構區別

和swich語句很像，如果判斷的具體數值不多，而且複合byte、short、int、char這四種類型。建議使用swich語句，因爲效率稍高；

其他情況：對區間進行判斷，對結果爲boolean型別進行判斷，使用if，if的使用範圍比較廣泛。

Java回圈語句

順序結構的程式語句只能被執行一次。如果您想要同樣的操作執行多次,，就需要使用回圈結構。

Java中有三種主要的回圈結構：

while 回圈
do…while 回圈
for 回圈

while 回圈

while是最基本的回圈，它的結構爲：

while( 布爾表達式 ) { //回圈內容 }

只要布爾表達式爲 true，回圈就會一直執行下去。

範例

public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

執行結果：

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

do…while 回圈

對於 while 語句而言，如果不滿足條件，則不能進入回圈。但有時候我們需要即使不滿足條件，也至少執行一次。

do…while 回圈和 while 回圈相似，不同的是，do…while 回圈至少會執行一次。

do {
       //程式碼語句
}while(布爾表達式);

**注意：**布爾表達式在回圈體的後面，所以語句塊在檢測布爾表達式之前已經執行了。如果布爾表達式的值爲 true，則語句塊一直執行，直到布爾表達式的值爲 false。

範例

public class Test {
   public static void main(String args[]){
      int x = 10;
 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}

執行結果：

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

for回圈

雖然所有回圈結構都可以用 while 或者 do…while表示，但 Java 提供了另一種語句 —— for 回圈，使一些回圈結構變得更加簡單。

for回圈執行的次數是在執行前就確定的。語法格式如下：

for(初始化; 布爾表達式; 更新) { //程式碼語句 }

關於 for 回圈有以下幾點說明：

最先執行初始化步驟。可以宣告一種型別，但可初始化一個或多個回圈控制變量，也可以是空語句。
然後，檢測布爾表達式的值。如果爲 true，回圈體被執行。如果爲false，回圈終止，開始執行回圈體後面的語句。
執行一次回圈後，更新回圈控制變量。
再次檢測布爾表達式。回圈執行上面的過程。

範例

public class Test {
   public static void main(String args[]) {
 
      for(int x = 10; x < 20; x = x+1) {
         System.out.print("value of x : " + x );
         System.out.print("\n");
      }
   }
}

執行結果：

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

for each 回圈

Java5 引入了一種主要用於陣列的增強型 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(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

以上範例編譯執行結果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

break 關鍵字

break 主要用在回圈語句或者 switch 語句中，用來跳出整個語句塊。

break 跳出最裏層的回圈，並且繼續執行該回圈下面下麪的語句。

語法

break 的用法很簡單，就是回圈結構中的一條語句：

break;

範例

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         // x 等於 30 時跳出回圈
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

以上範例編譯執行結果如下：

10
20

continue 關鍵字

continue 適用於任何回圈控制結構中。作用是讓程式立刻跳轉到下一次回圈的迭代。

在 for 回圈中，continue 語句使程式立即跳轉到更新語句。

在 while 或者 do…while 回圈中，程式立即跳轉到布爾表達式的判斷語句。

語法

continue 就是回圈體中一條簡單的語句：

continue;

範例

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

以上範例編譯執行結果如下：

Java陣列

陣列對於每一門程式語言來說都是重要的數據結構之一，當然不同語言對陣列的實現及處理也不盡相同。

Java 語言中提供的陣列是用來儲存固定大小的同類型元素。

你可以宣告一個數組變數，如 numbers[100] 來代替直接宣告 100 個獨立變數 number0，number1，…，number99。

本教學將爲大家介紹 Java 陣列的宣告、建立和初始化，並給出其對應的程式碼。

一維陣列

首先必須宣告陣列變數，才能纔能在程式中使用陣列。下面下麪是宣告陣列變數的語法：

dataType[] arrayRefVar;   // 首選的方法  或  dataType arrayRefVar[];  // 效果相同，但不是首選方法

注意: 建議使用 dataType[] arrayRefVar 的宣告風格宣告陣列變數。 dataType arrayRefVar[] 風格是來自 C/C++ 語言，在Java中採用是爲了讓 C/C++ 程式設計師能夠快速理解java語言。

範例

下面下麪是這兩種語法的程式碼範例：

double[] myList;         // 首選的方法  或  double myList[];         //  效果相同，但不是首選方法

建立陣列

Java語言使用new操作符來建立陣列，語法如下：

arrayRefVar = new dataType[arraySize];

上面的語法語句做了兩件事：

一、使用 dataType[arraySize] 建立了一個數組。
二、把新建立的陣列的參照賦值給變數 arrayRefVar。

陣列變數的宣告，和建立陣列可以用一條語句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，你還可以使用如下的方式建立陣列。

dataType[] arrayRefVar = {value0, value1, ..., valuek};

陣列的元素是通過索引存取的。陣列索引從 0 開始，所以索引值從 0 到 arrayRefVar.length-1。

範例

下面下麪的語句首先宣告瞭一個數組變數 myList，接着建立了一個包含 10 個 double 型別元素的陣列，並且把它的參照賦值給 myList 變數。

public class TestArray {
   public static void main(String[] args) {
      // 陣列大小
      int size = 10;
      // 定義陣列
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 計算所有元素的總和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("總和爲： " + total);
   }
}

以上範例輸出結果爲：

總和爲： 11367.373

處理陣列

陣列的元素型別和陣列的大小都是確定的，所以當處理陣列元素時候，我們通常使用基本回圈或者 For-Each 回圈。

範例

該範例完整地展示瞭如何建立、初始化和操縱陣列：

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 列印所有陣列元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 計算所有元素的總和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查詢最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

以上範例編譯執行結果如下：

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

For-Each 遍歷陣列

JDK 1.5 引進了一種新的回圈型別，被稱爲 For-Each 回圈或者加強型回圈，它能在不使用下標的情況下遍歷陣列。

語法格式如下：

for(type element: array)
{
    System.out.println(element);
}

範例

該範例用來顯示陣列 myList 中的所有元素：

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);
      }
   }
}

以上範例編譯執行結果如下：

1.9
2.9
3.4
3.5

陣列作爲函數的參數

陣列可以作爲參數傳遞給方法。

例如，下面下麪的例子就是一個列印 int 陣列中元素的方法:

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

下面下麪例子呼叫 printArray 方法列印出 3，1，2，6，4 和 2：

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;
}

以上範例中 result 陣列作爲函數的返回值。

多維陣列

多維陣列可以看成是陣列的陣列，比如二維陣列就是一個特殊的一維陣列，其每一個元素都是一個一維陣列。

多維陣列的動態初始化（以二維陣列爲例）

數據型別陣列名=new 數據型別[長度1] [長度2];
數據型別陣列名={}；
數據型別陣列名=new 數據型別[] []{};

String str[][] = new String[3][4];
String str[][] = {["a","b"],["c","d"],["e","f"]}
String str[][] = new String[][]{["a","b"],["c","d"],["e","f"]}

解析：

二維陣列 a 可以看成一個兩行三列的陣列，從最高維開始，分別爲每一維分配空間，例如：

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];

多維陣列的遍歷

for(int i=0;i<陣列.length;i++){
    for(int j=0;j<陣列[i].length;j++){
        System.out.println(陣列[i][j]);
    }
}

Arrays 類

java.util.Arrays 類能方便地運算元組，它提供的所有方法都是靜態的。

具有以下功能：

給陣列賦值：通過 fill 方法。
對陣列排序：通過 sort 方法,按升序。
比較陣列：通過 equals 方法比較陣列中元素值是否相等。
查詢陣列元素：通過 binarySearch 方法能對排序好的陣列進行二分查詢法操作。

具體說明請檢視下錶：

返回值型別	方法名和描述
`static <T> List<T>`	`asList(T... a)` 返回由指定陣列支援的固定大小的列表。
`static int`	`binarySearch(byte[] a, byte key)` 使用二進制搜尋演算法搜尋指定值的指定位元組陣列。
`static int[]`	`copyOf(int[] original, int newLength)` 複製指定的陣列，用零擷取或填充（如有必要），以便複製具有指定的長度。
`static int[]`	`copyOfRange(int[] original, int from, int to)` 將指定陣列的指定範圍複製到新陣列中。
`static boolean`	`equals(int[] a, int[] a2)` 如果兩個指定的int陣列彼此相等，則返回 `true` 。
`static void`	`fill(int[] a, int val)` 將指定的int值分配給指定的int陣列的每個元素。
`static void`	`sort(int[] a)` 按照數位順序排列指定的陣列。