Java学习笔记

最新推荐文章于 2024-07-24 17:27:32 发布

熊猫不睡教

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量22

点赞数

文章标签： java 学习笔记

本文链接：https://blog.csdn.net/m0_59824216/article/details/133145784

版权

Math类

在 Java 中，Math 类是一个数学计算类，提供了大量的数学计算相关的方法。这些方法都是静态方法，因此可以直接通过类名调用。以下是 Math 类中的一些常用方法：
- Math.abs(x)：返回 x 的绝对值；
- Math.ceil(x)：返回大于或等于x的最小的整数；
- Math.floor(x)：返回小于或等于x的最大的整数；
- Math.round(x)：返回将x四舍五入后的整数；
- Math.max(x, y)：返回x和y中的最大值；
- Math.min(x, y)：返回x和y中的最小值；
- Math.pow(x, y)：返回x的y次幂的值；
- Math.sqrt(x)：返回x的平方根的值；
- Math.random()：返回一个伪随机数，范围在 [0.0, 1.0) 之间。
除了以上方法外，Math 类中还有许多其他有用的数学方法，例如三角函数、指数函数等，可以根据具体需求使用或者查阅 Java 官方文档获取更多信息。
以下是 Math 类的示例代码：

public class MathDemo {
    public static void main(String[] args) {
        System.out.println("绝对值：" + Math.abs(-1));
        System.out.println("最小值：" + Math.min(1, 3));
        System.out.println("最大值：" + Math.max(1, 3));
        System.out.println("四舍五入：" + Math.round(3.4));
        System.out.println("平方根：" + Math.sqrt(9));
        System.out.println("e的2次方：" + Math.exp(2));
        System.out.println("π的值：" + Math.PI);
    }
}

以上代码中，我们使用了 Math 类中的 abs()、min()、max()、round()、sqrt()、exp() 等方法，输出了一些计算结果。
总之，Math 类提供了各种数学计算相关的方法，可以进行绝对值、最大值、最小值、平方根、指数函数等计算，是 Java 应用开发中不可缺少的一个数学类。

Math.random()

在 Java 中，Math.random() 是用来生成随机数（double类型）的方法，返回值是一个伪随机数，范围在 [0.0, 1.0) 之间。即这个方法返回的随机数不包括 1.0，但是包括 0.0。
注意，Math.random() 方法生成的是一个伪随机数，它不是真正的随机数，而是经过数学计算得出的伪随机数。在真正的随机数生成中，需要使用到与时间、硬件等有关的物理随机数源。
以下是 Math.random() 方法的使用示例：

public class RandomDemo {
    public static void main(String[] args) {
        double num1 = Math.random();
        double num2 = Math.random();
        System.out.println("第一个随机数：" + num1);  // 取值范围 [0.0, 1.0)
        System.out.println("第二个随机数：" + num2);
        
        // 生成 1 到 100 之间的随机数
        int num3 = (int) (Math.random() * 100) + 1;
        System.out.println("1 到 100 之间的随机整数：" + num3);
    }
}

在这段代码 Math.random() * 100 + 1 中，+1 的作用是将生成的随机数范围从 [0.0, 100.0) 扩展为 [1.0, 101.0)。
- Math.random() 方法生成的随机数范围是 [0.0, 1.0)。这意味着，生成的随机数可能等于 0.0 并且可能小于 1.0，但永远不会等于 1.0。如果我们要生成 [1, 100] 之间的随机整数，我们可以使用如下代码：

int randomInt = (int) (Math.random() * 100) + 1;

在这个代码中，首先使用 Math.random() 生成 [0.0, 1.0) 之间的随机数，然后将其乘以 100，得到了 [0.0, 100.0) 之间的随机数。接着，将其转换为整数类型，得到了 [0, 99] 之间的整数。最后，再加上 1，即可将数值范围扩展为 [1, 100]。
因此，+1 的作用在于将随机数生成的范围从 [0.0, 100.0) 扩展为 [1.0, 101.0)。这样就能够生成 [1, 100] 之间的随机整数了。
在以上示例中，我们使用 Math.random() 方法生成了两个随机数，并将它们输出到控制台；然后使用 Math.random() 方法和一些简单的数学运算生成了 1 到 100 之间的随机整数，并将其输出到控制台。
总之，Math.random() 方法是 Java 中用来生成伪随机数的方法，返回的值在 [0.0, 1.0) 之间（不包括 1.0）。在应用开发中，可以使用这个方法来生成一些随机数，例如生成验证码、密码等等。

Random类

Random 是 Java 中的一个类，它提供了生成随机数的功能。使用 Random 类可以生成伪随机数，即表现为随机但实际上不是真正的随机数，但是在日常应用中已经足够使用。
以下是使用 Random 类生成随机数的示例代码：

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();  // 创建一个 Random 类对象
        int num1 = random.nextInt(100);  // 生成 [0,100) 范围内的随机整数
        double num2 = random.nextDouble();  // 生成 [0.0,1.0) 范围内的随机小数
        boolean bool = random.nextBoolean();  // 生成随机的布尔值
        System.out.println("生成的随机整数：" + num1);
        System.out.println("生成的随机小数：" + num2);
        System.out.println("生成的随机布尔值：" + bool);
    }
}

