Java-day4-数组-debug

数组是什么

• 数组就是用来存储一批同种类型数据的内存区域（可以理解成容器)。
  例子：

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

牛二，西门，全蛋
String[] names ={"牛二","西门",""全蛋"};

静态初始化数组

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

静态初始化数组的格式:

完整格式：
数据类型[]数组名= new数据类型[]{元素1，元素2，元素3...};
double[] scores = new double[]{89.9，99.5，59.5,88.0};
int[]ages = new int[]{12，24，36}

简化格式:
数据类型[]数组名={元素1，元素2，元素3,.. };
int[] ages = {12，24，36};

实例：

public class 数组访问 {
    public static void main(String[] args) {
        int[] ages= {12,34,56};
        //取值，数组名称[索引]
        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);
        
        //赋值：数组名称[索引]=数据；
        ages[2] = 100;
        System.out.println(ages[2]);

        //访问数组的长度
        System.out.println(ages.length);
    }
}

问题:数组的最大索引可以怎么表示?

• 数组名.length - 1 //前提:元素个数大于0

数组的几个注意事项:

• “数据类型[]数组名”也可以写成“数据类型数组名[]”

  int[ ] ages =.. .;
  int ages[] =...;

  double[] scores = ...;
  double scores[] = ...;

• 什么类型的数组存放什么类型的数据，否则报错。
  例如：int[ ] arrs = new int[]{30，40，“黑马"}; （错误的）
• 数组一旦定义出来，程序执行的过程中，长度，类型就固定了。

静态和动态两种数组定义时的特点和场景有什么区别？

• 当前已经知道存入的元素值，用静态初始化。
• 当前还不清楚要存入哪些数据，用动态初始化。
  实例：

public class 数组的动态访问 {
    public static void main(String[] args) {
        double[] scores =new double[3];

        scores[0]=99;
        System.out.println(scores[0]);
        System.out.println(scores[2]);

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

、

动态初始化数组后元素的默认值是什么样的?

• byte、short、int . char、long类型数组元素的默认值都是0
• float、double类型数组元素的默认值都是0.0
• boolean类型数组元素的默认值是false
• String类型数组元素的默认值是null
  实例：

public class 默认值 {
    public static void main(String[] args) {
        //整形元素的元素默认值都为0
        int[] arr =new int[10];
        System.out.println(arr[0]);
        System.out.println(arr[2]);

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

        //浮点型数组的元素默认值都为0
        double[] doubles =new double[100];
        System.out.println(doubles[0]);
        System.out.println(doubles[2]);

        //布尔类型数组的元素默认值
        boolean[] booleans =new boolean[100];
        System.out.println(booleans[0]); //false
        System.out.println(booleans[99]); //false

        //引用类型数组的元素默认值
        String[] names =new String[100];
        System.out.println(names[0]);  //null
        System.out.println(names[2]); //  null
    }
}

数组遍历介绍

• 遍历:就是一个一个数据的访问。
• 为什么要遍历? 搜索、数据统计等等都需要用到遍历。
• ages.fori 快捷生成遍历语法
  实例：

public class 数组遍历 {
    public static void main(String[] args) {
        int[] ages = {20,30,40,50};
        //ages.fori 快捷生成遍历语法
        for (int i = 0; i < ages.length; i++) {
            System.out.println(ages[i]);
        }
    }
}

实例：

public class 数组_求和 {
    public static void main(String[] args) {
        int[] money ={11,44,446,22,12,78};
        int sum = 0;

        for (int i = 0; i < money.length; i++) {
            sum += money[i];
        }
        System.out.println("数组的元素和是：" + sum);
    }
}

实例：

public class 数组元素求最值 {
    public static void main(String[] args) {
        int[] score={15,61,66,88,181};

        int max=score[0];

        for (int i = 0; i < score.length; i++) {
            if(score[i] > max){
                max= score[i];
            }
        }
        System.out.println(max);
    }
}

分析

* 随机生成5个1-20之间的数据存储起来--->使用数组
* 定义一个死循环，输入数据猜测，遍历数组，判断数据是否在数组中，如果在，进行对应提示并结束死循环;
* 如果没有猜中，提示继续猜测直到猜中为止。

实例：

import java.util.Scanner;
import java.util.Random;

public class 猜数字 {
    public static void main(String[] args) {
        int[] data =new int[5];
        Random r =new Random();
        for (int i = 0; i < data.length; i++) {
            data[i]=r.nextInt(20) +1;
        }

        //使用一个死循环让用户进行猜测
        Scanner sc = new Scanner(System.in);
        OUT:
        while(true){
            System.out.println("1~20,请猜：");
            int guessData= sc.nextInt();

            for (int i = 0; i < data.length; i++) {
                if (data[i] == guessData ){
                    System.out.println("成功,该数据索引是:" + i);
                    break OUT;
                }

            }
            System.out.println("失败");
        }

        //输出数组的全部元素,让用户看到自己确实是猜中了某个数据。
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i] + "\t");
        }
    }
}

如何实现随机排名的?

• 定义一个动态初始化的数组用于录入数据。
• 遍历数组中的每个元素，每次随机一个索引值，让当前元素与该索引位置处的元素进行交换。
• 遍历输出数组中的内容即可。

实例：

import java.util.Scanner;
import java.util.Random;

public class 随机排名 {
    public static void main(String[] args) {
        int[] codes= new int[5];

        //定义一个循环,循环5次,依次录入一个工号存入对应的位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {

            //录入，存入到数组中去
            System.out.println("请输入第" + (i+1) + "个员工的工号");
            int code = sc.nextInt();
            codes[i] = code;
        }

        //遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换
        Random r =new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值: codes[i]
           //随机一个索引位置出来:codes[index]
            int index = r.nextInt(codes.length);

            //定义一个临时变量存储index位置处的值
            int temp=codes[index];
            codes[index]=codes[i];
            codes[i] =temp;
        }

        //遍历数组元素，随机排名后的结果
        for (int i = 0; i < codes.length; i++) {
            System.out.println(codes[i] + "\t");
        }
    }
}

冒泡排序的思想

• 从头开始两两比较，把较大的元素与较小的元素进行交换每轮把当前最大的一个元素存入到数组当前的末尾。

冒泡排序的实现步骤。

• 定义一个外部循环控制总共需要冒几轮（数组的长度-1)
• 定义一个内部循环，控制每轮依次往后比较几个位置（数组长度-i-1)。

实例：

public class 冒泡排序 {
    public static void main(String[] args) {
        int[] arr = {5,6,8,7};
        for (int i = 1; i <= arr.length; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j+1]){
                    int temp =arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j] =temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "\t");
        }
    }
}

数组的内存图

Java内存分配介绍

• 栈
• 堆
• 方法区
• 本地方法栈
• 寄存器

方法区 —— 字节码文件加载时进入的内存（XX.class）
栈内存 —— 方法运行时所进入的内存变量也是在这里
堆内存 —— new出来的东西会在这块内存中开辟空间并产生地址

实例：

public class 同一对象 {
    public static void main(String[] args) {
        int[] arr1={11,111,111};
        int[] arr2=arr1;
        //都为[I@16b98e56
        System.out.println(arr1);
        System.out.println(arr2);

        arr2[1]=99;
        //都为99
        System.out.println(arr1[1]);
        System.out.println(arr2[1]);
    }
}

数组使用常见问题

问题1∶

• 如果访问的元素位置超过最大索引，执行时会出现ArrayIlndexOutOfBoundsException(数组索引越界异常)

问题2:

• 如果数组变量中没有存储数组的地址，而是null,在访问数组信息时会出现NullPointerException(空指针异常)

Debug工具

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

DEBUG工具基本使用步骤

• 在需要控制的代码行左侧，点击一下，形成断点
• 选择使用Debug方式启动程序，启动后程序会在断点暂停
• 控制代码一行一行的往下执行