久久青青,久久国产亚洲,成人超碰

什么是數組

數組是相同類型數據的有序集合
數組描述的是相同類型的若干個數據,按照一定的先后次序排列組合而成。
其中,每一個數據稱作一個數組元素,每個數組元素可以通過一個下標來訪問它們

數組的聲明創建

首先必須聲明數組變量，才能在程序中使用數組。下面是聲明數組變量的語法:

dataType[] array;//例： int[] nums; 推薦使用這種寫法
或者
dataType array[];//例： int nums[];

使用new來創建數組的語法:

dataType[] array = new dataType[arraySize]//例 int[] nums = new int[10];

數組的元素是通過索引訪問的，數組索引從0開始。

獲取數組的長度：array.length

練習：用循環給數組賦值1到10，并輸出數組的總和

public static void main(String[] args) {
//創建一個數組
int[] array = new int[10];
//sum為總和
int sum = 0;
//循環給數組賦值
for (int i = 1;i<=array.length;i++){
array[i-1] = i;
}
//循環遍歷數組，把每位加到sum計算總和
for (int j = 0;j<array.length;j++){
sum = sum + array[j];
}
System.out.println("數組總和為:"+sum);
}

內存分析：

新手初學Java數組

結合以上練習和這張簡單的內存分析思維導圖來簡單分析一下數組是如何生成在java內存的？

新手初學Java數組

三種初始化狀態

靜態初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1)}//Man是類名

動態初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

數組的默認初始化

動態初始化包含了默認初始化。數組是引用類型，它的元素相當于類的實例變量，因此數組一經分配空間，其中的每個元素也被按照實例變量同樣的方式被隱式初始化。

int[] a = new int[2];//可以理解為一但通過new實例化了，數組的每個元素也同樣的被實例化位默認值存在堆的空間里

數組的四個基本特點

其長度是確定的。數組一旦被創建，它的大小就是不可以改變的。
其元素必須是相同類型,不允許出現混合類型。
數組中的元素可以是任何數據類型，包括基本類型和引用類型。
數組變量屬引用類型，數組也可以看成是對象，數組中的每個元素相當于該對象的成員變量。數組本身就是對象，Java中對象是在堆中的，因此數組無論保存原始類型還是其他對象類型，數組對象本身是在堆中的。

數組的使用

For-Each循環

public static void main(String[] args) {
int[] arrays = {1,3,5,7,9};
//JDK1.5以上可以使用，但是沒有下標
for (int array : arrays) {
System.out.println(array);
}
}

數組作方法入參

public static void main(String[] args) {
int[] arrays = {2,4,6,8,10};
printArray(reverse(arrays));//輸出10 8 6 4 2
}
//打印數組元素
public static void printArray(int[] arrays){
for(int i = 0; i < arrays.length; i++){
System.out.print(arrays[i]+" ");
}
}

數組作返回值

public static void main(String[] args) {
int[] arrays = {2,4,6,8,10};
//使用for-each遍歷出反轉后的數組
for(int array : reverse(arrays)){
System.out.print(array+" ");
}
}
//反轉數組，從數組最后一個元素到第一個元素
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}

多維數組

多維數組可以看成是數組的數組，比如二維數組就是一個特殊的一維數組，其每一個元素都是一個一維數組。

二維數組

int a[][] = new int[3][2]//可以看作一個3行2列的數組來理解

新手初學Java數組

例：創建并打印二維數組的所有元素

public static void main(String[] args) {
int[][] arrays = {{1,2},{3,4},{5,6}};
for (int i = 0; i <arrays.length ; i++) {
for (int j = 0;j<arrays[i].length;j++){
System.out.print(arrays[i][j]+" ");
}
System.out.println();
}
}

Arrays類

數組的工具類java.util.Arrays
由于數組對象本身并沒有什么方法可以供我們調用,但API中提供了一個工具類Arrays供我們使用,從而可以對數據對象進行一些基本的操作。
Arrays類中的方法都是static修飾的靜態方法,在使用的時候可以直接使用類名進行調用,而"不用"使用對象來調用(注意:是"不用”而不是"不能")

常用功能:

返回指定數組的內容的字符串表示形式，通過toString方法。

public static void main(String[] args) {
int[] arrays = {9,5,8,7,100,365,277,25,64};
System.out.println(Arrays.toString(arrays));
}

將指定的int值分配給指定的int數組的每個元素：通過fill方法。

public static void main(String[] args) {
int[] arrays = {9,5,8,7,100,365,277,25,64};
Arrays.fill(arrays,0);//給數組里面所有元素替換為0
System.out.println(Arrays.toString(arrays));
//輸出[0, 0, 0, 0, 0, 0, 0, 0, 0]
int[] arr = {9,5,8,7,100,365,277,25,64};
// a - 要填充的數組
// fromIndex - 要用指定值填充的第一個元素（包括）的索引
// toIndex - 要用指定值填充的最后一個元素（排除）的索引
// val - 要存儲在數組的所有元素中的值
Arrays.fill(arr,0,5,9);//給數組里面所有下標范圍替換為9
System.out.println(Arrays.toString(arr));
}

對數組排序:通過sort方法,按升序。

public static void main(String[] args) {
int[] arrays = {9,5,8,7,100,365,277,25,64};
Arrays.sort(arrays);//數組進行排序：升序
System.out.println(Arrays.toString(arrays));
//輸出[5, 7, 8, 9, 25, 64, 100, 277, 365]
}

比較數組:通過equals方法比較數組中元素值是否相等。

public static void main(String[] args) {
int[] arrays = {9,5,8,7,100,365,277,25,64};
int[] arrays2 = {9,5,8,7,100,365,277,25,64};
boolean flag = Arrays.equals(arrays, arrays2);
System.out.println("arrays和arrays2中的元素比較結果："+flag);
}

冒泡排序

冒泡排序算法的運作：

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。比較完最后一對則最后的元素會是最大的數。
針對所有的元素重復以上的步驟，除了最后一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

代碼示例：

public static void main(String[] args) {
int[] arrays = {9,5,8,7,100,365,277,25,64};
sort(arrays);
}
//冒泡排序:比較相鄰的元素。如果第一個比第二個大，就交換他們兩個的值
public static void sort(int array[]){
//temp是臨時變量，用于比較的值進行交換
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if(array[j]>array[j+1]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}

以上代碼通過可以通過斷點Debug發現，排序過程中，執行完最后的排序后，雖然數據已全部排序完備，但程序無法判斷是否完成排序

為了解決這一不足，可設置一個標志位flag來進行優化，將其初始值設置為false，表示被排序的表是一個無序的表，每一次排序開始前設置flag值為false，在進行數據交換時，修改flag為非true。在新一輪排序開始時，檢查此標志，若此標志為false，表示上一次沒有做過交換數據，則結束排序；否則進行排序；

例: