Java复习笔记入门阶段05：数组

1.数组概述

1.1数组是什么？

数组是用来存储一批同种类型数据的内存区域（容器）

1.2示例

        int[] arr={21,58,698,88};

        String[] names={"张三","lisi","王wu"};

1.3关键点

• 定义数组存储数据；

• 操作数组元素；

• 解决问题；

• 数组内存原理

• 数组使用注意点

2.数组定义方式

2.1静态初始化数组

定义数组时直接赋值：

数据类型[] 数组名 = new 数组数据类型[]{元素1，元素2}
int[] ages = new int[]{15,24,28};

//简化格式
数据类型[] 数组名 ={元素1，元素2}
int[] ages = {15,24,28};

 /**
         * 静态初始化数组
         */
        double[] money = new double[]{15.6,65.3,99.9};
        double[] money2 ={15.6,65.3,99.9};

        int[] ages = new int[]{5,6,5,6};
        int[] ages2 = {5,6,5,6};

        String[] names = new String[]{"张三","lisi","王wu"};
        String[] names2 = {"张三","lisi","王wu"};

2.2 数组基本原理

• 内存中开辟数组变量区域ages；

• new出来对象存储信息，是一片连续区域，地址给变量名；

• [I@4c873330:[代表数组；I代表int型；@表示地址，后接十六进制首地址；

• 引用类型里面存地址；基本类型里面存数据

2.3 数组访问

• 数组访问

  • 数组名[索引]

  • 数组长度属性：length

  • 数组最大索引：length-1；//元素最少有一个

• 注意事项

  • 数据类型[] 数组名 也可以是 数据类型 数组名[]

  • 数组存放数据类型固定

  • 数组一旦定义，程序执行过程中，长度、类型固定

2.4 动态初始化数组

• 定义数组时，只确定元素类型和长度，之后存值

  • 格式：int[] sums= new int[9];

• 原理：

  • 类似静态初始化，变量名存入首地址，长度确定，每个地址存入默认值，如：int型默认存0；引用类型null

• 静动两者使用场景区别：

  • 静态，知道具体值；

  • 动态，知道数据量，不知道具体值

3.数组遍历

3.1求和 求最大值

 int[] arr={21,58,698,88};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //求和
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println(sum);

        //求最大值
        //建议用第一个元素作为参照
        int Max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (Max<arr[i]){
                Max = arr[i];
            }
        }
        System.out.println("最大值："+Max);

3.2猜字游戏

public class ArrayDemo2 {
    public static void main(String[] args) {
        /**
         * 猜字游戏：
         *      随机生成1-20间5个数（不论是否重复）
         *      猜字：输出第一次出现该树的位置，全部输出结束
         */

        Random random = new Random();
        int[] Numbers = new int[5];
        int count = 0;
        for (int i = 0; i < 5; i++) {
            Numbers[i] = random.nextInt(20)+1;
        }
//        System.out.println(Arrays.toString(Numbers));
        Scanner scanner = new Scanner(System.in);
        OUT:
        while (count<5){
            boolean a = false;
            System.out.println("请输入1-20的数字");
            int test = scanner.nextInt();
            if (test<0 || test>20){
                System.out.println("数字范围输入错误");
                continue ;
            }
            for (int i = 0; i < 5; i++) {
                if (Numbers[i] == test){
                    System.out.println("运气不错，猜中了，数字"+Numbers[i]+"第一次出现在"+i+"位置");
                    Numbers[i]=99;
                    count++;
                    System.out.println("还差"+(5-count)+"个，就都猜中了！");
                    a=true;
                    //break OUT;//结束了整个循环，游戏结束
                }
            }
            if (!a){
                System.out.println("没猜中，再来一次吧");
            }
        }
        System.out.println("恭喜，猜中全部数字，本局结束。");
    }
}

3.3 随机排名

 /**
         * 随机排位：
         *      录入五个人，给他们随机排序
         */

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要给几个人排序");
        int length=scanner.nextInt();
        int[] users = new int[length];
        int count = 0;
        for (int i = 0; i < users.length; i++) {
            System.out.println("请输入第"+i+"个人的ID");
            users[i]=scanner.nextInt();
        }
        Random random = new Random();
        for (int i = 0; i < users.length; i++) {
            int temp=random.nextInt(users.length);
            int tempUser = users[0];
            users[0]=users[temp];
            users[temp]=tempUser;
        }
        System.out.println(Arrays.toString(users));

4.数组排序

• 数组排序

  • 对数组中元素，按从小到大或从大到小排序

• 排序技术

  • 冒泡排序

  • 选择排序

  • 快速

  • 插入

• 数组搜索相关技术

  • 二分搜素

  • 分块查找

  • 哈希表查找

4.1 冒泡排序：

1. 思想：

   1. 从头开始，两两排序，大小互换

   2. 每轮把当前数组最大元素，存到数组末尾

2. 实现步骤：

   1. 外部循环轮次（数组长度-1）

   2. 内部循环轮次，每轮次依次往后比较几个位置（数组长度-i-1）

   3. 前一个》后一个，二者交换

/**
         * 冒泡排序
         */
        int[] arr={6,8,7,3};
        //定义控制循环比较轮次
        for (int i = 0; i < arr.length-1; i++) {
            //0轮，比较3次，j=0 1 2
            //1轮，比较2次，j=0 1
            //2轮，比较1次，j=0
            for (int j = 0; j < arr.length-i-1 ; 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]);
        }
        System.out.println(Arrays.toString(arr));

5.数组的内存图

5.1 Java内存分配

• 栈（数据方法短暂地运行区域）

  • 栈内存：方法运行时进入的内存；变量也在这里

• 堆（数据停留较长时间的区域）

  • new出来东西，在此内存开辟空间并产生地址

  • 空间大，将new出大量数据存入

• 方法区

  • 字节码文件加载时进入的内存

• 本地方法栈

• 寄存器

5.2 Java内存分配流程：

1. 编译后运行，到main方法，放入方法区；

2. 方法，开辟栈内存空间，基本数据类型存入值，引用类型存入变量名；

3. new在栈内存中开辟空间，生成地址，存入数值，；

4. 根据从右向左运行的原理，将new生成的地址赋给变量；

5. 根据地址和空间内索引，赋值；

5.3两个变量指向同一数组

原理同上；将arr的地址赋给arr2；

        /**
         * 两个变量指向同一数组
         */
        int[] arr={6,8,7,3};
        int[] arr2=arr;
        System.out.println(arr);//[I@1b6d3586
        System.out.println(arr2);//[I@1b6d3586

        arr2[0]=1;
        System.out.println(arr[0]);//1

6.数组使用常见问题

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

ArrayIndexOutOfBoundsException（数组索引越界异常）

6.2数组变量中没存地址，null，访问

NullPointerException（空指针异常）