一起聊聊Java中陣列的定義與使用

本篇文章為大家帶來了關於java的相關知識，其中主要整理了數組的定義和使用的相關問題，包括了main方法中的String數組、數組中存儲引用數據類型、陣列擴容和拷貝等等內容，下面一起來看一下，希望對大家有幫助。

推薦學習：《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};##  動態初始化語法格式：
            int[] array = new int[5]; 
         

            初始化一個5個長度的int型別數組，每個元素預設值0

           
再例如：
String[] name 個長度的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视频教程》

以上是一起聊聊Java中陣列的定義與使用的詳細內容。更多資訊請關注PHP中文網其他相關文章！