[Java知识库]java学习记录十二：权限修饰符代码块java内部类，自动拆装箱

一、权限修饰符

一、解释

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。

• public：公共的
• protected：受保护的
• (空的)：默认的
• private：私有的

二、不同权限的访问能力

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用private ，隐藏细节。
• 构造方法使用public ，方便创建对象。
• 成员方法使用public ，方便调用方法。

二、代码块

一、构造代码块

一.解释

• 格式: {}
• 位置: 类中,方法外
• 执行: 每次在调用构造方法的时候,就会执行，在调用构造方法之前执行
• 使用场景: 统计创建了多少个该类对象

二.写法

public class Person{
    {
        构造代码块执行了
    }
}

二、静态代码块

一、解释

• 格式:static{}
• 位置: 类中,方法外
• 执行: 当类被加载的时候执行,并只执行一次
• 使用场景: 例如加载驱动,这种只需要执行一次的代码就可以放在静态代码块中

二、写法

public class Person {
    static {
        System.out.println("Person 静态代码块");
    }

    {
        System.out.println("Person 构造代码块");
    }

    public Person(){
        System.out.println("Person 构造方法");
    }
}

三、局部代码块

一、解释

• 格式:{}
• 位置: 方法中
• 执行: 调用方法,执行到局部代码块的时候就执行
• 使用场景: 节省内存空间,没有多大的意义

二、写法

public class Test {
    public static void main(String[] args) {
  
        System.out.println("开始");
        {
            int num1 = 10;
            System.out.println("局部代码块");
        }// 把局部代码块中的变量占用的空间会释放

        System.out.println("结束");
    }
}

三、Object类

一、解释

java.lang.Object`类是Java语言中的根类，即所有类的父类。如果一个类没有特别指定父类，那么默认则继承自Object类。根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。-java中所有的类都是直接或者间接继承Object类,也就意味着,java中所有的类都拥有Object类中的那11个方法。每个类的构造方法默认会调用父类的空参构造方法。

二、Object类常用方法

一、toString方法

一、解释

返回该对象的字符串表示，其实该字符串内容就是：对象的类型名+@+内存地址值。由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

二、写法

  // 创建Object对象
        Object obj = new Object();
        System.out.println(obj.toString());// java.lang.Object@50cbc42f
        System.out.println(obj);// java.lang.Object@50cbc42f

三、特点

• toString方法返回的字符串内容格式为: 类的全路径+@+十六进制数的地址值
• 直接打印对象名,其实就是打印对象调用toString方法返回的字符串内容
• 要是一个类toString打印的不是地址值，而是内容，说明该类重写了toString方法

四、重写toString方法

class Person{
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override//重写需要加上这个注解
    public String toString() {
        // 使用快捷键生成默认格式(alt+insert)
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

二、equals方法

一、解释

指示其他某个对象是否与此对象“相等”，Object类的equals()方法默认实心是==比较,也就是比较2个对象的地址值,对于我们来说没有用，如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。

二、写法

        // 创建Object类对象
        Object obj1 = new Object();
        Object obj2 = new Object();
        System.out.println(obj1 == obj2);// false
        System.out.println(obj1.equals(obj2));// false  执行代码:obj1 == obj2

三、Object类equals方法的特点

• Object类的equals()方法默认比较的是2个对象的地址值是否相等(==比较)
• 由于java中所有类都是继承Object类,所以如果类中没有重写equals方法,默认就是地址值比较，String类就重写了equals方法，比较的是内容
• 如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以重写equals方法，

二、重写equals方法

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*@Override
    //形参多态，只要参数数据类型是父类类型，就可以使用所有的子类类型
    public boolean equals(Object obj) {
        // 自定义比较规则
        //这边要向下转型，不然不能使用子类独有的成员。即obj.age访问报错。
        //这里就是多态的弊端，所以要向下转型。出现多态就i要考虑到弊端。
        //转型前最好判断一下是不是这个子类类型。
        Person p = (Person) obj;
        //这里age的== 是int的==比较的是值，name是String类型，==比较的是地址值，所以要用equals，比较的是值。
        return this.age == p.age && this.name.equals(p.name);
    }*/
   // 快捷键重写equals方法  alt+insert-->选择`equals() and hashCode()`进行自动代码生成。
    @Override
    public boolean equals(Object o) {
        // 如果2个对象的地址值相同,就直接返回true,结束方法
        if (this == o) return true;
        // 如果传入的对象为null,就直接返回false,结束方法
        // 如果2个对象的类型不一致,就直接返回false,结束方法
        //getClass获取对象的类
        if (o == null || this.getClass() != o.getClass()) return false;
        // 来到这里,说明要比较的2个对象地址值不同,并且一定是Person类型
        Person person = (Person) o;// 向下转型
        //  比较所有属性是否相同
        return age == person.age &&
                Objects.equals(name, person.name);
    }

四、Objects类

一、解释

java.util.Objects类是JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题

二、写法

//public static boolean equals(Object a, Object b):判断两个对象是否相等。
//源码
public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}


public class Test {
    public static void main(String[] args) {
         String name1 = "张三";
        String name2 = new String("张三");
        String name3 = null;
        System.out.println(name1);// 张三
        System.out.println(name2);// 张三

        // 比较name1和name2字符串内容是否相同
        //System.out.println(name1.equals(name2));// true
        //System.out.println(name3.equals(name1));// 空指针异常NullPointerException,因为null不能调用方法

        System.out.println(Objects.equals(name1, name2));// true
        //这时候使用Objects.equals就不会报空指针异常，可以比较null值。
        System.out.println(Objects.equals(name3, name1));// false
    }
}

五、native方法

一、解释

在Object类的源码中定义了 native 修饰的方法， native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,它是用来和其他编程语言进行交互的方法，当我们需要访问C或C++的代码时，或者访问操作系统的底层类库时，可以使用本地方法实现。也就意味着Java可以和其它的编程语言进行交互。本地方法的作用： 就是当Java调用非Java代码的接口。方法的实现由非Java语言实现，比如C或C++。

六、Date类

一、解释

java.util.Date类 表示一个日期和时间，内部精确到毫秒。

二、构造方法

1.无参构造方法

• public Date()`：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

2.有参构造方法

• public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数，即写多少就是距离1970年1月1日00:00:00 GMT）偏差多少的时间。1000毫秒等于1秒。

三、时间定义

1.标准时间
叫世界协调时间/格林威治时间，又称为“历元（epoch）”，即1970年1月1日00:00:00 GMT
2.中国时间
是东八区时间，比标准时间快8小时，叫1970年1月1日00:00:00 CST
1.中国人:一个星期的第一天是星期一,外国人:一个星期的第一天是星期天
2.日历对象中的月份是: 0-11

四、写法

     // 创建当前统时间对应的日期对象
        Date date1 = new Date();
        System.out.println(date1);// Thu Sep 10 11:21:00 CST 2020
    //在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串
     // 创建以标准基准时间为基准 指定偏移1000毫秒
        Date date2 = new Date(1000);
        System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
        
       // 创建日期对象,表示1970年1月1日07:59:59
        Date date3 = new Date(-1000);
        System.out.println(date3);// Thu Jan 01 07:59:59 CST 1970

五、Date类常用方法

1.获取当前日期对象距离标准基准时间的毫秒值。

         //public long getTime()：获取当前日期对象距离标准基准时间的毫秒值。
       // 创建当前统时间对应的日期对象
        Date date1 = new Date();
        System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020

      // 创建以标准基准时间为基准 指定偏移1000毫秒
        Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
        System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
        
      // 获取当前日期对象距离标准基准时间的毫秒值。
        System.out.println(date1.getTime());// 1599708576604
        System.out.println(date2.getTime());// 1000

2.设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象

   // public void setTime(long time) 设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象
    // 创建当前统时间对应的日期对象
        Date date1 = new Date();
        System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020

       // 创建以标准基准时间为基准 指定偏移1000毫秒
        Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
        System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
        
      // 修改date1距离标准基准时间的毫秒值为2000
        date1.setTime(2000);
        System.out.println(date1);// Thu Jan 01 08:00:02 CST 1970
        date2.setTime(2000);
        System.out.println(date2);// Thu Jan 01 08:00:02 CST 1970

3.测试此日期是否在指定日期之后或者之前

       //public boolean after(Date when) 测试此日期是否在指定日期之后。
       public boolean before(Date when) 测试此日期是否在指定日期之前。
      // 创建当前统时间对应的日期对象
        Date date1 = new Date();
        System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020

       // 创建以标准基准时间为基准 指定偏移1000毫秒
        Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
        System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970


      // 修改date1距离标准基准时间的毫秒值为2000
        date1.setTime(2000);
        System.out.println(date1);// Thu Jan 01 08:00:02 CST 1970
        date2.setTime(2000);
        System.out.println(date2);// Thu Jan 01 08:00:02 CST 1970
       // 创建当前统时间对应的日期对象
        Date date3 = new Date();
        System.out.println("date3表示的日期是否在date1之前:"+date3.before(date1));//  false
        System.out.println("date3表示的日期是否在date1之后:"+date3.after(date1));//   true

