JavaSE基础学习（六）——随机数 Random 和数组

1. 随机数 Random

1.1 概述

大家都看过电视上面抽奖的画面吧，主持人一声令下，大屏幕的数据开始滚动，随机选择一个号码，所以Random用于产生一个随机数。

1.2 使用步骤(和 Scanner 类似)

• 导包

import java.util.Random;

• 创建对象

Random r = new Random();

• 获取随机数

int number = r.nextInt(10);

产生的数据在 0 到 10 之间，包括 0，不包括 10。

括号里面的 10 是可以变化的，如果是 100，就是 0-100 之间的数据

例：获取 0-10 之间的随机数
       获取 1-100 之间的随机数

package com.study.demo.randomdemo;

import java.util.Random;

/**
 * @Auther: lds
 * @Date: 2018/10/22 10:00
 * @Description:获取 0-10 之间的随机数
                获取 1-100 之间的随机数
 */
public class RandomDemo01 {

    public static void main(String[] args) {
        // 获取0-10之间的随机数
        Random rm = new Random();
        for (int i = 0; i < 10; i++) {
            // 获取随机数
            int nextInt = rm.nextInt(10);// [0,10) 左边包括，右边不包括
            System.out.println("随机数是：" + nextInt);
        }
        System.out.println("------------------------");
        // 获取1-100之间的随机数
        for (int i = 0; i < 100; i++) {
            int nextInt = rm.nextInt(100) + 1;
            System.out.println("随机数为：" + nextInt);
        }
    }
}

例：猜数字小游戏案例
       系统产生一个 1-100 之间的随机数，请猜出这个数据是多少？

package com.study.demo.randomdemo;

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

/**
 * @Auther: lds
 * @Date: 2018/10/22 11:00
 * @Description:系统产生一个 1-100 之间的随机数，请猜出这个数据是多少
 */
public class RandomDemo02 {

    public static void main(String[] args) {
        // 系统产生一个随机数 1-100 之间的
        Random rm = new Random();
        int number = rm.nextInt(100) + 1;
        while (true) {
            // 键盘录入一个数据，作为我们猜的数据
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个1-100之间的整数：");
            int guessNumber = sc.nextInt();

            // 对比两个数据的大小，使用if判断
            if (guessNumber > number) {
                System.out.println("您猜大了！");
            } else if (guessNumber < number) {
                System.out.println("您猜小了！");
            } else {
                    System.out.println("恭喜您，猜对了！");// 猜对了之后，要结束循环哦
                break;
            }
        }
    }
}

2. 数组

2.1 概述

需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。
假设该公司有 80 名员工，用前面所学的知识，程序首先需要声明 80 个变量来分别记
住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java
就提供了数组供我们使用。

• 那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：
  • 数组是存储多个变量(元素)的东西(容器)
  • 多个变量的数据类型要一致

2.2  数组定义格式

• 数组概念
  • 数组是存储同一种数据类型多个元素的容器。
  • 数组既可以存储基本数据类型，也可以存储引用数据类型。

• 数组的定义格式
  • 格式 1：数据类型[] 数组名;
  • 格式 2：数据类型 数组名[];
  • 注意：这两种定义做完了，数组中是没有元素值的。如何对数组的元素进行初始化呢?

2.3 数组初始化

• 概述
  • Java 中的数组必须先初始化,然后才能使用。
  • 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

• 数组的初始化方式
  • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
  • 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

2.4  数组的初始化 （动态初始化）

• 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
  • 格式：数据类型[] 数组名 = new 数据类型[数组长度];
  • 数组长度其实就是数组中元素的个数。
  • 举例：
    • int[] arr = new int[3];
    • 解释：定义了一个 int 类型的数组，这个数组中可以存放 3 个 int 类型的值。

2.5  访问数组元素

• 直接打印数组名,打印的是数组堆内存中的地址。
• 数组中的每个元素都是有编号的，编号是从 0 开始的，最大的编号就是数组的长度-1。
• 用数组名和编号的配合我们就可以获取数组中的指定编号的元素。
• 这个编号的专业叫法：索引。
• 格式：数组名[编号] -- 数组名[索引]
  • 数组名称为 arr,索引为 0,1,2
  • 获取数组中元素的格式:
    • arr[0]获取数组中的第一个元素
    • arr[1]获取数组中的第二个元素
    • arr[2]获取数组中的第三个元素

2.6 Java  中的内存分配
Java 程序在运行时，需要在内存中的分配空间。
为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据
方式和内存管理方式。

• 栈 存储局部变量
  • 局部变量是定义在方法中或者语句中的变量
  • 局部变量使用完毕，立即回收

