JavaSE Day12

本节内容

包装类

1.什么是包装类
2.基本类型与包装类之间的转换
3.基本类型与字符串之间的转换

常用类

1.日期Date类

2. 日期格式化DateFormat

3.Calendar类

4.Math类

5.Random类

6.Object和Class类

7.BigDecimal类

一、包装类

我们知道Java是一门面向对象的语言，但是Java中的基本数据类型不是对象，这在我们的使用过程中存在很多的不便。为了解决这个问题，Java在设计类的时候为给个基本类型设计了一个对应的类进行代表，这样八个与基本类型对应的类统称为包装类

基本类型与包装类之间的转换

那么基本类型可以转换为包装类吗？应该怎么转换呢？
那么基本类型是可以转换为包装类的，那么我们将分为两个方面解说：
（1）基本类型转换为包装类
（2）包装类转换为基本类型
那么在这里还有一个概念，Java后续版本中加入了装箱与拆箱
那么这里该怎么理解装箱跟拆箱？
装箱是指基本类型转换为包装类，使其具有对象的性质
拆箱是指包装类转换为基本类型的值

1）基本类型转换为包装类，也就是装箱
装箱也分为两个，一个是手动装箱，一个是自动装箱

int a = 0;
Integer b = new Integer(a);//手动装箱
Integer c = a;//自动装箱

手动装箱的意思，就是你必须手动的new一个对象
那么自动装箱，就是程序默认将其自动的创建一个对象

2）包装类转换为基本类型
拆箱也分为两个，手动拆箱与自动拆箱

Double d = 9.2;
double e = d.doubleValue();//手动拆箱
double f = d;//自动拆箱

手动与自动的将包装类转换为基本类型

3.基本类型与字符串之间的转换

String类中内置的方法很多，所以会有时候我们会选择将基本类型转换为字符串然后使用内置的方法
那么这里我们也分为两个方面：
（1）基本类型转换为字符串
（2）字符串转换为基本类型

（1）基本类型转换为字符串
基本类型转换为字符串的方法有三种方法：
①使用包装类中的toString()方法
②使用String类的valueOf()方法
③加入空字符

String i = Integer.toString(h);//使用包装类中的toString()方法
String i = String.valueOf(h);//使用String类的valueOf()方法
String i = h + "";//加入空字符

（2）字符串转换为基本类型
包装类转换为基本类型有两种方法：
①使用包装类中的parseXXX()方法
②使用包装类中的valueOf()方法

int j = Integer.parseInt(i);//使用包装类中的parseXXX()方法
int j = Integer.valueOf(i);//使用包装类中的valueOf()方法

二、常用类

1.Date类

   在JDK1.0中，Date类是唯一的一个代表时间的类，但是由于Date类不便于实现国际化，所以从JDK1.1版本开始，推荐使用Calendar类进行时间和日期处理

Date类表示特定的瞬间，精确到毫秒。

创建Dtae对象的2中方式：

  

Date  date = new  Date()   //获取的是系统当前时间

public Date(long date)——根据给定的毫秒值创建日期对象

Date date =new  Date(long  date);//使用一个给定的毫秒数创建一个日期

日期与毫秒数之间的转换

//public long getTime()——日期转毫秒值

Date   date  =  new  Date();
System.out.print(date.getTime());

毫秒数与日期的转换

Date date = new Date();
date.setTime(time);
System.out.println(date);

比较2个日期的大小：

1、public boolean before(Date when)——测试此日期是否在指定日期之前，当且仅当此Date对象表示的瞬间比when表示的瞬间早，才返回true；否则返回false

  Date date1 = new Date(1000);
  Date date2 = new Date(2000);
  System.out.println(date1.before(date2));

2、public boolean after(Date when)——测试此日期是否在指定日期之后，当且仅当此Date对象表示的瞬间比when表示的瞬间晚，才返回true；否则返回false。

    Date date1 = new Date(1000);
    Date date2 = new Date(2000);
    System.out.println(date1.after(date2));

3.public int compareTo(Date anotherDate)——比较两个日期的顺序。

如果参数Date等于此Date，则返回值0；如果此Date在Date参数之前，则返回小于0的值；如果此Date在Date参数之后，则返回大于0的值。   

  Date date1 = new Date(1000);
  Date date2 = new Date(2000);
  System.out.println(date1.compareTo(date2));

2.日期格式化 DateFormat

   Java的API中为我们提供了日期与字符串相互转运的类DateForamt。DateForamt是一个抽象类，所以平时使用的是它的子类SimpleDateFormat

经常使用的SimpleDateFormat 的构造方法是第二个

构造函数中pattern为时间模式，具体有什么模式，API中有说明，如下

 

日期格式化：

1.日期转字符串

  

        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(sdf.format(date));
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(date));
        sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(sdf.format(date));

2、字符串转日期（解析）

        String string = "2018-08-01 21:59:06";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.parse(string));

在字符串转日期操作时，需要注意给定的模式必须和给定的字符串格式匹配，否则会抛出java.text.ParseException异常，例如下面这个就是错误的，字符串中并没有给出时分秒，那么SimpleDateFormat当然无法给你凭空解析出时分秒的值来

3.Calendar类

    Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量

与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化：

     Calendar rightNow = Calendar.getInstance();
 

Calendar 对象能够生成为特定语言和日历风格实现日期-时间格式化所需的所有日历字段值，例如，日语-格里高里历，日语-传统日历。

常用方法：

  

package com.xk;

import java.util.Calendar;

/*
 *作者：吴志龙
 *日期：2018年8月1日  
*/
public class CalendarDemo {

    public static void main(String[] args) {

        Calendar calendar = Calendar.getInstance();

        // 基本用法，获取年月日时分秒星期

        // 获取年
        int year = calendar.get(Calendar.YEAR);

        // 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
        int month = calendar.get(Calendar.MONTH) + 1;

        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        // 获取时
        int hour = calendar.get(Calendar.HOUR);
        // int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示

        // 获取分
        int minute = calendar.get(Calendar.MINUTE);

        // 获取秒
        int second = calendar.get(Calendar.SECOND);

        // 星期，英语国家星期从星期日开始计算
        int weekday = calendar.get(Calendar.DAY_OF_WEEK);

        System.out.println("现在是" + year + "年" + month + "月" + day + "日" + hour + "时" + minute + "分" + second + "秒"
                + "星期" + weekday);

        // 获取任意一个月的最后一天
        // 假设求6月的最后一天
        int currentMonth = 6;
        // 先求出7月份的第一天，实际中这里6为外部传递进来的currentMonth变量
        // 1
        calendar.set(calendar.get(Calendar.YEAR), currentMonth, 1);

        calendar.add(Calendar.DATE, -1);

        // 获取日
        int day1 = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("6月份的最后一天为" + day1 + "号");

        // 设置日期

        calendar.set(Calendar.YEAR, 2018);
        System.out.println("现在是" + calendar.get(Calendar.YEAR) + "年");

        calendar.set(2018, 8, 1);
        // 获取年
        int year1 = calendar.get(Calendar.YEAR);

        // 获取月
        int month1 = calendar.get(Calendar.MONTH);

        // 获取日
        int day2 = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("现在是" + year1 + "年" + month1 + "月" + day2 + "日");

    }

}

运行结果
现在是2018年8月1日2时25分36秒星期4
6月份的最后一天为30号
现在是2018年
现在是2018年8月1日

4.Math类

Math类位于Java.lang包中，包含用于执行基本数学运算的方法！Math类的所有执行方法都是静态方法，可以直接使用类名.方法名调用

 常用的方法:Math.round()    返回最接近参数的 int,它表示"四舍五入"
                        Math.rint()         返回最接近参数并等于某一整数的 double 值，如果有2个数同样接近，则返回偶数的那个
                        Math.floor()       返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数
                        Math.ceil()         返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数
                        Math.cbrt()        返回 double 值的立方根
                        Math.sqrt()        返回正确舍入的 double 值的正平方根
                        Math.pow()       返回第一个参数的第二个参数次幂的值
                        Math.max()       返回两个 double 值中较大的一个
                        Math.min()        返回两个 double 值中较小的一个

package com.xk;
/*
 *作者：吴志龙
 *日期：2018年8月1日  
*/
public class MathDemo {
    
    public static void main(String[] args) {
        sqrt(15);
        System.out.println("******************");
        pow(2, 4);
        System.out.println("******************");
        minAndMax(5, 8);
        System.out.println("******************");
        rint(4.5);
        System.out.println("******************");
        round(5.64);
        System.out.println("******************");
        floorAndCeil(2.35);
        System.out.println("******************");
        cbrt(8);
    }
    /**
     * 返回最接近参数的 int,它表示"四舍五入"
     * @param n
     */
    public static void round(double n){
        System.out.println(Math.round(n));
    }
    /**
     * Math.rint返回最接近参数并等于某一整数的 double 值，如果有2个数同样接近，则返回偶数的那个
     * @param n
     */
    public static void rint(double n){
        System.out.println(Math.rint(n));
    }
    /**
     * Math.floor返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数
     * Math.ceil返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数
     * @param n
     */
    public static void floorAndCeil(double n) {
        System.out.println(Math.floor(n));
        System.out.println(Math.ceil(n));
    }

