Java_60_陣列_多維陣列_基本語法
陣列概述和特點
陣列的定義：陣列是相同型別資料的有序集合，陣列描述的是相同型別的若干個資料，按照一定的先後次序排列組合而成。其中，每一個數據稱作一個數組元素，每個陣列元素可以通過一個下標來訪問它們。
陣列的四個基本特點：
1.其長度是確定的。陣列一旦被建立，它的大小就是不餓改變的。
2.其元素必須是相同型別，不允許出現混合型別。
3.陣列中的元素是任何資料型別，包括基本型別和引用型別。
4.陣列變數屬引用型別，陣列也惡意看成是物件，陣列中的每個元素相當於該物件的成員變數。陣列本身就是物件，Java中物件是在堆中的，因此陣列無論儲存原始型別還是其他物件型別，陣列物件本身是在堆中的。
建立陣列和初始化
宣告（一維陣列的宣告方式有兩種）
type[] arr_name; 推薦使用
type arrname[];
ps:
1.宣告的時候並沒有例項化任何物件，只有在例項化陣列物件時，JVM才分配空間，這時才與長度有關。因此，宣告陣列時不能指定其長度（陣列中元素的個數），例如：int a[5]//這是錯誤的
2.宣告一個數組的時候並沒有陣列被真正的建立。
3.構造一個數組，必須指定長度。
構建陣列：
建立基本型別一維陣列示例：
pulbic class Test{
public static void main(String[] args){
int[] s=null; //1
s=new int[10]; //2
for(int i=0;i<10;i++){
s[i]=2*i+1;
System.out.println(s[i]);
} //3
}
}
建立引用型別一維陣列示例：
class Man{
private int age;
private int id;
public Man(int age,int id){
super();
this.age=age;
this.id=id;
}
}
public class AppMain{
public static void main(String[] args){
Man[] mans;
mans=new Man[10]; //1
Man m1=new Man(1,11);
Man m2=new Man(2,22); //2
mans[0]=m1;
mans[1]=m2; //3
}
}
示例2：
public class Man {
private int age;
private int id;
public Man(int age,int id) {
super();
this.age=age;
this.id=id;
}
public String toString() {
return age+","+id;
}
}
public class Test {
public static void main(String[] args) {
Man[] mans=new Man[3];
mans[0]=new Man(1,11);
mans[1]=new Man(2,22);
System.out.println(mans[0]);
System.out.println(mans[1]);
}
}
初始化
靜態初始化
除了用new關鍵字來產生陣列以外，還可以直接定義陣列的同時就為陣列元素分配空間並賦值。
int[] a={1,2,3};
Man[] mans2={new Man(3,33),new Man(4,44)};
System.out.println(mans2[0]);
System.out.println(mans2[1]);
動態初始化
陣列定義與為陣列元素分配空間並賦值的操作分開進行。
int[] a=new int[2];
a[0]=1;
a[1]=2;
陣列的預設初始化：
陣列是引用型別，它的元素相當於類的例項變數，因此陣列一經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化。
int[] a=new int[2];//0,0
boolean[] b=new boolean[2];//false,false
String[] s=new String[2];//null,null
陣列的界限
1.下標的合法區間；【0，length-1】
* 1. 陣列是相同資料型別(資料型別可以為任意型別)的有序集合
* 2. 陣列也是物件。陣列元素相當於物件的成員變數(詳情請見記憶體圖)
* 3. 陣列長度的確定的，不可變的。如果越界，則報：ArrayIndexOutofBoundsException
陣列常見操作
陣列的拷貝
System類裡也包含了一個static void arraycopy(Object src,int srcpos,Object dest,int destpos,int length)方法，該方法可以將src數組裡的元素賦值給dests陣列的元素，其中srcpos指定從src陣列的第幾個元素開始賦值，length引數指定將src陣列的多少個元素賦給dest陣列的元素。
String[] s={"Mircosoft","IBM","Sun","Oracle","Apple"};
String[] Sbak=new String[6];
System.out.println(s,0,sba,0,s.length);
java.util.Arrays
列印陣列
int[] a={1,2};
System.out.println(a);//[23we45er]
System.out.println(Arrays.toString(a));
陣列排序
int[] a={1,2,323,23,543,12,59};
Sysrtem.out.println(Arrays.toString(a));
Arrays.sort(a);
System.out.println(Arrays.toString(a));
結果：
[1, 2, 323, 23, 543, 12, 59]
[1, 2, 12, 23, 59, 323, 543]
如果陣列元素是引用型別，那麼需要怎麼做呢?後面容器講
public class Test{
public static void main(String[] args){
Man[] msMans={new Man(3,"a"),new Man(60,"b"),new Man(2,"c")};
Arrays.sort(msMans);
System.out.println(Arrays.toString(msMans));
}
}
/*****************************************************************/
public class Test{
public static void main(String[] args) {
Man[] msMans = {new Man(3,"a"),new Man(60,"b"),new Man(2,"c")};
Arrays.sort(msMans);
System.out.println(Arrays.toString(msMans));
}
}
class Man implements Comparable {
int age;
int id;
String name;
public Man(int age, String name) {
super();
this.age = age;
this.name = name;
}
public String toString(){
return this.name;
}
public int compareTo(Object o) {
Man man = (Man) o;
if(this.age<man.age){
return -1;
}
if(this.age>man.age){
return 1;
}
return 0;
}
}
二分法查詢
int[] a = {1,2,323,23,543,12,59};
Arrays.sort(a); //使用二分法查詢，必須先對陣列進行排序
System.out.println("該元素的索引："+Arrays.binarySearch(a, 12));
複製
一般用System.arraycopy
填充
Arrays.fill(a,2,4,100);//將2到4索引的元素替換為100
asList
int[] a={1,2,323,23,543,,12,59}
List<int[]> list=new ArrayList<int[]>();
list = Arrays.asList(a);//將陣列轉成list物件中的一個元素
System.out.println(list.get(0)[1]);
-------------------------------------------------------------------------------------------------------------------華麗分割線
多維陣列
多位陣列可以看成以陣列為元素的陣列。預設初始化，靜態初始化，動態初始化
靜態初始化：
int[] [] a={
{1,2,3},
{3,4},
{3,5,6,7}
};
System.out.println(a[2][3]);
動態初始化：
int[][] a=new int[3][];
a[0]=new int[3];
a[1]=new int[5];
a[2]=new int[8];
a[0][0]=1;
a[0][1]=2;
a[0][2]=3;
System.out.println(a[0][0]);
public static void main(String[] arge) {
int[] [] a= { //二維靜態初始化
{1,2,3,4},
{3,4},
{5,6,7,8}
};
System.out.println(a[0][3]);
int[][] aa=new int[3][]; //二維動態初始化
aa[0]=new int[10];
aa[0][0]=10;
System.out.println(aa[0][0]);
int[][][] aaa=new int[3][][]; //三維動態初始化
aaa[0]=new int[3][];
aaa[0][0]=new int[2];
aaa[0][0][0]=10;
aaa[0][0][1]=110;
int[][][] aaaa= { //三維靜態初始化
{{1}},
{{3},{2}},
{{3}}
};
System.out.println(aaa[0][0][1]+"---"+aaaa[1][1][0]);
}