• 堆 存储 new 出来的东西
  • 每一个对象都有首地址值,是一个十六进制的地址
  • 每一个对象内的数据都有默认值
    • byte,short,int,long 0
    • float,double 0.0
    • char ‘\u0000’,一个空格
    • boolean false
    • 引用类型 null

使用完毕后，会被垃圾回收器空闲的时候回收。

• 静态域：存放在对象中用static定义的静态域成员
• 寄存器
• 常量池：存放常量
• 非RAM存储：硬盘等永久储存空间

2.7 数组内存图解

定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。

定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。

定义两个数组，先定义一个数组赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。

2.8  数组的初始化 （静态初始化）

• 概述

初始化时指定每个数组元素的初始值，由系统决定数组长度。

• 格式

数据类型[] 数组名 = new 数据类型[]{元素 1,元素 2,…};

• 举例

int[] arr = new int[]{1,2,3};

解释：定义了一个 int 类型的数组，这个数组中可以存放 3 个 int 类型的值，并且值分别是 1,2,3。

• 简化格式

数据类型[] 数组名 = {元素 1,元素 2,...};

2.9  数组操作的两个常见小问题

• 数组索引越界异常 ArrayIndexOfBoundsException

访问到了数组中的不存在的索引时发生。

• 空指针异常 NullPointerException

数组引用没有指向对象，却在操作对象中的元素时。

• 为什么要记住这些小问题呢?

因为写程序不仅仅是把代码写出来，还包括出现问题后要能够及时的把问题解决。而排错也应该是我们的基本功。所以，             我们也应该记住一些常见的问题，以及出错原因和解决方案。

2.10 遍历数组

• 依次输出数组中的每一个元素
• 获取数值长度：数值名.length

package com.study.demo.arraydemo;

/**
 * @Auther: lds
 * @Date: 2018/10/23 17:11
 * @Description:遍历数组
 */
public class ArrayDemo01 {
    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.study.demo.arraydemo;

/**
 * @Auther: lds
 * @Date: 2018/10/23 17:15
 * @Description:
 */
public class ArrayDemo02 {

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

2.11 二维数组
2.11.1 概述

• 学校每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个班级。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java 就提供了二维数组供我们使用。
• 由此可见：其实二维数组其实就是一个元素为一维数组的数组。

2.11.2 基本使用

• 二维数组定义格式
  • 数据类型[][] 数组名;
  • 数据类型 数组名[][]; 不推荐
  • 数据类型[] 数组名[]; 不推荐

• 初始化方式
  • 数据类型[][] 变量名 = new 数据类型[m][n];
  • 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  • 简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

package com.study.demo.arraydemo;

/**
 * @Auther: lds
 * @Date: 2018/10/24 15:14
 * @Description:定义二维数组
 */
public class ArrayDemo03 {

    public static void main(String[] args) {
        // 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        System.out.println(arr); // [[I@7637f22
        System.out.println(arr.length); // 二维数组中的一维数组的个数
        System.out.println(arr[0]);// [I@4926097b
        System.out.println(arr[0].length);
        System.out.println(arr[1]);// [I@762efe5d
        System.out.println(arr[2]);// [I@5d22bbb7
        //如何获取到一个二维数组的元素呢?
        System.out.println(arr[0][0]); // 1
        System.out.println(arr[1][1]); // 5
        System.out.println(arr[2][0]); // 7
    }
}

2.11.3 二维数组的遍历

• 嵌套 for 循环

例：int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

package com.study.demo.arraydemo;

/**
 * @Auther: lds
 * @Date: 2018/10/24 15:18
 * @Description:遍历二维数组
 */
public class ArrayDemo04 {

    public static void main(String[] args) {
        // 定义二维数组
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        // 第一个一维数组的元素
//        for (int x = 0; x < arr[0].length; x++) {
//            System.out.print(arr[0][x] + " ");
//        }
//        System.out.println();// 1 2 3
//
//        // 第二个一维数组的元素
//        for (int x = 0; x < arr[1].length; x++) {
//            System.out.print(arr[1][x] + " ");
//        }
//        System.out.println(); // 4 5 6
//
//        // 第三个一维数组的元素
//        for (int x = 0; x < arr[2].length; x++) {
//            System.out.print(arr[2][x] + " ");
//        }
//        System.out.println(); // 7 8 9

        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();//换行
        }
    }
}

ps：今天是1024，程序员节，祝大家节日快乐，无bug！ヽ(ﾟ∀ﾟ)ﾒ(ﾟ∀ﾟ)ﾉ  ヽ(ﾟ∀ﾟ)ﾒ(ﾟ∀ﾟ)ﾉ  ヽ(ﾟ∀ﾟ)ﾒ(ﾟ∀ﾟ)ﾉ