六、DateFormat类

一、解释

java.text.DateFormat` 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，把Date对象转换为String对象。
• 解析：按照指定的格式，把String对象转换为Date对象。
  由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。

二、构造函数

public SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。
常用的格式规则为：

三、构造函数写法

        // 创建当前日期对象
        Date date1 = new Date();
         // 创建日期格式化对象,并且指定日期格式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化,日期格式随便指定

四、DateFormat类的常用方法

1.将Date对象格式化为字符串

  //public String format(Date date)`：将Date对象格式化为字符串。
// 创建当前日期对象
        Date date1 = new Date();

        // 创建日期格式化对象,并且指定日期格式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化,日期格式随便指定

        // 使用日期格式化对象,把日期对象转换为String对象
        String dateStr = sdf1.format(date1);
        System.out.println(dateStr);// 2020-09-10 12:02:56

2.将字符串解析为Date对象

//public Date parse(String source)`：将字符串解析为Date对象。
 // 创建字符串对象
        String str = "2020年09月09日 12时00分00秒";

        // 创建日期格式化对象,并且指定日期格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");// 解析,日期格式要和字符串日期格式一样

        // 解析
        Date date = sdf2.parse(str);
        System.out.println(date);// Wed Sep 09 12:00:00 CST 2020

七、Calendar类

一、解释

java.util.Calendar类表示一个“日历类”，可以进行日期运算。它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。

二、获取GregorianCalendar对象

1.直接创建GregorianCalendar对象

GregorianCalendar cal = new GregorianCalendar()

2.通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象

 // 创建当前时间的日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
        /*

三、Calendarl类常用方法

1.获取当前日期的日历对象

//public static Calendar getInstance()` 获取当前日期的日历对象
 // 创建当前时间的日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
        /*

2.获取某个字段的值

/*public int get(int field)` 获取某个字段的值。
参数field:表示获取哪个字段的值,可以使用Calender中定义的常量来表示
Calendar.YEAR : 年
Calendar.MONTH ：月
Calendar.DAY_OF_MONTH：月中的日期
Calendar.HOUR：小时
Calendar.MINUTE：分钟
Calendar.SECOND：秒
Calendar.DAY_OF_WEEK：星期*/
           // 创建当前时间的日历对象
        Calendar cal = Calendar.getInstance();
           /// 获取cal日历对象年字段的值
        int year = cal.get(Calendar.YEAR);
        System.out.println(year);// 2020

		 // 获取cal日历对象月字段的值
        int month = cal.get(Calendar.MONTH);
        System.out.println(month);// 8

3.设置某个字段的值

   //public void set(int field,int value)设置某个字段的值
     // 创建当前时间的日历对象
        Calendar cal = Calendar.getInstance();
    // 设置cal日历对象中年字段的值为2030年
        cal.set(Calendar.YEAR,2030);
        System.out.println(cal.get(Calendar.YEAR));// 2030

        // 为cal日历对象的年字段的值+2
        cal.add(Calendar.YEAR,2);
        System.out.println(cal.get(Calendar.YEAR));// 2032

4.为某个字段增加/减少指定的值

     //public void add(int field,int amount)为某个字段增加/减少指定的值

    // 创建当前时间的日历对象
        Calendar cal = Calendar.getInstance();
    // 为cal日历对象的年字段的值+2
        cal.add(Calendar.YEAR,2);
        System.out.println(cal.get(Calendar.YEAR));// 2032

        // 为cal日历对象的年字段的值-1
        cal.add(Calendar.YEAR,-1);
        System.out.println(cal.get(Calendar.YEAR));// 2031
        System.out.println(cal.get(Calendar.MONTH));// 8

5.使用给定的 Date 设置此 Calendar 的时间

//public void setTime(Date date)  使用给定的 Date 设置此 Calendar 的时间。

   // 创建当前时间的日历对象
        Calendar cal1 = Calendar.getInstance();// 2020年09月10日

        // 需求: 获取1998年10月10日对应的日历对象
        String birthdayStr = "1998年10月10日";
        // 把字符串的日期转换为Date类型的日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date birthdayDate = sdf.parse(birthdayStr);

        // 调用cal的setTime方法,把日期对象传入
        cal1.setTime(birthdayDate);

        System.out.println("年:"+cal1.get(Calendar.YEAR));// 1998
        System.out.println("月:"+(cal1.get(Calendar.MONTH)+1));// 10
        System.out.println("日:"+cal1.get(Calendar.DAY_OF_MONTH));// 10