在以上示例中，我们首先创建了一个 Random 类对象，然后使用该对象的 nextInt() 方法生成一个 [0,100) 范围内的随机整数，使用 nextDouble() 方法生成一个 [0.0,1.0) 范围内的随机小数，使用 nextBoolean() 方法生成一个随机的布尔值，并将它们输出到控制台。
除了以上方法，Random 类还提供了很多其他生成随机数的方法，例如：nextLong()、nextFloat()、nextInt(int bound) 等等。其中，nextInt(int bound) 方法可以指定生成的随机整数的范围，如下所示：

int num = random.nextInt(50);  // 生成 [0,50) 范围内的随机整数

需要注意的是，Random 类生成的随机数是伪随机数，即它们实际上并不是真正的随机数，因此不要在需要高安全性的场景使用它们。在实际应用中，可以结合系统时间等其他因素来生成更为随机的数值。

有参Random和无参Random

在 Java 的 Random 类中，有两个构造方法：一个是无参构造方法，另一个是有参构造方法。它们分别对应着无参 random 和有参 random 方法。
无参构造方法创建了一个随机数生成器，并使用一个合适的种子（默认为系统时间的毫秒值）对其进行初始化，如下所示：

Random random = new Random();

在这个示例中，我们创建了一个 Random 类型的 random 对象，无参构造方法会使用默认种子（当前系统时间的毫秒值）对随机数生成器进行初始化。
有参构造方法可以通过输入一个长整型数值作为种子，来创建一个随机数生成器，并使用指定的种子对其进行初始化，如下所示：

Random random = new Random(1234L);

在这个示例中，我们输入的参数是 1234L，它会被用作随机数生成器的种子，从而生成一系列随机数。如果输入的种子相同，那么生成的随机数序列也会相同。
需要注意的是，虽然有参 random 方法可以指定种子，但它仍然是基于伪随机数生成的，即使输入种子相同，每次生成的序列也可能不同。因此，如果需要生成安全性更高的随机数，需要使用其他方法（例如 SecureRandom 类）来生成随机数。

常用Random类的方法

除了 nextInt() 方法，Random 类中还有许多其他常用方法，它们可以用于生成不同种类的随机数。以下是 Random 类中一些常见的方法：
- nextDouble()：生成一个精度为双精度浮点数的准随机数，取值范围位于 [0.0, 1.0)，不包含 1.0。
- nextFloat()：生成一个精度为单精度浮点数的准随机数，取值范围位于 [0.0, 1.0)，不包含 1.0。
- nextLong()：生成一个长整型随机数，取值范围为 $2^{63}$ 到 $2^{63}-1$ 。
- nextBoolean()：生成一个随机的布尔值，取值为 true 或 false。
此外，Random 类还有一个相对于其他方法用得较少但仍然有用的方法：
- nextInt(int bound)：生成一个指定范围内的随机整数，范围是 [0, bound)。例如，如果调用 random.nextInt(5)，则生成的随机整数范围是 [0, 5)。
- 以上这些方法可以通过 Random 类对象调用，例如：

Random random = new Random();
double num1 = random.nextDouble();
float num2 = random.nextFloat();
long num3 = random.nextLong();
boolean b = random.nextBoolean();
int num4 = random.nextInt(10);

需要注意的是，Random 类生成的随机数是伪随机数，即它们实际上并不是真正的随机数，因此不要在需要高安全性的场景使用它们。在实际应用中，可以结合系统时间等其他因素来生成更为随机的数值。

随机生成一个六位数

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int result = random.nextInt(900000) + 100000;
        System.out.println("生成的随机数：" + result);
    }
}

在以上示例中，我们使用了 Java 中的 Random 类，通过 nextInt() 方法生成一个 0 到 899999 的随机整数，然后再加上 100000，得到一个 100000 到 999999 之间的随机整数，即一个 6 位随机数。
注意，由于 nextInt() 方法生成的是一个整数，因此需要保证生成的随机数是 6 位的，需要使用 100000 到 999999 之间的范围进行限制。
除了使用以上代码，还可以通过使用 String.format() 方法生成指定长度的随机数字符串，例如：

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int result = random.nextInt(900000) + 100000;
        String resultStr = String.format("%06d", result);
        System.out.println("生成的随机数：" + resultStr);
    }
}

