数组

数组定义

int[] arr = new int[5];

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

int arr[][] = new int[2][3];   // 二维数组 相当于数组存数组 这个二位数组里面有两个一维数组，而每个一维数组里有三个元素

int [][] arr = new int[2][3];

数组的性质

1. 数组一旦创建，其大小不可变
        
2. 每个位置只能存储一个值,否则会被覆盖
        
3. 数组可以装任意类型的数据,但一个数组内存储的必须是相同类型

4. 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的变量成员。数组本身就是对象,
   Java中对象是在堆中的,因此数组类型无论是保存基本类型还是引用类型,数组对象本省是在堆中的

数组的扩容

    int[] arr = new int[]{1, 2, 3};                  // 定义一个数组
    arr = copyOf(arr, arr.length * 2);

private static int[] copyOf(int[] arr, int newLen) {
    int[] newArr = new int[newLen];                 // 定义一个临时加长的数组
    for (int i = 0; i < arr.length; i++) {
        newArr[i] = arr[i];                      // 拷贝数据到临时数组,旧数组引用指向新数组引用
    }
    return newArr;
}

冒泡排序

int[] arr = new int[]{5, 6, 9, 13, 3};
    for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

二分查找

private static int binarySearch(int[] nums, int target) {        
    if (null == nums || nums.length == 0) { return -1; }      // 目标数组目标数据

    int left = 0;
    int right = nums.length - 1;
    while (left < right) {
        int mid = (left + right) >> 1;
        if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return nums[left] == target ? left : -1;                 // 返回对应下标
}

有序数组归并排序

public static void mergeArray() {

    int[] array1 = {1, 6, 9, 10, 15, 18, 19};
    int[] array2 = {20, 25, 30, 36, 40, 45, 78};

    int i = 0;
    int j = 0;

    int[] newArray = new int[array1.length + array2.length];
    /* 当 i 或者 j 小于数组长度的时候继续执行 */
    while (i < array1.length || j < array2.length) {

        if (i == array1.length) {
            newArray[i + j] = array2[j];
            j++;
            continue;
        }
        if (j == array2.length) {
            newArray[i + j] = array2[i];
            i++;
            continue;
        }
        /* 当 i 大于 j 把 j 存入新数组,并指向 j 数组的下一位元素 */
        if (array1[i] > array2[j]) {
            newArray[i + j] = array2[j];
            j++;
        } else {
            newArray[i + j] = array1[i];
            i++;
        }
    }
}

数组去重

public static void removeDuplicate() {

    int[] array1 = {1, 6, 9, 10, 6, 18, 9};

    /* 使用HashSet去重,但是去重完数据是无序的 */
    HashSet<Integer> set = new HashSet<>();
    for (int i = 0; i < array1.length; i++) {
        set.add(array1[i]);
    }
    Integer[] arr = set.toArray(new Integer[]{});
    Arrays.sort(arr);


    /* 不重复特点的链表的哈希集合,有序 */
    LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
    for (int x = 0; x < array1.length; x++) {
        linkedHashSet.add(array1[x]);
    }
    Integer[] arr2 = linkedHashSet.toArray(new Integer[]{});


    /*利用contains()方法判断该元素是否已经存*/
    List<Integer> list = new ArrayList();
    for (int x = 0; x < array1.length; x++) {
        if (!list.contains(array1[x])) {
            list.add(array1[x]);
        }
    }
    Integer[] arr3 = list.toArray(new Integer[]{});
}

杨辉三角

                       1 
                     1   1 
                   1   2   1 
                 1   3   3   1 
               1   4   6   4   1 
             1   5  10  10   5   1 
           1   6  15  20  15   6   1 
         1   7  21  35  35  21   7   1 
       1   8  28  56  70  56  28   8   1 
     1   9  36  84 126 126  84  36   9   1 

public static void yangHui() {

    int high = 10;
    int triangle[][] = new int[high][];
    for (int i = 0; i < 10; i++) {
        triangle[i] = new int[i + 1];
        triangle[i][0] = 1;
        triangle[i][i] = 1;
        if (i > 1) {
            for (int j = 1; j < i; j++) {
                triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];
            }
        }
    }

    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 9 - i; j++) {
            System.out.print("  ");
        }
        for (int j = 0; j < i + 1; j++) {
            System.out.printf("%4d", triangle[i][j]);
        }
        System.out.println(" ");
    }

}

一维数组内存分析

二维数组内存分析