Java---數組概念和應用場景、遍歷方法、經典習目詳細解析，外加Arrays類中數組使用的一些方法。

數組

引入

   考試結束後，老師給冰冰分配了一項任務，讓他計算全班（30人）的平均分。

   解決辦法：定義三十個變量，然後相加求和，並計算平均分。

  數組: 存儲一組相同數據類型的容器
       本質就是一個變量的容器

數組的格式:

   數據類型[] 數組名 = new 數據類型[n];

   1.數據類型: 這裏可以是八大基本數據類型,也可以是引用數據類型

   2.數組名本質也是一個變量名,滿足變量的命名規範
      第一個單詞首字母小寫,其他單詞首字母大寫,見名知意,名詞,一般是複數

   3.既然是數組名是一個變量,它是引用數據類型,就應該滿足變量的三要素,先聲明後賦值,再使用
      數組的初始化
            聲明: 告訴計算機開闢多大的連續的內存空間
            賦值: 通過數組的下標、索引來訪問數組的每一個元素

   4.new 表示向堆區申請內存空間,申請空間之後會被系統分配一個地址值
      產生地址我們需要使用new關鍵字,我們是不能夠手動編寫地址值的

   5.n表示數組的長度,就是這個容器的大小

   6.數組容器中的每一個元素的訪問格式:
      數組名[下標/索引]
      這裏的下標從0 ~ n - 1

   7.內存原理
     int[] scores ;
     scores = new int[5];

數組的初始化

   靜態初始化

      1. 初始化的同時爲每個元素賦值,不需要指明長度

      2.由用戶來給出數組的元素內容

   格式一: 數據類型[] 數組名 = new 數據類型[]{元素1,元素2,元素3,…};
  格式二: 數據類型[] 數組名 = {元素1,元素2,元素3,…};
      int[] scores = {100,70,98,67}; //創建數組對象並初始化，存放4個成績

   動態初始化

      1.系統需要指定數組的長度

      2.數組中的每一個元素都會被賦予默認值,默認值的規律滿足堆區分配值的規律
         byte short int long 默認0
         float double 默認0.0
         boolean 默認 false
         char 默認 ‘\u0000’
         引用類型 默認 null

      3.可以後期動態來確定初始值
         a.通過數組的索引一個一個賦值
         b.通過鍵盤輸入
         c.通過隨機數

   數組的賦值
   數組創建完畢後可以通過下標對每個元素進行賦值

      下標從0開始
      數組長度 length，下標最大 length-1
          int[] scores = new int[5];
          scores[0] = 70;
          scores[1] = 90;

  數組的遍歷: 訪問到數組的每一個元素
     for (int i = 0; i < 3; i++) {
       System.out.println(arr[i]);
     }

  數組有一個屬性: length,能夠動態獲取數組的長度
    可將遍歷方法改進爲
       for (int i = 0; i < arr.length; i++) {
         System.out.println(arr[i]);
       }

代碼示例

public class ArrayDemo02 {
	public static void main(String[] args) {
		// 動態初始化
		int[] arr = new int[5];
		
		Scanner input = new Scanner(System.in);
		
		// c.通過隨機數
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 100);
		}
		
	}

	// b.通過鍵盤輸入
	private static void method2(int[] arr, Scanner input) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print("請輸入第" + (i + 1) + "個元素: ");
			arr[i] = input.nextInt();
		}
		
		System.out.println(Arrays.toString(arr));
	}

	public static void method1(int[] arr) {
		// 通過數組的索引一個一個賦值
		arr[0] = 10;
		arr[1] = 20;
		arr[2] = 30;
		
		//打印輸出
		/*System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);*/
		
		//使用for循環遍歷
		for (int i = 0; i < 3; i++) {
			System.out.println(arr[i]);
		}
	}
}

經典習題

  1、考試結束後，老師給冰冰分配了一項任務，讓他計算全班（30人）的平均分。

public class ArrayDemo05 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double[] scores = new double[30];
		
		double sum = 0;
		double averageScore = 0.0;
		for (int i = 0; i < scores.length; i++) {
			System.out.print("請輸入第" + (i + 1) + "個學生的成績: ");
			scores[i] = input.nextDouble();
			sum += scores[i];
		}
		
		averageScore = sum / scores.length;
		System.out.println("30個童鞋的平均分是: " + averageScore);
	}
}

  2、有一個數列：8, 4, 2, 1, 23, 344, 12

     A 循環輸出數列的值。arrayToString
     B 求數列中所有數值的和。
     C 求出最大值。
     D 將數組倒置並輸出

public class ArrayDemo06 {
	public static void main(String[] args) {
		int[] arr = {8, 4, 2, 1, 23, 344, 12};
		
		System.out.println(Arrays.toString(arr));
		System.out.println("所有數列元素的和: " + getSum(arr));
		System.out.println("所有元素的最大值爲: " + getMaxValue(arr));
		System.out.println("所有元素的最小值爲: " + getMinValue(arr));
		
		reverseArray(arr);
		System.out.println(Arrays.toString(arr));
		
		
	}
	
