為什么需要數組？
有時候需要存儲或處理一系列數據，數組就可以充當這樣的角色，它在內存中是相連的數據，並且在棧中的引用只有一個，如果不用數組，那數據就得一個一個定義一個一個聲明，浪費內存空間，顯然不合理。
什么是數組？
數組可以存放多個同一類型的數據。數組也是一種數據類型，是引用類型。 即：數(數據)組(一組)就是一組數據
Java的數組要求所有的數組元素具有相同的數據類型。因此，在一個數組中，數組元素的類型是唯一的，即一個數組里只能存儲一種數據類型的數據，而不能存儲多種數據類型的數據
數組本身是一個引用數據類型，數組內存儲的類型可以是基本類型 也可以是引用類型
總結：
①數組是一個引用數據類型
②數組是在堆內存中的一串連續的地址存在
③數組在初始化時必須指定長度
⑤堆內存的數組長度一旦確定 不能再次發生改變
⑥棧內存的變量中存儲的是數組的地址引用
⑦數組內部存儲的類型可以是基本的 也可一是引用
數組的特點：
（1）數組是一個對象，是一種引用數據類型。可以表示一組數據的集合。
（2）數組只能保存一種類型的數據。
（3）數組可以使用 new 關鍵字 進行初始化。
（4）數組中的每一個數據稱為 元素 element。元素是在堆內存中分配的。而且是連續分配的。
（5）數組的每一個元素都有一個序號，專業的稱謂：下標、索引、角標。下標是從0開始的、升序的、連續的、0序的。
（6）數組有一個屬性：長度的屬性，表示數組中元素的個數 該屬性是 int 類型。 通過 數組名.length 來訪問該屬性。
（7）數組中元素的下標的取值范圍是：[0~length-1]。
（8）通過new 關鍵字 在堆內存中元素被分配空間之后。每個元素被jvm 賦予默認值。
默認值規則：整數：0 浮點數：0.0 char：’\u0000’ boolean:false 引用數據類型：null。
（9）數組的每個元素通過 數組名[下標] 來訪問。每個元素都是一個變量。和變量的用法一致。
（10）數組變量、數組引用 保存的是 數組的實際元素的在堆內存中的"首地址"。
（11）[ ] 代表的是 數組這種類型。
（12）求下標是 n 的元素的地址：首地址+元素字節數*n。 數組根據下標訪問元素的效率非常快。（隨機訪問）。
（13）數組的長度可以是 0，但是不能是 負數。
（14）數組的長度一旦確定，就不能更改了。數組是定長的。
數組的聲明和創建：
1.首先必須聲明數組變量，才能在程序中使用數組。
數據類型[] 變量名;//強烈建議用這種命名
數據類型 變量名[];//只要知道就可以，c、c++是這種寫法，要區分開來
2.Java語言使用new操作符來創建數組，語法如下：
dataType[] arrayRefVar = new dataType[arraySize];
3.數組的元素是通過索引訪問的，數組索引從0開始
4.獲取數組長度的方法：arrays.length
//聲明一個數組 int[] nums; //創建一個數組 nums = new int[10]; //給數組元素中賦值 nums[0]=1; nums[1]=2; nums[2]=3; nums[3]=4; System.out.println(nums.length);
數組快速入門（案例分析）
/* 它們的體重分別是 3kg,5kg,1kg,3.4kg,2kg,50kg 。 請問這六只雞的總體重是多少?平均體重是多少? */ public class Array01 { //編寫一個 main 方法 public static void main(String[] args) { // double hen1 = 3; // double hen2 = 5; // double hen3 = 1; // double hen4 = 3.4; // double hen5 = 2; // double hen6 = 50; // double totalWeight = hen1 + hen2 + hen3 + hen4 + hen5 + hen6; // double avgWeight = totalWeight / 6; // System.out.println("總體重=" + totalWeight + "平均體重=" + avgWeight); //比如，我們可以用數組來解決上一個問題 => 體驗 // //定義一個數組 //解讀 //1. double[] 表示 是 double 類型的數組， 數組名 hens //2. {3, 5, 1, 3.4, 2, 50} 表示數組的值/元素,依次表示數組的 // 第幾個元素 // double[] hens = {3, 5, 1, 3.4, 2, 50, 7.8, 88.8,1.1,5.6,100}; //遍歷數組得到數組的所有元素的和， 使用 for //解讀 //1. 我們可以通過 hens[下標] 來訪問數組的元素 // 下標是從 0 開始編號的比如第一個元素就是 hens[0] // 第 2 個元素就是 hens[1] , 依次類推 //2. 通過 for 就可以循環的訪問 數組的元素/值 //3. 使用一個變量 totalWeight 將各個元素累積 System.out.println("===使用數組解決==="); //提示： 可以通過 數組名.length 得到數組的大小/長度 //System.out.println("數組的長度=" + hens.length); double totalWeight = 0; for( int i = 0; i < hens.length; i++) { //System.out.println("第" + (i+1) + "個元素的值=" + hens[i]); totalWeight += hens[i]; } System.out.println("總體重=" + totalWeight + "平均體重=" + (totalWeight / hens.length) ); } }
數組的使用
使用方式 1-動態初始化：
動態初始化：初始化時程序員只指定數組長度，由系統為數組元素分配初始值
簡單的來講動態初始化就是指定長度
執行動態初始化時，程序員只需指定數組長度，即為每個數組元素指定所需的內存空間，系統將負責為這些數組元素分配初始值。
使用方式 2-動態初始化：
先聲明數組
語法:數據類型 數組名[]; 也可以 數據類型[] 數組名;
int a[]; 或者 int[] a;
創建數組
語法: 數組名=new 數據類型[大小];
a=new int[10];
使用方式 3-靜態初始化：
靜態初始化：初始化時由程程序員顯示指定每個數組元素的初始值，由系統決定數組長度
簡單的來講靜態初始化就是指定內容
靜態初始化就是將數組的元素放到大括號中，元素之間用逗號（,）分隔
數組使用注意事項和細節：
（1) 數組是多個相同類型數據的組合，實現對這些數據的統一管理
（2) 數組中的元素可以是任何數據類型，包括基本類型和引用類型，但是不能混用。
（3) 數組創建后，如果沒有賦值，有默認值
int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
（4) 使用數組的步驟 1. 聲明數組並開辟空間 2 給數組各個元素賦值 3 使用數組
（5) 數組的下標是從 0 開始的。
（6) 數組下標必須在指定范圍內使用，否則報：下標越界異常，比如int [] arr=new int[5]; 則有效下標為 0-4
（7) 數組屬引用類型，數組型數據是對象(object)
案例分析：
//請求出一個數組 int[]的最大值 {4,-1,9, 10,23}，並得到對應的下標 public class ArrayExercise02 { public static void main(String[] args) { int[] arr = {4,-1,9,10,23}; int max = arr[0];//假定第一個元素就是最大值 int maxIndex = 0; for(int i = 1; i < arr.length; i++) {//從下標 1 開始遍歷 arr if(max < arr[i]) {//如果 max < 當前元素 max = arr[i]; //把 max 設置成 當前元素 maxIndex = i; } } //當我們遍歷這個數組 arr 后 , max 就是真正的最大值，maxIndex 最大值下標 System.out.println("max=" + max + " maxIndex=" + maxIndex); } }
數組拷貝
編寫代碼 實現數組拷貝(內容復制)
//將 int[] arr1 = {10,20,30}; 拷貝到 arr2 數組, //要求數據空間是獨立的. int[] arr1 = {10,20,30}; //創建一個新的數組 arr2,開辟新的數據空間 public class ArrayCopy { public static void main(String[] args) { int[] arr2 = new int[arr1.length];//大小 arr1.length; for(int i = 0; i < arr1.length; i++) { //遍歷 arr1 ，把每個元素拷貝到 arr2 對應的元素位置 arr2[i] = arr1[i]; } arr2[0] = 100;//修改 arr2， 不會對 arr1 有影響. System.out.println("====arr1 的元素===="); //輸出 arr1 for(int i = 0; i < arr1.length; i++) { System.out.println(arr1[i]);//10,20,30 } System.out.println("====arr2 的元素===="); for(int i = 0; i < arr2.length; i++) { System.out.println(arr2[i]);// } } }
數組反轉
把數組的元素內容反轉。
//要求：把數組的元素內容反轉。 //arr {11,22,33,44,55,66} -->{66, 55,44,33,22,11} public class ArrayReverse { public static void main(String[] args) { int[] arr = {11, 22, 33, 44, 55, 66};//定義數組 int temp = 0; int len = arr.length; //計算數組的長度 for( int i = 0; i < len / 2; i++) { temp = arr[len - 1 - i];//保存 arr[len - 1 - i] = arr[i]; arr[i] = temp; } System.out.println("===翻轉后數組==="); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t");//66,55,44,33,22,11 } } }
數組添加/擴容/縮減
實現動態的給數組添加元素效果，實現對數組擴容。
/* 要求：實現動態的給數組添加元素效果，實現對數組擴容。 1.原始數組使用靜態分配 int[] arr = {1,2,3} 2.增加的元素 4，直接放在數組的最后 arr = {1,2,3,4} 3.用戶可以通過如下方法來決定是否繼續添加，添加成功，是否繼續？y/n */ import java.util.Scanner; public class ArrayAdd02 { public static void main(String[] args) { Scanner myScanner = new Scanner(System.in); int[] arr = {1,2,3};//初始化數組 do { int[] arrNew = new int[arr.length + 1]; //遍歷 arr 數組，依次將 arr 的元素拷貝到 arrNew 數組 for(int i = 0; i < arr.length; i++) { arrNew[i] = arr[i]; } System.out.println("請輸入你要添加的元素"); int addNum = myScanner.nextInt(); //把 addNum 賦給 arrNew 最后一個元素 arrNew[arrNew.length - 1] = addNum; //讓 arr 指向 arrNew, arr = arrNew; //輸出 arr 看看效果 System.out.println("====arr 擴容后元素情況===="); for(int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } //問用戶是否繼續 System.out.println("是否繼續添加 y/n"); char key = myScanner.next().charAt(0); if( key == 'n') { //如果輸入 n ,就結束 break; } }while(true); System.out.println("你退出了添加..."); } }
數組的縮減和添加原理相同就不舉例說明了