在以上示例中，我们先生成了一个 6 位的随机整数，然后使用 String.format() 方法将其转为 6 位的字符串，不足 6 位时自动补零。
总之，通过使用 Random 类可以生成指定范围内的随机整数，可以使用这个方法随机生成任意长度的数字串。也可以使用 String.format() 方法保证随机数长度及其它格式的要求。
nextInt()
- nextInt() 是 Java 中 Random 类的方法之一，用于生成随机整数。该方法不需要输入参数，会随机生成一个整数。但如果需要指定整数的边界（上限和下限）的话，可以使用 nextInt(int bound) 方法，其中 bound 表示生成的随机整数的上限（不包括上限）。
- 以下是 nextInt() 方法的使用示例：
```
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int num1 = random.nextInt();
        int num2 = random.nextInt();
        System.out.println("生成的第一个随机整数：" + num1);
        System.out.println("生成的第二个随机整数：" + num2);
    }
}
```
- 在以上示例中，我们创建了一个 Random 类型的实例，然后分别使用了两次 nextInt() 方法来生成两个随机整数，并将它们输出到控制台。
- 以下是 nextInt(int bound) 方法的使用示例：
```
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int num1 = random.nextInt(10);  // 生成 0 到 9 的随机整数
        int num2 = random.nextInt(100);  // 生成 0 到 99 的随机整数
        System.out.println("生成的第一个随机整数：" + num1);
        System.out.println("生成的第二个随机整数：" + num2);
    }
}
```
- 在以上示例中，我们使用了 nextInt(int bound) 方法，指定了生成的随机整数的上限，从而生成了 0 到（上限-1）之间的随机整数。例如第一个随机整数生成的范围是 0 到 9，第二个随机整数生成的范围是 0 到 99。
- 总之，nextInt() 是 Random 类中用来生成随机整数的方法之一，可以直接生成一个随机整数，也可以使用 nextInt(int bound) 方法指定整数范围生成随机整数。需要使用 Random 类时，需要先创建该类的一个实例。

Random类和 Math.random() 区别

使用方式
- Random 类需要创建一个 Random 实例对象，然后调用其方法生成随机数
  
  例如：Random random = new Random(); int num = random.nextInt(100);
- Math.random() 方法是一个静态方法，直接通过类名调用
  
  例如：double num = Math.random();
随机数生成范围
- Random 类可以通过调整参数来生成指定范围的随机数
  
  例如：int num1 = random.nextInt(10); 将在 [0,10) 范围内生成随机整数。
- Math.random() 方法只能生成范围在 [0.0, 1.0) 内的随机小数。
随机数生成准确性
- Random 类生成的随机数具有更高的准确性和可预测性，因为它使用一个初始种子对算法进行重复的计算，生成的随机数序列是可预测的，因此可以在需要某些特定随机数的情况下进行重现。
- Math.random() 方法的随机数生成相对来说更为不可预测和不准确，它是基于 Random 类实现的，每次调用时都会使用不同的内部调用。
实现方式
- Random 类的生成过程是基于特定算法的实现，而底层的实现细节是不可见的。
- Math.random() 方法本质上是基于 Random 类的实现，生成的随机数是基于数学运算的结果得出的。
使用场景
- Random 类适用于需要控制随机数的生成范围和可预测性的场景。例如，在游戏中可以在特定的范围内生成随机数，以选择随机生成的游戏元素。
- Math.random() 方法适用于不需要关心随机数的生成范围和随机数的复杂性的场景。例如，在模拟过程中可以使用 Math.random() 方法来生成随机初始条件。
综上，Random 类和 Math.random() 方法各有优缺点：
- Random 类生成的随机数具有更高的可控制性和可预测性，但是在生成不同类型的随机数时需要使用不同的方法。
- Math.random() 方法生成简单，但无法在需要控制范围的情况下生成随机数。但其有一个缺点，它和系统时间有关，即在相隔时间很短的random()有可能会得到两个一模一样的double。
- 建议使用Random类；

伪随机数及其安全性

随机数是一种具有不可预测性质的数值或序列，它们在密码学、模拟、数值计算等领域中都有广泛的应用。真正的随机数往往是物理随机数，例如电子噪音、收音机的信号、激光干涉等等，而计算机和程序所生成的随机数通常是伪随机数。
伪随机数是由计算机算法产生的数列，根据固定的初始值(seed)，通过固定的计算方法得来。伪随机数可以在任何时候被重现，由于其生成是基于确定性的计算规则，每次得到的随机数序列是固定的。因此，虽然它们在表现上看起来是随机的，但本质上并没有真正的随机性，也被称为伪随机数。
伪随机数的安全性低的原因在于，攻击者可以猜测出随机数的生成规律，并利用这个规律来破解加密算法。例如，在密码学中使用伪随机数作为加密密钥，攻击者可以通过猜测随机数的起始位置来还原出整个密钥，从而进行加密解密操作。
因此，在需要高安全性的场景下，应该使用真正的随机数，例如物理随机数，在计算机中可以通过硬件随机数生成器来获得。在没有硬件随机数生成器的情况下，可以使用加密学中的伪随机数生成器，例如 SecureRandom 类生成的随机数，这种方法是将伪随机数生成器通过加密的方式进行强化，提高了随机数的安全性。

熊猫不睡教

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记

在以上示例中，我们首先创建了一个 Random 类对象，然后使用该对象的 nextInt() 方法生成一个 [0,100) 范围内的随机整数，使用 nextDouble() 方法生成一个 [0.0,1.0) 范围内的随机小数，使用 nextBoolean() 方法生成一个随机的布尔值，并将它们输出到控制台。在没有硬件随机数生成器的情况下，可以使用加密学中的伪随机数生成器，例如 SecureRandom 类生成的随机数，这种方法是将伪随机数生成器通过加密的方式进行强化，提高了随机数的安全性。
复制链接

扫一扫