    /**
     * 返回 double 值的立方根
     * 
     * @param n
     */
    public static void cbrt(double n) {
        System.out.println(Math.cbrt(n));
    }

    /**
     * 返回正确舍入的 double 值的正平方根
     * 
     * @param n
     */
    public static void sqrt(double n) {
        System.out.println(Math.sqrt(n));
    }

    /**
     * 返回第一个参数的第二个参数次幂的值
     * 
     * @param m
     * @param n
     */
    public static void pow(double m, double n) {
        System.out.println(Math.pow(m, n));
    }

    /**
     * max返回两个 double 值中较大的一个 min返回两个 double 值中较小的一个
     * 
     * @param m
     * @param n
     */
    public static void minAndMax(double m, double n) {
        System.out.println(Math.min(m, n));
        System.out.println(Math.max(m, n));
    }


}

运行结果
3.872983346207417
******************
16.0
******************
5.0
8.0
******************
4.0
******************
6
******************
2.0
3.0
******************
2.0

5.Random类

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

package com.xk;
/*
 *作者：吴志龙
 *日期：2018年8月1日  
*/

import java.util.Random;

public class RandomDemo {
    
    public static void main(String[] args) {
        
        
        Random random =new Random(10);
        int a=random.nextInt();
        Random random1 =new Random(10);
        int b=random1.nextInt();
        //他们生成的随机数是一样的
        System.out.println(a+"   "+b);
        
        
    }

}

Random类的使用

1、Random对象的生成

Random类包含两个构造方法，下面依次进行介绍：

a、public Random()

该构造方法使用一个和当前系统时间对应的相对时间有关的数字作为种子数，然后使用这个种子数构造Random对象。

b、public Random(long seed)

该构造方法可以通过制定一个种子数进行创建。

Random rd = new Random();

Random rd1 = new Random(10);

2、Random类中的常用方法

a、public boolean nextBoolean()
该方法的作用是生成一个随机的boolean值，生成true和false的值几率相等，也就是都是50%的几率。
b、public double nextDouble()
该方法的作用是生成一个随机的double值，数值介于[0,1.0)之间。
c、public int nextInt()
该方法的作用是生成一个随机的int值，该值介于int的区间，也就是-231到231-1之间。
如果需要生成指定区间的int值，则需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。
d、public int nextInt(int n)
该方法的作用是生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。
如果想生成指定区间的int值，也需要进行一定的数学变换，具体可以参看下面的使用示例中的代码。
e、public void setSeed(long seed)
该方法的作用是重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同。

6.Object和Class类

 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

大家都知道Object是所有类的父类，任何类都默认继承Object

理论上Object类是所有类的父类，即直接或间接的继承java.lang.Object类。由于所有的类都继承在Object类，因此省略了extends Object关键字。
该类中主要有以下方法: toString(),getClass(),equals(),clone(),finalize(), 其中toString(),getClass(),equals是其中最重要的方法。

注意：

    Object类中的getClass(),notify(),notifyAll(),wait()等方法被定义为final类型，因此不能重写。

 

方法介绍：

1.Object()

    这个方法是Object类的一个默认的构造方法，在构造子类时，都会先调用这个默认构造方法。

2. public final   Class<?> getClass()

      getClass()方法是一个final方法，这就意味着不允许子类重写 。

      getClass()返回该对象的运行时类的 java.lang.Class 对象，该对象保存着原对象的类信息，比如原对象的类名叫什么，类里有什么方法，字段等，这些信息可以由Class对象的getName()、getMethods()等方法获取。该方法返回值为Class对象，后面的“？”是泛型（“？”则属于类型通配符的一种），代表着正在运行的类。

3. public   int hashCode()

       该方法返回对象的哈希码值。hashCode是用来在散列存储结构中确定对象的存储地址的，在HashMap、Hashtable等底层实现都有用到，其主要是用于查找的快捷性，因为在集合查找时，hashcode能大大降低对象比较次数，提高查找效率。

      关于hashCode有几点常规的约定：
      ① 在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
      ② 如果根据 equals(Object) 方法判定两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
      ③ 如果根据equals方法得到两个对象不相等，那么这2个对象的hashCode值不需要必须不相同，即可以相同。但是，不相等的对象的hashCode值不同的话可以提高哈希表的性能。
      ④当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定。
