03-java.lang.Math+java.util.Random+java.math.BigDecimal

最新推荐文章于 2023-10-25 20:06:52 发布

ruyu00

最新推荐文章于 2023-10-25 20:06:52 发布

阅读量345

点赞数

分类专栏： API

本文链接：https://blog.csdn.net/ruyu00/article/details/80423331

版权

API 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、java.lang.Math

1、概述

（1）public final class Math：不能被继承，即没有子类

（2）Math类包含用于执行基本数学运算的方法，其中的方法都是静态的 -- 工具类

2、字段

（1）static final double E：自然对数的底数

（2）static final double PI：圆周率

3、方法（返回值多为double）

（1）static double abs(Xxx a)：a的绝对值。Xxx可以是int、long、float、double类型

（2）static double max(Xxx a, Xxx b)：a、b中的较大值。Xxx可以是int、long、float、double类型

（3）static double min(Xxx a, Xxx b)：a、b中的较小值。Xxx可以是int、long、float、double类型

（4）static double ceil(double a)：进1，为double类型的整数

（5）static double floor(double a)：去尾，为double类型的整数

（6）static long round(double a)：四舍五入取整long

（7）static int round(float a)：四舍五入取整int

        double arg = 12.56;
        double a = Math.floor(arg);
        // int d = Math.round(arg);    //报错，long-->int会有精度损失
        long b = Math.round(arg);
        double c = Math.ceil(arg);
        System.out.println(a);  //12.0
        System.out.println(b);  //13
        System.out.println(c);  //13.0

（8）static double random()：伪随机数，返回带正号的double值，范围为[0.0, 1.0)

        double a = Math.floor(Math.random() * 10); //[0.0, 9.0]
        double b = Math.ceil(Math.random() * 10);  //[1.0, 10.0]
        double c = (int) (Math.random() * 6 + 1);  //[1.0, 6.0]，类似摇骰子

注：随机数是没有任何规律的，而伪随机数当计算次数足够多时，可以找到规律（伪随机数在指定范围内近似均匀分布）

补充：java.util.Random类，也可获取伪随机数

（9）static double sqrt(double a)：double值的正平方根

（10）static double pow(double a, double b)：a的b次幂

（11）static double exp(double a)：e的a次幂

（12）static double log(double a)：double值的自然对数（底数是e）

（13）static double log10(double a)：double值的底数为10的对数

二、java.util.Random

1、Random通常用作随机数生成器

2、构造方法

（1）Random()：使用当前时间作为种子 -- 常用

（2）Random(long seed)：以一个固定值作为种子

说明：构造函数 Random() 中使用 this(xxx); 调用构造函数 Random(seed)

调用 new Random(seed); 等效于 Random rnd = new Random(); rnd.setSeed(seed);

    public Random() {
        this(seedUniquifier() ^ System.nanoTime());
    }

    private static long seedUniquifier() {
        long var0;
        long var2;
        do {
            var0 = seedUniquifier.get();
            var2 = var0 * 181783497276652981L;
        } while(!seedUniquifier.compareAndSet(var0, var2));

        return var2;
    }

    public Random(long var1) {
        this.haveNextNextGaussian = false;
        if (this.getClass() == Random.class) {
            this.seed = new AtomicLong(initialScramble(var1));
        } else {
            this.seed = new AtomicLong();
            this.setSeed(var1);
        }

    }

3、方法

（1）protected int next(int bits)：生成下一个伪随机数。使用seed进行计算，其他nextXxx()方法都是调用next()方法

（2）int nextInt(int n)：[0, n)之间的int值

（3）float nextFloat()：[0.0, 1.0]之间的float值

（4）double nextDouble()：[0.0, 1.0)之间的double值

（5）boolean nextBoolean()：值为true或false

（6）int nextInt()

（7）long nextLong()

