Random类
这个Random类，它可以产生多种数据类型的随机数，在这里我们主要介绍生成整数与小数的方式。
查看类
- java.util.Random ：该类需要 import导入使后使用。
查看构造方法
- public Random() ：创建一个新的随机数生成器。
查看成员方法
- public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
- public double nextDouble() 产生[0,1)范围的随机小数，包含0.0，不包含1.0。
猜数字小游戏
- 游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与 number 作比较，系统提示大了或者小了，直到玩家猜中，游戏结束。
import java.util.Random; // 导包 import java.util.Scanner; public class DemoRandom { public static void main(String[] args) { // 系统产生一个随机数1‐100之间的。 Random r = new Random(); int number = r.nextInt(100) + 1; Scanner sc = new Scanner(System.in); while (true) { // 键盘录入我们要猜的数据 System.out.println("请输入你要猜的数字(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; } } } }
数组
概念：数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。简单来说数组就是一个容器。将多个数据存储到一起，每个数据称为该容器的元素。生活中的容器：水杯，衣柜，教室。数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组的特点
- 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
- 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
- 数组的长度一旦确定，就不能修改。
- 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
- 数组的分类： 按照维度：一维数组、二维数组、三维数组、… 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)
数组的初始化
- 在内存当中创建一个数组，并且向其中赋予一些默认值。
两种常见的初始化方式：
- 动态初始化（指定长度）：数组声明且为数组元素分配空间与赋值的操作分开进行
- 静态初始化（指定内容）：在定义数组的同时就为数组元素分配空间并赋值。
数组的定义
方式一：动态初始化数组
格式：
- 数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[长度];
格式详解：
- 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
- [ ] : 表示数组。
- 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
- new：关键字，创建数组使用的关键字。
- 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
- [长度]： 数组的长度，表示数组容器中可以存储多少个元素。
注意：
扫描二维码关注公众号，回复：
11140273 查看本文章
- 数组有定长特性，长度一旦指定，不可更改。 和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
举例：
//定义可以存储3个整数的数组容器 int[] array1 = new int[3]; //定义可以存储6个double的数组容器 double array2[] = new double[6];
一维数组的使用
索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。格式：数组名[数组元素下标]
- 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
- 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数 组的最大索引值为 数组名.length-1 。
总结一下：
- 为数组中的元素赋值 格式：数组名[索引]=数值
- 获取出数组中的元素 格式：变量=数组名[索引]
- 获取数组元素的个数 格式：数组名.length
代码示例
package com.wrg; public class ArrayDemo01 { public static void main(String[] args) { //定义可以存储3个整数的数组容器 int[] array1 = new int[3]; //定义可以存储6个double的数组容器 double array2[] = new double[6]; System.out.println(array1);//[I@880ec60 System.out.println(array2);//[D@3f3afe78 // 直接打印数组当中的元素 System.out.println(array1[0]); // 0 System.out.println(array1[1]); // 0 System.out.println(array2[2]); // 0.0 // 也可以将数组当中的某一个单个元素，赋值交给变量 double num = array2[1]; System.out.println(num); // 0.0 } }
数组的默认值
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式 初始化。简而言之：数组创建之后系统就会给它分配一个默认值。不同类型的数组有不同的默认值，如下图所示：
数组原理内存图
内存概述：内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。 Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
Java虚拟机的内存划分
- 为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
JVM的内存划分：
每个区域的具体作用如下所示
单个数组的内存图
方式二：静态初始化基本格式
格式：
- 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
示例：
//定义存储1，2，3，4，5整数的数组容器。 int[] array = new int[]{1,2,3,4,5};
注意事项：
- 虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。
方式三：静态初始化数组的省略格式
格式：
- 数据类型[] 数组名 = {元素1,元素2,元素3...};
//定义存储1，2，3，4，5整数的数组容器 int[] array1 = {1,2,3,4,5};
注意事项：
- 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
- 静态初始化标准格式可以拆分成为两个步骤。
- 动态初始化也可以拆分成为两个步骤。
- 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。
使用建议：
- 如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
代码演示
public class DemoArrayNotice { public static void main(String[] args) { // 省略格式的静态初始化 int[] arrayA = {10, 20, 30}; // 静态初始化的标准格式，可以拆分成为两个步骤 int[] arrayB; arrayB = new int[]{11, 21, 31}; // 动态初始化也可以拆分成为两个步骤 int[] arrayC; arrayC = new int[5]; // 静态初始化的省略格式，不能拆分成为两个步骤。 // int[] arrayD; // arrayD = { 10, 20, 30 }; } }
数组操作的两个常见小问题
- 索引越界异常:我们访问l 数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一 旦出现了，就必须要修改我们编写的代码。
示例：
int[] arr = {1,2,3}; System.out.println(arr[3]);
- 数组空指针异常：arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候 会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修 改我们编写的代码。
示例：
int[] arr = {1,2,3}; arr = null; System.out.println(arr[0]);
多维数组的使用
- Java 语言里提供了支持多维数组的语法。
- 对于二维数组的理解，我们可以看成是一维数组 array1又作为另一个一维数组array2的元素而存 在。其实，从数组底层的运行机制来看，其实没有多维数组。
定义二维数组的方式
格式1：
- （动态初始化）：数据类型[ ] [ ] 数组名称 = new 数据类型[ 二维数组中一维数组的个数][ 一维数组中元素的个数]；
示例：
package demo02; public class Demo01ArrayOne { public static void main(String[] args) { /* 定义了名称为arr的二维数组 二维数组中有3个一维数组 每一个一维数组中有2个元素 一维数组的名称分别为arr[0], arr[1], arr[2] */ int[][] arr = new int[3][2]; // 给第一个一维数组1脚标位赋值为78： arr[0][1] = 78; } }
格式2：
- （动态初始化）：数据类型[ ] [ ] 数组名称 = new 数据类型[ 二维数组中一维数组的个数][ ]；
示例：
package demo02; public class Demo02ArrayTwo { public static void main(String[] args) { /* 二维数组中有3个一维数组。 每个一维数组都是默认初始化值null (注意：区别于格式1） 注：int[][]arr = new int[][3]; //非法 */ int[][] arr = new int[3][]; //对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2]; } }
格式3：
- （静态初始化）：数据类型[ ] [ ] 数组名称 = new 数据类型[ ][ ]{{具体的元素},{具体的元素},{具体的元素}};
示例：
package demo02; public class Demo03ArraySame { public static void main(String[] args) { /* 定义一个名称为arr的二维数组，二维数组中有三个一维数组 每一个一维数组中具体元素也都已初始化 */ int[][] arr = new int[][]{{3, 8, 2}, {2, 7}, {9, 0, 1, 6}}; //第一个一维数组 arr[0] = new int[]{3, 8, 2}; //第二个一维数组 arr[1] = new int[]{2, 7}; //第三个一维数组 arr[2] = new int[]{9, 0, 1, 6}; //第三个一维数组的长度表示方式 int length = arr[2].length; System.out.println(length);//4 } }
遍历一维数组
package demo03; /* 遍历数组，说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出。 */ public class Demo04Array { public static void main(String[] args) { int[] array = { 15, 25, 30, 40, 50, 60, 75 }; // int len = array.length; 获取数组元素的个数 for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } } }
遍历二维数组
package demo03; public class Demo { public static void main(String[] args) { //1.定义二维数组 int[] arr[] = new int[][]{{1, 2, 3}, {4, 5, 9, 10}, {6, 7, 8}}; //2.如何调用数组的指定位置的元素 System.out.println(arr[0][1]);//2 System.out.println(arr[1][1]);//5 //3.获取二维数组中一维数组数组的个数 System.out.println(arr.length);//3 //4.获取二维数组中一维数组数组的长度 System.out.println(arr[0].length);//3 System.out.println(arr[1].length);//4 //5.如何遍历二维数组 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + " "); } System.out.println(); } } }
数组获取最大值元素
package demo03; public class Demo05ArrayMax { public static void main(String[] args) { int[] array = { 5, 15, 30, 20, 10000, 30, 35 }; int max = array[0]; //定义变量，保存数组中0索引的元素 for (int i = 1; i < array.length; i++) { //如果数组元素大于max if (array[i] > max) { //max记录住大值 max = array[i]; } } System.out.println("最大值：" + max); } }
数组的反转
- 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
实现思想：数组最远端的元素互换位置。
- 实现反转，就需要将数组最远端元素位置交换
- 定义两个变量，保存数组的最小索引和最大索引
- 两个索引上的元素交换位置
- 最小索引++，最大索引--，再次交换位置
- 最小索引超过了最大索引，数组反转操作结束
package demo03; /* 数组元素的反转： 本来的样子：[1, 2, 3, 4] 之后的样子：[4, 3, 2, 1] 要求不能使用新数组，就用原来的唯一一个数组。 */ public class Demo07ArrayReverse { public static void main(String[] args) { int[] array = {10, 20, 30, 40, 50}; /* 初始化语句：int min = 0, max = array.length - 1 条件判断：min < max 步进表达式：min++, max-- 循环体：用第三个变量倒手 */ for (int min = 0, max = array.length - 1; min < max; min++, max--) { int temp = array[min]; array[min] = array[max]; array[max] = temp; } } }