一起聊聊Java中陣列的定義和使用
推薦學習：《》
一維陣列
Java語言中的陣列是一種參照資料型別；不屬於基本資料型別；陣列的父類別是Object。
陣列實際上是一個容器，可以同時容納多個元素。（陣列是一個資料的集合）
陣列：字面意思是「一組資料」
陣列當中可以儲存「基本資料型別」的資料，也可以儲存「參照資料型別」的資料。
陣列因為是參照型別，所以陣列物件是堆記憶體當中。（陣列是儲存在堆當中的）
陣列當中如果儲存的是「java物件」的話，實際上儲存的是物件的「參照（記憶體地址）」，陣列中不能直接儲存java物件(存它的地址)。
陣列一旦建立，在java中規定，長度不可變。（陣列長度不可變）
陣列的分類：一維陣列、二維陣列、三維陣列、多維陣列...（一維陣列較多，二維陣列偶爾使用！）
所有的陣列物件都有length屬性(java自帶的)，用來獲取陣列中元素的個數。
java中的陣列要求陣列中元素的型別統一。比如int型別陣列只能儲存int型別，Person型別陣列只能儲存Person型別。例如：超市購物，購物袋中只能裝蘋果，不能同時裝蘋果和橘子。（陣列中儲存的元素型別統一）
陣列在記憶體方面儲存的時候，陣列中的元素記憶體地址(儲存的每一個元素都是有規則的挨著排列的)是連續的。記憶體地址連續。這是陣列儲存元素的特點（特色）。陣列實際上是一種簡單的資料結構。
所有的陣列都是拿「第一個小方框的記憶體地址」作為整個陣列物件的記憶體地址。（陣列中首元素的記憶體地址作為整個陣列物件的記憶體地址。）
陣列中每一個元素都是有下標的，下標從0開始，以1遞增。最後一個元素的下標是：length - 1；下標非常重要，因為我們對陣列中元素進行「存取」的時候，都需要通過下標來進行。
陣列這種資料結構的優點和缺點是什麼？
優點：查詢/查詢/檢索某個下標上的元素時效率極高。可以說是查詢效率最高的一個資料結構。為什麼檢索效率高？
第一：每一個元素的記憶體地址在空間儲存上是連續的。
第二：每一個元素型別相同，所以佔用空間大小一樣。
第三：知道第一個元素記憶體地址，知道每一個元素佔用空間的大小，又知道下標，所以通過一個數學表示式就可以計算出某個下標上元素的記憶體地址。直接通過記憶體地址定位元素，所以陣列的檢索效率是最高的。陣列中儲存100個元素，或者儲存100萬個元素，在元素查詢/檢索方面，效率是相同的，因為陣列中元素查詢的時候不會一個一個找，是通過數學表示式計算出來的。（算出一個記憶體地址，直接定位的。）
缺點：
第一：為了保證陣列中每個元素的記憶體地址連續，所以在陣列上隨機刪除或者增加元素的時候，效率較低，因為隨機增刪元素會涉及到後面元素統一向前或者向後位移的操作。
第二：陣列不能儲存巨量資料量，為什麼？因為很難在記憶體空間上找到一塊特別大的連續的記憶體空間。對於陣列中最後一個元素的增刪，是沒有效率影響的。
怎麼宣告/定義一個一維陣列？
語法格式：int[] array1; double[] array2; boolean[] array3; String[] array4; Object[] array5;怎麼初始化一個一維陣列呢？
包括兩種方式：靜態初始化一維陣列，動態初始化一維陣列。
（1）靜態初始化語法格式：
int[] array = {100, 2100, 300, 55};
（2）動態初始化語法格式：
int[] array = new int[5];這裡的5表示陣列的元素個數。
初始化一個5個長度的int型別陣列，每個元素預設值0
再例如：String[] names = new String[6];初始化6個長度的String型別陣列，每個元素預設值null。
什麼時候使用靜態陣列初始化？什麼時候使用動態陣列初始化？
（1）創鍵陣列的時候，確定陣列中儲存哪些具體的元素時，採用靜態初始化方式
（2）創鍵陣列的時候，不確定將來儲存哪些資料，可以採用動態初始化的方式，預先分配記憶體空間
package com.bjpowernode.javase.array;
public class ArrayTest01 {
public static void main(String[] args) {
//1.靜態初始化
int[] a1 = {1,3,5,7,9};
//所有的陣列物件都有length屬性，而不是方法！
System.out.println("陣列元素的個數是："+a1.length);
//取第一個元素
System.out.println(a1[0]);
//取最後一個元素
System.out.println(a1[a1.length-1]);
//改資料
a1[a1.length-1] = 0;
//遍歷資料
for(int i=0;i< a1.length;i++){
System.out.println(a1[i]);
}
//資料下標越界異常，例如：存取下面為6的資料元素
//System.out.println(a1[6]);// ArrayIndexOutOfBoundsException
//2.動態初始化
int[] a2 = new int[5]; //預設值是0
for(int i=0;i< a2.length;i++){
System.out.println(a2[i]);
}
//初始化一個Object型別的陣列，
//1.採用靜態初始化方式
Object o1 = new Object();
Object o2 = new Object();
Object o3 = new Object();
Object[] object = {o1,o2,o3};
//上面就等價於：Object[] object = {new Object(),new Object(),new Object()};
for(int i=0;i<object.length;i++){
System.out.println(object[i]);// 預設呼叫toString方法
}
//2.採用動態初始化的方式
Object[] obj = new Object[3];
for(int i=0;i<obj.length;i++){
System.out.println(obj[i]);// null null null
}
//初始化一個String型別的陣列
//1.靜態初始化
String[] str1 = {"abc","bcd","cde"};
for (int i = 0; i < str1.length; i++) {
System.out.println(str1[i]);
}
//2.動態初始化
String[] str2 = new String[3];
for (int i = 0; i < str2.length; i++) {
System.out.println(str2[i]);
}
}
}動態儲存記憶體圖
方法的引數是陣列
當傳遞的是一個陣列，方法也用陣列的形式進行接收；這個陣列可以是靜態的，也可以是動態建立的；並且我們把方法寫成寫成靜態的，這樣不需要new物件就可以呼叫！
例1：
package com.bjpowernode.javase.array;
public class ArrayTest02 {
//也可以採用C++的風格,寫成String args[]
public static void main(String args[]) {
System.out.println("HelloWorld");
// 1.方法的引數傳陣列---靜態初始化方式
int[] a = {1,2,3,4,5};
printArray(a);
// 2.方法的引數傳陣列---動態初始化方式
int[] arr = new int[5];
printArray(arr);
// 直接一步完成
printArray(new int[3]);
}
//靜態方法進行列印
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}例2：（掌握）
（1）一種特殊情況傳遞靜態陣列；如果直接傳遞一個靜態陣列的話，語法必須這樣寫！
（2）我們先看一個例子：int[] arr = {1,2,3};我們傳遞陣列的引數時候，一般就是傳遞陣列名arr，例如：printArray(arr)；但是另一種方法就是傳過去，去掉陣列名arr剩餘的組成部分：
int[]{1,2,3}，但是要加上new關鍵字，例如： printArray(new int[]{1,2,3});
package com.bjpowernode.javase.array;
public class ArrayTest03 {
public static void main(String[] args) {
//----------1.動態初始化一位陣列（兩種傳參方式）
//第一種傳參方式
int[] a1 = new int[5];//預設是5個0
printArray(a1);
System.out.println("-------------");
//第二種傳參方式
printArray(new int[3]);
System.out.println("-------------");
//----------2.靜態初始化一位陣列（兩種傳參方式）
//第一種傳參方式
int[] a2 = {1,2,3};
printArray(a2);
System.out.println("-------------");
//第二種傳參方式----直接傳遞一個靜態陣列
printArray(new int[]{4,5,6});
}
//呼叫的靜態方法----靜態方法比較方便，不需要new物件
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}main方法中的String陣列
（1）對於main(String[] args)；分析一下：誰負責呼叫main方法（JVM）
JVM呼叫main方法的時候，會自動傳一個String陣列過來，長度為0。
例1：
package com.bjpowernode.javase.array;
public class ArrayTest04 {
// 這個方法程式設計師負責寫出來，JVM負責呼叫。JVM呼叫的時候一定會傳一個String陣列過來。
public static void main(String[] args) {
// JVM預設傳遞過來的這個陣列物件的長度？預設是0
// 通過測試得出：args不是null。
System.out.println("JVM給傳遞過來的String陣列引數，它這個陣列的長度是？"
+ args.length); //0
// 以下這一行程式碼錶示的含義：陣列物件建立了，但是陣列中沒有任何資料。就等價於：
String[] strs = new String[0]; //動態的方式
//String[] strs = {}; // 靜態初始化陣列，裡面沒東西。
printLength(strs); //呼叫printLength靜態方法
/*
既然傳過來的「String[] args」陣列裡什麼都沒有；那麼這個陣列什麼時候裡面會有值呢？
其實這個陣列是留給使用者的，使用者可以在控制檯上輸入引數，這個引數自動會被轉換為「String[] args」
例如這樣執行程式：java ArrayTest04 abc def xyz；相當於在編譯時進行傳參
那麼這個時候JVM會自動將「abc def xyz」通過空格的方式進行分離，分離完成之後，自動放到「String[] args」陣列當中。
所以main方法上面的String[] args陣列主要是用來接收使用者輸入引數的。
把abc def xyz 轉換成字串陣列：{"abc","def","xyz"}
*/
// 遍歷陣列
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
//既然是編譯時進行傳參，對於編譯執行一體的IDEA怎麼使用呢？
//Run--->EditConfiguration--->Program Arguments裡面進行傳參，然後在從後重新執行
}
public static void printLength(String[] args){
System.out.println(args.length); // 0
}
}例2：
（1）main方法上面的「String[] args」有什麼用？
可以用來模擬一個登陸系統！請看下面這個有趣的例題：
package com.bjpowernode.javase.array;
/*
模擬一個系統，假設這個系統要使用，必須輸入使用者名稱和密碼。
*/
public class ArrayTest05 {
public static void main(String[] args) {
//先判斷長度，是不是兩個字串長度，不是2直接終止程式
if(args.length != 2){
System.out.println("請輸入使用者名稱和密碼");
return;
}
//取出使用者名稱和密碼
String username = args[0];
String password = args[1];
// 假設使用者名稱是admin，密碼是123的時候表示登入成功。其它一律失敗。
// 判斷兩個字串是否相等，需要使用equals方法。
// if(username.equals("admin") && password.equals("123")){ //這樣有可能空指標異常
// 下面這種編寫方式，也可以避免空該指標異常!
if("admin".equals(username) && "123".equals(password)){
System.out.println("恭喜你，登入成功");
System.out.println("您可以繼續使用該系統");
}else{
System.out.println("賬戶或密碼錯誤，請重新輸入");
}
}
}陣列中儲存參照資料型別（重點）
（1）一維陣列的深入：陣列中儲存的型別為：參照資料型別；對於陣列來說，實際上只能儲存java物件的「記憶體地址」。陣列中儲存的每個元素是「參照」。下面這個例題重點理解！
（2）陣列要求陣列中元素的型別統一；但是也可以儲存它的子型別！
package com.bjpowernode.javase.array;
public class ArrayTest06 {
public static void main(String[] args) {
//1.靜態建立一個Animal型別的陣列
Animal a1 = new Animal();
Animal a2 = new Animal();
Animal[] animals = {a1,a2};
//對Animal陣列進行遍歷
for (int i = 0; i < animals.length; i++) {
//方法1
/*Animal a = animals[i];
a.move();*/
//方法2
animals[i].move();
}
//2.動態初始化一個長度為2的animal型別的陣列
Animal[] ans = new Animal[2];
ans[0] = new Animal();
//ans[1] = new Product(); //err，Product和Animals沒有任何關係
//Animal陣列中只能存放Animal型別，不能存放Product型別
//3.Animal陣列中可以存放Cat型別的資料，因為Cat是Animal一個子類
ans[1] = new Cat();
for (int j = 0; j < ans.length; j++) {
ans[j].move();
}
//4.建立一個Animal型別的資料，陣列當中儲存Cat和Bird
//4.1靜態建立
Cat cat = new Cat();
Bird bird = new Bird();
Animal[] anim = {cat,bird};
for (int i = 0; i < anim.length; i++) {
//直接呼叫子類和父類別都有的move()方法
//anim[i].move();
//這裡想要呼叫子類Bird裡面特有的方法，需要向下轉型
if(anim[i] instanceof Bird){
Bird b = (Bird)anim[i]; //向下轉型
b.move();
b.sing(); //呼叫子類特有的方法
}else{
anim[i].move();
}
}
}
}
//動物類
class Animal{
public void move(){
System.out.println("Animals move.....");
}
}
//商品類
class Product{
}
//有一個貓類繼承動物類
class Cat extends Animal{
public void move(){
System.out.println("Cat move.....");
}
}
//有一個鳥類繼承動物類
class Bird extends Animal{
public void move(){
System.out.println("Bird move.....");
}
//鳥特有的方法
public void sing(){
System.out.println("鳥兒在歌唱！");
}
}陣列擴容和拷貝
在Java開發中，陣列長度一旦確定不可變，那麼陣列滿了，需要擴容怎麼辦？
（1）java中對陣列的擴容是：先建立一個大容量的陣列，然後將小容量陣列中的元素一個個拷貝到大陣列當中，小容量會被釋放。
（2）結論：陣列擴容效率較低。因為涉及到拷貝的問題。所以在以後的開發中請注意：儘可能少的進行陣列的拷貝。可以在建立陣列物件的時候預估計以下多長合適，最好預估準確，這樣可以減少陣列的擴容次數。提高效率。（3）利用System.arraycopy進行拷貝，總共5個引數；System.arraycopy(源頭陣列，下標，目的地陣列，下標，要拷貝的個數)
package com.bjpowernode.javase.array;
public class ArrayTest07 {
public static void main(String[] args) {
//java中的陣列是怎樣拷貝的呢？System.arraycopy(5個引數)
//System.arraycopy(源,下標,目的地,下標,個數)
//拷貝源---把3、5、7拷貝過去
int[] src = {1,3,5,7,9};
//拷貝目的地---拷貝到下標為5的地方
int[] dest = new int[20];
//呼叫拷貝函數
System.arraycopy(src,1,dest,5,3);
//列印驗證
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]+" ");
}
//拷貝參照資料型別
String[] str = {"hello","world"};
String[] strs = new String[10];
System.arraycopy(str,0,strs,3,2);
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println("--------------");
//採用動態開闢的時候拷貝的是地址
Object[] objs = {new Object(),new Object(),new Object()};
Object[] objects = new Object[5];
System.arraycopy(objs,0,objects,0,3);
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
}
}記憶體圖
推薦學習：《》
以上就是一起聊聊Java中陣列的定義和使用的詳細內容，更多請關注TW511.COM其它相關文章！