（8）void setSeed(long seed)：使用单个long种子设置此随机数生成器的种子

        System.out.println("Random 不含参构造方法：");
        for (int i = 0; i < 5; i++) {
            Random random = new Random();
            for (int j = 0; j < 8; j++) {
                System.out.print(" " + random.nextInt(100) + ", ");
            }
            System.out.println("");
        }

        /**
         Random 不含参构造方法：
         99,  45,  33,  23,  26,  23,  83,  12,
         17,  24,  91,  91,  77,  19,  2,  64,
         52,  60,  79,  26,  66,  27,  72,  30,
         0,  93,  33,  16,  74,  77,  82,  1,
         31,  48,  45,  61,  28,  41,  11,  14,
         */

        System.out.println("");

        /**
         Random 含参构造方法：
         17,  88,  93,  12,  51,  61,  36,  58,
         17,  88,  93,  12,  51,  61,  36,  58,
         17,  88,  93,  12,  51,  61,  36,  58,
         17,  88,  93,  12,  51,  61,  36,  58,
         17,  88,  93,  12,  51,  61,  36,  58,
         */

        System.out.println("Random 含参构造方法：");
        for (int i = 0; i < 5; i++) {
            Random random = new Random(50);
            for (int j = 0; j < 8; j++) {
                System.out.print(" " + random.nextInt(100) + ", ");
            }
            System.out.println("");
        }

说明：随机数是种子经过计算生成的。无参的构造函数每次都使用当前时间作为种子，随机性更强。而含参的构造函数其实是伪随机，更有可预见性

三、生成随机数的方法

1、Math类：static double random() -- 此方法使用时需要 (int) (Math.random() * 6 + 1)

2、Random类：int nextInt(int n) 、 double nextDouble() -- 此方法使用时需要用 (int) (new Random().nextDouble() * 6 + 1); 强转

四、编程：获取digit位验证码

    /**
     * 获取验证码
     *
     * @param digit 验证码的位数
     * @return
     */
    public static String getVerificationCode(int digit) {
        StringBuffer sb = new StringBuffer();
        Random rnd = new Random();
        for (int i = 0; i < digit; i++) {
            sb.append(rnd.nextInt(10));
        }
        return sb.toString();
    }

五、java.math.BigDecimal

1、BigDecimal extends Number：不可变的、任意精度的有符号十进制数。BigDecimal提供以下操作：算数、标度操作、舍入、比较、哈希算法和格式转换

2、在需要精确的小数计算时，才使用BigDecimal。因为BigDecimal的性能比float和double差

3、每次进行运算后，都会产生一个新的对象，要记得保存操作后的值

4、构造函数

（1）BigDecimal(Xxx xxx)：将Xxx类型的参数转换成BigDecimal类型。Xxx类型可以为：String、char[]、BigInteger、int、long、 double

注：尽量使用参数类型为String的构造函数

5、方法

（1）static BigDecimal valueOf(double val)：将double转换为BigDecimal（使用Double.toString(double)方法提供的double规范的字符串表示形式）

注：valueOf()通常是将double/float转化为BigDecimal的首选方法（还可以用BigDecimal的构造函数）

        BigDecimal b1 = new BigDecimal("1.34");
        BigDecimal b2 = BigDecimal.valueOf(1.34);

（2）int intValue()：将BigDecimal转换为int。此转换会丢失关于BigDecimal值的总大小（返回32位低位字节）和精度（丢弃小数部分）的信息，并返回带有相反符号的结果 -- 基本收缩转换

（3）int intValueExact()：将BigDecimal转换为int，以检查丢失的信息。如果BigDecimal具有非零小数部分，或者超出int结果的可能范围，则抛出ArithmeticException

（4）BigDecimal add(BigDecimal augend)：加法，返回（this + augend）

    /**
     * 加法add
     * @param value1
     * @param value2
     * @return
     */
    public static double add(double value1, double value2) {
        BigDecimal b1 = new BigDecimal(value1);
        BigDecimal b2 = new BigDecimal(value2);
        return b1.add(b2).doubleValue();
    }

（5）BigDecimal subtract(BigDecimal subtrahend)：减法，返回（this - subtrahend）

（6）BigDecimal multiply(BigDecimal multiplicand)：乘法，返回（this * multiplicand）

（7）BigDecimal divide(BigDecimal divisor)：除法，返回（this / divisor）