实际上，由于hashCode一般是通过将该对象的内部地址转换成一个整数来实现的，所以通常情况下，不同的对象产生的哈希码是不同的。

4. public boolean equals(Object obj)

equals()方法用来比较两个对象是否相等，默认实现是使用“==”直接比较，即比较两个对象的内存地址是否相等:

5. public String toString()

      toString()方法是用来放回一个简明易懂的“以文本方式表示”的字符串，建议Object所有的子类都重写这个方法。

Class类：

    Class怎么说也是一个类，只不过这个类是一个特殊的类。特殊在这是一个在类加载过程中由虚拟机生成的，由于表示被加载类的类型信息的对象

它代表着一个类的类型信息。正是因为这个特殊作用的存在，Class类能够实现它所代表的这个类的所有功能，包括创建这个类的实例，获得所有的构造函数，方法，字段值等等，可以说无所不能。

Class类中存储了对应类的几乎所有的信息，当然这些信息是未初始化的信息，比如所有的方法，所有的构造函数，所有的字段（成员属性）等等。

java里的所有类都有一个Class对象，通过这个Class对象我们能够获取此类的各种信息。
当某个字节码文件被JVM加载的时候，Class对象就被创建。
Class类没有构造方法，是内部的一个defineClass方法来创建此对象的，此对象与被加载的字节码文件的类的类型相对应。

class的forName方法

同时class里有一个static的方法forName,可以让我们显示的来把一个类的.class文件加载至JVM虚拟机。

返回这个类的一个class对象，但是这个是个运行时的class对象。

如何获取这个类的对象

使用newInstance()方法类创建这个class对象所表示的类的一个对象。

7.BigDecimal类

Java中提供了大数字(超过16位有效位)的操作类,即 java.math.BinInteger 类和 java.math.BigDecimal 类,用于高精度计算.
其中 BigInteger 类是针对大整数的处理类,而 BigDecimal 类则是针对大小数的处理类.
BigDecimal 类的实现用到了 BigInteger类,不同的是 BigDecimal 加入了小数的概念.
float和Double只能用来做科学计算或者是工程计算;在商业计算中,对数字精度要求较高,必须使用 BigInteger 类和 BigDecimal 类,它支持任何精度的定点数,可以用它来精确计算货币值.
BigDecimal类创建的是对象,不能使用传统的+、-、*、/等算术运算符直接对其进行数学运算,而必须调用其对应的方法.方法的参数也必须是BigDecimal类型的对象.

构造 BigDecimal 对象常用以下方法:
BigDecimal BigDecimal(double d); //不允许使用
BigDecimal BigDecimal(String s); //常用,推荐使用
static BigDecimal valueOf(double d); //常用,推荐使用

其中,
1. double 参数的构造方法,不允许使用!!!!因为它不能精确的得到相应的值;
2. String 构造方法是完全可预知的: 写入 new BigDecimal("0.1") 将创建一个 BigDecimal,它正好等于预期的0.1; 因此,通常建议优先使用 String 构造方法;
3. 静态方法 valueOf(double val) 内部实现,仍是将 double 类型转为 String 类型; 这通常是将 double(或float)转化为 BigDecimal 的首选方法;

package com.xk;

import java.math.BigDecimal;

/*
 *作者：吴志龙
 *日期：2018年8月1日  
*/
public class BigDecimalDemo {
    
     //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */

    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1    被加数
     * @param v2    加数
     * @param scale 保留scale 位小数
     * @return 两个参数的和
     */
    public static String add(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1    被减数
     * @param v2    减数
     * @param scale 保留scale 位小数
     * @return 两个参数的差
     */
    public static String sub(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }


    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static String mul(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */

    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商
     */
    public static String div(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v1);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static String round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }


    /**
     * 取余数
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static String remainder(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数  BigDecimal
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 比较大小
     *
     * @param v1 被比较数
     * @param v2 比较数
     * @return 如果v1 大于v2 则 返回true 否则false
     */
    public static boolean compare(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        int bj = b1.compareTo(b2);
        boolean res;
        if (bj > 0)
            res = true;
        else
            res = false;
        return res;
    }


}