java--数组
一.随机数
我们在分析需求的过程中，我们往往会需要用到随机数，我们来看看java中生成随机数的过程
java中随机数的一些简介：
/* 作用： 用于产生一个随机数 使用步骤(和Scanner类似) 1.导包 import java.util.Random; 2.创建对象 Random r = new Random(); 3.获取随机数 int number = r.nextInt(10); ps: 产生的数据在0到10之间，包括0，不包括10。 括号里面的10是可以变化的，如果是100，就是0-100之间的数据 */
示例代码：
package com.it_01; 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 */ public class RandomDemo { public static void main(String[] args){ //创建一个对象 Random r = new Random(); //获取1-10之间的随机数 for(int i=1;i<=10;i++){ //获取随机数 int number = r.nextInt(11); System.out.println("number:"+number); } System.out.println("-----------------"); //获取1-100之间的随机数 for(int i=1;i<=10;i++){ //获取随机数 int number1 = r.nextInt(101); System.out.println("number:"+number1); } } }
二.数组
数组的介绍与基本使用
/* 一:数组概述 需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。 假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资， 然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。 那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话： 1.数组是存储多个变量(元素)的东西(容器) 2.这多个变量的数据类型要一致 二:数组概念 1.数组是存储同一种数据类型多个元素的容器。 2.数组既可以存储基本数据类型，也可以存储引用数据类型。 数组的定义格式 格式1：数据类型[] 数组名; 格式2：数据类型 数组名[]; 注意：这两种定义做完了，数组中是没有元素值的。 三:数组初始化概述： Java中的数组必须先初始化,然后才能使用。 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。 数组的初始化方式 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。 四:动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。 格式：数据类型[] 数组名 = new 数据类型[数组长度]; 数组长度其实就是数组中元素的个数。 举例： int[] arr = new int[3]; 解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值 */
示例代码：
package com.it_01; /* * 数组：存储同一种数据类型的多个元素的容器。 * * 定义格式： * A:数据类型[] 数组名; (推荐的方式) * B:数据类型 数组名[]; * * 举例: * int[] arr; 定义了一个int类型的数组,数组名是arr * int arr[]; 定义了一个int类型的变量,变量名是arr数组 * * 数组初始化： * 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:数组的长度,其实就是数组中的元素个数 */ //输出数组名 System.out.println("arr:"+arr); //[I@104c575 //我们获取数组的地址值是没有意义的,我要的是数组中的元素值,该怎么办呢? //不用担心,Java已经帮你想好了这个问题 //其实数组中的每个元素都是有编号的,编号从0开始,最大的编号是数组的长度-1 //通过数组名和编号的配合使用我们就可以获取指定编号的元素值 //这个编号的专业叫法：索引 //访问格式：数组名[索引] System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
内存图解：
示例代码二：
package com.it_01; public class ArrayDemo02 { 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]); System.out.println("---------------------"); //给数组中的元素赋值 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]); } }
内存图解：
示例代码二的输出结果：
/* [I@7852e922 0 0 0 --------------------- [I@7852e922 100 0 200 从结果中我们可以看出：数组的内存地址没有发生变化，但是数组中的值已经发生变化了 */
示例代码三：
package com.it_01; public class ArrayDemo03 { 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]); System.out.println("--------------------"); //然后分别给数组中的元素赋值 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]); } }
内存图解：
上述代码的结果：
/* [I@7852e922 0 0 [I@4e25154f 0 0 0 -------------------- [I@7852e922 0 100 [I@4e25154f 200 0 300 从上述结果中，我们可以看出，同时定义多个数组，修改其中的值后，数组的内存地址也是不会发生变化的 */
示例代码四：
package com.it_01; public class ArrayDemo04 { 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]); System.out.println("--------------------------"); //然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。 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("--------------------------"); System.out.println(arr2); System.out.println(arr2[0]); System.out.println(arr2[1]); System.out.println(arr2[2]); } }
内存图解：
上述代码的结果：
package com.it_01; /* * 定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。 * 然后给第二个数组赋值，再次输出两个数组的名及元素。 */ public class ArrayDemo04 { 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]); System.out.println("--------------------------"); //然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。 int[] arr2 = arr; //给第二个数组赋值 // arr[0] = 111; // arr[1] = 222; // arr[2] = 333; 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("--------------------------"); System.out.println(arr2); System.out.println(arr2[0]); System.out.println(arr2[1]); System.out.println(arr2[2]); } }
上述代码是结果：
/* [I@7852e922 100 200 300 -------------------------- [I@7852e922 111 222 333 -------------------------- [I@7852e922 111 222 333 从结果中我们可以得出：当把一个数组的值赋值给另外一个数组的时候，当一个数组中的值发生变化，另外一个数组中的值也会发生相应的变化， */
2.静态初始化
package com.it_02; /* * 静态初始化的格式： * 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...}; * * 举例： * int[] arr = new int[]{1,2,3}; * * 简化格式： * 数据类型[] 数组名 = {元素1,元素2,元素3,...}; * int[] arr = {1,2,3}; */ public class ArrayDemo { public static void main(String[] args) { int [] arr = {1,2,3}; System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
内存图解：
3.数组中常见的两个问题
package com.it_02; /* * 两个常见小问题： * ArrayIndexOutOfBoundsException:数组索引越界异常 * 产生的原因：我们访问了不存在的索引 * * NullPointerException:空指针异常 * 产生的原因：数组已经不在指向堆内存的数据了，你还使用数组名去访问元素 */ public class ArrayDemo02 { public static void main(String[] args) { //定义数组 int[] arr = {1,2,3}; //访问数组元素 // System.out.println(arr[3]); 超出索引 //引用类型：类,接口,数组 //常量：空常量,null,是可以赋值给引用类型的 arr = null; System.out.println(arr[1]); //数组的数据的指向发生了变化 } }
内存图解：
4.遍历数组的中的元素
package com.it_02; public class ArrayDemo06 { public static void main(String[] args) { //定义一个数组 int [] arr = {1,2,3}; //arr.length是一个属性，获取数组的长度 for(int i = 0;i<arr.length;i++) { System.out.println(arr[i]); } } }
5.求数组中的最值问题
package com.it_02; /* * 需求：求数组中最大是元素 * * 解题思路： * 1.先找到一个参照物，把数组中的每一个元素和这个参照物进行对比 * 2.选择参照物：只能是数组中存在的元素，我们通常选择第一个元素作为参照物 * * */ public class ArrayDemo08 { public static void main(String[] args) { //定义一个数组 int [] arr = {22,35,11,13,63,36,92,100}; // 选择参照物 int max = arr[0]; //循环遍历数组中的 for(int i = 0;i<arr.length;i++) { if(max<arr[i]) { max = arr[i]; } } System.out.println(max); } }
三.java中数组的内存问题
Java内存分配主要包括以下几个区域:
- 1. 寄存器：我们在程序中无法控制（给cpu使用的）
- 2. 栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
- 3. 堆：存放用new产生的数据
- 4. 静态域：存放在对象中用static定义的静态成员
- 5. 常量池：存放常量
- 6. 非RAM(随机存取存储器)存储：硬盘等永久存储空间
Java内存分配中的栈
在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
Java内存分配中的堆
堆内存用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
在堆中产生了一个数组或对象后，还可以 在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。
引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍 然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因。
实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！
java内存栈和堆的图解：
四.二维数组相关问题
1.二维数组的定义以及相关介绍：
/* * 二维数组：其实就是元素为一维数组的数组。 * * 定义格式： * A:数据类型[][] 数组名; (推荐的方式) * B:数据类型 数组名[][]; * C:数据类型[] 数组名[]; * 初始化： * A:动态初始化 * 数据类型[][] 数组名 = new 数据类型[m][n]; * m表示的是二维数组中一维数组的个数 * n表示的是一维数组中的元素个数 * B:静态初始化 * 数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...}; * 简化格式： * 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...}; * * 二维数组名配合索引可以获取到每一个一维数组。 * 每一个一维数组配合索引名可以获取到数组中的元素。 * * 假如我有一个二维数组：arr。 * 我要从中获取一维数组：arr[索引] * 我要从中获取二维数组的元素：arr[索引][索引] */
示例代码：
package com.it_03; public class myTwoArray { public static void main(String[] args) { //定义一个二维数组:数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...}; int [][] arr = {{1,2,3},{4,5,6},{7,8,9},}; //获取二维数组的地址 System.out.println(arr); //[[I@7852e922 //获取二维数组中一维数组的名称 System.out.println(arr[0]); //[I@4e25154f System.out.println(arr[1]); //[I@70dea4e System.out.println(arr[2]); //[I@5c647e05 //获取一维数组中元素 System.out.println(arr[0][0]); //1 System.out.println(arr[0][1]); //2 System.out.println(arr[0][2]); //3 } }
2.循环遍历二维数组中元素：
package com.it_03; /* * 二维数组的遍历 * * System.out.println():输出内容,并换行 * System.out.print():输出内容 */ public class myTwoArray02 { public static void main(String[] args) { //定义一个数组 int [][] arr = {{1,2,3},{4,5,6},{7,8,9},}; for(int x=0;x<arr.length;x++) { for(int y = 0;y<arr[x].length;y++) { //这个是一行只打印一个元素 // System.out.println(arr[x][y]); //把一个一维数组中的所有元素打印到一行中 System.out.print(arr[x][y]+" "); } System.out.println(); //加上一个空行 } } }
3.找出二维数组中的最值问题
package com.it_03; /* * 需求：求数组中最大是元素 * * 解题思路： * 1.先找到一个参照物，把数组中的每一个元素和这个参照物进行对比 * 2.选择参照物：只能是数组中存在的元素，我们通常选择第一个元素作为参照物 * * */ public class myTwoArray03 { public static void main(String[] args) { //定义一个数组 int [][] arr = {{1,2,3},{4,5,6},{7,8,9},}; //定义一个参照物 int max = arr[0][0]; for(int x=0;x<arr.length;x++) { for(int y = 0;y<arr[x].length;y++) { if(max<arr[x][y]) { max =arr[x][y]; } } } System.out.println(max); } }
浙公网安备 33010602011771号