一维数组

数组初始化的三种方式

数组的默认初始化

数组是引用类型(除了八大基本数据类型，都是引用类型)，他的元素相当于类的实例变量。其中每个元素也按照实例变量的方式倍隐式初始化。
静态初始化
int[] array={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};//这是引用类型
动态初始化
int[] array=new int[10];
 array[0]=1;

package MethodDemo;

public class Demo08 {
    public static void main(String[] args) {
//        int[] array = new int[7];//两种方法效果相同，但是这个更简洁
        int[] array;//声明，操作之后会压栈
        array = new int[7];//创建，操作之后会在堆里面开辟一定的空间
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
            System.out.println("array[" + i + "]" + "=" + array[i]);
        }
    }
}

创建数组操作内存的过程：

第一步声明一个数组时，JDK会分配一个空间进行压栈，但是此时并没有分配空间
第二步对数组进行初始化，JDK会在堆内分配一定数量的内存空间
第三步赋值操作，JDK会按照顺序进行赋值，如果不赋值，数组内保存的就是默认值(int类型的默认值是0)

当然，书写代码并不一定非要是上述的步骤，可以直接使用一行代码完成，但是内存操作还是相同的。

关于java内存的补充

数组边界

数组下标的合法区间是[0,length-1]，如果越界，就会报错：ArraylndexOutOfBoundsException：数组下标越界异常！
数组也是对象。数组元素相当于对象的成员变量。

数组的使用

普通的for循环
for-each循环
数组作为方法的形参
数组作为返回值

练习

package MethodDemo;

public class Demo08 {
    public static void main(String[] args) {
        int[] array = new int[5];
        //给一维数组赋值
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        PrintArray(array);
        System.out.println("--------------");
        int[] reverseArray = ReverseArray(array);
        PrintArray(reverseArray);
    }

    //把原来数组里面的元素倒序输出
    public static int[] ReverseArray(int[] ArrayTemp) {
//        int[] Re_array = new int[ArrayTemp.length];
//        for (int i = 0, j = Re_array.length-1; i < Re_array.length; i++, j--) {
//            Re_array[j] = ArrayTemp[i];
//        }
//        return Re_array;
        int temp;//使用一个中间变量依然可以实现倒序输出
        for (int i = 0; i < ArrayTemp.length/2; i++) {
            temp = ArrayTemp[i];
            ArrayTemp[i] = ArrayTemp[ArrayTemp.length - i-1];
            ArrayTemp[ArrayTemp.length - i - 1] = temp;
        }
        return ArrayTemp;
    }

    //打印数组里面的元素的方法
    public static void PrintArray(int[] ArrayTemp) {
//        for (int i = 0; i < ArrayTemp.length; i++) {
//            System.out.println(ArrayTemp[i]);
//        }
        //增强型for循环省去了数组下标
        for (int i : ArrayTemp) {
            System.out.println(i);
        }
    }
}

数组补充

2020/10/17/22:22

package Arrays;

public class testArray {
    public static void main(String[] args) {
        int[] array = new int[2];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
            System.out.print(array[i]+"    ");
        }
        System.out.println();
        Car[] cars = new Car[2];
//        cars[0]= new Car("奔驰");
//        cars[0] = new Car(10);
//        cars[1] = new Car("比亚迪");
//        cars[1] = new Car(12);
        cars[0] = new Car("奔驰", 10);
        cars[1] = new Car("比亚迪", 12);
        for (int i = 0; i < cars.length; i++) {
            System.out.print(cars[i].name+"    ");
            System.out.println(cars[i].length);
        }
        System.out.println(cars.length);
    }
}

package Arrays;

public class Car {
    String name;
    int length;

    public Car(String name) {
        this.name = name;
    }

    public Car(int length) {
        this.length = length;
    }

    public Car(String name, int length) {
        this.name = name;
        this.length = length;
    }
}

运行结果：

这里是自定义的数组类型，使用起来的感觉跟C语言里面的结构体比较像。

我们看自定义类型的数组：Car类里面有两个属性，使用Car类new一个引用类型的数组，那么这个数组的每个元素都包含Car类的所有属性(至于包不包含Car类里面的方法还不清楚，不过我判断是包含的，只不过是包含方法的引用地址)，也就是说，数组car[i]里面存的是Car类里面每个属性的地址，其内存图如下：

需要注意的是：如果使用下面的方法对引用类型数组进行初始化，输出结果就是：
cars[0]= new Car("奔驰");
        cars[0] = new Car(10);
        cars[1] = new Car("比亚迪");
        cars[1] = new Car(12);
运行结果：

为什么会这样，明明对name属性赋值了，内存中却是null？

经调试发现：我初始化引用数组元素的属性时，使用的是有参构造方法(一个参数)，运行完“奔驰”的赋值后，cars[0].name确实被初始化成功，此时cars[0].length也被初始化了，只不过被初始化成默认值0(经测试：正确)，也就是说我调用一个参数的构造方法时，JDK对另一个参数也进行了初始化(初始化成默认值)，同理，执行cars[0] = new Car(10);这一句时，又调用一次一个参数的构造方法把cars[0].length初始化为10，此时cars[0].name也被初始化成默认值null。

11java的一维数组

一维数组

数组边界

数组的使用

数组补充

猜你喜欢