當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

JAVA进阶教学之（一维数组）

發布時間：2024/7/23 编程问答 26 豆豆

生活随笔收集整理的這篇文章主要介紹了 JAVA进阶教学之（一维数组）小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

1、java語言中的數組是一種引用數據類型。不屬于基本數據類型

? ? ? 數組的父類是object

2、數組實際上是一個容器，可以同時容納多個元素（數組是一個數據的集合）

3、字面意思：數組意味著一組數據

4、數組當中可以存儲“基本數據類型”的數據，也可以存儲“引用數據類型” 的數據

5、數組因為是引用類型，所以數組對象是堆內存中（數組是存儲在堆當中的）

6、數組中如果存儲的是java對象的話，實際上存儲的是對象的引用（內存地址）

7、數組一旦創建，在java中規定，數組長度不可改變

8、數組的分類：一維數組、二維數組、三維數組

9、所有數組對象都有length屬性（java自帶的），用來獲取數組中元素的個數

10、java中的數組要求數組中元素的類型統一，比如：int類型數組只能存儲int類型，Person類型數組只能存儲Person類型

11、數組在內存方面存儲的時候，數組中的元素內存地址是連續的?（存儲的每一個元素都是有規則的挨著排列的）

12、所有的數組都是拿“第一個小方框的內存地址”作為整個數組對象的內存地址

? ? ? ?這就意味著只要我們獲取到數組的第一個內存地址，就可以通過數學表達式推算出數組其它空間的內存地址

圖示：

13、數組的每一個元素都是有下標的，下標從0開始，以1遞增，最后一個元素的下標是length - 1

? ? ? ?下標非常重要，因為我們對數組中元素進行存取的時候，都需要通過下標進行

14、數組這種數據結構的優點和缺點:

優點：

查詢、查找、檢索某個下標上的元素時效率極高。可以說是查詢效率最高的一個數據結構

為什么檢索效率高：

第一：每一個元素的內存地址在空間存儲上都是連續的

第二：每一個元素的類型相同，所以占用的內存空間大小是一樣的

第三：知道第一個元素的內存地址，知道每一個元素占用空間的大小，又知道下標，所以通過一個數學表達式就可以計算出某個下標上元素的內存地址

? ? ? ? ? ?直接通過內存地址定位元素，所以數組的檢索效率是最高的

數組中存儲100個元素，或者存儲100萬個元素，在元素查詢、檢索方面，效率是相同的，因為數組中元素查找的時候，不會一個個找，是通過數學表達式計算出來的

【算出一個內存地址，直接定位的】

缺點：

第一：由于為了保證數組中每個元素的內存地址連續，所以在數組上隨機刪除或者增加元素的時候，效率極低，因為隨機增刪元素會設計到后面元素統一向前或者向后位移的操作。

第二：數組不能存儲大的數據量，因為很難在內存空間中找到一塊特別大的連續的內存空間

注意：對于數組中，最后一個元素的增刪，是沒有效率影響的

15、怎么聲明一個一維數組？

語法格式：

int[ ] array1;

double[ ] array2;

String[ ]? array3;

Object[ ] array4;

16、怎么初始化一個一維數組呢？

包括兩種方式：靜態初始化一維數組，動態初始化一維數組

靜態初始化語法格式：

int[ ] array = {100,200,300};

動態初始化語法格式：

int[ ] array = new int [5];

這里的5表示數組的元素個數，意思是初始化一個5個長度的int類型數組，每個元素默認值為0

String[ ] names = new String[6];

這里的6表示數組的元素個數，意思是初始化一個6個長度的String類型數組，每個元素默認值為null

案例測試：

運行結果：

