JAVA数组（2） 笔记

1.青蛙跳台阶问题
2.数组转字符串
3.数组拷贝
native方法
（1）native 此方法为本地方法
（2） src:源数组
srcPos:源数组的pos开始拷贝
dest:拷贝到的目的数组
destPost:拷贝到的目的数组的Pos位置
length:拷贝多长

Arrays.copyOf
array.clone()
Arrays.copyOfRange 拷贝范围

4.深拷贝，浅拷贝（针对对象）
可以认为，拷贝时产生副本
深拷贝：只是针对简单（基础）类型，当修改考背后的数组当中的下标的元素师，不影响原来数组的元素值
浅拷贝：拷贝时，数据类型为引用类型，数组中数据为地址，副本也为地址，则改变副本，即改变了原来的地址

(查看源码，ctrl+左键单击)

package NewJavaClass.Test2007;


import java.util.Scanner;
import java.util.Arrays;
/**
 * @ Author     ：CYD
 * @ Date       ：Created in 9:16 2020/7/23
 * @ Description：
 * @ Modified By：
 * @Version: $
 */

/*
* 1.青蛙跳台阶问题
* 2.数组转字符串
* 3.数组拷贝
*    native方法
* （1）native 此方法为本地方法
 *（2） src:源数组
 *    srcPos:源数组的pos开始拷贝
 *    dest:拷贝到的目的数组
 *    destPost:拷贝到的目的数组的Pos位置
 *    length:拷贝多长
 *
*    Arrays.copyOf
*    array.clone()
*    Arrays.copyOfRange 拷贝范围
*
* 4.深拷贝，浅拷贝（针对对象）
* 可以认为，拷贝时产生副本
* 深拷贝：只是针对简单（基础）类型，当修改考背后的数组当中的下标的元素师，不影响原来数组的元素值
* 浅拷贝：拷贝时，数据类型为引用类型，数组中数据为地址，副本也为地址，则改变副本，即改变了原来的地址
*
*(查看源码，ctrl+左键单击)
*
*
*
* */
public class Test0723 {
    //1.青蛙跳台阶问题

    public static int jumpFlor(int n) {
        if (n <= 0) {
            return -1;
        }
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        return jumpFlor(n - 1) + jumpFlor(n - 2);

    }

    public static void main1(String[] args) {
        System.out.println(jumpFlor(3));
    }

//=======================================================================================

    //1.数组转字符串
    //(1.)
    public static void main2(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(array));
        //[1,2,3,4,5]
    }

    //(2.)
    public static String myString(int[] array) {
        //参数判断必不可少
        if (array == null) {
            return null;
        }
        if (array.length == 0) {
            return "[]";
        }
        String begin = "[";
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1) {
                begin = begin + array[i] + ", ";
            } else {
                begin = begin + array[i] + "]";
            }
        }
        return begin;
    }

    public static void main3(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(myString(array));
    }


    //2.数组拷贝
    //(1)(引用）
    public static int[] copyString(int[] array) {
        int[] array2 = new int[array.length];//在堆上开辟新的空间，大小和array一样
        for (int i = 0; i < array.length; i++) {//通过for循环复制array在堆上的值
            array2[i] = array[i];
        }
        return array2;
    }

    public static void main4(String[] args) {
        int[] array = {1, 2, 3};
        int[] ret = new int[array.length];
        System.out.println(Arrays.toString(copyString(array)));
    }

    //(2)
    public static void main5(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        int[] ret = Arrays.copyOf(array, array.length);//(拷贝的数组，拷贝的数组长度)
        System.out.println(Arrays.toString(ret));

    }


    //(3)最快，native方法
    public static void main6(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        int[] ret = new int[array.length];
        System.arraycopy(array, 0, ret, 0, array.length);
        System.out.println(Arrays.toString(ret));
        /**
         * 源码：
         *  public static native void arraycopy(Object src,  int  srcPos,
         *                                         Object dest, int destPos,
         *                                         int length);
         * 1.native 此方法为本地方法
         * 2. src:源数组
         *    srcPos:源数组的pos开始拷贝
         *    dest:拷贝到的目的数组
         *    destPost:拷贝到的目的数组的Pos位置
         *    length:拷贝多长
         * */
    }


        //(4)
        public static void main(String[] args) {
            int[] array = {1, 2, 3, 4, 5};
            int[] ret=array.clone();//产生需要克隆的对象的副本  数组名.clone()
            System.out.println(Arrays.toString(ret));


            //拷贝范围
            int []ret1=Arrays.copyOfRange(array,2,4);
            System.out.println(Arrays.toString(ret1));
            //[3,4]  默认左闭右开

    }

}