Java第六次学习笔记---数组（定义、遍历、内存图）

小西程序员之路

已于 2023-02-18 21:49:51 修改

阅读量566

点赞数

分类专栏： # Java基本语法学习文章标签： java

于 2022-04-24 22:01:37 首次发布

本文链接：https://blog.csdn.net/xiaoxixicc/article/details/124222375

版权

Java基本语法学习专栏收录该内容

24 篇文章 0 订阅

订阅专栏

一、数组

1.1数组定义

解释：看例子和数据的含义概念，我们可以理解到，格式如下：

数据类型数组的名字 = {数据内容}

数组定义与变量存储的优势：

学习数组，需要解决的问题：（学习思路）

1.2静态初始化数组

数组的基本原理：

解释：

1、实际上 = 是将数据的地址传递给了定义的变量，而且如果数据的首个数据的地址就能够获取得到后面其他数据的信息了。

2、地址的解释：[表示的是数组类型的地址；I表示的是整型的数据的地址；@表示在哪里；@后面的内容表示的是他十六位的地址。

3、引用类型：通过地址来寻找得到数据的一种形式。

1.2.1数组的访问

利用数组的地址信息能够找到第一个数据，再结合索引，就能够找到剩下其他的数据。

代码如下：

public class Arraytest2 {
    public static void main(String[] args){
        int[] scores = new int[]{12,1,13};
        //取值 数组名称【索引】
        System.out.println(scores[2]);
        System.out.println(scores[0]);
        System.out.println(scores[1]);

        //给存在的数组赋值 数组名称【索引】=数据；
        scores[2] = 100;
        System.out.println(scores[2]);

        //访问数组的长度大小 数组名称.length
        System.out.println(scores.length);


    }
}

1.2.2数组的注意事项

1.3动态初始化数组

定义：定义数组时，只确定元素的类型和数组的长度，之后在存入具体的数据。即定义时没有数值，不确定具体的数值。

用途：数据登记存储。

原理解释：同样和静态初始化类似，所定义的数组变量实际上在堆内存中是一个地址，再根据数组的长度进行填充或者修改。

如何赋值。

1、先定义动态数组

2、利用数组赋值即可。

该部分代码如下：

public class Arraytest3 {
    public static void main(String[] args){
        //1、定义动态数组
        double[] scores = new double[3];
        //2、给动态数组进行赋值处理
        scores[0] = 99.7;
        System.out.println(scores);//输出只是该数组变量的地址
        System.out.println(scores[0]);
        System.out.println(scores[1]);//未被赋值的数组，整型数组为0，字符型数组为null。

    }
}

输出结果：

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

1.5两种数组的定义的特点和场景区别

二、数组的遍历

代码如下：

public class Traverse {
    public static void main(String[] args){
        //原始遍历的方式-1
        int[] arry = {10,11,12,13,14,15};

        System.out.println(arry[0]);
        //使用循环进行遍历方式2---已知遍历的长度
        for(int i = 0;i > 5;i++){
            System.out.println(arry[i]);
        }
        //使用循环进行遍历方式3---未知遍历的长度
        for(int j = 0;j < arry.length;j++){
            System.out.println(arry[j]);
        }
    }
}

使用快捷键遍历的方式：

arry.fori //数组名.fori，回车后。。。。。。直接快捷键形成数组遍历
arry.sout//数组名.sout。 直接快捷键形成输出

三、数组的案例

3.1数组元素求和

代码如下：

public class Arraytest1 {
    public static void main(String[] args){
        //1、定义数组
        int[] arr ={16,32,35,67,89};
        //2、定义求和的变量
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
        //3、求和
            sum +=arr[i];
        }
        //4、求和结果输出
        System.out.println(sum);
    }
}

3.2数组中求最值

案例：

思路分析：

代码如下：

public class Arraytest2 {
    public static void main(String[] args){
        //1、定义一个静态的初始数组
        int[] facescores ={15,9000,10000,20000,-15};
        //2、定义一个最大值的变量，注意：尽量定义的最大值变量为数组第一个数值，避免我们所定义的最大值变量为最大值。例如 int max = 0；但是数组元素都是负数，最大值的结果就是为0了。
        int max = facescores[0];
        //3、数组元素的遍历
        for (int i = 0; i < facescores.length; i++) {
        //4、最大值的判断依据  
            if(facescores[i] > max){
                max = facescores[i];
            }
        }
        //5、最大值的输出
        System.out.println("最大的评分为："+max);
    }
}

3.3猜数字游戏

案例：

思路分析：

代码如下：


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

public class Arraytest3 {
    public static void main(String[] args){
        //1、定义一个动态的初试数组，由于数组未知。该数组用于结束随机数产生的数据
        int[] arr = new int[5];
        //2、产生随机的数据
        Random r = new Random();
        //3、对动态初始数组进行赋值
        for(int i = 0;i < 5;i++){
        arr[i] = r.nextInt(1,21);
            System.out.println(arr[i]);
        }
        //4、接收键盘输入的数据。注意：需要又结束的数据
    Scanner sc = new Scanner(System.in);
    out:
    //循环检测，测试数据
    while(true){
        System.out.println("请输入1-20之间的一个随机数字:");
        //5、添加扫描接收数据
        int guessData = sc.nextInt();
        //6、不断的循环检测5次数据，看输入的数据是否与随机产生的一致
        for (int i = 0; i < arr.length; i++) {
            if(guessData == arr[i]){
                System.out.println("恭喜您！猜对了，猜测数字的索引:"+i);
        //7、添加中断死循环的语句，与上面的out进行呼应，相当于设置了一个标志位。
                break out;
            }
        }
        //8、设置没有猜中的提示，并讲最终的结果发布出来。
        System.out.println("很遗憾，您没有猜中");
        for (int j = 0; j < arr.length; j++) {
            System.out.println("随机的数字为"+arr[j]);
        }
        }
    }
}

3.4随机排名

案例：

案例分析：

代码如下：

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

public class Arrytest3 {
    public static void main(String[] args){
        //1、定义动态初始数组
        int[] codes = new int[5];
        //2、扫描输入
        Scanner sc = new Scanner(System.in);
        //3、数组赋值处理
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请您输入"+(i+1)+"个员工的工号：");
            int code = sc.nextInt();
            codes[i] = code;
        }
        //4、随机输出，通过随机数组的索引，进而随机输入的数据
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            int index =r.nextInt(codes.length);
        //5、冒泡排序
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }
        //6、输出处理
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i]+"\t");//注意却别println和print之间的区别，println自身带有一个“\n”
        }
            }
}

3.5数组排序

代码如下：

public class Arraytest4 {
    public static void main(String[] args){
        //1、定义静态初始数组
        int[] arr = {5,2,1,3};
        //2、通过双循环进行执行检测
        //2-1、该部分是定义循环控制比较次数，两两之间进行对比，比较的次数一般是数组的元素个数-1.
        // for(int i = 1;i<=arr.length;i++)   该部分i是从1开始的，所以需要在判断的条件时添加上”=“。在第二次循环种，需要在j的基础上（arr.length-i）-1
        for (int i = 0; i <arr.length ; i++) {
            // i = 0 比较的次数有3次  j的取值为 0 1 2
            // i = 1 比较的次数有2次  j的取值为 0 1
            // i = 2 比较的次数有1次  j的取值为 0
            //j是循环控制比较次数循环的一个索引。
            //3、定义一个循环控制每轮比较次数，占位
            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;
                }
            }
        }
        System.out.println("排列顺序：");
        for (int i= 0; i< arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

注意：在定义一个循环，循环的变量为i，不能在该循环内部再用该变量作为变量参与。

错误代码如下所示：已经定义i变量了，不能再其循环的内部再使用该变量i了。

        for (int i = 0; i <arr.length ; i++) {
            System.out.println("排列顺序：");
            for (int i= 0; i< arr.length; i++) {
                System.out.print(arr[i] + "\t");
        }

总结：

四、数组的内存图

数组如何的工作

4.1Java内存分配、数组内存图

Java内存分配介绍共有五个分配的区域。

方法区：放Class文件

栈内存：比如数main以及其涉及到的变量都会放在这个栈内存当中。运行的方法，main方法，定义的变量。

堆内存：new出来的对象

举例说明：

int a:定义了一个整型的。只是涉及到方法区和栈内存两个部分。

第一步：类变成class文件，并放到在方法区内。

第二步：然后将main文件提取到栈内存中。在堆内存中为变量a开辟一个空的区域，本案例中，a变量开辟的区域被赋予了数据10。对于非引用类型的数据，数据内容会在该部分被分配。

int[ ] arr:定义的是一个数组，数组是引用类型的数据，涉及到三部分，方法区、栈内存以及堆内存。

第一步：同样，类变成class文件，并放到在方法区内。

第二步：在堆内存中开辟数组名的空间区域，此时并没有数据。此时是执行的int[ ] arr={ }，等号左边的内容赋予数组名的空区域。也就是该空区域被赋予了存储数据的堆内存的地址。

第三步：第二步执行完毕后，执行等号右边的new部分，new出来了一个对象，该部分则放到堆内存当中。在堆内存里面开辟一个数组的空间，由索引的长度构建几个区域。第一个数据（起始位置）的地址会赋予给栈内存为数组创建的空区域中。

4.2 两个向量指向同一个数组

内容解释：实际上是定义了一个数组变量，将该数组变量重新赋值给另外一个数组变量，其实实际上是地址的传送。两者实质上是同一个内容数据。

实质上将arr1的起始数据的地址赋予给了arr2。经过测试发现，两个向量指向同一个数据，结果这两个向量是一样的。

作用：将一个数组转递给另外一个数组。两者之间可以相互操作，通过地址进行两个数组内部数据的修改。

代码如下：

public class ArrayDemo2 {
    public static void main(String[] args){
        int arr1[] ={11,22,33};
        int arr2[] = arr1;
        System.out.println(arr2[1]);

        arr2[2] = 99;

        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + "\t");
            System.out.println();

        }
        System.out.println("arr2输出:");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);

        }

    }
}

内容解释：

第一步：将class文件导入到方法区

第二步：在栈内存的区域加载main，并在栈内存中开辟了数组变量arr1和arr2，此时是没有数据内容。但是开辟的空间被赋予了起始数据的地址。

第三步：在堆内存中开辟数据，起始位置和终点位置。

4.3数组使用常见的问题

问题一：数组内的元素越界问题

问题二：

自己定义数组变量名称为null，也就是将其数组变量的地址设置为null，会出现报错问题。

注意：查看定义的数组变量地址后，是能够正常的输出来的。但是调用该数组的其他内容，则会出现报错的问题。不能访问数组其他内容的功能。

输出结果：

4.4Debug工具的使用

作用：调试代码，检查代码，观察代码的流程，定位程序bug错误代码位置的作用。可以一行一行的调试代码。

如果已经检查完代码，想快速结束，可以点击这个按钮进行完成Debug。

小西程序员之路

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Java第六次学习笔记---数组（定义、遍历、内存图）

一、数组解释：看例子和数据的含义概念，我们可以理解到，格式如下：数据类型数组的名字 = {数据内容}数组定义与变量存储的优势：学习数组，需要解决的问题：（学习思路）...
复制链接

扫一扫

专栏目录