以下演示靜態初始化數組的例子：

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/2/15 20:42* @Copyright 公司*/ public class ArrayTest01 {public static void main(String[] args) {//聲明一個int類型的數組，使用靜態初始化的方式int[] a1={1,100,10,20};//所有的數組對象都有length屬性System.out.println("數組中元素的個數"+a1.length);//數組中的每個元素都有下標//通過下標對數組中的元素進行存(改操作)/取（讀操作）System.out.println("第一個元素"+a1[0]);System.out.println("最后一個元素"+a1[3]);System.out.println("最后一個元素"+a1[a1.length-1]);//存（改操作）//把第一個元素改為100a1[0]=100;//把最后一個元素改為1a1[3]=1;a1[a1.length-1]=1;//結果演示System.out.println("修改后第一個元素"+a1[0]);System.out.println("修改后最后一個元素"+a1[3]);System.out.println("修改后最后一個元素"+a1[a1.length-1]);//一維數組如何遍歷呢？for (int i=0;i<a1.length;i++){System.out.println("遍歷后的數組為"+"第"+i+"個"+a1[i]);}//下標為4表示為第5個元素，系統檢測到第5個元素沒有，說明下標越界，會出現下標越界異常//ArrayIndexOutOfBoundsException//System.out.println(a1[4]);//從最后一個元素遍歷到第1個元素for(int i=a1.length-1;i>=0;i--){System.out.println("顛倒遍歷后的數組為"+"第"+i+"個"+a1[i]);}} }

演示結果：

以下是動態初始化一維數組的演示：

什么時候采用靜態初始化方式，什么時候使用動態初始化方式？

靜態初始化：當你創建數組的時候，確定數組中存儲哪些具體的元素時候，采用靜態初始化的方式

動態初始化：當你創建數組的時候，不決定將來數組中存儲哪些數據，你可以采用動態初始化的方式，預先分配內存空間

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/2/16 21:55* @Copyright 公司*/ public class ArrayTest02 {public static void main(String[] args) {//聲明一個數組，采用動態初始化的方式創建//創建長度為3的數組，數組中每個元素都存在系統自帶的默認值int[] a=new int[3];//遍歷數組for(int i=0;i<a.length;i++){System.out.println("遍歷出數組的"+i+"個元素"+a[i]);}} }

以下演示的是方法的參數是數組的時候的例子

package com.lbj.javase.array;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.array* @date 2021/2/16 22:47* @Copyright 公司*/ public class ArrayTest04 {public static void main(String[] args) {//靜態初始化一維數組int[] a={1,2,3};printArray(a);//思考：傳遞一個靜態數組的是時候，為什么下面這樣語法不行//printArray({1,2,3});//動態初始化一維數組int[] a2=new int[3];printArray(a2);//和上面的不同之處在于，數組內的值是自定義的，不是系統默認的，相當于靜態一維數組printArray(new int[]{1,2,3});}//為什么要使用靜態方法？因為方便，不需要new對象public static void printArray(int[] array){for (int i = 0; i <array.length; i++) {System.out.println(array[i]);}} }

思考：

main方法上面的String[] args 有什么用？

分析：

誰負責調用main方法

答案：

JVM

JVM調用main方法的時候，會自動傳遞一個String數組過來

main方法上面的String[] args 數組主要是用來接收用戶輸入參數的

package com.lbj.javase.array;public class ArrayTest05 {public static void main(String[] args) {//JVM默認傳遞過來的這個數組對象的長度默認是0//通過測試得出args不是nullSystem.out.println("JVM傳遞過來的String數組參數，它這個數組的長度是？"+args.length);//這個數組什么時候里面會有值呢？//其實這個數組是留給用戶的，用戶可以在控制臺上輸入參數，這個參數會自動被轉換成 String[] agrs} }

模擬一個系統，假設這個系統要使用，必須輸入用戶名和密碼 package com.lbj.javase.array;/** 模擬一個系統，假設這個系統要使用，必須輸入用戶名和密碼*/ public class ArrayTest06 {//用戶名和密碼輸入到String[] args 數組中public static void main(String[] args) {if (args.length != 2) {System.out.println("請輸入正確的格式例如張三 123");return;}//程序執行到此處說明用戶提供了賬號和密碼//接下來你就應該判斷賬號和密碼是否正確//取出賬號String name=args[0];//取出密碼String password=args[1];//假設賬號是admin，密碼是123//判斷這兩個字符串是否相等，需要使用equals方法//if(name.equals("admin") && password.equals("123")){//上面寫可能會導致空指針異常//采用以下編碼風格，即使name和password都是null，也不會出現空指針異常//這是老程序員給的建議if("admin".equals(name) && "123".equals(password)){System.out.println("登錄成功");}else{System.out.println("對不起，賬號密碼不存在");}} }

一維數組的深入，數組中存儲的類型為：引用數據類型
?對于數組來書，實際上只能存儲java對象的內存地址，數組中存儲的每個元素都是“引用”

package com.lbj.javase.array;/** 一維數組的深入，數組中存儲的類型為：引用數據類型對于數組來書，實際上只能存儲java對象的內存地址，數組中存儲的每個元素都是“引用”*/ public class ArrayTest07 {public static void main(String[] args) {//靜態初始化創建一個Animal類型的數組Animal a1=new Animal();Animal a2=new Animal();Animal[] animals={a1,a2};//對數組進行遍歷for (int i = 0; i <animals.length ; i++) {Animal a=animals[i];a.move();System.out.println("遍歷結果為"+i+animals[i]);}//動態初始化一個長度為2的Animal類型一維數組Animal[] a3=new Animal[2];//創建一個animal對象，放到數組的第一個盒子中a3[0]=new Animal();//Animal和Product沒有關系，因此Animal數組中只能存放Animal類型的數據//a3[1]=new Product();報錯//Animal數組中可以存放Cat類型的數據，因為Cat是一個Animal的子類//子類對象指向父類，這就是多態的用法a3[1]=new Cat();//向下類型轉換要強制類型轉換，向上類型轉換需要自動類型轉換//創建一個Animal類型的數組，數組中存放的Cat和BirdCat cat=new Cat();Bird bird=new Bird();Animal[] animals1={cat,bird};//Animal[] animals1={new Cat(),new Bird()};//該數組中存儲了兩個對象的內存地址for (int i = 0; i <animals.length ; i++) {//這個取出來可能是Cat類型的，也可能是Bird類型的，不過，肯定是一個Animal類型的//注意：以下代碼演示的是如果調用的方法是父類中存在的方法則不需要向下轉型，直接使用父類型調用即可//向下類型轉換要強制類型轉換，向上類型轉換需要自動類型轉換//注意：這里不是向下轉型，這是子類重寫了父類的方法，多以調用子類的時候運行的是Cat和BirdAnimal animals2=animals1[i];animals2.move();//調用子類中特有方法的話，需要向下轉型if(animals1[i] instanceof Cat){Cat cat1= (Cat) animals1[i];cat1.catchMouse();}else if(animals1[i] instanceof Bird){Bird bird1= (Bird) animals1[i];bird1.sing();}}}}class Animal{public void move(){System.out.println("move...");} }//創建一個毫不相關的商品類 class Product{}//創建一個繼承Animal類的子類Cat類 class Cat extends Animal{//重寫父類的方法public void move(){System.out.println("Cat can moveCat...");}//Cat類特有的方法public void catchMouse(){System.out.println("Cat can catchMouse");} }//創建一個繼承Animal類的子類Bird類 class Bird extends Animal{//重寫父類的方法public void move(){System.out.println("Bird can moveBird...");}//Bird類特有的方法public void sing(){System.out.println("Bird can sing");}}

關于一維數組的擴容

問：

在java開發中，數組長度一旦確定意味著不可變，呢們數組滿了怎么辦？

答案：

數組滿了需要擴容

問：

如何擴容

答案：

java中對數組的擴容是，先創建一個大容量的數組，然后將原先小容量數組中數據一個一個拷貝到大數據中

結論：

數組擴容效率較低，因為涉及到拷貝問題，應該盡可能少進行對數組的擴容

解決：

可以在創建數組對象的時候預估計一下多長合適，這樣可以減少數組的擴容次數，提高效率

因此我們引入一個方法

public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length); Object src源數組地址、int srcPos源數組拷貝位置、Object dest新數組地址、int destPos新數組拷貝位置、int length拷貝長度

其實拷貝就是將內存地址進行復制到一個新的位置去存儲，新的數組實際上也是用內存地址去指向對象，只不過新數組和源數組的內存地址不一致

以下是代碼演示：

package com.lbj.javase.array;/** java中數組的拷貝*/ public class ArrayTest08 {public static void main(String[] args) {// public static native void arraycopy(Object src, int srcPos,// Object dest, int destPos,// int length);//Object src源數組地址、int srcPos源數組拷貝位置、Object dest新數組地址、int destPos新數組拷貝位置、int length拷貝長度//源數組地址int[] src={1,2,3};//新數組地址int[] dest=new int[20];//調用JDK System類中的arraycopy方法，來完成數組的拷貝//System.arraycopy(src,1,dest,2,1);//如果源數組的拷貝位置和拷貝長度有矛盾，拷貝會報錯// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException// at java.lang.System.arraycopy(Native Method)// at com.lbj.javase.array.ArrayTest08.main(ArrayTest08.java:22)System.arraycopy(src,1,dest,2,src.length);//拷貝源數組的全部元素到新數組上//System.arraycopy(src,0,dest,0,src.length);//遍歷拷貝完后的新數組for (int i = 0; i <dest.length ; i++) {System.out.println(dest[i]);}} }

總結

以上是生活随笔為你收集整理的JAVA进阶教学之（一维数组）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：倒计时小工具_这款高颜值的 APP 可以
下一篇： IOC操作Bean管理XML方式（注入内