Java-數組
1.數組概述
數組的定義
● 數組是相同類型數據的有序集合
● 數組描述的是相同類型的若干個數據，按照一定的先后次序排列組合而成
● 其中，每一個數據乘坐一個數組元素，每個數組元素可以通過一個下標來訪問它們。
2.數組聲明創建
數組聲明創建
● 首先必須聲明數組變量，才能在程序中使用數組。
● Java語言使用new操作符來創建數組。
● 數組和元素是通過索引訪問的，數組索引從0開始。
● 獲取數組長度：arrays.length
Java內存分析
● 內存分析
三種初始化
● 靜態初始化
int[] a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)}
● 動態初始化
int[] a=new int[2];
a[0]=1;
a[1]=2;
● 數組的默認初始化
○ 數組是引用類型，它的元素相當於類的實例化變量，因此數組一經分配空間，其中的每個元素也被按照實例變量同樣的方式被隱式初始化
//靜態初始化:創建+賦值
int[] a={1,2,3,4,5,6,7,8,9,10,};
System.out.println(a[0]);
//動態初始化
int[] b=new int[10];
b[0]=1;
System.out.println(b[0]);
System.out.println(b[5]);
數組的四個基本特點
● 數組的長度是固定的。數組一旦被創建，它的大小就是不可改變的。
● 數組的元素必須是相同類型，不允許出現混合類型。
● 數組中的元素可以是任何數據類型，包括基本類型和引用類型。
● 數組變量屬於引用類型，數組也可以看成是對象，數組中的每個元素相當於該對象的成員變量。數組本身就是對象，Java中對象是在堆中的，因此數組無論保存原始類型還是其他對象類型，數組對象本身是在堆中的。
數組邊界
● 下標的合法區間：[0,length-1],如果越界就會報錯
● ArrayIndexOutOfBoundsException:數組下標越界異常！
● 小結：
○ 數組是相同對象數據類型（數據類型可以為任意類型）的有序集合
○ 數組也是對象。數組元素相當於對象的成員變量
○ 數組長度是確定的，不可變的。越界則報錯：ArrayIndexOutOfBoundsException
3.數組使用
● 普通for循環
int[] arrays={1,2,3,4,5,6};
//打印全部的數組元素
for(int i=0;i<arrays.length;i++){
System.out.println(arrays[i]);
}
System.out.println("==");
//計算數組所有元素之和
int sum=0;
for (int j=0;j<arrays.length;j++){
sum+=arrays[j];
}
System.out.println("sum="+sum);
System.out.println("=");
//查找最大元素
int max=0;
for (int k=0;k<arrays.length;k++){
if(max<arrays[k]){
max=arrays[k];
}
}
System.out.println("max="+max);
● for-each循環
int[] arrays={1,2,3,4,5,6,};
//JDK1.5版本，沒有下標
for(int array:arrays){
System.out.println(array);
}
● 數組作為方法入參
//打印數組元素
public static void printArrays(int[] arrays){
for(int i=0;i<arrays.length;i++){
System.out.print(arrays[i]+"\t");
}
}
● 數組作為返回值
//反轉數組:數組作為返回值
public static int[] reverse(int[] arrays){
int[] result=new int[arrays.length];
for(int i=0;i<arrays.length;i++){
int j=arrays.length-i-1;
result[j]=arrays[i];
}
return result;
}
4.多維數組
● 多維數組可以看成是數組的數組，比如二位數組就是一個特殊的一維數組。
● 二維數組
int a[][]=new int [2][5];
● 解析：以上二維數組a可以看成一個兩行五列的數組。
● 思考：多維數組的使用
public static void main(String[] args) {
//[3][4]
/*
1,2,3,4 arrays[0]
2,3,4,5 arrays[1]
3,4,5,6 arrays[2]
*/
int[][] arrays={{1,2,3,4},{2,3,4,5},{3,4,5,6}};
System.out.println(arrays[0]);
printArrays(arrays);
}
//打印數組元素
public static void printArrays(int[][] arrays){
for(int i=0;i<arrays.length;i++){
for(int j=0;j<arrays[i].length;j++) {
System.out.print(arrays[i][j] + "\t");
}
System.out.println();
}
}
5.Arrays類
● 數組的工具類java.until.Arrays
● 由於數組對象本身並沒有什么方法可以供我們調用，但API中提供了一個工具類Arrays供我們使用，從而可以對數據對象進行一些基本的操作
● 查看JDK幫助文檔
● arrays類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行調用，而“不用”使用對象來調用（注意是“不用”，而不是“不能”）
● 具有以下常用功能
○ 給數組賦值fill方法
○ 對數組排序：通過sort方法，升序
○ 比較數組：通過equals方法比較數組中元素值是否相等
○ 查找數組元素：通過binarySearch方法能對排序好的數組進行二分法查找操作
int[] a={68,854,24896,3587,166,751,3,7611,493};
System.out.println(a);
//對數組進行排序
Arrays.sort(a);
//打印數組元素
System.out.println(Arrays.toString(a));
//將數組內全部元素賦0
//Arrays.fill(a,0);
//給數組內區間賦值[2，4）
Arrays.fill(a,2,4,0);
System.out.println(Arrays.toString(a));
冒泡排序
● 冒泡排序無疑是最為出名的排序算法之一，總共有八大排序
● 冒泡排序：兩層循環，外層冒泡數，里層依次比較
● 看到嵌套循環，應該可以立馬得出算法的時間復雜度為O(n的2次方)
public static void main(String[] args) {
int[] arrays={58,347,465,63,79,676,865,768,67,85,5,5876,};
int[] a=sort(arrays);
System.out.println(Arrays.toString(a));
}
//冒泡排序
//1.比較數組中兩個相鄰的元素，如果第一個數比第二個數大，就交換它們的位置
//2.每一次比較，都會產生出一個最大，或者最小的數組
//3.下一輪可以少一次排序
//4.依次循環，直到結束
public static int[] sort(int [] arrays){
int m = 0;
//外層循環，判斷循環要走多少次
boolean flag=false;
for(int i=0;i<arrays.length-1;i++){
//外層循環，判斷要走多少次
for (int j=0;j<arrays.length-i-1;j++){
//內存循環，比較判斷兩個數,如果第一個數大於第二個數，交換兩個數的位置
if(arrays[j+1]<arrays[j]){
m=arrays[j];
arrays[j]=arrays[j+1];
arrays[j+1]=m;
flag=true;
}
}
if(flag==false){
break;
}
}
return arrays;
}
● 思考：如何優化？
○ 判斷本輪是否發生位置交換，不發生時則代表數據為有序，跳出循環
6.稀疏數組
● 需求：編寫五子棋游戲中，有存盤退出和續上盤的功能
● 分析問題：因為該二維屬豬的很多值是默認值0，因此記錄了很多沒有意義的數據
● 解決:稀疏數組
● 當一個數組中大部分元素為0，或者為同一值得數組時，可以使用稀疏數組來保存該數組
● 稀疏數組的處理方式是：
○ 記錄數組一共有幾行幾列，有多少個不同值
○ 把具有不同值的元素和行列及值記錄在一個小規模的數組中，從而縮小程序的規模
● 左為原始數組，右為稀疏數組
public static void main(String[] args) {
//1.創建一個二維數組 11*11 0:沒有棋子 1：黑棋 2：白棋
int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
//輸出原始的數組
for (int[] ints:array1) {
for (int anInt:ints
) {
System.out.print(anInt+"\t");
}
System.out.println();
}
//轉換為稀疏數組
//獲取有效值的個數
int sum=0;
for (int i = 0; i < array1.length; i++) {
for (int i1 = 0; i1 < array1[i].length; i1++) {
if(array1[i][i1]!=0){
sum++;
}
}
}
System.out.println("有效值的個數："+sum);
//創建一個稀疏數組
int[][] array2=new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
int count=0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1.length; j++) {
if(array1[i][j]!=0){
count++;
array2[count][0]=i;
array2[count][1]=j;
array2[count][2]=array1[i][j];
}
}
}
//輸出稀疏數組
System.out.println("稀疏數組");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]);
}
System.out.println("還原數組");
//1.讀取稀疏數組
int[][] array3=new int[array2[0][0]][array2[0][1]];
//2.給其中的元素賦值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
/*
//實現較為復雜，在默認值為0時可以用上面的方式進行賦值，非0默認值可以用下面方法
int count2=1;
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
if(count2<3) {
if (i == array2[count2][0] && j == array2[count2][1]) {
array3[i][j] = array2[count2][2];
count2++;
} else {
array3[i][j] = 0;
}
}else {
array3[i][j]=0;
}
}
}*/
//輸出數組
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
System.out.print(array3[i][j]+"\t");
}
System.out.println();
}
}