Java中的数组（二）

数组是引用类型

int arry = {1，2，3，4，5，6};        //此时arry就是引用类型

简单了解JVM

内存是一段连续的存储空间，主要用来存储程序运行时数据的

1. 程序运行时代码需要加载到内存
2. 程序运行产生的中间数据要存放在内存
3. 程序中的常量也要保存
4. 有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁

因此JVM对使用的内存按照功能的不同进行了划分

基本类型变量与引用类型变量

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；

引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址；

    public static void main(String[] args) {

         //a、array都是函数内部的变量，因此其空间都在main方法对应的栈中分配。
        //a是内置类型变量，因此其空间中保存的就是给该变量初始化的值（10）
        int a=10;

        //array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址

        int [] array = new int[]{1,2,3};

}

引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址，通过该地址，引用变量便可以去操作对象。

进一步理解引用变量

    public static void main(String[] args) {
        //创建array1，在栈上分配内存，存的是该对象保存在堆上的地址（假设该地址为0X11）
        //同理创建array2，假设在内存中存的地址是0X22
        int [] array1 =  {1,2,3,4};
        int [] array2 =  {11,22,33,44};
        //此时将array2的地址赋值给array1   
        // 那么array1和array2此时在内存中存储的地址都是指向同一对象保存在堆上的地址（0X22）
        array1=array2;
        //将array1下标为0的元素改成666
        // 因为array1栈上地址指向的是0X22，那么它下标为0的元素就是11，
        array1[0]=666;
        System.out.println(Arrays.toString(array1));//输出：[666,22,33,44]
        System.out.println(Arrays.toString(array2));//输出：[666,22,33,44]

    }

null

null在Java中表示“空引用”，也就是一个不指向对象的引用

    public static void main(String[] args) {
        int []arry = null;
        System.out.println(arry);   //直接输出null
        //下面两个输出报错-->空指针异常--> 若赋值null后对其进行任何操作都会报错显示空指针异常
        //原因：使用了一个值为null的引用
       // System.out.println(arry[0]);
       // System.out.println(arry.length);
    }

null的作用类似于C语言中的NULL（空指针），都是表示一个无效的内存位置，因此不能对这个内存进行任何读写操作，一旦尝试读写，就会报出Null Pointer Exception。

注意：Java中并没有约定null和0号地址的内存有任何关联

数组的应用场景

保存数据

    public static void main(String[] args) {
        int [] arr = {1,2,3};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

作为函数的参数

参数传基本数据类型

    public static void fun(int n){
        n=100;
        System.out.println("n="+n); //n=100
    }
    public static void main(String[] args) {
        int a= 10;
        fun(a);
        System.out.println("a="+a); //a=10
    }

参数传数组类型（引用数据类型）

    public static void func(int []a) {
        a[0]=11;
        System.out.println("a[0]="+a[0]);
    }
    public static void main(String[] args) {
        int[]array = {1,2,3};
        func(array);
        System.out.println("array[0]="+array[0]);
    }

发现在func方法内部修改数组的内容，方法外部的数组内容也发生改变。

因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。

当数组作为参数进行传递的时候，其实还是按值传递，不过此时的值是一个地址；那么就会出现两种情况：

1. 形参修改指向：array = new int [ ]  //只会影响形参的指向
2. 形参修改指向对象的值：array[0] =9 //此时才会影响实参

作为函数的返回值

    public static int[] grow(int[] array){
        for (int i = 0; i < array.length; i++) {
           array[i] = array[i]*2;
        }
        return array;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        grow(array);
        int[] ret = grow(array);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(ret));
    }

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

对比grow和grow2来看有无返回值结果都一样  他们都相当于是在同一个对象上进行了修改

    public static int[] grow3(int[] array){
        //3.此时grow3中定义了另一个array 其也在栈上分配内存，他存的是实参array的值（0x1），因此他也指向同一个堆上的对象
        //4.定义了一个引用变量tmpArr 它的大小和array一样，他在堆上指向对象的地址假设为0x2
        int[] tmpArr = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            //5.通过形参array访问，并传给tmpArr
            tmpArr[i] = array[i]*2;
        }
        //6.return相当于把tmpArr在栈上的值传给ret
        return tmpArr;
    }
    public static void main(String[] args) {
        //1.为数组array在栈上分配内存，在堆上有所指对象的地址（假设为0x1）
        int[] array = {1,2,3,4,5,6,7,8,9};
        //2.调用grow3
        //7.此时引用变量ret在栈上的地址是0x2
        int[] ret = grow3(array);
        //8.打印实参array 实参array并没有发生变化
        System.out.println(Arrays.toString(array));
        //此时ret栈上存的是，堆上指向对象的地址是0x2
        System.out.println(Arrays.toString(ret));
    }

获取斐波那契数列的前N项

    public static int [] fib(int n){
        if (n<=0){
            return null;
        }
        int[] array = new int[n];
        array[0] = array[1]=1;
        for (int i = 2; i < n; i++) {
            array[i]=array[i-1]+array[i-2];
        }
        return array;
    }
    public static void main(String[] args) {
        int[] array =fib(10); //假设n为10
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }