java基础学习之Java数组（第四课），养成良好编程习惯很重要

最新推荐文章于 2025-07-04 12:26:30 发布

原创最新推荐文章于 2025-07-04 12:26:30 发布 · 472 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java基础学习 #java数组 #一维数组与二维数组 #栈与堆的图解

Java 专栏收录该内容

54 篇文章

订阅专栏

本文详细介绍Java中数组的使用，包括一维数组与二维数组的定义、初始化、访问及遍历方法。同时，深入讲解如何利用Random类生成随机数，提供实际应用场景如猜数字小游戏的代码示例。

java数组
步骤：1.1.1 Random的使用步骤
我们想产生1~100(包含1和100)的随机数该怎么办呢? 我们不需要自己去写算法,因为Java已经为我们提供好了产生随机数的类—Random:
作用：
– 用于产生一个随机数
• 使用步骤(和Scanner类似)
– 导包
• import java.util.Random;
– 创建对象
• Random r = new Random();
– 获取随机数
• int number = r.nextInt(10);
• 产生的数据在0到10之间，包括0，不包括10。
• 括号里面的10是可以变化的，如果是100，就是0-100之间的数据
举例：

   package com.itheima;
    import java.util.Random;
    
    /*
     * Random:用于产生随机数
     * 
     * 使用步骤：
     * 		A:导包
     * 			import java.util.Random
     * 		B:创建对象
     * 			Random r = new Random();
     * 		C:获取随机数
     * 			int number = r.nextInt(10);
     * 			获取的是0-10之间的随机数，包括0，不包括10
     * 
     * 需求：如何获取到一个1-100之间的随机数呢?
     */
    public class RandomDemo {
    	public static void main(String[] args) {
    		// 创建对象
    		Random r = new Random();
    
    		for (int x = 0; x < 10; x++) {
    			// 获取随机数是0~9之间的随机数
    			int number = r.nextInt(10);
    			// 输出随机数
    			System.out.println("number:" + number);
    		}
    		System.out.println("--------------------");
    
    		// 如何获取到一个1-100之间的随机数呢?
    		int i = r.nextInt(100) + 1;
    		System.out.println("i:" + i);
    	}
    }

人性化小游戏：

  package shuzu;
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class shuz {
    	public static void main(String[] args) {
    		//获取0~100之间的随机数
    		Random r = new Random();
    		//获取随机数
    		int number = r.nextInt(100)+1;
    		int n = 0;
    		while(n < 10) {
    			System.out.println(number);
    			//键盘录入我们要猜的随机数
    			Scanner sc = new Scanner(System.in); 
    			//接收数据
    			System.out.print("请输入你要猜的数据（1-100）：");
    			int guessNumber = sc.nextInt();
    			//比较这两个数据，用if语句实现
    			if(guessNumber > number) {
    				System.out.println("你猜的数据"+guessNumber+"太大了！");
    			}else if(guessNumber < number) {
    				System.out.println("你猜的数据"+guessNumber+"太小了！");
    			}else {
    				System.out.println("恭喜你，猜对了！");
    				break;
    			}
    			n++;
    		}
    		System.out.println("游戏结束（game over）！");
    	}
    
    }

数组概述
需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。
那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致

数组的定义格式
数组概念
数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组的定义格式
格式1：数据类型[] 数组名;
int[] arr;定义一个int类型的数组，数组名是arr（推荐使用格式）
int arr[]；定义一个int类型的变量，变量名是arr
格式2：数据类型数组名[];
注意：这两种定义做完了，数组中是没有元素内容，仅仅是声明了一下。
数组的初始化
数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
a、静态初始化
初始化时指定每个数组元素的初始值，由系统决定数组长度
b、动态初始化:
初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
举例：

  package com.itheima_01;
    /*
     * 数组：存储同一种数据类型的多个元素的容器。
     * 
     * 定义格式：
     * 		A:数据类型[] 数组名;
     * 		B:数据类型 数组名[];
     * 举例：
     * 		A:int[] a; 定义一个int类型的数组，数组名是a
     * 		B:int a[]; 定义一个int类型的变量，变量名是a数组
     * 
     * 数组初始化：
     * 		A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
     * 		B:我们有两种方式对数组进行初始化
     * 			a:动态初始化	只指定长度，由系统给出初始化值
     * 			b:静态初始化	给出初始化值，由系统决定长度
     * 
     * 动态初始化：
     * 		数据类型[] 数组名 = new 数据类型[数组长度];
     */
    public class ArrayDemo {
    	public static void main(String[] args) {
    		//数据类型[] 数组名 = new 数据类型[数组长度];
    		int[] arr = new int[3];
    		/*
    		 * 左边：
    		 * 		int:说明数组中的元素的数据类型是int类型
    		 * 		[]:说明这是一个数组
    		 * 		arr:是数组的名称
    		 * 右边：
    		 * 		new:为数组分配内存空间
    		 * 		int:说明数组中的元素的数据类型是int类型
    		 * 		[]:说明这是一个数组
    		 * 		3:数组的长度，其实就是数组中的元素个数
    		 */
    	
    	}
    }

