Java-数学和随机api

使用Math类提供的各类数学方法

•Math类位于java.lang包中，是一个final类，不能被继承；

•Math类中所有方法都是static方法，可以直接使用类名Math调用；

•Math中定义了大量与数学运算有关的方法，包括求绝对值、三角函数、平方根等；

•部分方法如下：

方法声明	方法描述
static double ceil(double a)	返回最小的double 值，该值大于等于参数，并等于某个整数。 （向上取整，返回值为double）
static double floor(double a)	返回最大的double 值，该值小于等于参数，并等于某个整数。 （向下取整，返回值为double）
static long round(double a)	返回最接近参数的 long。 四舍五入
static int round(float a)	返回最接近参数的 int。 四舍五入
static double random()	返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

public class TestMath {
    public static void main(String[] args) {
        double a = 2.75;
        double b = -2.75;
        //向上取整
        System.out.println(Math.ceil(a));  //3.0
        System.out.println(Math.ceil(b));  //-2.0
        //向下取整
        System.out.println(Math.floor(a));  //2.0
        System.out.println(Math.floor(b));  //-3.0
        //四舍五入
        System.out.println(Math.round(a));  //3
        System.out.println(Math.round(b));  //-3
        System.out.println(Math.round((float) a)); //3
        System.out.println(Math.round((float) b)); //-3
        //绝对值
        System.out.println(Math.abs(a));  //2.75
        System.out.println(Math.abs(b));  //2.75
        //比大小
        System.out.println(Math.min(1, 2)); // 1
        System.out.println(Math.max(2, 5)); // 5
        //幂
        System.out.println(Math.pow(2, 3)); //2^3 = 8.0
        //随机数
        System.out.println(Math.random());  //返回 0.0~1.0随机数
        System.out.println(Math.random() * 100);  //返回0.0~100.0随机数
    }
}

• BigInteger

• Java中整数最大范围是long型，64位，如果需要使用超过long范围的大整数，可以使用BigInteger类；
• BigInteger位于java.math包中，定义了一系列的数学运算方法，调用这些方法可以进行计算，不能使用运算符计算；

  import java.math.BigInteger;
  
  public class TestBigInteger {
      public static void main(String[] args) {
          //使用字符串表示超出范围的大整数
          String s1 = "3213213123322342342380808999798";
          String s2 = "3213213123322342342380808999798";
          //字符串转成BigInteger对象
          BigInteger bigInteger1 = new BigInteger(s1);
          BigInteger bigInteger2 = new BigInteger(s2);
          //加减乘除
          System.out.println("大数相加：" + bigInteger1.add(bigInteger2));
          System.out.println("大数相减：" + bigInteger1.subtract(bigInteger2));
          System.out.println("大数相乘：" + bigInteger2.multiply(bigInteger1).toString());
          System.out.println("大数相除：" + bigInteger1.divide(bigInteger2));
          System.out.println(bigInteger1.doubleValue());
          System.out.println(bigInteger2.intValue());
          System.out.println("大数求幂运算：" + bigInteger1.pow(3));
          System.out.println("大数更大：" + bigInteger1.max(bigInteger2));
      }
  }
  /*
  大数相加：6426426246644684684761617999596
  大数相减：0
  大数相乘：10324738575890922418377053668706422592152145188159153164040804
  大数相除：1
  3.213213123322342E30
  525767542
  大数求幂运算：33175585486925143748326223249503583909007251202004587699354304113247480574160033591299757592
  大数更大：3213213123322342342380808999798
   */

• BigDecimal

  import java.math.BigDecimal;
  import java.math.RoundingMode;
  
  public class TestBigDecimal {
      public static void main(String[] args) {
          System.out.println("======================double的精度问题=======================");
          System.out.println("0.05+0.01=" + (0.05 + 0.01));
          //0.06
          //0.06*2=0.12    0
          //0.12*2=0.24    0
          //0.24*2=0.48    0
          //0.48*2=0.96    0
          //0.96*2=1.92    1
          //0.92*2=1.84    1
          //0.84*2=1.68    1
          System.out.println("1.0 - 0.42=" + (1.0 - 0.42));
          System.out.println("4.015 * 100=" + (4.015 * 100));
          System.out.println("123.3 / 100=" + (123.3 / 100));
          System.out.println("=========================BigDecimal=============================");
          //BigDecimal
          BigDecimal bigD1 = new BigDecimal("0.05");
          BigDecimal bigD2 = new BigDecimal("0.01");
          System.out.println("0.05+0.01=" + bigD1.add(bigD2).toString());
  
          BigDecimal bigD3 = new BigDecimal("1.0");
          BigDecimal bigD4 = new BigDecimal("0.42");
          System.out.println("1.0-0.42=" + bigD3.subtract(bigD4));
  
          BigDecimal bigD5 = new BigDecimal("4.015");
          BigDecimal bigD6 = new BigDecimal("100");
          System.out.println("4.015 * 100=" + bigD5.multiply(bigD6));
  
          BigDecimal bigD7 = new BigDecimal("123.3");
          //new BigDecimal()
          System.out.println("123.3 / 100=" + bigD7.divide(bigD6));
  
          BigDecimal bigD8 = new BigDecimal("7");
          //divide除法不能除尽，要设置保留小数的位数和保留位数的规则
          System.out.println("123.3 / 7=" + bigD7.divide(bigD8, 5, RoundingMode.HALF_UP));
          //（例如四舍五入）
      }
  }
  /*
  ======================double的精度问题=======================
  0.05+0.01=0.060000000000000005
  1.0 - 0.42=0.5800000000000001
  4.015 * 100=401.49999999999994
  123.3 / 100=1.2329999999999999
  =========================BigDecimal=============================
  0.05+0.01=0.06
  1.0-0.42=0.58
  4.015 * 100=401.500
  123.3 / 100=1.233
  123.3 / 7=17.61429
   */

