【Java】数组

 数组

        数组就是用来存储一批同种类型数据的容器

例：

int[] arr ={10,20,30,40};

String[] names = {"大珍珠","小珍珠","黑珍珠","白珍珠"};

静态初始化数组

        定义数组的时候直接给数组赋值

完整格式：

数据类型[] 数组名 = new 数据类型[] {元素1，元素2，元素3...};

例：double[] scores = new double[]{20.5,12.5,30.8,50.8};

例：int[] ages = new int[]{12,18,23};

简化格式：

数据类型[] 数组名 = {元素1，元素2，元素3...};

例：int[] ages ={18,25,28};

public class ArrayDemo {
    public static void main(String[] args) {
//        完整格式: 定义类型[] 名称 = new 定义类型{}
double[] d = new double[]{12.2,12.3,12.4,12.5};

int[] i = new int[]{12,13,14,15,16};

String[] s = new String[]{"大珍","小珍","黑珍"};

//        简化格式: 定义类型[] 名称 = new 定义类型{}
double[] d1 ={12.2,12.3,12.4,12.5};

int[] i1 ={12,13,14,15,16};

String[] s1 ={"大珍","小珍","黑珍","白珍"};
    }
}

注意：数组变量名存储的是数组在内存中的地址，数组是引用类型

[ :代表数组 I :代表类型 @ :代表16进制位置

数组的访问

定义一个数组:

int[] i = new int[]{10,20,30,40};

取值：

System.out.println(arr[0]);//10

赋值

arr[1] = 100;

System.out.println(arr[1]);//100

数组的长度属性：

System.out.println(arr.length);

数组的最大索引：

arr.length-1

public class ArrayDemo {
    public static void main(String[] args) {
//        数组的两种形式
        int[] age ={12,34,56};
        int age1[] ={12,34,56};
        
//        定义什么类型就是什么类型
//        错误：int[] i ={1,2,3,"123"};
        
//        数组一旦定义出来类型的数据，程序执行的过程中，长度，类型就固定了
        int[] j = {1,2,3,4,5,6};
        System.out.println(j.length);
    }
}

数组的几个注意事项

注意：

        "数据类型[] 数组名" 也可以写成"数据类型 数组名[]"

        什么类型的数组存放什么类型的数据，否则报错

        数组一旦定义出来，程序执行的过程中，长度，类型就固定了

动态初始化数组

        定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据

数组的动态初始化格式：

数据类型[] 数组名 = new 数据类型[长度];

例：int[] arr = new int[3];

public class ArrayDemo {
    public static void main(String[] args) {
        int[] i = new int[10];
        i[1] = 10;
        System.out.println(i[1]);//10
        System.out.println(i[2]);//0
    }
}

 动态初始化数组的元素默认值

元素默认值规则

public class ArrayDemo {
    public static void main(String[] args) {
        int[] i = new int[5];
//        char底层也是0

        double[] d = new double[5];

        boolean[] b = new boolean[5];

        String[] s = new String[5];

        System.out.println(i[1]);//0
        System.out.println(d[1]);//0.0
        System.out.println(b[1]);//false
        System.out.println(s[1]);//null
    }
}

两种初始化的使用场景总结

静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景

动态初始化：只指定数组长度，后期赋值，适合知道开始数据的数量，但是不确定具体元素值的业务场景

两种格式的写法是独立的，不能混用 

数组的遍历

        遍历就是一个一个数据的访问

为什么要遍历：因为要值的索引，查找数据等等操作

public class ArrayDemo {
    public static void main(String[] args) {
        int[] i = new int[]{10,20,30,40,50};
        
//			快捷方式 i.fori
        for (int j = 0; j < i.length; j++) {
            System.out.println(i[j]);
        }
    }
}

数组使用的常见问题

访问的元素位置超过最大索引：

        执行时会出现ArrayIndexOutOfBoundsException

数组变量中没有存储数组的地址，而是null：

        在访问数组信息时会出现NullPointerException