Java基础——数组

1. 数组属于什么类型，数组变量名中存储的是什么?
     引用数据类型，存储的数组在内存中的地址信息。
2.如何访问数组元素
     数组名称[索引]
3.如何访问数组的长度？
     数组名称.length
4.数组的最大索引怎么获取?
     数组名.length - 1 //前提：元素个数大于0
5. “数据类型[] 数组名” 也可以写成 “数据类型 数组名[]”
   什么类型的数组存放什么类型的数据，否则报错
   数组一旦定义出来，程序执行的过程中，长度、类型就固定了
6.动态初始化的写法是什么样的？
     数据类型[] 数组名 = new 数据类型[长度];
     int[] ages = new int[4];
7.两种数组定义时的特点和场景有什么区别?
     当前已经知道存入的元素值，用静态初始化。
     当前还不知道要存入哪些元素，用动态初始化。
     动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但不确定具体元素值的业务场景
     静态初始化：开始就存入元素值，适合开始就能确定元素值的业务场景。
     两种格式的写法是独立的，不可以混用。

        实例：

public class ArrayDemo {
    public static void main(String[] args) {
        //学会使用静态初始化方式定义数组
//        double[] source = new double[]{99.5,88.8,75.5};
        double[] source = {99.5,88.8,75.5}; //简化写法
        int[] ages = new int[]{12,24,36,14};

        String[] names= new String[]{"张三","李四"};
    }
}

public class ArrayDemo1 {
    public static void main(String[] args) {
        //访问数组元素
        int[] ages = {12,24,36};
        System.out.println(ages[0]);
        //数组的长度
        System.out.println(ages.length);
    }
}

 

public class ArrayDemo2 {
    public static void main(String[] args) {
        //学会动态初始化数组的定义和使用
        double[] scores = new double[3];

        //赋值
        scores[0] = 99.5;
        System.out.println(scores[0]);

        System.out.println(scores[2]);

        String[] names = new String[90];
        names[0] = "李四";
        names[2] = "张三";
        System.out.println(names[1]);
        System.out.println(names[2]);
    }
}

public class ArrayDemo3 {
    public static void main(String[] args) {
        //掌握动态初始化元素默认值的规则
        //1.整型数组的元素默认值都是0
        int[] arr = new int[10];
        System.out.println(arr[0]);
        System.out.println(arr[9]);

        //2.字符数组的元素默认值      0
        char[] chars = new char[100];
        System.out.println(chars[0]);
        System.out.println((int)chars[99]);

        //3.浮点型数组的元素默认值是0.0
        double[] scores = new double[90];
        System.out.println(scores[0]);

        //4.布尔类型的数组     false
        boolean[] booleans = new boolean[10];
        System.out.println(booleans[0]);
        System.out.println(booleans[1]);

        //5.引用类型的数组     null
        String[] names = new String[90];
        System.out.println(names[0]);
        System.out.println(names[89]);
    }
}

public class ArrayDemo4 {
    public static void main(String[] args) {
        //理解2个数组变量指向统一个数组
        int[] arr1 = {11,22,33};
        //把数组arr1变量赋值给int类型的数组变量arr1
        int[] arr2 = arr1;
        System.out.println(arr1);
        System.out.println(arr2);

        arr1[0] = 44;
        System.out.println(arr1[0]);
        System.out.println(arr2[0]);
    }
}

public class ArrayAttentionDemo {
    public static void main(String[] args) {
        //理解数组的注意事项
        //1.“数据类型[] 数组名” 也可以写成 “数据类型 数组名[]”
        int[] ages = {11,22,33};
        int ages1[] = {11,22,33};


        //2.什么类型的数组存放什么类型的数据，否则报错
//        String[] names = {"张三","李四",23};  //错误的

        //3.数组一旦定义出来，程序执行的过程中，长度、类型就固定了
        int[] ages2 = {11,22,33};
//        ages2[3] = 44;
        System.out.println(ages2[3]);   //报错，长度固定是3，不能访问第四个元素
        String[] arr = null;
        System.out.println(arr);    //null
        System.out.println(arr[0]);     //NullPointerException
    }
}

/*
 * 如果访问的元素位置超过了最大索引，执行时会出现ArrayIndexOutOfBoundsException(数组索引越界异常)
 *
 * 如果数组变量中没有存储数组的地址，而是null，在访问数据信息时会出现NullPointerException(空指针异常)
 * */