6.判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前或之后，返回判断结果。

//boolean before(Object when) `判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。
//boolean after(Object when) 判断当前日历对象的时间是否在指定日历对象时间之后

     // 创建当前时间的日历对象
        Calendar cal1 = Calendar.getInstance();// 2020年09月10日

        // 需求: 获取1998年10月10日对应的日历对象
        String birthdayStr = "1998年10月10日";
        // 把字符串的日期转换为Date类型的日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date birthdayDate = sdf.parse(birthdayStr);

        // 调用cal的setTime方法,把日期对象传入
        cal1.setTime(birthdayDate);
        // 创建当前时间的日历对象
        Calendar cal2 = Calendar.getInstance();// 2020年09月10日
        System.out.println("cal1表示的时间是否在cal2表示的时间之前:"+cal1.before(cal2));// true
        System.out.println("cal1表示的时间是否在cal2表示的时间之后:"+cal1.after(cal2));// false
       

八、Math类

一、解释

• java.lang.Math(类): Math类包含执行基本数字运算的方法。
• 它不能创建对象，它的构造方法被“私有”了。因为他内部都是“静态方法”，通过“类名”直接调用即可。

二、Math常用方法

/* public static int abs(int a) 获取参数a的绝对值：
 public static double ceil(double a) 向上取整  例如:3.14 向上取整4.0
 public static double floor(double a) 向下取整 例如:3.14 向下取整3.0
 public static double pow(double a, double b)  获取a的b次幂
 public static long round(double a) 四舍五入取整 例如:3.14 取整3  3.56 取整4
 public static int max(int a, int b)  返回两个 int 值中较大的一个。
 public static int min(int a, int b)  返回两个 int 值中较小的一个。*/
        System.out.println("10的绝对值:"+Math.abs(10));// 10
        System.out.println("-10的绝对值:"+Math.abs(-10));// 10

        System.out.println("3.14向上取整:"+Math.ceil(3.14));// 4.0
        System.out.println("3.54向上取整:"+Math.ceil(3.54));// 4.0
        System.out.println("-3.54向上取整:"+Math.ceil(-3.54));// -3.0

        System.out.println("==================================");
        System.out.println("3.14向下取整:"+Math.floor(3.14));// 3.0
        System.out.println("3.54向下取整:"+Math.floor(3.54));// 3.0
        System.out.println("-3.54向下取整:"+Math.floor(-3.54));// -4.0

        System.out.println("==================================");
        System.out.println("2的3次幂:"+Math.pow(2,3));// 8.0

        System.out.println("==================================");
        System.out.println("3.14四舍五入取整:"+Math.round(3.14));// 3
        System.out.println("3.54四舍五入取整:"+Math.round(3.54));// 4
        System.out.println("-3.54四舍五入取整:"+Math.round(-3.54));// -4


        System.out.println("==================================");
        System.out.println("获取10和20的最大值:"+Math.max(10,20));// 20
        System.out.println("获取10和20的最小值:"+Math.min(10,20));// 10

九、System类

一、解释