（8）BigDecimal divideToIntegralValue(BigDecimal divisor)：返回向下舍入所得商值（this / divisor）的整数部分

        BigDecimal b1 = new BigDecimal("101.9");
        BigDecimal b2 = new BigDecimal("3");
        //divideToIntegralValue()：向下取整
        System.out.println(b1.divideToIntegralValue(b2));   //33.0
        BigDecimal b3 = new BigDecimal("102.1");
        System.out.println(b3.divideToIntegralValue(b2));   //34.0
        BigDecimal b4 = new BigDecimal("101.99");
        System.out.println(b4.divideToIntegralValue(b2));   //33.00

（9）BigDecimal remainder(BigDecimal divisor)：取余，返回（this % divisor）

        BigDecimal b1 = new BigDecimal("513.54");
        BigDecimal b2 = new BigDecimal("5");
        System.out.println(b1.remainder(b2));   //3.54

（10）BigDecimal[] divideAndRemainder(BigDecimal divisor)：返回由两个元素组成的BigDecimal数组，商值（this / val）是初始元素，余数（this % val）是最终元素。如果同时需要整数商和余数，divideAndRemainder()比 divideToIntegralValue() + remainder() 更快速，因为相除仅需执行一次

        BigDecimal b1 = new BigDecimal("513.54");
        BigDecimal b2 = new BigDecimal("5");
        BigDecimal[] bigDecimals = b1.divideAndRemainder(b2);
        System.out.println(Arrays.deepToString(bigDecimals));   //[102.00, 3.54]

（11）BigDecimal movePointLeft(int n)：等效于将该值的小数点向左移动n位。n为负数等效于movePointRight(-n)

（12）BigDecimal movePointRight(int n)：等效于将该值的小数点向右移动n位。n为负数等效于movePointLeft(-n)

（13）BigDecimal negate()：返回（ - this ）

        BigDecimal b1 = new BigDecimal("101.9");
        BigDecimal b2 = new BigDecimal("-101.9");
        System.out.println(b1.negate());   //-101.9"
        System.out.println(b2.negate());   //101.9

（14）BigDecimal plus()：返回（ + this ）

        BigDecimal b1 = new BigDecimal("101.9");
        BigDecimal b2 = new BigDecimal("-101.9");
        System.out.println(b1.plus());   //101.9
        System.out.println(b2.plus());   //-101.9"

（15）BigDecimal pow(int n)：返回this的n次方

（16）int compareTo(BigDecimal val)：BigDecimal与指定的BigDecimal比较。值相等但具有不同标度的两个BigDecimal对象被认为是相等的。当此BigDecimal在数字上小于、等于、大于val时，返回 -1、0、1

注：equals()比的是值是否相同

        BigDecimal b1 = new BigDecimal("1");
        BigDecimal b2 = new BigDecimal("2");
        BigDecimal b3 = new BigDecimal("1");

        System.out.println(b1.compareTo(b2));   //-1
        System.out.println(b1.compareTo(b3));   //0
        System.out.println(b2.compareTo(b1));   //1

        System.out.println(b1.equals(b2));  //false
        System.out.println(b1.equals(b3));  //true

（17）BigDecimal abs()：绝对值

（18）BigDecimal max(BigDecimal val)：BigDecimal和val的最大值

（19）BigDecimal min(BigDecimal val)：BigDecimal和val的最小值

（20）int precision()：返回BigDecimal的精度（精度是非标度值的数字个数，0值的精度是1）

（21）int scale()：返回BigDecimal的标度。如果为0或正数，标度是小数点后的位数；如果为负数，则将该数的非标度值乘以10的负scale次幂

（22）BigInteger toBigInteger()：将BigDecimal转换为BigInteger。此转换会丢失关于BigDecimal值的精度信息

（23）BigInteger toBigIntegerExact()：将BigDecimal转换为BigInteger，以检查丢失的信息。如果BigDecimal具有非零小数部分，则抛出ArithmeticException异常

（24）String toString()：返回BigDecimal的字符串表示形式，如果需要指数，则使用科学记数法

（25）String toEngineeringString()：返回BigDecimal的字符串表示形式，需要指数时，则使用工程记数法

（26）String toPlainString()：返回不带指数字段的BigDecimal的字符串表示形式

6、练习

https://pan.baidu.com/s/1_FGv17c4xOfUzgPE1KbY7Q 密码：aoa0