	/**
	 * 功能: 循環輸出數列的值
	 * @param arr 需要遍歷的數組
	 */
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	
	/**
	 * 功能: 求數列中所有數值的和。getSum
	 * @param arr 需要對數組中的每一個元素遍歷求和
	 * @return 數組中所有元素相加的和
	 */
	public static int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}
	
	/**
	 * 最值思想
	 * 功能: 求出最大值。
	 * @param arr 
	 * @return 獲取數列中的最大值
	 */
	public static int getMaxValue(int[] arr) {
		// 1.假定數組的第一個數爲最大值
		int max = arr[0];
		// 2.遍歷數組中的每一個元素,獲取到每一個元素,和假定的max進行比較
		for (int i = 0; i < arr.length; i++) {
			// 如果這個元素比假定的最大值max還要大,就更新最大值
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		return max;
	}
	
	/**
	 * 最值思想
	 * 功能: 求出最小值。
	 * @param arr 
	 * @return 獲取數列中的最小值
	 */
	public static int getMinValue(int[] arr) {
		// 1.假定數組的第一個數爲最小值
		int min = arr[0];
		// 2.遍歷數組中的每一個元素,獲取到每一個元素,和假定的min進行比較
		for (int i = 0; i < arr.length; i++) {
			// 如果這個元素比假定的最小值min還要小,就更新最小值
			if (arr[i] < min) {
				min = arr[i];
			}
		}
		return min;
	}
	
	/**
	 * 功能: 將數組倒置並輸出
	 * @param arr
	 * 
	 * 思路:
	 * 	[8, 4, 2, 1, 23, 344, 12]
	 *  第一次倒置
	 *  arr[0]和arr[arr.length - 1 - 0] 交換位置
	 *  第二次倒置
	 *  arr[1]和arr[arr.length - 1 - 1] 交換位置
	 *  第三次倒置
	 *  arr[2]和arr[arr.length - 1 - 2] 交換位置
	 *  
	 *  重複了三次,就是交換了3次
	 *  1個數 0
	 *  2個數 1
	 *  3個數 1
	 *  4個數 2
	 *  5個數 2
	 *  6個數 3
	 *  7個數 3
	 *  i個數 i / 2
	 *  
	 *  一共交換的規律 arr.length / 2
	 */
	public static void reverseArray(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
	}
}

Arrays工具類

  針對數組操作的工具類,方便我們更高效更靈活地處理數組

  Arrays.toString: 輸出一個數組,返回字符串

  Arrays.sort: 對數組進行排序

   Arrays.binarySearch: 對數組進行排序

  System.arraycopy: 數組元素的拷貝,這是一個本地方法,不是Java實現的,是C實現的

   Arrays.copyOf: 表示拷貝數組,可以實現元素的拷貝,還能夠動態擴容和縮容,集合底層依賴這個方法,這個方法依賴System.arraycopy

   Arrays.copyOfRange: 表示拷貝數組一部分

   Arrays.fill: 填充數組所有元素,還可以填充一部分

   Arrays.equals: 比較兩個數組的所有元素是否相等

   asList: 將數組轉換成集合

   Arrays.stream: 將數組轉換成 流式API

數組長度固定不變,一旦我希望在後期給數組中添加或者刪除一個元素,是做不到的

   數組拷貝:
     Java對索引的一個原則: 左閉右開原則 [1,3)

代碼示例

ublic class ArraysUtilDemo {
	public static void main(String[] args) {
		int[] arr = {11, 22, 79, 77, 88, 33};
		System.out.println(Arrays.toString(arr));
		
		// Arrays.sort(arr);
		// System.out.println("排序後: " + Arrays.toString(arr));
		
		// Arrays.sort(arr, 2, 5);
		// System.out.println("排序後: " + Arrays.toString(arr));
		
		// System.out.println(Arrays.binarySearch(arr, 79));
		
		// int[] newArray = new int[arr.length + 1];
		
		/*for (int i = 0; i < arr.length; i++) {
			newArray[i] = arr[i];
		}*/
		
		// System.arraycopy(arr, 0, newArray, 0, arr.length);
		
		// int[] newArray = Arrays.copyOf(arr, arr.length - 1);
		
		// int[] newArray = Arrays.copyOfRange(arr, 2, 5);
		
		// newArray[newArray.length - 1] = 100;
		
		// System.out.println(Arrays.toString(newArray));
		
		Arrays.fill(arr, 0);
		System.out.println(Arrays.toString(arr));
		
		Arrays.fill(arr, 1, 4, 100);
		System.out.println(Arrays.toString(arr));
		
		int[] arr2 = Arrays.copyOf(arr, arr.length + 1);
		
		System.out.println(Arrays.equals(arr, arr2));
		
	}
}