java.lang.System`类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

二、System类常用方法

1.终止当前运行的Java虚拟机，非零表示异常终止

 //public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
        System.out.println("开始");
        System.out.println("执行");
        //System.exit(0);// 程序正常退出
        //System.exit(-1);// 程序非正常退出

2.返回当前时间距离标准基准时间的毫秒值(以毫秒为单位)

 //public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值(以毫秒为单位)
      // 获取当前时间距离标准基准时间的毫秒值
        Date date = new Date();
        System.out.println(date.getTime());
        System.out.println(System.currentTimeMillis());

3.拷贝数组中的元素到另一个数组

  /*public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
 拷贝数组中的元素到另一个数组
                          参数1src: 源数组
                          参数2srcPos:源数组要拷贝的元素的起始索引(从哪个索引位置开始拷贝)
                          参数3dest: 目标数组
                          参数4destPos:目标数组接收拷贝元素的起始索引(从哪个索引位置开始接收)
                          参数5length:需要拷贝多少个元素(拷贝多少个)*/
                          // 拷贝数组元素到另一个数组中
        int[] arr1 = {1,2,3,4,5,6,7,8};
        int[] arr2 = {10,20,30,40,50,60,70,80};
        // 需求:把arr1中的3,4,5,6,7元素拷贝到arr2数组中,使得arr2数组变成{10,3,4,5,6,7,70,80};
        System.arraycopy(arr1,2,arr2,1,5);

十、BigInteger类

一、解释

java.math.BigInteger 类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用
BigInteger类实现，该类的计算整数是不限制长度的。

二、构造方法

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

三、常用方法（加、减、乘、除）

 // 创建一个BigInteger类的对象,表示一个无限大的整数
        BigInteger b1 = new BigInteger("1000000000000000000000");
        BigInteger b2 = new BigInteger("1223435453543654354354");

        // b1 + b2
        BigInteger res1 = b1.add(b2);
        System.out.println("b1 + b2 = "+res1);// 2223435453543654354354

        // b1 - b2
        BigInteger res2 = b1.subtract(b2);
        System.out.println("b1 - b2 = " + res2);// -223435453543654354354

        // b1 * b2
        BigInteger res3 = b1.multiply(b2);
        System.out.println("b1 * b2 = "+res3);// 1223435453543654354354000000000000000000000

        // b1 / b2
        BigInteger res4 = b1.divide(b2);
        System.out.println("b1 / b2 = " + res4);// 0  10/3=3


        // int a = 1000000000000;// 编译报错,因为超出了int类型所能表示的数据范围
        // long l = 1000000000000000000000L;// 编译报错,因为超出了long类型所能表示的数据范围
    }

十一、BigDecimal类

一、解释

表示超大小数，解决小数运算问题，有些小数运算有精度问题。对于浮点运算，不要使用基本类型，而用"BigDecimal类型。dobule类型的数据封装成BigDecimal还是有精度问题建议用字符串包装。

二、构造方法

1.将double类型的数据封装为BigDecimal对象

//BigDecimal(double val)：将double类型的数据封装为BigDecimal对象
BigDecimal b1 = new BigDecimal(0.09);

2.将 BigDecimal 的字符串表示形式转换为 BigDecimal

//BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal 
BigDecimal b1 = new BigDecimal("0.09");

3.区别
第一种方法还是有可能存在精度问题，推荐使用第二种。

三、BigDecimal类常用方法（加、减、乘、除）

           注意：对于divide方法来说，如果除不尽的话，
                就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法；

                BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode):
                                divisor：除数对应的BigDecimal对象；
                                scale:精确的位数；
                                roundingMode取舍模式  RoundingMode枚举: RoundingMode.HALF_UP 四舍五入

igDecimal b1 = new BigDecimal("0.09");
        BigDecimal b2 = new BigDecimal("0.01");
        BigDecimal res1 = b1.add(b2);
        System.out.println("res1:"+res1);// 0.10

        // 减法运算:
        BigDecimal b3 = new BigDecimal("1.0");
        BigDecimal b4 = new BigDecimal("0.32");
        BigDecimal res2 = b3.subtract(b4);
        System.out.println("res2:"+res2);// 0.68

        // 乘法运算
        BigDecimal b5 = new BigDecimal("1.015");
        BigDecimal b6 = new BigDecimal("100");
        BigDecimal res3 = b5.multiply(b6);
        System.out.println("res3:"+res3);// 101.500

        // 除法运算
        BigDecimal b7 = new BigDecimal("1.301");
        BigDecimal b8 = new BigDecimal("100");
        BigDecimal res4 = b7.divide(b8);
        System.out.println("res4:"+res4);// 0.01301

        // 加法运算: 有问题的
        BigDecimal b9 = new BigDecimal(0.09);
        BigDecimal b10 = new BigDecimal(0.01);
        BigDecimal res5 = b9.add(b10);
        System.out.println("res5:"+res5);// res5:0.0999999999999999968774977432417472300585359334945678710937

        // 除法运算: 有问题的
        /*BigDecimal b11 = new BigDecimal("10");
        BigDecimal b12 = new BigDecimal("3");
        BigDecimal res6 = b11.divide(b12);// 报异常
        System.out.println("res6:"+res6);*/

        /*BigDecimal b13 = new BigDecimal("20");
        BigDecimal b14 = new BigDecimal("3");
        BigDecimal res7 = b13.divide(b14);// 报异常
        System.out.println("res7:"+res7);*/

        // 注意：对于divide方法来说，如果除不尽的话，
        // 就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法；
        BigDecimal b11 = new BigDecimal("10");
        BigDecimal b12 = new BigDecimal("3");
        BigDecimal res6 = b11.divide(b12,2, RoundingMode.HALF_UP);
        System.out.println("res6:"+res6);// 3.33

        BigDecimal b13 = new BigDecimal("20");
        BigDecimal b14 = new BigDecimal("3");
        BigDecimal res7 = b13.divide(b14,3,RoundingMode.HALF_UP);
        System.out.println("res7:"+res7);// 6.667


        // System.out.println(0.09+0.01);// 期望: 0.10     实际:0.09999999999999999
       // System.out.println(1.0 - 0.32);// 期望; 0.68    实际:0.6799999999999999
       // System.out.println(1.015 * 100);// 期望:101.500 实际:101.49999999999999
       // System.out.println(1.301 / 100);// 期望:0.01301 实际:0.013009999999999999
    }

十二、Arrays类

一、解释

java.util.Arrays类：该类包含用于操作数组的各种方法（如排序和搜索）

二、常用方法

1.按照数字顺序排列指定的数组

     //public static void sort(int[] a)：按照数字顺序排列指定的数组
     int[] arr = {12,334,53,543,43,32};
    System.out.println("排序之前的数组:"+Arrays.toString(arr));//[12, 334, 53, 543, 43, 32]
    // 对arr数组中的元素进行升序排序
    Arrays.sort(arr);
    System.out.println("排序之后的数组:"+Arrays.toString(arr));//[12, 32, 43, 53, 334, 543]

2.返回指定数组的内容的字符串表示形式

区分静态的tostring和非静态的tostring()

     //public static String toString(int[] a)：返回指定数组的内容的字符串表示形式
        int[] arr = {12,334,53,543,43,32};
        System.out.println("排序之前的数组:"+Arrays.toString(arr));//[12, 334, 53, 543, 43, 32]
        // 对arr数组中的元素进行升序排序
        Arrays.sort(arr);
        System.out.println("排序之后的数组:"+Arrays.toString(arr));//[12, 32, 43, 53, 334, 543]

十三、包装类

一、解释

ava提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，对基本数据类型进行包装成对象，然后进行操作。

二、包装类分类

十四、Integer类

一、解释

将int类型的基本类型，包装成一个对象类型，为Integer类型。

二、构造方法

1.根据int值创建

//public Integer(int   value)：根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(10);// i1对象表示的整数就是10

2.根据字符串类型创建

   //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
   Integer i3 = new Integer("100");// i3对象表示的整数就是100

三、常用方法

1.返回表示指定的 int 值的 Integer 实例

//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer   实例
 Integer i2 = Integer.valueOf(10);//    i2对象表示的整数就是10

2.返回保存指定String值的 Integer 对象

  //public static Integer valueOf(String s)：返回保存指定String值的 Integer 对象
    Integer i4 = Integer.valueOf("100");// i4对象表示的整数就是100

3.Integer 对象转int基本类型

  Integer i1 = new Integer(10);// i1对象表示的整数就是10
     // Integer--->int
        int num1 = i1.intValue();

十四、装箱和拆箱

一、解释

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

二、自动装箱与拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。

  // int--->Integer
  ///手动装箱，这里也可直接int接收。
    Integer i1 = new Integer(10);// i1对象表示的整数就是10
    Integer i2 = Integer.valueOf(10);//    i2对象表示的整数就是10
    //所有包装类都有valueOf方法转对应的包装类型。

    // 手动拆箱
    // Integer--->int
    int num1 = i1.intValue();
    int num2 = i2.intValue();



    // 自动装箱
    Integer i3 = 10;

    // 自动拆箱
    int num3 = i3;

可以将“包装类”和“基本类型”混合使用，比较方便

十五、字符串和基本类型之间的转换

区分包装类和基本数据类型，字符串是引用数据类型。它和其它基本类型的转换又不一样。

一、基本类型转String

1.直接在数字后加一个空字符串

      //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);

2.通过String类静态方法valueOf()

       int number = 100;
     //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);

二、String类型转基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
  以Integer类为例

 // 基本类型--->字符串:
        String str1 = 100 + "";// str1字符串的内容:"100"
        String str2 = String.valueOf(100);// str2字符串的内容: "100"

        // 字符串--->基本类型:
        int num1 = Integer.parseInt(str1);
        int num2 = Integer.parseInt(str2);
        System.out.println(num1+num2);// 200

如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。