Java

1.1 數組概述
需求：現在需要統計某公司員工的工資情況，例如計算平均工資、找到最高工資等。假設該公司有80名員工，用前面所學的知識，程序首先需要聲明80個變量來分別記住每位員工的工資，然後在進行操作，這樣做會顯得很麻煩。為了解決這種問題，Java就提供了數組供我們使用。
那麽數組到底是什麽呢?有什麽特點呢?通過上面的分析：我們可以得到如下兩句話：
數組是存儲多個變量(元素)的東西(容器)
這多個變量的數據類型要一致
1.2 數組的定義格式1.2.1 數組概念
數組是存儲同一種數據類型多個元素的容器。
數組既可以存儲基本數據類型，也可以存儲引用數據類型。
1.2.2 數組的定義格式
格式1：數據類型[] 數組名;
格式2：數據類型 數組名[];
註意：這兩種定義做完了，數組中是沒有元素值的。
1.3 數組的初始化1.3.1 數組初始化概述：
Java中的數組必須先初始化,然後才能使用。
所謂初始化：就是為數組中的數組元素分配內存空間，並為每個數組元素賦值。
1.3.2 數組的初始化方式1.3.2.1 動態初始化:初始化時只指定數組長度，由系統為數組分配初始值
格式：數據類型[] 數組名 = new 數據類型[數組長度];
數組長度其實就是數組中元素的個數。
舉例：
int[] arr = new int[3];
int[ ] arr = {1,2,3};
解釋：定義了一個int類型的數組，這個數組中可以存放3個int類型的值。
1.3.2.2 案例代碼三:

package com.itheima_01;
/*
 * 數組：存儲同一種數據類型的多個元素的容器。
 *
 * 定義格式：
 * A:數據類型[] 數組名;
 * B:數據類型 數組名[];
 * 舉例：
 * A:int[] a; 定義一個int類型的數組，數組名是a
 * B:int a[]; 定義一個int類型的變量，變量名是a數組
 *
 * 數組初始化：
 * A:所謂初始化，就是為數組開辟內存空間，並為數組中的每個元素賦予初始值
 * B:我們有兩種方式對數組進行初始化
 * a:動態初始化        只指定長度，由系統給出初始化值
 * b:靜態初始化        給出初始化值，由系統決定長度
 *
 * 動態初始化：
 * 數據類型[] 數組名 = new 數據類型[數組長度];
 */
public class ArrayDemo {
public static void main(String[] args) {
//數據類型[] 數組名 = new 數據類型[數組長度];
int[] arr = new int[3];
/*
 * 左邊：
 * int:說明數組中的元素的數據類型是int類型
 * []:說明這是一個數組
 * arr:是數組的名稱
 * 右邊：
 * new:為數組分配內存空間
 * int:說明數組中的元素的數據類型是int類型
 * []:說明這是一個數組
 * 3:數組的長度，其實就是數組中的元素個數
 */
}
}
 

1.3.2.3 靜態初始化:初始化時指定每個數組元素的初始值，由系統決定數組長度1.3.2.4 案例代碼四:

package com.itheima_01;
/*
 * 靜態初始化的格式：
 * 數據類型[] 數組名 = new 數據類型[]{元素1,元素2,...};
 *
 * 簡化格式：
 * 數據類型[] 數組名 = {元素1,元素2,...};
 *
 * 舉例：
 * int[] arr = new int[]{1,2,3};
 *
 * 簡化後：
 * int[] arr = {1,2,3};
 */
