1.JavaSE知识点总结（数组）

第四章：数组
1.数组的优点缺点
    优点：查询或者检索某个下标上的元素效率高
    缺点：1.随机增删元素的时候，效率较低，
        因为为了保证数组中每个元素在内存地址上的内存地址连续会涉及到后面元素统一向前或者向后位移的操作。
        （最后一个元素的增删效率不受影响）
          2.数组无法存储大数据量
    为什么检索效率高：
        第一：每个元素的内存地址在空间存储是连续的
        第二：元素的类型一致，所以占用空间大小一样的
        第三：当知道第一个元素的内存地址，以及元素占用空间的大小，又知道下标，
            那么就可以通过一个数学表达式来计算出某个下标上的元素的内存地址
    
2.一维数组静态初始化和动态初始化
    静态初始化:
    int[] array1 = {1,2,3,4};
    Object[] array2 = {new Object(),new Object()};
    动态初始化:
    int[] array1 = new int[5];    //5表示元素的个数，每个元素的默认值为0
    String[] names = new String[6]    //每个元素的默认值为null
3.一维数组的遍历
    for(int i=0; i<a.length; i++){
        System.out.println(a[i]);
    }
    注意：当下标越界的时候会报数组越界异常（运行时异常）：ArrayIndexOutOfBoundsException
4.一维数组中的元素如何访问
    int[] a ={1,3,2,6,9};
    例如
        System.out.println("第一个元素："+a[0]);
        System.out.println("最后一个元素："+a[a.length-1]);
5.二维数组静态初始化和动态初始化
    静态初始化：
    int[][] array = {{1,2,3},{2,3,4},{0,0,0,0}};
    动态初始化：
    int[][] array = new int[3][4]
    Object[][] object = new Object[3][4]
6.二维数组的遍历
    for(int i=0; i<array.length; i++){
      for(int j=0; j<array[i].length; j++){
        System.out.println(array[i][j]);
      }
    }
7.一维数组中的元素如何访问
    int[][] a = {{1,2,3},{2,3,4},{0,0,0,0}};
    System.out.println("第一个数组的第一个元素："+a[0][0]);

8.数组的空间复杂度和时间复杂度
9.main方法上的String[] args参数是干什么的？
10.数组的扩容和数组的拷贝
    关于一维数组的扩容：
        java对数组的扩容是：新建一个大容量的数组，然后将小容量的数组拷贝到大数组中
        小数组对象被垃圾回收
    结论：因为数组的扩容效率较低，涉及拷贝的问题，所有在创建的时候预估一个数组的长度，
        尽量减少数组的扩容次数，提高效率。
    
11.冒泡、选择、插入、二分法
    冒泡：
        核心：拿着左边的数据和右边的数据进行对比，当左边大于右边，交换位置
    代码：
        for(int i=arr.length-1;i>0;i--) {
            for(int j=0; j<i; j++) {
                if(arr[j]>arr[j+1]) {
                    int temp;
                    temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    选择：
        核心：循环一次，找出参比较的这堆数据中最小的拿着这个最小的值和最前面的数据进行交换位置
    代码：
        for(int i=0;i<arr.length-1;i++) {
            //用来记录最小值的索引
            int minIndex = i;
            for(int j=i+1;j<arr.length;j++) {
                if(arr[j]<arr[minIndex]) {
                    minIndex = j;  
                }
            }
                if(i != minIndex) {
                    int temp = arr[i];
                    arr[i]=arr[minIndex];
                    arr[minIndex]=temp;
                }
        }
    插入：
        代码：
            public void insert(){

            for(int i = 1 ; i<arr.length; i++){

                for(int j = i; j > 0 ; j--){

                    if(arr[j] < arr[j-1]){

                        int temp = arr[j];

                        arr[j] = arr[j-1];

                        arr[j-1] = temp;
                    }
                }
            
            }
            
        
        }
    二分法：
        核心：建立在排序之上
    代码：
        public static void main(String[] args) {
        int arr[] = {1,3,4,9,11,19,81,111};
        int dext = 3;
        int index = binarySort(arr, dext);
        System.out.println(index == -1? "该元素不存在":"该元素下标"+index);
    }
    public static int binarySort(int arr[],int dext) {
        int begin = 0;
        int end = arr.length-1;
        int mid =(begin + end)/2;
        while(begin <= end) {
        if(dext == arr[mid]) {
            return mid;
        }else if(dext > arr[mid]){
            begin = mid+1;
        }else {
            end = mid-1;
            }
        }
        return -1;
    }
        
12.数组的工具类（java.util.Arrays;）
    
    Arrays.toString();
    Arrays.sort();
    Arrays.binarySearch(arr,key="");
    ...
13.能够使用数组模拟栈数组数据结构