Java SE 数组

Java SE 数组

思考题：

递归

1.在方法内部自己调用自己（若栈溢出，则无结束条件）

2.一定有趋于终止条件

递归相当于起始条件，后有一个递推公式

1.每次执行到当前一部分函数式，去执行另一部分了

2.回来之后继续执行就要保护现场

斐波那契数列不用递归，因为类似二叉树时间复杂度高

数组

java中通过数组名.length来告诉你数组长度是多少

    public static void main5(String[] args) {
        int[] array={1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=======for each=======");
        for (int x:array) {
            System.out.println(x+" ");
        }
        System.out.println("=======Arrays.toString=======");
        String ret=Arrays.toString(array);
        System.out.println(ret);
    }

三种方式打印数组

    public static void main(String[] args) {
        int[] array=new int[3];
        array[0]=10;
        array[1]=20;
        array[2]=30;
        int[] array2=new int[]{1,2,3,4,5};
        array2[0]=100;
        array2[1]=200;
        array=array2;
        array[2]=300;
        array[3]=400;
        array[4]=500;
        for(int i = 0;i<array2.length;i++){
            System.out.println(array2[i]);
        }
    }

当array=array2时array的地址就已经指向了array2也就是再进行读取数组数据时，将读取array2的数据。

当没有人引用某一对象时，这个对象就会被JVM的垃圾回收器回收了。

> array2=array;

array2这个引用指向了array这个引用所指向的对象。

    public static void main(String[] args){
        int[] array3=null;
        System.out.println(array3.length);
    }

空指针异常array.length无法使用

数组拷贝两种方法

第一种方法直接for循环拷贝数组

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] copy=new int[array.length];
        for (int i=0;i<array.length;i++){
            copy[i]=array[i];
        }
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(copy));
    }

第二种方法使用自带函数Arrays.copyof，该函数的参数需要两个，第一个为需要拷贝的数组，第二个要拷贝的数组长度。（Arrays.copyofRange是范围拷贝，System.copy直接拷贝方法，底层是C++代码写的）

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] copy=Arrays.copyOf(array,array.length);
        int[] copy2= Arrays.copyOfRange(array,0,3);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(copy));
        System.out.println(Arrays.toString(copy2));
    }

第三种方法array.clone()（了解即可）

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] copy=array.clone();
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(copy));
    }

深浅拷贝

如果能够做到修改拷贝之后的数组，不影响原来的数组，这个就是深拷贝

浅拷贝是将copy修改后也会影响array数组

深拷贝和浅拷贝不能以for循环或拷贝基本数据类型还是引用类型来判断，具体还是要看代码实现

二分查找

以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找

    public static int binarySearch(int[] array,int key){
        int left=0;
        int right=array.length-1;
        while(left<=right){
            int mid=(left+right)/2;
            if (array[mid]==key){
                return mid;
            }else if(array[mid]<key){
                left = mid+1;
            }else{
                right=mid-1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
         int[] array={1,2,3,4,5,6};
         int index=binarySearch(array,13);
        System.out.println(index);
    }

假设我们要找的数据为4当mid<key，将left右移

相反也成立

冒泡排序

常见数据结构排序

插入排序，希尔排序，冒泡排序，快速排序，归并排序，选择排序，堆排序

冒泡排序：首先，我们比较第一对相邻的两个数字，也就是第一个数字和第二个数字，如果前一个数字大于后一个数字，就将两个数字交换；然后我们比较第二对数字，即第二个数字和第三个数字。

同理当第二个数字比第三个数字大时就交换两个数字，否则不进行操作。重复进行此操作，直到比较到第n个数字和第n-1个数字，当本步骤交换完毕后，第n个数字（即最后一个数字）就是本数列中的最大数。

public static void bubbleSort(int[] array){
        for(int i=0;i<array.length-1;i++){
            boolean flg=false;
            for (int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flg=true;
                }
            }
            if (flg==false){
                return;
            }
        }
    }

数组逆置

设置left和right标签，二者比较，若小于则一直置换二者位置，而后left往后一位，right往前一位

 public static void reverse(int[] array){
        int left=0;
        int right=array.length-1;
        for (int i=0;i<(array.length-1)/2;i++){
            if (left<right){
                int tmp=array[left];
                array[left]=array[right];
                array[right]=tmp;
                left++;
                right--;
            }
        }
    }

二维数组

先写几个样例

    public static void main(String[] args) {
        int[][] array={{1,2,3,4,5},{1,3,4,5,6}};
        int[][] array2=new int[2][3];
        int[][] array3=new int[][]{{1,2},{3,4}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
    }

二维数组可以看成一个一维数组的其中一个元素为另一个数组

二维数组遍历

三种方式

1、for循环 2、for each打印 3、Arrays.deepToString（array）

    public static void main(String[] args) {
        int[][] array={{1,2,3,4,5},{1,3,4,5,6}};
        int[][] array2=new int[2][3];
        int[][] array3=new int[][]{{1,2},{3,4}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        for each打印
        for(int[] tmp:array){
            for(int x:tmp){
                System.out.print(x+" ");
            }
            System.out.println();
        }
        Arrays.deepToString遍历数组
        System.out.println(Arrays.deepToString(array));
    }

二维数组还有一种创建方式，由于二维数组是特殊的一维数组，因此可以先创建空的二维数组，然后插入几个新的一维数组

    public static void main(String[] args) {
         int[][] array=new int[2][];
         array[0]=new int[3];
         array[1]=new int[5];
        System.out.println(Arrays.deepToString(array));
    }