• 随机API

• • 熟练使用Math.random以及Random类的相关方法获取符合要求的随机数值

  • 熟悉UUID的定义及功能

  • 熟练使用UUID工具

• Random类

1、java.util包中的Random类可以用来生成不同类型的随机值，功能更为强大；

Random类创建对象两种方式：

方法声明	方法描述
Random()	创建Random对象，该对象每次生成的随机数不同
Random(long seed)	使用一个种子参数创建Random对象，参数相同的Random对象，每次生成的随机数相同。

2、java.util包中的Random类有多个生成随机数的相关方法：

方法声明	方法描述
int nextInt()	生成int类型随机数，数值范围不定；
int nextInt(int n)	生成int类型随机数，数值范围[0,n)；
long nextLong()	生成long类型随机数
float nextFloat()	生成float类型随机数，数值范围[0,1.0)；
double nextDouble()	生成double类型随机数，数值范围[0,1.0)；
boolean nextBoolean()	生成boolean类型随机数；
void setSeed(long seed)	修改Random对象的种子值

•  一个种子对应一组随机(这组不再变化)

  import java.util.Random;
  
  public class TestRandom {
      public static void main(String[] args) {
          //创建Random对象
          Random random = new Random();
          //无范围的int类型的值（包括负值）
          int intRandom = random.nextInt();
          System.out.println(intRandom);
          System.out.println();
          for (int i = 0; i < 3; i++) {
              //控制随机值的范围
              int intRandom1 = random.nextInt(10000); //[0,10000)范围的值
              System.out.println(intRandom1);
          }
          System.out.println("========随机3个double值=============");
          for (int i = 0; i < 3; i++) {
              double dRandom = random.nextDouble();
              System.out.println(dRandom);  //[0,1.0)
          }
          System.out.println("=======使用一个种子参数创建Random对象=======");
          //new Random(种子)
          Random random1 = new Random(100);
          //一个种子对应一组随机(这组不再变化)
          for (int i = 0; i < 3; i++) {
              System.out.println(random1.nextInt(10000));
          }
      }
  }

• UUID的定义及功能

1. UUID是通用唯一识别码 (Universally Unique Identifier)的缩写，是唯一的机器生成的标识符；

• UID都不能是人工生成的，这样风险太高；

• UUID是16字节128位长的数字，通常以36字节的字符串表示，示例如下：3F2504E0-4F89-11D3- 9A0C-0305E82C3301

• 通常在分布式系统中用来生成唯一ID

1. UUID具有多个版本，每个版本的算法不同；

• UUID Version 1：基于时间的UUID
• 通过计算当前时间戳、随机数和机器MAC地址得到。
• UUID Version 2：DCE安全的UUID
• 和基于时间的UUID算法相同，但会把时间戳的前4位置换为POSIX的UID或GID。这个版本的UUID 在实际中较少用到。
• UUID Version 3：基于名字的UUID（MD5）
• 通过计算名字和名字空间的MD5散列值得到。
• UUID Version 4：随机UUID
• 根据随机数，或者伪随机数生成UUID。
• UUID Version 5：基于名字的UUID（SHA1）
• 和版本3的UUID算法类似，只是散列值计算使用SHA1（Secure Hash Algorithm 1）算法。

1. UUID由以下几部分的组合：

• 当前日期和时间，UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同。
• 时钟序列。
• 全局唯一的IEEE机器识别号，如果有网卡，从网卡MAC地址获得，没有网卡以其他方式获得。

  import java.util.UUID;
  
  public class TestUUID {
      public static void main(String[] args) {
          for (int i = 0; i < 2; i++) {
              UUID uuid = UUID.randomUUID();
              System.out.println(uuid);
              System.out.println(uuid.toString().replace("-", ""));
          }
      }
  }
  /*
  随机的
  25db6126-17d7-4f62-ba73-d52ae2accf49
  25db612617d74f62ba73d52ae2accf49
  75a27a04-e457-498f-aa37-e177beeb756c
  75a27a04e457498faa37e177beeb756c
   */