1. Array数组

数组是指一组相同类型的数据的集合，数组中的每个数据被称作元素。同一个数组里存放的元素类型必须一致。

  • Define: 数据类型[] 数组名 = new数据类型[元素个数或数组长度];
    int[] arr = new int[100];
    为了更好地理解数组的这种定义方式，可以将上面的一句代码分成两句来写，具体如下：
    int[] x; // 声明一个int[]类型的变量
    x = new int[100];// 创建一个长度为100的数组
    第一行代码 int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。内存中的状态如下图所示：image.png
    第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化，如下图所示：
    image.png

  • 直接初始化定义：

    1. int[] arr = new int[]{1,2,3,4};
    2. int[] arr = { 1, 2, 3, 4 };

  • 访问元素： arr[2]

  • length属性： int length = arr.length;
  • Traverse: ```java for(int i=0; i< arr.length; i++){ System.out.println(arr[i]); }

for(int num : arr){ System.out.println(num); }

  1. <a name="IJiO1"></a>
  2. # 2. Two Dimensional Array
  4. - Define:
  5.    - 第一种定义格式：`int[][] arr = new int[3][4];`<br />上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组。![image.png](https://cdn.nlark.com/yuque/0/2020/png/10379114/1609147943994-b6f1cc66-b00e-4272-98ef-28d16372ea6d.png#align=left&display=inline&height=74&margin=%5Bobject%20Object%5D&name=image.png&originHeight=98&originWidth=720&size=48506&status=done&style=none&width=540)
  7.    - 第二种定义格式：`int[][] arr = new int[3][];` 第二种方式和第一种类似，只是数组中每个元素的长度不确定：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/10379114/1609148007894-5f6a6e3e-ce92-47e0-a0f9-d246d7b1bd0e.png#align=left&display=inline&height=74&margin=%5Bobject%20Object%5D&name=image.png&originHeight=98&originWidth=606&size=31621&status=done&style=none&width=455)
  8.    - 第三种定义格式：`int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};`<br />二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}：<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/10379114/1609148084602-52230f41-7215-4547-8f83-982cb1ef4635.png#align=left&display=inline&height=74&margin=%5Bobject%20Object%5D&name=image.png&originHeight=98&originWidth=718&size=26013&status=done&style=none&width=539)
  9. - Visit: `arr[0][1]`
  10. - Traverse:
  11. ```java
  12. public static void main(String[] args){
  13.     int[][] arr = {{1,2},{3,4,5},{6,7,8,,9,10}};
  14.     int sum = 0;
  15.     for(int i=0; i<arr.length; i++){
  16.         for(int j=0; j<arr[i].length; j++){
  17.             sum += arr[i][j];
  18.         }
  19.     }
  20.     System.our.println("sum = "+sum);
  21. }

3. Array Practice

A. Reverse

image.png

  1. public static void receive(int[] arr){
  2.     for (int start = 0, end = arr.length-1; start < end; start++,end--) {
  3.         int temp = arr[start];
  4.         arr[start] = arr[end];
  5.         arr[end] = temp;
  6.     }
  7. }

B. Pop Sort - 交换排序

image.png

  1. /**
  2.  *冒泡排序:数组的相邻元素排序.每次循环会将最大值放到数组的末尾.
  3.  *外循环控制要跑的次数
  4.  *内循环控制相邻元素的交换
  5.  */
  6. public static void popSort(int[]array){
  7.     if(array==null || array.length<=1){
  8.         return;
  9.     }
  10.     for(inti=0; i<array.length-1; i++){
  11.         boolean isSwitched=false;
  12.         for(intj=1; j<array.length-i; j++){
  13.             if(array[j-1] > array[j]){
  14.                 inttemp = array[j];
  15.                 array[j] = array[j-1];
  16.                 array[j-1] = temp;
  17.                 isSwitched = true;
  18.             }
  19.         }
  20.         //If the array is already sorted,quit the program.
  21.         if(!isSwitched){
  22.             break;
  23.         }
  24.     }
  25. }

C. Binary Search

前提:被查找的数组中的元素必须是有序的.
image.png

  1. public static int bianrySearch(int[] arr, int target){
  2.     int low = 0;
  3.     int high = arr.length-1;
  4.       while(low<=high){
  5.         int mid = low + (high-low)/2; //防止high+low的数过大导致内存溢出
  6.         if(arr[mid] == target){
  7.             return mid;
  8.         }else if(arr[mid] > target){
  9.             high = mid -1;
  10.         }else if(arr[mid] < target){
  11.             low = mid + 1;
  12.         }
  13.     }
  14.     return -1;
  15. }

4. java.util.Arrays

Arrays是数组的工具类， 此类包含用来操作数组（比如排序和搜索）的各种方法。需要注意，如果指定数组引用为 null，则访问此类中的方法都会抛出空指针异常NullPointerException。

常用方法：

  • int binarySearch(int[] a, int key)
  • void sort(int[] a) 或 void sort(int[] a, Competitor competitor)
  • String toString(int[] a)
  • equals()和deepEquals()方法：判断两个数组是否相等。
    基本类型数组：boolean equals(int[] a, int[] a2)
    引用类型数组：boolean deepEquals(Object[] a1, Object[] a2)

  • int[] copyOf(int[] originarlArr, newLength) ==> 可用于数组resize

    1. int[] arr1 = new int[] {45, 32, 75};
    2. int[] arr2 = Arrays.copyOf(arr1, 5);
    3. System.out.println(Arrays.toString(arr2));

  • int[] copyOfRange(int[] array, int from, int to) ==> from包含，to不包含

  • List asList(Integer[] array) ==> array的元素类型必须是Wrapper类型
  • System类方法,复制数组：
    void arraycopy(int[] src, int srcPos, int[] dest, int destPos, int length)
    1. public static void function_4(){
    2.   int[] src = {11,22,33,44,55,66};
    3.   int[] desc = {77,88,99,0};
    4.   //将src数组的1位置开始(包含1位置)的两个元素,拷贝到desc的1,2位置上
    5.   System.arraycopy(src, 1, desc, 1, 2);
    6.   for(int i = 0 ;  i < desc.length ; i++){
    7.       System.out.println(desc[i]);
    8.   }
    9. }