|
開始本文前，先跟大家推薦個知識星球：小猿和他的朋友們 ，目前星球還在優(yōu)惠階段，大家可以點進來看看 。 今天重點介紹下數(shù)組的概念，數(shù)據(jù)就是一種數(shù)據(jù)結(jié)構(gòu)，可以用來存儲多個數(shù)據(jù)，每個數(shù)組中可以存放相同類型的數(shù)據(jù)。比如，在學校，我們是一個班，這里的班級中每個同學都是這個班級數(shù)組中的元素，都是同樣的類型為學生，對應的學號就是我們的索引，但是在現(xiàn)實中的學號一般都是從1開始的，而在Java中的數(shù)組索引是從0開始的。 定義一個數(shù)組為方括([])，通過數(shù)組元素的索引(或下標，角標)來訪問數(shù)組中的元素，同時可以為數(shù)組賦值和取出數(shù)組的元素值。 數(shù)組
問: 在Java中為什么要有數(shù)組呢?
答: 數(shù)組就是一個容器，是用來存儲同種數(shù)據(jù)類型的多個值。 數(shù)組的概念 同一種類型的數(shù)據(jù)的集合，用來裝數(shù)據(jù)的，數(shù)組就是一個容器。在Java中數(shù)組的好處就是可以用數(shù)組中的元素從0開始編號，可以利用下標(索引)，對齊進行操作，即方便又快捷。 在Java中的數(shù)組是用存儲同種數(shù)組的元素，其指的是數(shù)據(jù)類型要相同，在數(shù)組中存放的數(shù)據(jù)類型是唯一的，只能存儲一種數(shù)據(jù)類型，不能存儲多種數(shù)據(jù)類型。數(shù)組可以存儲基本數(shù)據(jù)類型，也可以存儲引用數(shù)據(jù)類型。 數(shù)組的定義格式： 一般數(shù)組的定義為： int[] array; 或 int array[];
這兩種定義的語法通常都可以用，但是建議是使用 int[] array 這種語法，因為大多數(shù)程序員常用，這種語法定義更具有可讀性。 格式1： 數(shù)據(jù)類型[] 數(shù)組名 = new 數(shù)組類型[元素個數(shù)或者數(shù)組的長度];
例如： int[] arr = new int[5];
格式2： 元素類型[] 數(shù)組名 = new 元素類型[]{元素1，元素2，。。。};
例如： int[] arr = new int[]{1，2，3，4};
int[] arr = {2，3，4，5};
數(shù)組的定義方式： 數(shù)組的表示：[]，通過關(guān)鍵字new來創(chuàng)建數(shù)組
一個數(shù)組一旦初始化建立，那么數(shù)組就會在內(nèi)存中有一塊空間被固定下來，那么這塊空間就是這個數(shù)組的，不可變，即數(shù)組的長度將不可改變。就算把這個數(shù)組中的數(shù)組清空，在內(nèi)存中還是這塊空間被保存下來。比如，一家酒店我們把它定義一個數(shù)組，那么每個房間就是這家就是的長度，這家酒店我們就把它當做是我們在內(nèi)存中開辟的一塊固定下來的空間，每個房間中入住的人就是這塊空間，也就是數(shù)組的元素，房間號碼我們可以當做的數(shù)組的索引，通過房間號找到相應的入住者。當這家酒店中的每個元素即是客人都走時，這家酒店中的房間依然保留著，依然還是酒店，所以依然還是數(shù)組了。數(shù)組中的長度即酒店中的房間還是這個數(shù)量（長度）。 數(shù)組代碼示例： package com。dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 數(shù)據(jù)類型[] 數(shù)組名=new 數(shù)據(jù)類型[數(shù)組的長度];
int[] arr = new int[5];
/*
* int: 代表數(shù)據(jù)類型
* []: 代表數(shù)組
* arr: 合法的標識符
*
* new: 創(chuàng)建新的實體或?qū)ο?br> * int: 數(shù)據(jù)類型
* []: 代表的數(shù)組
* 5: 代表數(shù)組的長度
*/
}
}
數(shù)組的索引 例如： int[] arr = new int[3];
數(shù)組可以存儲多個數(shù)據(jù)，并且會對數(shù)組進行編號，從0開始操作元素，可以通過編號（索引，角標，下標）找到該元素。代碼中會在內(nèi)存空間中開辟3個空間，如三個房子編號，從0開始，第二個房子為1，第三個房子為2。這只是一種比如，我們把它看作三個空間，對應的三個地址編號而已，通過地址是不是就可以找到房子了呢！ 數(shù)組也是一種數(shù)據(jù)類型，為引用類型，如int為一種基本數(shù)據(jù)類型，那么int[]這是一種屬于int數(shù)組的一種引用類型，所以int[]是一種數(shù)據(jù)類型，創(chuàng)建int[]類型的對象為創(chuàng)建數(shù)組。 什么是數(shù)組的初始化？ 就是為數(shù)組開辟連續(xù)的內(nèi)存空間，并為每個數(shù)據(jù)元素賦予值。 只要數(shù)組進行分配，就具有初始化值，數(shù)組變量一旦在內(nèi)存空間分配了區(qū)域，就會在每個空間里存儲數(shù)組的初始化值，就算內(nèi)存空間為空，也會有一個初始化的值為null，這里的值會根據(jù)變量類型來給定初始化值，初始化值可以有系統(tǒng)進行自動分配，如果我們不給定值的話，另一種就是由我們程序員給定初始化值。 如何對數(shù)組進行初始化？ 動態(tài)初始化就是程序員指定數(shù)組的長度，有系統(tǒng)進行數(shù)組元素的分配初始值。 例如： int[] arr = new int[5];
格式如下： arrayName = new type[length];
使用動態(tài)初始化過程如下： int[] array = new int[5];
靜態(tài)初始化就是程序員給定初始化值，然后由系統(tǒng)進行決定長度。 靜態(tài)初始化的語法格式： array = new type[]{元素1，元素2，元素3，。。。};
定義一個int數(shù)組類型的變量： int[] intArray;
靜態(tài)初始化，給定數(shù)組元素的初始化值，不給定數(shù)組長度，由系統(tǒng)決定數(shù)組長度： intArray = new int[]{2，3，4，5，6}; 或 intArray = {2，3，4，5，6};
在程序員的通常寫法中，數(shù)組的定義和數(shù)組進行初始化都是同時完成如： int[] a = {1，2，3，4};
代碼案例： package com。dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 數(shù)據(jù)類型[] 數(shù)組名 = new 數(shù)據(jù)類型[數(shù)組長度];
int[] arr = new int[5]; // 動態(tài)初始化，在內(nèi)存中開辟連續(xù)的5塊空間
System。out。println(arr[0]); // 系統(tǒng)會給出默認的初始化值
// 整數(shù)類型都為0
arr[0] = 12;
System。out。println(arr[0]);
}
}
結(jié)果： 效果
結(jié)果在內(nèi)存中開辟連續(xù)的5塊空間，在內(nèi)存中進行存儲，這5塊空間有自己的地址，用于方便去找到，可以通過地址先找到該數(shù)組，如找一棟樓，需要地址，然后找數(shù)組中的元素，如每個房間，通過編號找到每個元素。 案例： System。out。println(arr);// 打印結(jié)果
[I@7852e922// 16進制的表現(xiàn)形式// [ 代表數(shù)組// I 代表是int類型// @ 固定的// 7852e922 代表16進制的地址值
在Java中運行程序會進行劃分空間進行運行程序：五塊內(nèi)存空間 1.棧：用來存儲局部變量的
2.堆：存儲new出來的數(shù)組或?qū)ο?br>3.方法區(qū)：面向?qū)ο?br>4.本地方法區(qū)：和系統(tǒng)相關(guān)
5.寄存器：供給CPU使用（不需要了解） 局部變量是定義在方法聲明上或方法中的變量，在棧內(nèi)存中，存儲的都是局部變量，只要在方法中定義的變量都是局部變量，一旦變量的生命周期結(jié)束該變量就會被釋放，用完就會被刪掉了。 堆內(nèi)存，存儲的都是實體，就是對象，凡是用new 創(chuàng)建的都是在堆里面。 new，一個new指在內(nèi)存中進行開辟空間，在堆內(nèi)存中每個實體都是一個首地址值，堆內(nèi)存的變量都是有默認的初始化值的，不同類型都不一樣，當實體不在使用時，堆中的變量不會馬上刪除，會由Java系統(tǒng)中的垃圾回收機制進行回收（Java中有個垃圾回收機制，自動回收垃圾） 數(shù)組地址，例如：0x0011，可以通過索引找到每個值，系統(tǒng)會給初始化值。 整數(shù)類型： byte， short， int， long 的默認初始化值都為0 浮點類型： float， double 的默認初始化值都為0。0 布爾類型： boolean的默認初始化值為false 字符類型： char默認初始化值為 “\u0000”，char在內(nèi)存中是占兩個字節(jié)，是16個二進制位。\u0000每個0代表16進制的0，那么四個0就是代表16個二進制位。 一個字節(jié)代表8個二進制位，那么兩個字節(jié)，就代表16個二進制位。'\u0000'每個0代表16進制的0，那么四個0就是代表16個二進制位。 char在內(nèi)存中占兩個字節(jié) 代表16個二進制位， 兩個字節(jié)代表16個二進制位。
一個字節(jié)代表8個二進制位，那么兩個字節(jié)就代表16個二進制位。 \u0000:
每個0代表16進制的0，那么四個0就代表16個二進制位。
兩個字節(jié)就代表16個二進制位，那么四個0代表16個二進制位。 char:就代表16個二進制位。
\u0000`:就代表16個二進制位 = 四個0就代表16個二進制位。
每個0就代表16個進制的二進制數(shù)。1個0就代表4位，16進制是4位代表一位的，4個就代表16個二進制數(shù)。 16個二進制位: 0000
一個就代表4個二進制位，那么4個就代表16個二進制位。 數(shù)組元素如果是引用數(shù)據(jù)類型為類，接口和數(shù)組，那么數(shù)組元素的初始化值是null。 注意：靜態(tài)初始化和動態(tài)初始化不能同時用，不要在進行數(shù)組初始化值是，既要分配數(shù)組元素初始化值，還要給定數(shù)組的長度，千萬不要，知道嗎！ 槍 槍中的彈夾，子彈是一顆一顆地壓進去的，第一顆壓進的子彈是最后打出來的，最后一顆的子彈先發(fā)射出來。所以java中的方法就想彈夾一樣，而主方法，是先進入內(nèi)存的，虛擬機調(diào)用主方法，程序運行起來，首先進入內(nèi)存的，進入棧的，是主方法。 主方法就像子彈一樣，放入到棧低，壓進棧，壓棧。主方法直接壓入棧底，運行完之后會彈出去，就叫彈棧。棧是先進后出。主方法壓進棧。方法里的局部變量，類型為數(shù)組類型。 代碼案例： package com。dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// int x = 12; // x就是局部變量
int[] arr = new int=[3];
// 動態(tài)初始化，創(chuàng)建3塊連續(xù)的空間
// 方法里的局部變量
}
}
在棧中存放主方法，主方法內(nèi)有局部變量，這個局部變量為數(shù)組類型: int[] arr; 然后在堆中是數(shù)組類型new出來的值。 內(nèi)存分析案例： 效果
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// int x = 12; // x就是局部變量
int[] arr = new int[3];
// 動態(tài)初始化，創(chuàng)建3塊連續(xù)的空間
// 方法里的局部變量
arr[0] = 10;
arr[1] = 20;
System.out.println(arr[0]);
System.out.println(arr[1]);
}
}
制作內(nèi)存圖： 地址值是賦予給arr，只是通過地址找到實體的。 效果
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[3]; // 創(chuàng)建數(shù)組長度為3
int[] arr2 = new int[3];
System.out.println(arr1); // 打印數(shù)組的地址值
System.out.println(arr2);
arr1[0] = 10; // 給第一個數(shù)組中的第一個元素賦值
arr2[1] = 20; // 給第二個數(shù)組中的第二個元素賦值
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println('-----------');
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
效果
制作內(nèi)存圖： 效果
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr1 = new int[3];
int[] arr2 = new int[5];
int[] arr3 = arr2;
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr3);
arr1[0] = 10;
arr1[1] = 20;
arr2[1] = 30;
arr3[1] = 40;
arr3[2] = 50;
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println('--------------');
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);
System.out.println(arr2[4]);
System.out.println('--------------');
System.out.println(arr3[0]);
System.out.println(arr3[1]);
System.out.println(arr3[2]);
System.out.println(arr3[3]);
System.out.println(arr3[4]);
}
}
結(jié)果： 效果
制作內(nèi)存圖： 效果
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 數(shù)據(jù)類型[] 數(shù)組名=new 數(shù)據(jù)類型[]{元素1，元素2，...};
// int[] arr = new int[] {1，23，45，67，28};
// int[] arr2 = {2，35，6，12}; // 靜態(tài)初始化的簡寫形式
// int[] arr; //聲明數(shù)組引用
// arr = new int[] {11，22，33，44}; // 可以不同行
// int [] arr2;
// arr2 = {23，43，55}; // 簡寫形式聲明和賦值必須在同一行
// int[] arr = new int[3]{23，22，1}; //會報錯，不允許動靜結(jié)合
// 應該寫成 int[] arr = new int[3]; 為動態(tài)初始化
// int[] arr = new int[]{23，44，2}; 為靜態(tài)初始化
}
}
package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 數(shù)據(jù)類型[] 數(shù)組名=new 數(shù)據(jù)類型[]{元素1，元素2，...};
// int[] arr = new int[] {1，23，45，67，28};
// int[] arr2 = {2，35，6，12}; // 靜態(tài)初始化的簡寫形式
int[] arr = {12，23，34};
System.out.println(arr);
System.out.println(arr[0]);
}
}
制作內(nèi)存圖： 效果
數(shù)組中的異常問題： 程序員寫程序不能保證自己寫的代碼是正確的，總會出現(xiàn)一些錯誤，這時我們要學會調(diào)式這些代碼程序保證可以正常的運行。 數(shù)組索引越界異常
ArrayIndexOutOfBoundsException，指你訪問的索引不存在。 int arr = {1，34，234};
System.out.println(arr[23]);
空指針異常
NullPointerException，指數(shù)組已經(jīng)不在指向堆內(nèi)存了，而你還用數(shù)組名去訪問元素。 int[] arr = {1，2，3};
arr = null;
System.out.println(arr[0]);
package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = new int[5];
System.out.println(arr[5]); // 當訪問數(shù)組中不存在的索引，就會出現(xiàn)索引越界異常.
}
}
結(jié)果圖： 效果
當訪問數(shù)組中不存在的索引的時候就會導致數(shù)組越界異常。 同理 System.out.println(arr[-1]); 同樣導致數(shù)組越界異常。
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = new int[5];
// System.out.println(arr[5]);
arr = null;
System.out.println(arr[0]); // 當數(shù)組引用賦值為null，在去調(diào)用數(shù)組中的元素就會出現(xiàn)空指針異常.
}
}
結(jié)果圖片： 效果
數(shù)組的遍歷： 循環(huán)數(shù)組中的每個數(shù)組元素。 使用foreach循環(huán)，這種循環(huán)遍歷數(shù)組是非常方便的，foreach循環(huán)的格式如下： for (type variableName : array ){
// 訪問每個元素
}
代碼案例： public class ForeachTest {
public static void main(String[] args){
String[] names = { “dashu”, “dashucoding”};
// 使用foreach循環(huán)遍歷數(shù)組中的每個元素
for(String name : names){
System.out.println(name);
}
}
}
代碼案例： package com.dashucoding;/*
* 數(shù)組的遍歷：依次輸出數(shù)組中的每個元素
* 數(shù)組的屬性：arr.length數(shù)組的長度
* 數(shù)組的最大索引：arr.length-1;
* */public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
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]);*/
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println('---------');
// arr.length 代表數(shù)組的長度
System.out.println(arr.length);
System.out.println('---------');
int[] arr2 = {1，2，3};
print(arr2);
}
/*
* 遍歷數(shù)組的方法
* 返回值類型為void
* 參數(shù)列表int[] arr
* */
private static void print(int[] arr) {
// TODO Auto-generated method stub
for(int i = 0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
結(jié)果圖片： 效果
最大值 代碼案例： package com.dashucoding;/*
* 數(shù)組
* 如何獲取數(shù)組的最大值
* */public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {23，34，12，33};
int max = getMax(arr);
System.out.println(max);
}
/*
* 獲取數(shù)組最大值
* 返回值類型為int
* 參數(shù)列表為int[] arr
* */
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) { // 從數(shù)組的第二個元素開始遍歷
if(max < arr[i]) { // 如果max記錄的值小于數(shù)組中的元素，就max記錄記錄最大的
max = arr[i];
}
}
return max;
}
}
結(jié)果圖： 效果
分析制圖： 效果
數(shù)組的操作反轉(zhuǎn)： 操作反轉(zhuǎn)，就是前后倒置 package com.dashucoding;/*
* 數(shù)組
* 如何獲取數(shù)組的最大值
* */public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {22，33，44，55};
reverseArray(arr);
print(arr);
}
/*
* 數(shù)組元素的反轉(zhuǎn)
* 返回值類型void
* 明確參數(shù)列表int[] arr
* */
public static void reverseArray(int[] arr) {
for(int i=0; i < arr.length / 2; i++) {
// arr[0] 第一個 和 arr[arr.length-1-0] 最后一個 交換
// arr[1] 和 arr[arr.length-1-1] 交換
// arr[2] 和 arr[arr.length-1-2] 交換
// ...
/*int temp = arr[0];
arr[0] = arr[arr.length-1];
arr[arr.length-1] = temp;*/
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
/*
* 數(shù)組遍歷
* 明確返回值類型void
* 明確參數(shù)列表int[] arr
* */
public static void print(int[] arr) {
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + ' ');
}
}
}
結(jié)果圖片： 效果
根據(jù)鍵盤錄入索引，查找對應的星期： 代碼案例： package com.dashucoding;
import java.util.Scanner;
/*
* 數(shù)組
* 如何進行數(shù)組查表（根據(jù)鍵盤錄入索引，查找對應的星期)
* */public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println('星期' + getWeek(2));
System.out.println('----------');
// 鍵盤錄入
Scanner sc = new Scanner(System.in);
System.out.println('請輸入對應的星期范圍，對應1至7');
int week = sc.nextInt();
System.out.println('星期' + getWeek(week));
}
/*
* 根據(jù)索引返回對應的星期
* 返回值的類型char
* 能存儲中文的char
* 參數(shù)列表int week
* 通過索引獲取數(shù)組中的元素
* */
public static char getWeek(int week) {
char[] arr = {' '，'一'，'二'，'三'，'四'，'五'，'六'，'日'}; // 定義一張星期表
return arr[week]; // 通過索引獲取數(shù)組中的元素
}
}
數(shù)組元素查找： package com.dashucoding;
import java.util.Scanner;
/*
* 數(shù)組
* 數(shù)組元素查找
* 查找指定元素第一次在數(shù)組中出現(xiàn)的索引
* */public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {11，22，33，44，55};
int index = getIndex(arr，22);
System.out.println(index);
System.out.println('----------');
int index2 = getIndex(arr，10);
System.out.println(index2);
}
/*
* 查找元素索引
* 返回值類型int
* 參數(shù)列表int[] arr， 要查找的值int value
* */
public static int getIndex(int[] arr， int value) {
for(int i = 0; i < arr.length; i++) { // 數(shù)組的遍歷
if(arr[i] == value) { // 如果數(shù)組中的元素與查找元素匹配，就是這個元素
return i; // 返回索引
}
}
// 如果沒有查到，沒找到返回給你一個-1，如果返回值為-1，就知道沒在數(shù)組中找到
return -1;
}
}
結(jié)果圖片： 效果
二維數(shù)組的格式： int[][] arr = new int[3][2];
表示二維數(shù)組的格式: 數(shù)據(jù)類型 數(shù)組名[][] = new 數(shù)據(jù)類型[m][n];
數(shù)據(jù)類型[] 數(shù)組名[] = new 數(shù)據(jù)類型[m][n];
// 建議這么寫
int[][] arr = new int[3][2];
// 一維數(shù)組
int[] x; // 二維數(shù)組int[] x，y[];int[] y[];
二維數(shù)組案例: package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* 二維數(shù)組
* 二維數(shù)組中有3個一維數(shù)組
* 每個一維數(shù)組中有2個元素
* */
int[][] arr = new int[3][2];
// 打印二維數(shù)組
System.out.println(arr);
// 打印二維數(shù)組中的第一個一維數(shù)組
System.out.println(arr[0]);
// 打印二維數(shù)組中的第一個一維數(shù)組的第一個元素
System.out.println(arr[0][0]);
// 打印結(jié)果
/*
* [[I@7852e922 // 二維數(shù)組的地制值
* [I@4e25154f // 一維數(shù)組的地址值
* 0 // 元素值
* */
}
}
結(jié)果圖片： 效果
二維數(shù)組： package com.dashucoding;
import java.util.Scanner;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[][] arr = new int[3][2];
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[0][0]);
}
}
內(nèi)存分析： 效果
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 二維數(shù)組，二維數(shù)組中有3個一維數(shù)組，三個一維數(shù)組都沒有被賦值
int[][] arr = new int[3][];
// 打印二維數(shù)組中的三個一維數(shù)組
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
arr[0] = new int[3]; // 第一個一維數(shù)組中存儲三個int值
arr[1] = new int[5]; // 第二個一維數(shù)組中存儲五個int值
System.out.println('-----');
// 打印二維數(shù)組中的三個一維數(shù)組
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
結(jié)果圖片： 效果
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 二維數(shù)組，二維數(shù)組中有3個一維數(shù)組，三個一維數(shù)組都沒有被賦值
int[][] arr = new int[3][];
// 打印二維數(shù)組中的三個一維數(shù)組
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
分析內(nèi)存圖： 效果
二維數(shù)組格式： int[][] arr = { {1，2，3}， {4，5}， {6，7，8，9} };
代碼案例： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 二維數(shù)組
int[][] arr = { {1，2，3}， {4，5}， {6，7，8，9} };
System.out.println(arr); //二維數(shù)組的地址值
System.out.println(arr[0]); //一維數(shù)組的地址值
System.out.println(arr[0][0]); //元素
}
}
結(jié)果圖： 效果
內(nèi)存分析圖： 效果
二維數(shù)據(jù)的遍歷： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 二維數(shù)組的遍歷
int[][] arr = { {1，2，3}， {4，5}， {6，7，8，9} };
for(int i = 0; i < arr.length; i++) {
// 獲取每個二維數(shù)組中的一維數(shù)組
// 獲取一維數(shù)組中的元素
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + ' ');
}
System.out.println();
}
}
}
結(jié)果圖： 效果
二維數(shù)組的求和： package com.dashucoding;
public class DemoArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 二維數(shù)組求和
int[][] arr = { {1，2，3}， {4，5，6}， {7，8，9} };
int sum = 0;
for(int i = 0; i < arr.length; i++) {
// 獲取每個一維數(shù)組
for(int j = 0; j < arr[i].length; j++) {
//獲取每個一維數(shù)組
sum = sum + arr[i][j];
}
}
System.out.println(sum);
}
}
結(jié)果圖： 效果
基本數(shù)據(jù)類型的值傳遞，不會改變原值，因為調(diào)用后會彈棧，局部變量就會隨之消失，而引用數(shù)據(jù)類型的值傳遞，會改變原值，因為使用方法彈棧，但是堆內(nèi)存數(shù)組對象還在，可以通過地址繼承訪問。 數(shù)組的綜合應用 代碼案例： // 打印數(shù)組public static void printArray(int[] arr){
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1){
System.out.print(arr[x]+',');
}else{
System.out.print(arr[x]);
}
}
}
數(shù)組轉(zhuǎn)字符串： // 數(shù)組轉(zhuǎn)換成為字符串// 結(jié)果返還為字符串，參數(shù)為數(shù)組public static String toString (int[] arr){
// 定義字符串變量
String temp = '[';
for(int x = 0; x<arr.length; x++){
// 判斷是否為最后一位元素
if(x != arr.length - 1){
temp = temp + arr[x] + ',';
}else{
temp = temp + arr[x] + ']';
}
}
}
public static String getWeek(int num){
String[] weeks = { '1', '2', '3', '4', '5', '6', '7' };
if(num>7 || num<1){
return num + '沒有對應的星期';
}
return weeks[num];
}
選擇排序 選擇排序是第一個人和后續(xù)排序的人進行比較，若第一個人大于第二個人，就進行交換，那么這時第一人就是最小的，然后這時的第一個人和第三個人進行比較，若這時的第一個人大于第三個人，就進行交換位置，這時第一個人又換人了，也變得更小了，就這樣，把剩下的人以這種方法進行比較，直到最后，第一輪結(jié)束，在第一位的就是最小的值。 這種就是排序算法，比如有6個人，第一輪要進行5次比較。小的值往前跑嘛。 //第一輪 for(int index=1;index<arr.length;index++)
{ if(arr[0]>arr[index])
{
int temp = arr[0];
arr[0] = arr[index];
arr[index] = temp;
}
}
print(arr);
//第二輪 for(int index=2;index<arr.length;index++)
{ if(arr[1]>arr[index])
{
int temp = arr[1];
arr[1] = arr[index];
arr[index] = temp;
}
}
print(arr);
//第三輪 for(int index=3;index<arr.length;index++)
{ if(arr[2]>arr[index])
{
int temp = arr[2];
arr[2] = arr[index];
arr[index] = temp;
}
}
print(arr);
//第四輪 for(int index=4;index<arr.length;index++)
{ if(arr[3]>arr[index])
{
int temp = arr[3];
arr[3] = arr[index];
arr[index] = temp;
}
}
print(arr);
//第五輪 for(int index=5;index<arr.length;index++)
{ if(arr[4]>arr[index])
{
int temp = arr[4];
arr[3] = arr[index];
arr[index] = temp;
}
}
print(arr);
//第六輪沒有，我們arr.length=6舉例 //int index = 6;index<arr.length; false
優(yōu)化： public static void selectionSort(int[] arr) {
for(int count=1;count<arr.length;count++)
{
for(int index=count;index<arr.length;index++)
{
if(arr[count-1]>arr[index])
{
int temp = arr[count-1];
arr[count-1] = arr[index];
arr[index] = temp;
}
}
}
for(int x = 0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++){
if(arr[x]>arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
冒泡排序 為什么這個排序要叫冒泡呢？為什么不叫其他名詞呢？ 其實這個取名是根據(jù)排序算法的基本思路命名的，見名知意，冒泡排序，就是想泡泡在水里一樣，在水里大的泡泡先浮出水面，就是大的先排出來，最小的最慢排出。 冒泡排序，是對排序的各個元素從頭到尾依次進行相鄰的大小比較，比如你是隊長，在你的面前有一排人，你要將其進行排序，依次按照從小到大排序。 怎么理解最大的值被排除，你是隊長，你對面前的一群人看不慣，進行排序，從左到右開始，第一個和第二個進行比較，大的那個就被挑出來，與第三個進行比較，接下來就是依次按照這個方法比較，就能把那個最大的值，最高的給挑出來不是，這就是第一輪的比較。 接下來，最大的就不用跟他比較了，上面所述，在排序時，你面前的人，是不能亂動的，一旦比較哪個大，兩者就換位，如果第一比第二個小，就是第二個大時，兩者不用換位，第二個就與第三個進行比較。 依照這個方法，兩兩比較，大的都被排到了最后，那么一旦排完，是不是都依照從小到大，（從低到高）的順序在你面前排好了。 代碼示例 我們用索引下標來解釋 //第一輪 for(int index=0;index < arr.length-1; index++）{ //相鄰兩個比較
if(arr[index] > arr[index+1]){
int temp = arr[index];
arr[index] = arr[index+1];
arr[index+1] = temp;
}
}
print(arr);
for(int index=0;index < arr.length-2;index++){ //這里arr.length-2,為什么比上一次多減了1呢？ //因為第一輪，把最大的排出來了，就不用比較了，少了一個人
if(arr[index] > arr[index+1]){
int temp = arr[index];
arr[index] = arr[index+1];
arr[index+1] = temp;
}
}
print(arr);
for(int index=0;index < arr.length-3;index++){
if(arr[index]>arr[index+1]){
int temp = arr[index];
arr[index] = arr[index+1];
arr[index+1] = temp;
}
}
print(arr);
優(yōu)化： for(int num=1;num<arr.length;num++){
for(int index=0;index<arr.length-num;index++){
if(arr[index]>arr[index+1]){
int temp = arr[index];
arr[index] = arr[index+1];
arr[index+1] = temp;
}
}
}
for(int x=0;x<arr.length-1;x++){
for(int y=0;y<arr.length-1-x;y++){
if(arr[y]>arr[y+1]){
int temp = arr[y];
arr[y] = arrp[y+1];
arr[y+1] = temp;
}
}
}
二分查找，折半查找 什么是二分查找，折半查找呢？就是我說一個數(shù)，你來猜，你答一個數(shù)，我說大了，或小了，直到找到為止。 public static int searchKey(int[] arr, int key){
for(int x=0;x<arr.length;x++){
if(arr[x] == key){
rerurn x;
}
return -1;
}
}
二分 public static int binarySearch(int[] arr, int key){
int max,min,mid;
min = 0;
max = arr.length - 1;
mid = (max+min)>>1;
while(arr[mid] != key){
if(key>arr[mid]){
min = mid + 1;
}else if(key<arr[mid])
max = mid - 1;
mid = (max+min)>>1;
}
return mid;
}
}
public static int binarySearch(int[] arr, int key）{
int max, min , mid;
min = 0;
max = arr.length - 1;
while(min <= max){
mid = (min+max)>>1;
if(key>arr[mid]){
min = mid + 1;
}else if(key < arr[mid])
max = mid - 1;
} else {
return mid;
}
return -1;
}
二維數(shù)組 格式： int[][] arr = new int[2][3];
int[][] arr = { {3,5,6}, {33,44,66}, {23,21,6} };
for(int x=0; x<arr.length; x++){
for(int y=0; y<arr[x].length; y++){
sum += arr[x][y];
}
}
public static void revese(int[] arr){
for(int start=0, end = arr.length-1; start<end; start++,end--){
swap(arr,start,end);
}
}
public static void swap(int[] arr, int a, int b){
int temp=arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
本章小結(jié) 本章主要介紹了數(shù)組的定義，初始化，使用等基本知識，結(jié)合了大量的分析內(nèi)存圖用來分析數(shù)組在內(nèi)存中的運行機制，數(shù)組的引用變量和數(shù)組直接的關(guān)系，大量講解多維數(shù)組的實質(zhì)性問題，文章中給出了多種代碼案例來展示數(shù)組的運用擴展。 結(jié)言好了，歡迎在留言區(qū)留言，與大家分享你的經(jīng)驗和心得。
|
