陣列是一種資料結構，陣列不一定裡面是數，也可以是char，String，boolean，int，double
陣列通過一個整型下標可以訪問陣列中每一個值。例如a是一個整形陣列，則a[i]就是陣列中下標為i的整數。
在宣告（區別於建立）陣列時，需要指出陣列型別（資料元素型別[ ]+陣列變數名字）
int[ ] a; //只是聲明瞭陣列變數a，而沒有建立陣列a
應該使用new運算子建立陣列：
int[] a=new int[100]; //建立了int型的陣列a，並將陣列元素都初始化為0
陣列長度不要求是常量，可以為int[] a=new int[n];

package 第3章;

public
 
 class 第3章a
{
    public static void main(String[] args)
    {
        int[] b=new int[10];
        int i;
        for(i=0;i<10;++i)
        {
            b[i]=i;
        }
        for(i=9;i>=0;--i)
        {
            System.out.println(b[i]);
        }   
    }          
}

建立一個數字陣列時，所有元素都初始化為0，boolean陣列的元素會初始化為false，物件陣列的元素則初始化為null，這表示這些元素還未存放任何物件。

 String[] name=new String[10];   //此時10個字串全部為null

如果希望這個陣列包含空串，可以為元素制定空串（空串“”與null串是不一樣的值）

package 第3章;

public class 第3章a
{
    public static void main(String[] args)
    {
        String[] name=new String[10];   //此時10的元素全部為null
        String[] name2=new String[10];
        for(int i=0;i<10;++i)
        {
            name[i]=null
 
;
            name2[i]="";
        }
        for(int i=0;i<10;++i)
        {
            System.out.println(name[i]);
            System.out.println(name2[i]);

        }

    }          
}

要想獲得陣列中的元素個數，可以使用array.length（陣列名.length)而不是 陣列名.length();
陣列名.length 適用於任何型別的陣列（String，boolean……）

package 第3章;
public class 第3章a
{
    public static void main(String[] args)
    {
        String[] name=new String[10];   //此時10的元素全部為null
        int c=name.length;
        //不是 int c=name.length（）;
        System.out.println(c);
    }          
}

一旦建立了陣列，就不能在改變它的大小（儘管可以改變每一個數組元素），如果經常需要在執行過程中擴充套件陣列的大小，就應該使用另一種資料結構–陣列列表（array list）
for each 迴圈
Java有一種功能很強的迴圈結構，可以用來依次處理陣列中的每個元素，而不必為下標值而分心。

for(變數 ：陣列名）
{

}

//例如：
package 第3章;
import java.util.Arrays;
public class 第3章a
{
    public static void main(String[] args)
    {
        int[] a=new int[2];
        int i=1;
        a[0]=1;
        a[1]=3;
        for(int element:a)
        {
          //  System.out.println(element);
           System.out.println(element);
        }
        System.out.println(Arrays.toString(a));
    }          
}

for(int element:a)
{
System.out.println(element);
}
列印陣列a的每一個元素，一個元素佔一行
這個迴圈應讀作：迴圈a中的每一個元素（for each element in a)
使用for each語句顯得更加簡潔，更不易出錯
for each 迴圈語句的迴圈變數element將遍歷陣列中的每一個元素

package 第3章;
import java.util.Arrays;
public class 第3章a
{
    public static void main(String[] args)
    {
        int[] a=new int[2];

        int i=1;
        a[0]=1;
        a[1]=3;

        System.out.println(Arrays.toString(a));

    }          
}

有個更加簡潔的方式列印陣列中的所有值，即利用Arrays類的toString方法，
import java.util.Arrays ;
呼叫Arrays.toString(a)方法，返回一個包含陣列元素的字串，這些元素被放置在中括號內，元素之間以逗號分隔，例如：“[1,2,3,4,5]”
要想列印陣列，可以呼叫
System.out.println(Arrays.toString(a));

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] a=new int[5];
       for(int i=0;i<5;++i)
       {
           a[i]=i;
       }
       System.out.println(Arrays.toString(a));
    }          
}

package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] a=new int[5];
       for(int element:a)
       {
           System.out.println(element);
       }

    }          
}

陣列初始化以及匿名陣列
在java中，提供了一種建立陣列物件同時賦予初始值的簡化書寫形式：
int [] hello={1,2,3,4,5};
請注意，在使用這種語句時，不需要呼叫new：
int [] hello=new int[5];
甚至還可以初始化一個匿名的陣列：
new int [] {1,2,3,4,5,6,7}; //可以用來重新初始化一個已有的陣列：
hello=new int[] {1,2,3,4,5,6,7};
以上為下列語句的簡寫：
int[] annoymous={1,2,3,4,5,6,7};
hello=annoymous ;

 package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] hello=new int[3];
       hello=new int[] {1,2,3};
       for(int element:hello)
       {
           System.out.println(element);
       }
       System.out.println(Arrays.toString(hello));
    }          
}

在java中，允許陣列的長度為0，在編寫一個結果維陣列的方法時，如果碰巧結果為空，則這種語法形式就顯得非常有用，此時可以建立一個長度為0的陣列：

int[] well=new int[0];

在java中，允許將一個數組變數拷貝給另一個數組變數，這時，兩個變數引用同一個陣列。
如同兩個指標指向同一個陣列
int [] hello=new int [5];
int [] well=hello;

//例如：
package 第3章;
import java.util.*;
public class 第3章a
{
    public static void main(String[] args)
    {
       int[] hello=new int[3];
       hello[0]=1;
       hello[1]=3;
       hello[2]=0;
       int [] well=hello;
       System.out.println(Arrays.toString(well));
       //兩個陣列變數指向同一個陣列
       //如果希望將一個數組的所有制拷貝到另一個新的陣列中，就要使用Arrays類的copyOf方法
       int[] what=Arrays.copyOf(well, well.length);
       int[] how=Arrays.copyOf(hello, 2*hello.length);
       System.out.println("what= "+Arrays.toString(what));
       System.out.println("how= "+Arrays.toString(how));
       char[] a=new char[3];
       boolean[] b=new boolean[3];
       String[] c=new String[3];
       char[] A=Arrays.copyOf(a, a.length);
       boolean[] B=Arrays.copyOf(b, b.length);
       String[] C=Arrays.copyOf(c, c.length);
       System.out.println("A= "+Arrays.toString(A));
       System.out.println("B= "+Arrays.toString(B));
       System.out.println("C= "+Arrays.toString(C));

       //Arrays.copyOf(陣列名，拷貝而成的陣列的長度）;
       //數值型（int，long，double）多餘的元素賦值為0，布林型boolean，多餘元素賦值為false，如果長度小於原陣列長度，則只拷貝最前面的陣列元素。
       //JAVA中的陣列語句：int[] hello=new int[5];   等同於int *hello=new int[5];
       //JAVA中的[]運算子被預定義為檢查陣列邊界，而且java沒有指標運算，既不能通過hello+1來得到陣列的下一個元素。
    }          
}
run:
[1, 3, 0]
what= [1, 3, 0]
how= [1, 3, 0, 0, 0, 0]
A= [, , ]
B= [false, false, false]
C= [null, null, null]

char[] A;
A 為空時，A= [ , , ]；
boolean[] B;
B為空時，B= [false, false, false];
String[] C;
C為空時，C= [null, null, null]