文章目錄
-
- 數組【重點】
-
-
- 1. 數組
-
- 1.1 生活中的數組
- 1.2 代碼中對于數組的期望
- 1.3 Java中定義數組的格式【重點】
- 1.4 Java中定義數組示範
- 1.5 數組使用和下标問題
-
- 數組操作【重點】
-
-
- 1. 數組分析
-
- 1.1 數組記憶體分析
-
- 1.1.1 生活案例引入
- 1.1.2 數組記憶體分析圖【重點】
- 1.2 數組轉移問題
- 2. 數組操作
-
- 2.1 數組和for循環不得不說的故事
- 2.2 數組作為方法參數的封裝
- 2.3 逆序數組中的資料
- 2.4 找出數組中最大值下标位置
- 2.5 找出數組中最小值下标位置
- 2.6 找出指定元素在數組中的下标位置
- 2.7 在指定數組中的指定下标位置插入元素【難點】
- 2.8 删除數組中的指定下标的元素【難點】
- 2.9 找出指定元素在指定數組中所有下标位置 【難點】
- 2.10 排序算法推演
- 3.二維數組
-
數組【重點】
1. 數組
1.1 生活中的數組
超市
生活中非常常見的歸納總結資料的過程。
圖書館
圖書分類
社科類 T
圖書會根據書架位置有一個獨立編碼
一本書可能出現多本
<<NIO與Socket程式設計技術指南>> 10本
T-1-20-01 ~ T-1-20-10
1. 可以統一管理
2. 又可以做到獨立操作。
總結:
1. 該圖書會在圖書館中占據一個連續的存儲空間
2. 該圖書有一個統一的名稱<<NIO與Socket程式設計技術指南>> ==> T-1-20
3. 每一本圖書都有一個獨立編号T-1-20-01 ~ T-1-20-10
1.2 代碼中對于數組的期望
實際開發場景中，一定會出現大量相同資料的使用情況。如果按照單一變量資料方式處理，會導緻代碼中出現以下問題；
1. 代碼過程臃腫
2. 代碼閱讀性極差
3. 代碼操作性，維護性極差
可以模仿圖書館管理圖書的方式來處理資料操作過程:
1. 連續存儲
2. 統一名稱
3. 獨立編号
1.3 Java中定義數組的格式【重點】
資料類型[] 數組名 = new 資料類型[容量];
指派号左側:
資料類型:
明确告知編譯器，目前數組可以儲存支援的資料類型到底是哪一個，并且有且隻能
是哪一個。保證【資料類型一緻化】
[]:
1. 明确告知編譯器，這裡定義的是一個數組類型
2. 告知編譯器，目前數組名是一個【引用資料類型】的變量
數組名:
1. 是目前數組的操作使用的，重要名稱
2. 數組名是一個【引用資料類型】變量
指派号右側:
new:
new關鍵字在記憶體中申請記憶體【堆區】資料空間，并且将申請的記憶體空間全部擦除幹
淨。
堆區：相當于一個生活中的倉庫，new關鍵字用于申請倉庫中的空間。目前申請的倉
庫空間需要清理幹淨
資料類型:
前後呼應，要求和指派号左側完全一緻，明确告知編譯器，目前能夠使用的資料類
型到底是哪一個。保證【資料類型一緻化】
[容量]:
目前數組可以儲存指定資料類型的容量個數，容量一旦确定無法更改~~~
1.4 Java中定義數組示範
/*
Java中定義數組的形式
*/
class Demo2 {
public static void main(String[] args) {
/*
在代碼中定義了一個數組，
數組的資料類型為int
數組名 arr
數組容量 10，可以儲存10個int類型數組
數組容量有且隻允許在int類型範圍以内，不允許負數
目前數組占用記憶體空間 40+
*/
int[] arr = new int[10];
}
}
1.5 數組使用和下标問題
1. 數組操作是依賴于數組名進行
數組名是代表整個數組
2. 數組操作需要使用下标，下标範圍是0 ~ 數組容量 - 1
int[] arr = new int[10];
有效下标範圍:
0 ~ 9
【原則】下标沒有負數，負數可以用于操作非法情況
如果操作過程中下标位置超出範圍
ArrayIndexOutOfBoundException 數組下标越界異常
數組操作【重點】
1. 數組分析
1.1 數組記憶體分析
1.1.1 生活案例引入
洗浴中心
引用資料類型 ==> 洗浴中心的名片
洗浴中心的名片有該洗浴中心的位址
開着凱迪拉克 XT4 根據位址導航到目的地
尋址 ==> 尋找目前位址
我在門口等着你，給你一個小驚喜(手牌)
手牌有對應櫃子的編号，可以存放物品
櫃子就是數組的資料空間，手牌是數組中的下标位置
1.1.2 數組記憶體分析圖【重點】
1.2 數組轉移問題
class Demo1 {
public static void main(String[] args) {
// 定義兩個int類型數組，數組容量都為10
int[] arr1 = new int[10];
int[] arr2 = new int[10];
arr1[0] = 10;
arr2[5] = 200;
System.out.println(arr1[0]);
System.out.println(arr2[5]);
arr1 = arr2;
arr1[5] = 500;
arr2[0] = 100;
System.out.println(arr1[0]); // 100 [100] 10 10
System.out.println(arr2[5]); // 200 [500] 500 200
}
}
2. 數組操作
2.1 數組和for循環不得不說的故事
數組屬性:
數組名.length 擷取目前數組的容量/長度
for循環格式
for (循環條件初始化; 循環條件判斷; 循環條件變更) {
// 循環體
}
例如:
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
}
/*
數組和for循環完成指派和取值問題
*/
class Demo2 {
public static void main(String[] args) {
// 定義了一個int類型數組，容量為10
int[] arr = new int[10];
// 使用for循環對數組中的每一個元素進行指派操作
// arr.length . ==> 的 數組arr的容量
for (int i = 0; i < arr.length; i++) {
// 指派數組中指定下标的元素，i從0開始到9結束，對應數組下标
arr[i] = i + 1;
}
// 取值展示資料
for (int i = 0; i < arr.length; i++) {
System.out.println("arr[" + i + "] = " + arr[i]);
}
}
}
2.2 數組作為方法參數的封裝
模版:
public static void main(String[] args) {
}
格式:
public static 傳回值類型 方法名(資料類型[] 參數數組名) {
}
/*
數組和for循環完成指派和取值問題
*/
class Demo3 {
public static void main(String[] args) {
// 定義了一個int類型數組，容量為10
int[] arr = new int[10];
// 如果一個方法所需參數為數組類型，這裡傳入對應數組的數組名即可
assignIntArray(arr);
printIntArray(arr);
}
/**
* 指派使用者指定的int類型數組
*
* @param arr 要求使用者傳入的int類型數組
*/
public static void assignIntArray(int[] arr) {
// 使用for循環對數組中的每一個元素進行指派操作
// arr.length . ==> 的 數組arr的容量
for (int i = 0; i < arr.length; i++) {
// 指派數組中指定下标的元素，i從0開始到9結束，對應數組下标
arr[i] = 2 * i;
}
}
/**
* 展示使用者提供的int類型數組
*
* @param arr 使用者提供的int類型數組
*/
public static void printIntArray(int[] arr) {
// 取值展示資料
for (int i = 0; i < arr.length; i++) {
System.out.println("arr[" + i + "] = " + arr[i]);
}
}
}
2.3 逆序數組中的資料
數組原型:
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
==>
{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
/**
* 逆序int類型數組中的所有元素
*
* @param arr 使用者指定的int類型數組
*/
public static void reverse(int[] arr) {
// i < arr.length / 2 依次1,10；2，9 。。。調換順序
for (int i = 0; i < arr.length / 2; i++) {
// arr[i] <==> arr[arr.length - 1 - i];
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
2.4 找出數組中最大值下标位置
數組原型:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
max index = 4
/*
2.4 找出數組中最大值下标位置
數組原型:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
max index = 4
*/
class Demo5 {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 19, 2, 4, 16, 28, 1};
int maxIndex = findMaxIndex(arr);
System.out.println("maxIndex : " + maxIndex);
}
/**
* 找出指定int類型數組中最大值下标位置
*
* @param arr 使用者指定的int類型數組
* @return 傳回值是最大值下标所在位置
*/
public static int findMaxIndex(int[] arr) {
// 假設思想
// 在目前數組中下标為0的元素是最大值
int maxIndex = 0;
// 利用循環周遊整個數組，如果發現有元素大于目前maxIndex儲存
// 下标對應元素，記錄目前下标
for (int i = 1; i < arr.length; i++) {
if (arr[maxIndex] < arr[i]) {
maxIndex = i;
}
}
return maxIndex;
}
}
2.5 找出數組中最小值下标位置
數組原型:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
max index = 0
/*
2.5 找出數組中最小值下标位置
數組原型:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
max index = 0
*/
class Demo5 {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 19, 2, 4, 16, 28, 1};
int minIndex = findMinIndex(arr);
System.out.println("minIndex : " + minIndex);
}
/**
* 找出指定int類型數組中最小值下标位置
*
* @param arr 使用者指定的int類型數組
* @return 傳回值是最小值下标所在位置
*/
public static int findMinIndex(int[] arr) {
// 假設思想
// 在目前數組中下标為0的元素是最大值
int minIndex = 0;
// 利用循環周遊整個數組，如果發現有元素小于于目前minIndex儲存
// 下标對應元素，記錄目前下标
for (int i = 1; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i;
}
}
return minIndex;
}
}
2.6 找出指定元素在數組中的下标位置
數組原型:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}
找出元素 5 對應下标為 2
找出元素 10 對應下标為 9
找出元素 20 對應下标為 -1 表示沒有找到
/*
2.6 找出指定元素在數組中的下标位置
數組原型:
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}
找出元素 5 對應下标為 2
找出元素 10 對應下标為 9
找出元素 20 對應下标為 -1 表示沒有找到
*/
class Demo6 {
public static void main(String[] args) {
int num = 9;
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
int index = indexOf(arr, num);
if (-1 == index) {
System.out.println("指定資料未找到");
} else {
System.out.println("目标元素所在下标位置 : " + index);
}
}
/**
* 在指定數組中，找出指定元素的下标位置
*
* @param arr 指定查詢資料的目标int類型數組
* @param num 指定需要查詢的資料
* @return 找到對應元素傳回值大于等于0，否則 -1
*/
public static int indexOf(int[] arr, int num) {
/*
需要擷取下标位置
存在未找到情況！！！
這裡index初始化為-1 更友善的擷取對應的下标資訊
*/
int index = -1; // -1
// 利用循環周遊整個數組，比對資料
for (int i = 0; i < arr.length; i++) {
// 如果發現存在元素和目前指定元素一緻。儲存下标【終止循環】
if (num == arr[i]) {
index = i;
// 已經找到目标元素，需要終止循環，使用break關鍵字
break;
}
}
return index;
}
}
2.7 在指定數組中的指定下标位置插入元素【難點】
存在一個數組，數組中的元素為
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
要求
1. 0是無效元素，僅占位使用
2. 目前數組中【有效元素】個數為 9
需求
在該數組中的指定下标位置放入指定元素
/*
存在一個數組，數組中的元素為
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
要求
1. 0是無效元素，僅占位使用
2. 目前數組中【有效元素】個數為 9
需求
在該數組中的指定下标位置放入指定元素
*/
class Demo7 {
public static void main(String[] args) {
int index = 5;
int insert = 20;
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
boolean result = add(arr, index, insert);
if (result) {
printIntArray(arr);
}
}
/*
方法分析:
public static:
不要問，固定格式
傳回值:
boolean 類型 如果方法運作成功，傳回true，失敗傳回false
失敗是因為使用者提供的資料不合法！！！
方法名:
add 添加
形式參數清單:
int[] arr 指定操作資料
int index 指定下标位置
int insert 插入資料
方法聲明:
public static boolean add(int[] arr, int index, int insert)
*/
/**
* 在數組中指定下标位置，添加使用者指定的元素
*
* @param arr 指定操作資料
* @param index 指定下标位置
* @param insert 插入資料
* @return 方法運作成功傳回true，否則傳回false
*/
public static boolean add(int[] arr, int index, int insert) {
// 使用者輸入參數合法性判斷
if (index < 0 || index > arr.length - 1) {
System.out.println("Illegal Index 非法下标！");
// return終止方法運作，同時false表示目前方法運作失敗
return false;
}
/*
移動數組中的内容，騰出插入資料的下标位置
*/
for (int i = arr.length - 1; i > index; i--) {
arr[i] = arr[i - 1];
}
arr[index] = insert;
// 傳回true表示方法運作成功
return true;
}
/**
* 展示使用者提供的int類型數組
*
* @param arr 使用者提供的int類型數組
*/
public static void printIntArray(int[] arr) {
// 取值展示資料
for (int i = 0; i < arr.length; i++) {
System.out.println("arr[" + i + "] = " + arr[i]);
}
}
}
2.8 删除數組中的指定下标的元素【難點】
存在一個數組，數組中的元素為
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
要求:
1. 0是無效元素，僅占位使用
需求:
在目前數組中删除指定下标的元素
例如:
指定下标5
結果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0}
0占位！！！
class Demo8 {
public static void main(String[] args) {
int index = 1;
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
boolean ret = remove(arr, index);
if (ret) {
printIntArray(arr);
}
}
/**
* 删除數組中指定下标的元素
*
* @param arr 删除資料的目标數組
* @param index 指定删除的下标位置
* @return 成功傳回true，否則傳回false
*/
public static boolean remove(int[] arr, int index) {
if (index < 0 || index > arr.length - 1) {
System.out.println("ArrayIndexOutOfBoundsException 數組下标越界");
return false;
}
for (int i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
arr[arr.length - 1] = 0;
return true;
}
/**
* 展示使用者提供的int類型數組
*
* @param arr 使用者提供的int類型數組
*/
public static void printIntArray(int[] arr) {
// 取值展示資料
for (int i = 0; i < arr.length; i++) {
System.out.prin2tln("arr[" + i + "] = " + arr[i]);
}
}
}
2.9 找出指定元素在指定數組中所有下标位置 【難點】
/*
要求：
a. 不允許在方法内列印展示
b. 考慮多個資料情況
c. 需要在方法外擷取到下标資料資訊
d. 不允許使用數組作為傳回值
*/
2.10 排序算法推演
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
第一題:
找出數組中最大值，和下标為0的元素交換位置
{10, 3, 5, 7, 9, 2, 4, 6, 8, 1}
第二題:
找出數組中剩餘資料最大值(目前數組中下标為0的元素是最大值)，和下标為1的元素交換位置
{10, 9, 5, 7, 3, 2, 4, 6, 8, 1}
第三題:
找出數組中剩餘資料最大值(目前數組中下标為0, 1的元素是最大值)，和下标為2的元素交換位置
{10, 9, 8, 7, 3, 2, 4, 6, 5, 1}
核心思路
1. 找
2. 換
3.二維數組
二維數組可以看做數組的數組：二維數組就是一個特殊的以為數組，其每一個元素都是一維數組
int array[][] = new int[2][3];
這個二維數組array可以看做一個二行三列的數組
int a[][] = {{1,2}, {2,3}}
public class Test {
public static void main(String[] args) {
int a[][] = {{1,2}, {2,3}};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j <a[i].length ; j++) {
System.out.println(a[i][j]);
}
}
}
}
/*
輸出結果為：
1
2
2
3
*/