public class ArrayDemo2 {
public static void main(String[] args) {
//定義數組
int[] arr = {1,2,3};
//輸出數組名和元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}

1.4 數組的內存分配1.4.1 JVM內存劃分
Java 程序在運行時，需要在內存中的分配空間。為了提高運算效率，就對空間進行了不同區域的劃分，因為每一片區域都有特定的處理數據方式和內存管理方式。
棧 存儲局部變量
堆 存儲new出來的東西
方法區 (面向對象進階講)
本地方法區 (和系統相關)
寄存器 (給CPU使用)

1.4.2 一個數組的內存圖
定義一個數組，輸出數組名及元素。然後給數組中的元素賦值，再次輸出數組名及元素
1.4.2.1 案例代碼五:

package com.itheima_01;
/*
 * 需求：定義一個數組，輸出數組名及元素。然後給數組中的元素賦值，再次輸出數組名及元素。
 */
public class ArrayTest {
public static void main(String[] args) {
//定義一個數組
int[] arr = new int[3];
//輸出數組名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//給數組中的元素賦值
arr[0] = 100;
arr[2] = 200;
//再次輸出數組名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}

1.4.2.2 代碼內存圖解:

1.4.3 兩個數組的內存圖
定義兩個數組，分別輸出數組名及元素。然後分別給數組中的元素賦值，分別再次輸出數組名及元素
1.4.3.1 案例代碼六:

package com.itheima_01;
/*
 * 需求：定義兩個數組，分別輸出數組名及元素。然後分別給數組中的元素賦值，分別再次輸出數組名及元素。
 */
public class ArrayTest2 {
public static void main(String[] args) {
//定義兩個數組
int[] arr = new int[2];
int[] arr2 = new int[3];
//分別輸出數組名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
//然後分別給數組中的元素賦值
arr[1] = 100;
arr2[0] = 200;
arr2[2] = 300;
//再次輸出數組名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}

1.4.3.2 代碼內存圖解:

1.4.4 兩個數組指向同一個地址的內存圖
定義兩個數組，先定義一個數組，賦值，輸出。然後定義第二個數組的時候把第一個數組的地址賦值給第二個數組。然後給第二個數組賦值，再次輸出兩個數組的名及元素
1.4.4.1 案例代碼七:

/*
 * 需求：定義兩個數組，先定義一個數組，賦值，輸出。然後定義第二個數組的時候把第一個數組的地址賦值給第二個數組。
 * 然後給第二個數組賦值，再次輸出兩個數組的名及元素。
 */
public class ArrayTest3 {
public static void main(String[] args) {
// 先定義一個數組，賦值，輸出
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

// 然後定義第二個數組的時候把第一個數組的地址賦值給第二個數組
int[] arr2 = arr;
// 然後給第二個數組賦值
arr2[0] = 111;
arr2[1] = 222;
arr2[2] = 333;

// 再次輸出兩個數組的名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}

1.4.4.2 代碼內存圖解:

 ![](http://i2.51cto.com/images/blog/201803/08/5a6fcea23754e314f614accf561fff76.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)

1.5 數組的使用1.5.1 數組的元素訪問1.5.1.1 案例代碼八:

package com.itheima_01;
/*
 * 數組：存儲同一種數據類型的多個元素的容器。
 *
 * 定義格式：
 * A:數據類型[] 數組名;
 * B:數據類型 數組名[];
 * 舉例：
 * A:int[] a; 定義一個int類型的數組，數組名是a
 * B:int a[]; 定義一個int類型的變量，變量名是a數組
 *
 * 數組初始化：
 * A:所謂初始化，就是為數組開辟內存空間，並為數組中的每個元素賦予初始值
 * B:我們有兩種方式對數組進行初始化
 * a:動態初始化        只指定長度，由系統給出初始化值
 * b:靜態初始化        給出初始化值，由系統決定長度
 *
 * 動態初始化：
 * 數據類型[] 數組名 = new 數據類型[數組長度];
 */
public class ArrayDemo {
public static void main(String[] args) {
//數據類型[] 數組名 = new 數據類型[數組長度];
int[] arr = new int[3];
/*
 * 左邊：
 * int:說明數組中的元素的數據類型是int類型
 * []:說明這是一個數組
 * arr:是數組的名稱
 * 右邊：
 * new:為數組分配內存空間
 * int:說明數組中的元素的數據類型是int類型
 * []:說明這是一個數組
 * 3:數組的長度，其實就是數組中的元素個數
 */`

System.out.println(arr); //[I@3fa5ac,地址值
//我們獲取到地址值沒有意義，我要的是數組中的數據值，該怎麽辦呢?
//不用擔心，java已經幫你想好了
//其實數組中的每個元素都是有編號的，編號是從0開始的，最大的編號就是數組的長度-1
//用數組名和編號的配合我們就可以獲取數組中的指定編號的元素
//這個編號的專業叫法：索引
//格式：數組名[編號] -- 數組名[索引]
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}

1.5.2 數組使用的兩個小問題1.5.2.1 案例代碼九:

package com.itheima_02;

/*
 * 兩個常見小問題：
 * A:java.lang.ArrayIndexOutOfBoundsException
 * 數組越界異常
 * 產生的原因：就是你訪問了不存在的索引元素。
 * B:java.lang.NullPointerException
 * 空指針異常
 * 產生的原因：數組已經不指向堆內存的數據了，你還使用數組名去訪問元素。
 * 為什麽我們要記住這樣的小問題呢?
 * 編程不僅僅是把代碼寫出來，還得在出現問題的時候能夠快速的解決問題。
 */
public class ArrayDemo {
public static void main(String[] args) {
// 定義數組
int[] arr = { 1, 2, 3 };
//System.out.println(arr[3]);
//引用類型：類,接口,數組
//常量：空常量 null，是可以賦值給引用類型的
//arr = null;
System.out.println(arr[1]);
}
}

1.6 一維數組練習1.6.1 一維數組遍歷1.6.1.1 案例代碼十:

package com.itheima_03;

/*
 * 需求：數組遍歷(依次輸出數組中的每一個元素)
 * 獲取數組中元素的個數：數組名.length
 */
public class ArrayTest {
public static void main(String[] args) {
// 定義數組
int[] arr = { 11, 22, 33, 44, 55 };
// 原始做法
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("--------------------");

// 用for循環改進
for (int x = 0; x < 5; x++) {
System.out.println(arr[x]);
}
System.out.println("--------------------");
//為了解決我們去數數組中元素個數的問題，數組就提供了一個屬性：length
//用於獲取數組的長度
//格式：數組名.length
System.out.println("數組共有："+arr.length+"個");
System.out.println("--------------------");
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}
}

1.6.2 數組操作之獲取最值:

1.6.2.1 案例代碼十一:

package com.itheima_03;
/*
 * 需求：數組獲取最值(獲取數組中的最大值最小值)
 */
public class ArrayTest2 {
public static void main(String[] args) {
//定義數組
int[] arr = {12,98,45,73,60};
//定義參照物
int max = arr[0];
//遍歷數組，獲取除了0以外的所有元素，進行比較
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
System.out.println("數組中的最大值是："+max);
}

}
1.7 二維數組1.7.1 二維數組概述
我們黑馬程序員的Java基礎班每個班有很多個學生，所以，可以用數組來存儲，而我們又同時有很多個Java基礎班。這個也應該用一個數組來存儲。如何來表示這樣的數據呢?Java就提供了二維數組供我們使用。
由此可見：其實二維數組其實就是一個元素為一維數組的數組。
1.7.2 二維數組格式
定義格式
數據類型[][] 數組名;
數據類型 數組名[][]; 不推薦
數據類型[] 數組名[]; 不推薦
初始化方式
數據類型[][] 變量名 = new 數據類型[m][n];
數據類型[][] 變量名 = new 數據類型[][]{{元素…},{元素…},{元素…}};
簡化版格式：數據類型[][] 變量名 = {{元素…},{元素…},{元素…}};
1.7.2.1 案例代碼十二:

package com.itheima_04;

/*
 * 二維數組：就是元素為一維數組的數組。
 *
 * 定義格式：
 * A:數據類型[][] 數組名;
 * B:數據類型 數組名[][];        不推薦
 * C:數據類型[] 數組名[];        不推薦
 *
 * 如何初始化呢?
 * A:動態初始化
 * 數據類型[][] 數組名 = new 數據類型[m][n];
 * m表示這個二維數組有多少個一維數組
 * n表示每一個一維數組的元素有多少個
 * B:靜態初始化
 *       數據類型[][] 數組名 = new 數據類型[][]{{元素...},{元素...},{元素...},...};
 * 簡化格式：
 * 數據類型[][] 數組名 = {{元素...},{元素...},{元素...},...};
 */
public class ArrayArrayDemo {
public static void main(String[] args) {
// 數據類型[][] 數組名 = {{元素...},{元素...},{元素...},...};
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

System.out.println(arr); // [[I@104c575
System.out.println(arr.length); // 二維數組中的一維數組的個數
System.out.println(arr[0]);// [I@3fa5ac
System.out.println(arr[0].length);
System.out.println(arr[1]);// [I@95cfbe
System.out.println(arr[2]);// [I@179dce4
//我如何獲取到一個二維數組的元素呢?
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][0]);
}
}

1.7.3 二維數組的遍歷
遍歷思想:首先使用循環遍歷出二維數組中存儲的每個一維數組,然後針對每個遍歷到的一維數組在使用循環遍歷該一維數組中的元素
1.7.3.1 案例代碼十三:

package com.itheima_04;

/*
 * 二維數組遍歷
 *
 * System.out.println():輸出內容並換行
 * System.out.print():輸出內容
 * System.out.println():換行
 */
public class ArrayArrayTest {
public static void main(String[] args) {
// 定義二維數組
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

// 二維數組中的一維數組名稱：二維數組名[索引]
// arr[0] 其實就是二維數組中的第一個一維數組的名稱
// arr[1] 其實就是二維數組中的第二個一維數組的名稱
// arr[2] 其實就是二維數組中的第三個一維數組的名稱

// for (int x = 0; x < arr[0].length; x++) {
// System.out.println(arr[0][x]);
// }

// System.out.println("hello");
// System.out.println("world");
// System.out.print("hello");
// System.out.print("world");

/*
// 第一個一維數組的元素
for (int x = 0; x < arr[0].length; x++) {
System.out.print(arr[0][x] + "  ");
}
System.out.println();

// 第二個一維數組的元素
for (int x = 0; x < arr[1].length; x++) {
System.out.print(arr[1][x] + "  ");
}
System.out.println();

// 第三個一維數組的元素
for (int x = 0; x < arr[2].length; x++) {
System.out.print(arr[2][x] + "  ");
}
System.out.println();
*/
//        for(int y=0; y<3; y++) {
//        for (int x = 0; x < arr[y].length; x++) {
//        System.out.print(arr[y][x] + "  ");
//        }
//        System.out.println();
//        }
for(int y=0; y<arr.length; y++) {
for (int x = 0; x < arr[y].length; x++) {
System.out.print(arr[y][x] + "  ");
}
System.out.println();
}

}
}

第2章 數組