举例：

   package shuzu;
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class shuz {
    	public static void main(String[] args) {
    		int[] arr = new int[3];
    		System.out.println("arr:"+arr);
    		//此处获取的是数组的地址值，没有意义
    		//其实数组中的每个元素都是有编号的，编号从0开始，最大的编号是数组的长度
    		//这个编号的专业叫法为索引
    		//访问格式，数组名[索引]
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

此处需要了解java中的内存分配：
JVM内存划分
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈（重点）
A、存储的是局部变量
B、局部变量就是定义在方法中的变量
C、使用完毕立即回收

堆（重点）
存储new出来的东西，又称实体，对象，
A、每一个对象都会有地址值
B、每一个对象的数据都有默认值
byte
short
int
long 0
float
double 0.0
char ‘\u0000’
boolean false
引用类型 null
C、使用完毕后，会在垃圾回收器空闲的时候回收
方法区 (面向对象进阶讲)（目前不需要掌握）
本地方法区 (和系统相关)（目前不需要掌握）
寄存器 (给CPU使用)（目前不需要掌握）
在这里插入图片描述
一个数组的内存图
定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素
举例：

 package com.itheima_01;
    /*
     * 需求：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
     */
    public class ArrayTest {
    	public static void main(String[] args) {
    		//定义一个数组
    		int[] arr = new int[3];
    		
    		//输出数组名及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		
    		//给数组中的元素赋值
    		arr[0] = 100;
    		arr[2] = 200;
    		
    		//再次输出数组名及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

代码内从图解：
在这里插入图片描述 两个数组的内存图
定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素
举例：

   package com.itheima_01;
    /*
     * 需求：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
     */
    public class ArrayTest2 {
    	public static void main(String[] args) {
    		//定义两个数组
    		int[] arr = new int[2];
    		int[] arr2 = new int[3];
    		
    		//分别输出数组名及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    		
    		//然后分别给数组中的元素赋值
    		arr[1] = 100;
    		
    		arr2[0] = 200;
    		arr2[2] = 300;
    		
    		//再次输出数组名及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    	}
    }

代码内存图解：
在这里插入图片描述 两个数组指向同一个地址的内存图
定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素
举例：

   /*
     * 需求：定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
     * 然后给第二个数组赋值，再次输出两个数组的名及元素。
     */
    public class ArrayTest3 {
    	public static void main(String[] args) {
    		// 先定义一个数组，赋值，输出
    		int[] arr = new int[3];
    		arr[0] = 100;
    		arr[1] = 200;
    		arr[2] = 300;
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    
    		// 然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组
    		int[] arr2 = arr;
    		// 然后给第二个数组赋值
    		arr2[0] = 111;
    		arr2[1] = 222;
    		arr2[2] = 333;
    
    		// 再次输出两个数组的名及元素
    		System.out.println(arr);
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    
    		System.out.println(arr2);
    		System.out.println(arr2[0]);
    		System.out.println(arr2[1]);
    		System.out.println(arr2[2]);
    	}
    }

代码内存图解：
在这里插入图片描述 数组的使用
数组的元素访问：
举例：

 package com.itheima_01;
    /*
     * 数组：存储同一种数据类型的多个元素的容器。
     * 
     * 定义格式：
     * 		A:数据类型[] 数组名;
     * 		B:数据类型 数组名[];
     * 举例：
     * 		A:int[] a; 定义一个int类型的数组，数组名是a
     * 		B:int a[]; 定义一个int类型的变量，变量名是a数组
     * 
     * 数组初始化：
     * 		A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
     * 		B:我们有两种方式对数组进行初始化
     * 			a:动态初始化	只指定长度，由系统给出初始化值
     * 			b:静态初始化	给出初始化值，由系统决定长度
     * 格式：
     * 数据类型[] 数组名= new 数据类型[{元素1，元素2，元素3，元素4.。。。}
     * 简化格式：
     * 数据类型[] 数组名= {元素1.元素2，元素3.。。}
     * 
     * 动态初始化：
     * 		数据类型[] 数组名 = new 数据类型[数组长度];
     */
    public class ArrayDemo {
    	public static void main(String[] args) {
    		//数据类型[] 数组名 = new 数据类型[数组长度];
    		int[] arr = new int[3];
    		/*
    		 * 左边：
    		 * 		int:说明数组中的元素的数据类型是int类型
    		 * 		[]:说明这是一个数组
    		 * 		arr:是数组的名称
    		 * 右边：
    		 * 		new:为数组分配内存空间
    		 * 		int:说明数组中的元素的数据类型是int类型
    		 * 		[]:说明这是一个数组
    		 * 		3:数组的长度，其实就是数组中的元素个数
    		 */`
    		
    		System.out.println(arr); //[I@3fa5ac,地址值
    		//我们获取到地址值没有意义，我要的是数组中的数据值，该怎么办呢?
    		//不用担心，java已经帮你想好了
    		//其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是数组的长度-1
    		//用数组名和编号的配合我们就可以获取数组中的指定编号的元素
    		//这个编号的专业叫法：索引
    		//格式：数组名[编号] -- 数组名[索引]
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    	}
    }

注意：
a、切记数组访问越界的问题，产生的原因是访问了不存在的缩影
b、空指针异常，产生原因是数组已经不在指向堆内存的数据了，你还在使用数组名去访问元素
数组的练习：
一维数组遍历

  package com.itheima_03;
    
    /*
     * 需求：数组遍历(依次输出数组中的每一个元素)
     * 获取数组中元素的个数：数组名.length
     */
    public class ArrayTest {
    	public static void main(String[] args) {
    		// 定义数组
    		int[] arr = { 11, 22, 33, 44, 55 };
    		// 原始做法
    		System.out.println(arr[0]);
    		System.out.println(arr[1]);
    		System.out.println(arr[2]);
    		System.out.println(arr[3]);
    		System.out.println(arr[4]);
    		System.out.println("--------------------");
    
    		// 用for循环改进
    		for (int x = 0; x < 5; x++) {
    			System.out.println(arr[x]);
    		}
    		System.out.println("--------------------");
    		
    		//为了解决我们去数数组中元素个数的问题，数组就提供了一个属性：length
    		//用于获取数组的长度
    		//格式：数组名.length
    		System.out.println("数组共有："+arr.length+"个");
    		System.out.println("--------------------");
    		
    		for(int x=0; x<arr.length; x++) {
    			System.out.println(arr[x]);
    		}
    	}
    }

数组操作之获取最值:
在这里插入图片描述举例：

 package com.itheima_03;
    /*
     * 需求：数组获取最值(获取数组中的最大值最小值)
     */
    public class ArrayTest2 {
    	public static void main(String[] args) {
    		//定义数组
    		int[] arr = {12,98,45,73,60};
    		
    		//定义参照物
    		int max = arr[0];
    		
    		//遍历数组，获取除了0以外的所有元素，进行比较
    		for(int x=1; x<arr.length; x++) {
    			if(arr[x] > max) {
    				max = arr[x];
    			}
    		}
    		System.out.println("数组中的最大值是："+max);
    	}
    }

最小值由自己来进行练习
**二维数组：**
**二维数组概述**

我们黑马程序员的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。
由此可见：其实二维数组其实就是一个元素为一维数组的数组。
定义格式
数据类型[][] 数组名;
数据类型数组名[][]; 不推荐
数据类型[] 数组名[]; 不推荐
初始化方式
动态初始化：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示的是二维数组中一维数组的个数
n表示的是一维数组中的元素个数
静态初始化：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：

  package com.itheima_04;
    
    /*
     * 二维数组：就是元素为一维数组的数组。
     * 
     * 定义格式：
     * 		A:数据类型[][] 数组名;
     * 		B:数据类型 数组名[][];	不推荐
     * 		C:数据类型[] 数组名[];	不推荐
     * 
     * 如何初始化呢?
     * 		A:动态初始化
     * 			数据类型[][] 数组名 = new 数据类型[m][n];
     * 			m表示这个二维数组有多少个一维数组
     * 			n表示每一个一维数组的元素有多少个
     * 		B:静态初始化
     * 	      数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
     * 			简化格式：
     * 			数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
     */
    public class ArrayArrayDemo {
    	public static void main(String[] args) {
    		// 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
    		int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    
    		System.out.println(arr); // [[I@104c575
    		System.out.println(arr.length); // 二维数组中的一维数组的个数
    		System.out.println(arr[0]);// [I@3fa5ac
    		System.out.println(arr[0].length);
    		System.out.println(arr[1]);// [I@95cfbe
    		System.out.println(arr[2]);// [I@179dce4
    		
    		//我如何获取到一个二维数组的元素呢?
    		System.out.println(arr[0][0]);
    		System.out.println(arr[1][1]);
    		System.out.println(arr[2][0]);
    	}
    }

二维数组的遍历
遍历思想:首先使用循环遍历出二维数组中存储的每个一维数组,然后针对每个遍历到的一维数组在使用循环遍历该一维数组中的元素
举例：

  package com.itheima_04;
    
    /*
     * 二维数组遍历
     * 
     * System.out.println():输出内容并换行
     * System.out.print():输出内容
     * System.out.println():换行
     */
    public class ArrayArrayTest {
    	public static void main(String[] args) {
    		// 定义二维数组
    		int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    
    		// 二维数组中的一维数组名称：二维数组名[索引]
    		// arr[0] 其实就是二维数组中的第一个一维数组的名称
    		// arr[1] 其实就是二维数组中的第二个一维数组的名称
    		// arr[2] 其实就是二维数组中的第三个一维数组的名称
    
    		// for (int x = 0; x < arr[0].length; x++) {
    		// System.out.println(arr[0][x]);
    		// }
    
    		// System.out.println("hello");
    		// System.out.println("world");
    		// System.out.print("hello");
    		// System.out.print("world");
    
    		/*
    		// 第一个一维数组的元素
    		for (int x = 0; x < arr[0].length; x++) {
    			System.out.print(arr[0][x] + "  ");
    		}
    		System.out.println();
    
    		// 第二个一维数组的元素
    		for (int x = 0; x < arr[1].length; x++) {
    			System.out.print(arr[1][x] + "  ");
    		}
    		System.out.println();
    
    		// 第三个一维数组的元素
    		for (int x = 0; x < arr[2].length; x++) {
    			System.out.print(arr[2][x] + "  ");
    		}
    		System.out.println();
    		*/
    		
    //		for(int y=0; y<3; y++) {
    //			for (int x = 0; x < arr[y].length; x++) {
    //				System.out.print(arr[y][x] + "  ");
    //			}
    //			System.out.println();
    //		}
    		
    		for(int y=0; y<arr.length; y++) {
    			for (int x = 0; x < arr[y].length; x++) {
    				System.out.print(arr[y][x] + "  ");
    			}
    			System.out.println();
    		}
    
    	}
    }

java第三课课后练习
1. 【应用】理解Random与一维数组介绍
a. 【记忆】能够阐述Random类的概述和基本使用
b. 【应用】能够独立编写猜数字小游戏案例

c. 【记忆】能够阐述数组概述和定义格式
d. 【应用】能够独立写出数组初始化之动态初始化

e. 【应用】能够独立写出数组中元素的访问

2. 【理解】一维数组内存结构及静态初始化
a. 【记忆】能够阐述Java中的内存划分哪几块区域
b. 【理解】能够根据代码阐述一个数组在内存中的分布图
c. 【理解】能够根据代码阐述两个数组在内存中的分布图
d. 【理解】能够根据代码阐述两个数组指向同一个地址值的内存图
e. 【应用】能够独立写出数组初始化之静态初始化

3. 【应用】一维数组常见问题及练习

a. 【应用】能够独立写出数组操作的两个常见小问题的代码

b. 【应用】能够独立编写数组操作之遍历数组的代码

c. 【应用】能够独立编写数组操作之获取最值的代码

4. 【理解】二维数组的定义和使用
d. 【理解】能够阐述二维数组的概述和基本使用
e. 【应用】能够独立编写二维数组遍历代码