Java基础 - 4 - 数组

数组是什么？

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

int[] arr = {20, 10, 80, 60, 90};

String[] name = {"张三","李四","王二"};

一. 数组的定义

        数据的定义有两种方案：静态初始化数组和动态初始化数组

1.1 静态初始化数组

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

1.1.1 静态初始化数组的格式

        完整格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,……};

        简化格式：数据类型[] 数组名 = {元素1,元素2,元素3,……};

//静态初始化数组-完整格式
int[] a = new int[]{1, 2, 3, 4};
double[] b = new double[]{89.9, 99.5, 59.2, 88};
String[] name = new String[]{"张三","李四"};

//静态初始化数组-简化格式
int[] a1 = {1, 2, 3, 4};
double[] b1 = {89.9, 99.5, 59.2, 88};
String[] name1 = {"张三","李四"};

注：

       1. 数据类型[] 数据名 也可以写成 数据类型 数据名[]

       2. 什么类型的数组只能存放什么类型的数据

1.2 动态初始化数组

        定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组的长度

  1.2.1 数组的动态初始化格式

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

int[] a = new int[3];

注：

        静态初始化和动态初始化数组的写法是独立的，不可以混用

        int[] a = new int[3]{1,2,3}  ××× 这是一个错误写法

1.2.2 动态初始化数组元素默认值规则

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
	float、double	0.0
	boolean	false
引用类型	类、接口、数据、String	null

int[] a = new int[3];
for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);      //输出结果0
}

char[] b = new char[3];
for (int i = 0; i < b.length; i++) {
    System.out.println((int)b[i]);  //输出结果0（强转int后，不强转是0但是显示不出来）
}

double[] c = new double[3];
for (int i = 0; i < c.length; i++) {
    System.out.println(c[i]);   //输出结果0.0
}

boolean[] d = new boolean[3];
for (int i = 0; i < d.length; i++) {
    System.out.println(d[i]);   //输出结果false
}

String[] e = new String[3];
for (int i = 0; i < e.length; i++) {
    System.out.println(e[i]);   //输出结果null
}

1.2.3 动态初始化数组的案例

        问题描述：求6位评委打分的平均值

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    double[] sorce = new double[6];
    double sum = 0;
    for (int i = 0; i < sorce.length; i++) {
        System.out.println("请评委" + (i+1) + "打分：");
        sorce[i] = sc.nextDouble();
        sum += sorce[i];
    }
    double avg = sum / sorce.length;
    System.out.println("平均分是" + avg);
}

1.3 两种定义方法的业务场景

        动态初始化：适合开始不确定具体元素值，只知道元素个数的业务场景

        静态初始化：适合一开始就知道要存入哪些元素值的业务场景

二. 数组的访问

        数组的访问：数组名[索引]

        数组的长度：数组名.length

//静态初始化数组
int[] a = {1, 2, 3, 4};
//取值   输出2
System.out.println(a[1]);
//赋值后取值 输出10
a[1] = 10;
System.out.println(a[1]);
//数组的长度属性length  输出4
System.out.println(a.length);

注：访问数组时，使用的索引不能超过最大索引，如果超过会出现索引越界的异常提示

2.1 数组的遍历

        遍历：一个一个数据的访问

        遍历数组的应用场景：求和，元素搜索，找最大（小）值……

int[] a = {1, 2, 3, 4};
//快捷写法 a.fori
for (int i = 0; i < a.length; i++) {
    //快捷写法 a[i].sout
    System.out.println(a[i]);
}

2.1.1 数组遍历的案例

//求数组a的和
int[] a = {16, 26, 36, 6, 100};
int sum = 0;
for (int i = 0; i < a.length; i++) {
    sum += a[i];
}
System.out.println(sum);

三. java内存分配介绍

        JVM可以分为5个部分（执行一个java程序，主要看JVM中包含的方法区、栈、堆）

                · 方法区：字节码文件（class文件）先加载到这里

                · 栈：方法运行时所进入的内存，变量也是在这里

                · 堆：new出来的东西会在这块内存中开辟空间并产生地址

                · 本地方法栈

                · 程序计数器

3.1 数组在计算机中的基本原理

        数组是一种引用数据类型，因为数组变量名中存储的是数组在内存中的地址信息

        下图展示的是静态初始化和动态初始化两种方法下的数组在计算机中的存储

  

        数组变量存放在栈中，new出来的数组对象存放在堆中，数组变量在栈中记录的是数组对象在堆内存中的地址

        如果某个数组变量存储的地址是null，那么该变量将不再指向任何数组对象，可以输出这个变量，但不能用这个数组变量去访问数据或者访问数组长度

int[] arr1 = null;
System.out.println(arr1);  //输出null
System.out.println(arr1[0]); //出异常（空指针异常Exception in thread "main" java.lang.NullPointerException）
System.out.println(arr1.length); //出异常（空指针异常Exception in thread "main" java.lang.NullPointerException）

3.2 多个变量指向同一个数组的问题

        多个数组变量中存储的是同一个数组对象的地址，其中一个数组变量修改数组对象中的数据，其他数组变量看到的数组对象中的数据也发生了修改

//多个变量指向同一数组对象
int[] arr1 = {1,2,3};
//把int类型的数组变量arr1赋值给int类型的数据变量arr2
int[] arr2 = arr1;

arr2[1]=99;
System.out.println(arr1[1]);  //输出结果也是99

四. 案例

4.1 找数组中的最大值

public static void main(String[] args) {
    int[] arr = {15,9000,10000,20000,9500,-5};
    int max = arr[0];  //建议使用第一个元素值作为参照
    for (int i = 1; i < arr.length; i++) {   //从第二个元素开始遍历
        if(arr[i] > max){
            max =  arr[i];
        }
    }
    System.out.println(max);
}

4.2 数组反转

public static void main(String[] args) {
    int[] arr = {10,20,30,40,50};
    for (int i = 0,j = arr.length-1; i < j; i++,j--) {
        int count;
        count = arr[i];
        arr[i] = arr[j];
        arr[j] = count;
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

4.3 随机排名

public static void main(String[] args) {
    //完成随机排名
    //扫描器 + 随机数
    Scanner sc = new Scanner(System.in);
    Random r = new Random();
    //定义一个动态初始化的数组
    int[] arr = new int[5]; //[0,0,0,0,0]
    //提示用户录入5名员工工号
    for (int i = 1; i <= arr.length; i++) {
        System.out.println("请输入第"+i+"名员工工号");
        arr[i-1] = sc.nextInt();
    }
    //打乱数组中的元素顺序
    for (int i = 0; i < arr.length; i++) {
        //每遍历到一个数据，都随机一个数组索引范围内的值，然后让当前遍历的数据与该索引位置的值交换。
        int index = r.nextInt(arr.length);
        int temp = arr[index];
        arr[index] = arr[i];
        arr[i] = temp;
    }
    //输出
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+" ");
    }
}

五. debug工具的使用

        IDEA自带的断点调试工具，可以控制代码从断点处开始一行一行的执行，然后详细观看程序执行的情况