Review07数组_日期类_数组工具类

1、数组
    数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”。
    数组一旦创建，在java中规定，长度不可变。
    所有的数组对象都有length属性（java自带），用来获取数组中元素的个数。
    所有的数组都是拿第一个元素的内存地址（第一个小方框）的内存地址作为整个对象的内存地址。
    常见异常：
        ArrayIndexOutOfBoundsException数组索引越界异常
    怎么声明/定义一个一维数组？
        语法格式：
            int[] array1;
            double[] array2;
            Object[] array3;
            ......

    数组的遍历：

for (int i = a.length-1;i >= 0;i--){
            System.out.println(a[i]);//i为下标
        }

2、调用以数组为参数的方法（即数组可以作为方法的参数）
    如：public static void printArray(String[] array){}
            String[] y = new String[5];
            printArray(y);//5个null

3、关于数组的扩容：
    无法直接扩容（因为一旦确定，长度不变），只能新建一个大容量的数组，再将原数组中的元素一个一个copy过去。
    因为涉及到copy，所以数组的扩容效率很低，所以以后尽量少扩容，最好一开始创建的时候就预估准确一点，减少后期的扩容次数。
     copy方法：
        System.arraycopy(object src,int srcPos, Object dest, int destPos,int length);
        System.arraycopy(源数组,源数组需要copy的起始位置, 目标数组, 目标数组开始存放的起始位置,copy长度);
     如：
        int[] i1 = {1,2,3,4,5,6,7,8,9};
        int[] i2 = new int[11];
        System.arraycopy(i1,2,i2,3,5);//00034567000

4、二维数组
    关于java中的二维数组
   4.1、二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中每一个元素是一个一维数组。
   4.2、三维数组是什么？
        同理
   4.3、二维数组的静态、动态初始化
        int[][] array = {{1,2,3},{0,0,0,0,2},{10,20}}
        int[][] array = new int[3][4];//new一个包含三个一维数组，每个一维数组有4个元素的二维数组
   4.4、二维数组的遍历及相关操作（见代码）

int[][] b1 = {{1,2,3},{0,0,0,0,2},{10,20}};
        //二维数组的遍历
        for (int i = 0;i < b1.length;i++){
            for (int j = 0;j < b1[i].length;j++){
                System.out.print(b1[i][j]);
            }
            System.out.println();
        }

        //访问二维数组的length属性
        System.out.println(b1.length);//3
        //访问二维数组中元素（一维数组）的length属性
        System.out.println(b1[1].length);//5
        //访问二维数组中元素（一维数组）的元素(以下是b1第2个元素（数组）的第3个元素)。不要忽略下标0.
        System.out.println(b1[1][2]);//0

5、选择排序
    每一次从这一堆参与比较的数据中找出最小值，
    拿着这个最小值和“参与比较的这堆元素最前面的元素”交换位置。

public class SelectSort {
    public static void main(String[] args) {
        int[] array = {9,8,8,8,6,0,11};
        int k = 0;//计算比较次数
        int k2 = 0;//交换次数
        for (int i = 0; i < array.length-1; i++) {//外层选择循环次数：length-1
            //i正好是参与比较的元素中第一个元素的下标（对于整个数组而言）
            //假设比较的元素中第一个元素是最小的：
            int min = i;//
            for (int j = i+1; j < array.length; j++) {
                k++;
                if (array[j] < array[min]) {
                    min = j;//最小值下标是j
                }
            }
            if (min != i) {
                int temp = array[min];//怎么交换？建立中间变量
                array[min] = array[i];
                array[i] = temp;//完成交换
                k2++;
            }
        }
        System.out.println(k);
        System.out.println(k2);
        for (int i = 0; i < array.length ; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

6、冒泡排序
    冒泡排序算法实现
    int[] array = {9,5,24,16,7,3,2,854,264,45,12,1,85,236};
    排序循环次数：array.length-1
    排序原理，两个相邻的数据比对，将较大的数据放到右边。

    冒泡排序跟选择排序的算法实现需要记住。

public class BubbleTest {
    public static void main(String[] args) {
        int[] array = {9,8,8,8,6,0,11};
        int k = 0;//比较次数
        int k2 = 0;//交换次数
        //两层循环，外层控制排序循环次数，里层控制本次循环的交换次数
        //外层循环
        for (int i = array.length-1; i > 0 ; i--) {//为什么从i = array.length-1开始？i取不取0？
            for (int j = 0; j < i; j++) {
                k++;//内层循环多少次怎么确定？比如：7个元素，总循环6次，第一次循环是7个数据比较7次（即内层循环7次）
                if (array[j] > array[j+1]){//当前一个数据比后一个数据大的时候，交换位置。前一个数据是什么
                    int temp = array[j];//怎么交换？建立中间变量
                    array[j] = array[j+1];
                    array[j+1] = temp;//完成交换
                    k2++;
                }
            }
        }
        System.out.println(k);
        System.out.println(k2);
        //遍历看看？
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

7、数组的遍历查找

public static int arraySearch(int[] array, int j) {
        for (int i = 0;i < array.length;i++){
            if (array[i] == j ){
                return i;
            }
        }
        return -1;
    }
}

8、二分法查找代码

public static int binarySearch2(int[] array, int i) {
        int begin = 0;
        int end = array.length-1;
        //开始元素下标在结束元素的左边就有机会循环，直到两者相等
        while (begin <= end){
            int mid = (begin + end)/2;
            if (array[mid] == i){
                return mid;
            }else if (array[mid] < i){
                begin = mid + 1;
            }else {
                end = mid - 1;
            }
        }
        return -1;
    }

9、数组工具类
    排序方法sort：
         Arrays.sort(array);//Arrays均为静态方法，使用类名.调用
         Arrays.sort(byte[] a, int fromIndex, int toIndex)//指定范围排序
    二进制查找：
        Arrays.binarySearch(int[] a, int key);
        Arrays.binarySearch(int[] a, int fromIndex, int toIndex, int key)//指定范围内查找
    按字典顺序比较：
        compare(int[] a, int[] b)//暂且不看

int[] arr = {12,23,323,4545,232,32,1235,55,765,44};
        Arrays.sort(arr);//升序排序
        int index = Arrays.binarySearch(arr,44);
        System.out.println(index);//3,返回查找值的下标