API（Application Programming Interface，应用程序接口）

• 集合Collection
  • 泛型
    • 概述
      • 泛型,不是指一种具体的类型,而是说,这里有个类型需要设置，那么后续具体需要设置成什么类型,得看具体的业务
        • 其实就是< ? >的部分,它就是泛型

          • 

    • 作用
      • 泛型通常与集合一起使用,用来限制集合中存入的元素类型
      • 泛型具体设置成什么类型,那么这个集合只能存这个类型的元素
    • 泛型是一颗“语法糖”
      • 1)泛型可以把报错的时机提前,用于在编译期检查集合的元素类型，只要不是泛型设置的类型,就报错,通不过编译
      • 2)泛型只在编译时生效,编译通过以后,说明符合语法规范，泛型就会被抛弃,编译生成的字节码文件中没有泛型
    • 泛型的类型
      • 必须使用引用类型,比如:Student String Integer
    • 泛型的方法
      • 如果想要在方法上使用泛型,必须两处同时出现
        • 1)一个是方法的参数列表中的参数类型
        • 2)方法返回值类型前的泛型类型,表示这是一个泛型方法
    • 泛型声明

      • 

  • 集合Collection
    • 创建Collection相关的对象
      • Collection c = new Collection();//报错，因为Collection是接口
        • Collection<Integer> c = new ArrayList<>();
    • 概念
      • Collection是集合层次中的根接口
        • 集合的英文名称是Collection,是用来存放对象的数据结构,而且长度可变,可以存放不同类型的对象
    • 与数组性比的优点
      • 提到容器不难想到数组,集合类与数组最主要的不同之处是,数组的长度是固定的,集合的长度是可变的，而数组的访问方式比较单一,插入/删除等操作比较繁琐,而集合的访问方式比较灵活

        • 

    • 集合的继承关系

      • 

    • 是集合层次的根接口，学习抽象父级的公共方法
    • 高效for循环
      • 增强for循环的格式：
        • for(数据类型 变量名 :遍历的目标){ //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素}
    • 方法总结
      • 单个集合的操作
        • boolean add(E e) 将指定元素添加到集合中
        • void clear() 清空集合
        • boolean contains(Object o) 判断本集合是否包含指定的元素
        • boolean equals(Object o) 比较集合对象与参数对象o是否相等
        • int hashCode() 返回本集合的哈希码值。
        • boolean isEmpty() 判断本集合是否为空
        • boolean remove(Object o) 从本集合中移除指定元素o
        • int size() 返回本集合中元素的个数
        • Object[] toArray() 将本集合转为数组
      • 集合间的操作
        • boolean addAll(Collection<> c) 将c集合中的所有元素添加到本集合中
        • boolean containsAll(Collection<> c) 判断本集合是否包含c集合的所有元素
        • boolean removeAll(Collection<> c) 移除本集合中属于参数集合c的所有元素
        • boolean retainAll(Collection<> c) 保留本集合与参数集合c的公共元素
      • 集合的迭代
        • Iterator iterator() 返回本集合的迭代器
          • 迭代步骤:
            • 1.获取迭代器 集合名.iterator();
            • 2.通过迭代器判断集合中是否有下一个元素可以迭代 迭代器.hasNext()
            • 3.获取当前迭代到的元素

              • 

            • 注意:迭代器的泛型取决于要迭代的集合的泛型,比如c2是Integer*/

      • 

  • List接口
    • 概述
      • 有序的colletion(也称为序列).此接口的用户可以对列表中的每个元素的插入位置进行精确的控制,用户可以根据元素的整数索引(在列表中的位置)来访问元素,并搜索列表中的元素.
    • 特点
      • 元素都有下标
      • 数据是有序的
      • 允许存放重复的元素
    • List方法速查表

      • 

    • ArrayList
      • 概述
        • 存在java.util包中
        • 内部是用数组结构存放数据,封装数组的操作,每个对象都有下标
        • 内部数组默认的初始容量是10,如果不够会以1.5倍的容量增长
        • 查询快,增删数据效率会低
      • 创建对象

        • 

      • 特点
        • List的接口实现类
        • 创建ArrayList对象时底层会创建数组用于存放对象，数组的初始容量是10
        • 数组增删慢 因为数组增删需要创建新的数组 查询快 因为数组的内存空间是连续的 （数据量较大的情况下）
        • 元素有下标，有序，允许存放重复元素
        • 通常根据下标进行操作
      • ArrayList扩容
    • LinkedList
      • 概述
        • 链表,两端效率高,底层就是链表实现的

          • 

             

            • 

               

              • 

      • 创建对象
        • LinkedList() 构造一个空列表
      • 特点
        • List的接口实现类
        • 底层数据结构是链表，内存空间不连续
        • 元素有下标，有序，允许存放重复元素
        • 通常进行首尾操作较多
        • 增删快查询慢（数据量比较大时）
          • LinkedList的查询操作也不是很慢，首尾操作快
      • 常用方法
        • void addFirst(E e) 添加首元素
        • void addLast(E e) 添加尾元素
        • E getFirst() 获取首元素
        • E getLast() 获取尾元素
        • E element() 获取首元素
        • E removeFirst() 删除首元素
        • E removeLast() 删除尾元素
        • boolean offer(E e) 添加尾元素
        • boolean offerFirst(E e) 添加首元素
        • boolean offerLast(E e) 添加尾元素
        • E peek() 获取首元素
        • E peekFirst() 获取首元素
        • E peekLast() 获取尾元素
        • E poll() 返回并移除头元素
        • E pollFirst() 返回并移除头元素
        • E pollLast() 返回并移除尾元素
  • Set接口
    • 概述
      • Set是一个不包含重复数据的Collection
      • Set集合中的数据是无序的(因为Set集合没有下标)
      • Set集合中的元素不可以重复 – 常用来给数据去重
    • Set集合的特点
      • 数据无序且数据不允许重复
        • HashSet : 底层是哈希表，包装了HashMap，相当于向HashSet中存入数据时，会把数据作为K，存入内部的HashMap中。当然K仍然不许重复。
        • TreeSet : 底层是TreeMap,也是红黑树的形式,便于查找数据
  • Map接口
    • 概述
      • Java.util接口Map<K,V>
      • 类型参数 : K - 表示此映射所维护的键 V – 表示此映射所维护的对应的值，也叫做哈希表、散列表. 常用于键值对结构的数据.其中键不能重复,值可以重复

        • 

    • 特点
      • Map可以根据键来提取对应的值
      • Map的键不允许重复,如果重复,对应的值会被覆盖
      • Map存放的都是无序的数据
      • Map的初始容量是16,默认的加载因子是0.75
    • 继承结构

      • 

    • 常用方法
      • void clear() 从此映射中移除所有映射关系（可选操作）
      • boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true
      • boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true
      • Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图
      • boolean equals(Object o) 比较指定的对象与此映射是否相等
      • V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
      • int hashCode() 返回此映射的哈希码值
      • boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true
      • Set keySet() 返回此映射中包含的键的 Set 视图
      • V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）
      • void putAll(Map m)从指定映射中将所有映射关系复制到此映射中（可选操作）
      • V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
      • int size() 返回此映射中的键-值映射关系数
      • Collection values() 返回此映射中包含的值的 Collection 视图
    • Map的迭代
      • 方式一： * 遍历map中的数据，但是map本身没有迭代器，所以需要先转换成set集合 * Set<Key>:把map中的所有key值存入到set集合当中--keySet()*/
      • 方式二： * 遍历map集合，需要把map集合先转成set集合 * 是把map中的一对键值对key&value作为一个Entry<K,V>整体放入set * 一对K,V就是一个Entry*/

      • 

    • HashMap
      • 前言
        • HashMap的键要同时重写hashCode()和equlas()
        • hashCode()用来判定二者的hash值是否相同,重写后根据属性生成
        • equlas()用来判断属性的值是否相同,重写后,根据属性判断
          • –equlas()判断数据如果相等,hashCode()必须相同
          • –equlas()判断数据如果不等,hashCode()尽量不同
      • HashMap的存储过程：
        • HashMap的结构是数组+链表 或者 数组+红黑树 的形式
        • HashMap底层的Entry[ ]数组，初始容量为16，加载因子是0.75f,扩容按约为2倍扩容
        • 当存放数据时,会根据hash(key)%n算法来计算数据的存放位置，n就是数组的长度,其实也就是集合的容量
        • 当计算到的位置之前没有存过数据的时候,会直接存放数据
        • 当计算的位置,有数据时,会发生hash冲突/hash碰撞
          • 解决的办法就是采用链表的结构,在数组中指定位置处以后元素之后插入新的元素
          • 也就是说数组中的元素都是最早加入的节点
        • 如果链表的长度>8且数组长度>64时，链表会转为红黑树，当链表的长度<6时，红黑树会重新恢复成链表

        • 

 

• IO流
  • File文件类
    • 概述
      • 封装一个磁盘路径字符串,对这个路径可以执行一次操作
      • 可以封装文件路径、文件夹路径、不存在的路径
    • 常用方法

      • 

  • IO流
    • 流Stream
      • 为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意:
        • 1.流只能单方向流动
        • 2.输入流用来读取 → in
        • 3.输出流用来写出 → out
        • 4.数据只能从头到尾顺序的读写一次
        • 所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.

          • 

    • 修改
      • 流的分类
        • 根据方向：输入流 输出流
        • 根据操作单位：字节流 字符流
        • 具体分类
          • 字节输入流InputStream：
            • InputStream--抽象父类--不能实例化
            • FileInputStream--文件字节输入流-FIS
            • BufferedInputStream--高效字节输入流-BIS
              • FIS in = new FIS(new File(路径));
              • FIS in = new FIS(路径)；
              • BIS in = new BIS( new FIS(new File(路径)));
              • BIS in = new BIS(new FIS(路径));
          • 字节输出流OutputStream：
            • OutputStream--抽象父类，不能实例化
            • FileOutputStream--文件字节输出流--FOS
            • BufferedOutputStream--高效字节输出流-BOS
              • FOS out = new FOS(new File(路径));
              • FOS out = new FOS(路径);
              • BOS out = new BOS(new FOS(new File(路径)));
              • BOS out = new BOS(new FOS(路径))；
          • 字符输入流Reader：
            • Reader--抽象父类--不能实例化
            • FileReader--文件字符输入流-FR
            • BufferedReader--高效字符输入流-BR
              • FR in = new FR(new File(路径));
              • FR in = new FR(路径)；
              • BR in = new BR(new FR(new File(路径)))
              • BR in = new BR(new FR(路径));
          • 字符输出流Writer：
            • Writer--抽象父类，不能实例化
            • FileWriter--文件字符输出流--FW
            • BufferedWriter--高效字符输出流--BW
              • FW out = new FW(File/File,append/String pathname/String pathname,append);
              • BW out = new BW(Writer--所以传的是子类FW(上面那4种));
              • 注意：这里的append参数表示流向文件输出数据的时候是追加还是覆盖，如果不写，默认false是覆盖
      • 序列化与反序列化
        • 序列化与反序列化的作用就是对象的保存与传输
          • 序列化：把内存中的对象通过序列化流输出到磁盘中(比如文件里),使用的流是ObjectOutputStream【把数据写出到文件】
          • 反序列化：通过反序列化流将磁盘中的数据恢复成对象,使用的流是ObjectInputStream【把之前写到文件里的数据读到程序中】
        • 注意事项
          • 注意1：一个类的对象如果想被序列化，那么这个类必须实现可序列化接口
            • 实现这个接口的目的是相当于给这个类做了一个标记，标记可以序列化
          • 注意2：序列化时会自动生成一个UID，表示当前序列化输出的对象的版本信息
            • 反序列化时会拿着当前的UID与之前序列化输出的UID做比较，一致，反序列化成功，不一致，报错
          • 注意3: 所以，标准操作是一次序列化对应一次反序列化
            • 如果目标对象所在的类没有做任何修改，一次序列化也可以对应多次反序列化(根本原因是UID没变)
  • 序列化和反序列化
    • 概念
      • 序列化是指将对象的状态信息转换为可以存储或传输形式的过程.在序列化期间,对象将其当前状态写入到临时或持久性存储区.以后可以通过从存储区中读取或者反序列化对象的状态,重新创建该对象.
        • 序列化:利用ObjectOutputStream,把对象的信息,按照固定的格式转成一串字节值输出并持久保存到磁盘
          • 将程序中对象的各项信息，序列化输出到文件中保存
          • 方向是Out,使用的流是ObjectOutputStream
          • 使用的方法是out.writeObject(目标对象)；
          • 注意：如果一个类的对象想要被序列化，那么这个类必须实现Serializable接口
        • 反序列化:利用ObjectInputStream,读取磁盘中之前序列化好的数据,重新恢复成对象
          • 将之前输出到文件中的数据，读取回程序中，并把读到的数据重新恢复成对象
          • 方向是in,使用的流是ObjectInputStream
          • 使用的方法是in.readObject();
          • 注意：反序列化指定的文件路径，必须与序列化输出的文件路径一样
          • 注意:自定义类需要重写toString()才能查看对象的属性与属性值,否则打印地址值
          • 注意：一次序列化操作对应一次反序列化操作，或者UID必须保持一致，如果不一致，会报错
    • 关系图

      • 

    • 反序列化如何成功?
      • 核心:Student类中的UID,与反序列化流中的UID保持一致
        • 1)一次序列化对应一次反序列化[推荐]
        • 2)一次序列化后不修改Student中的内容，然后反序列化
        • 3)将Student中的UID写成固定值
      • 注意：反序列化流持有的UID与Student类中的UID不一致时,反序列化会失败
    • 常见小错误
      • NotSerializableException:
        • 报错原因:要序列化对象所在的类并没有实现序列化接口
        • 解决方案:实现序列化接口
      • InvalidClassException:
        • 报错原因:本次反序列化时使用的UID与序列化时的UID不匹配
        • 解决方案:反序列化时的UID与序列化时的UID要保持一致，或者测试时一次序列操作对应一次反序列化操作,否则不匹配就报错
    • 为什么反序列化版本号需要与序列化版本号一致
      • 我们在反序列化时，JVM会拿着反序列化流中的serialVersionUID与序列化时相应的实体类中的serialVersionUID来比较，如果不一致，就无法正常反序列化，出现序列化版本不一致的异常InvalidClassException
      • 而且我们在定义需要序列化的实体类时，如果没有手动添加UID,Java序列化机制会根据编译的class自动生成一个，那么只有同一次编译生成的class才是一样的UID
      • 如果我们手动添加了UID,只要这个值不修改，就可以不论编译次数，进行序列化和反序列化操作。

 

• API（Application Programming Interface，应用程序接口）
  • 什么是API
    • 是一些预先定义的函数,一种通用功能集，是一些别人制定或者写好的应用程序接口/功能
    • 目的是提供应用程序与开发人员基于某软件可以访问的一些功能集，但又无需访问源码或理解内部工作机制的细节.
    • Java.util包是java中的工具包,包含各种实用工具类/集合类/日期时间工具等各种常用工具包
    • java.lang包是java的核心,包含了java基础类
      • 包括基本Object类/Class类/String类/基本数学类等最基本的类,这个包无需导入,默认会自动导入
  • Object
    • 顶级父类
    • 如果一个类没有明确的指定父类，那么这个类默认继承Object
    • java.lang包是Java的核心包，无需导包，会自动导入
    • 常用方法介绍
      • toString()
        • 本方法用于返回对应对象的字符串表示
          • 默认实现是 ：对象包名.类名@十六进制的哈希码值
          • 子类重写了父类Object中的toString()以后，不再打印对象的地址值，子类重写了toString()以后：打印是对象的类型+属性+属性值
      • hashCode()
        • 用于返回对应对象的哈希码值
          • hashCode() 作用 根据对象地址值返回相应对象的int类型的哈希码值目的 让不同的对象返回不同的哈希码值，用来区分对象
      • equals()
        • 用于指示其他某个对象是否与当前对象”相等”
          • ==比较的是值 基本类型比较的是字面值 引用类型比较的是引用类型变量引用地址值
          • Object中的equals()默认使用==进行比较，比较的结果实际上取决于equals()方法的具体实现
            • equals()和hashCode()逻辑上要保持一致 要重写全部重写，要不全部不重写
              • 如果不重写：hashCode()的哈希码根据地址值生成 equals()底层使用==比较两个对象的地址值
              • 如果重写了：hashCode()的哈希码根据重写传入的属性值生成 equals()比较的是重写后类型 + 所有属性与属性值
  • String
    • String是一个封装char[]数组的对象,字符串不可变
      • 创建String对象的方式
        • String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
        • String str = “abc”;

          • 

             
            • 如果是第一次使用字符串，java会在字符串堆中常量池创建一个对象。
            • 再次使用相同的内容时，会直接访问堆中常量池中存在的对象。
      • String API总结
        • 继承的方法
          • int hashCode() 返回此字符串的哈希码。
          • boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容
          • String toString() 返回此对象本身（它已经是一个字符串！）。
        • int length() 返回此字符串的长度。
        • String toUpperCase() 所有字符都转换为大写。
        • String toLowerCase() 所有字符都转换为小写
        • boolean startsWith(String prefix) 测试此字符串是否以指定的元素开头。
        • boolean endsWith(String suffix) 测试此字符串是否以指定的字符串结束。
        • char charAt(int index) 返回指定索引/下标处的 char 值/字符
        • int indexOf(String str) 返回指定字符在此字符串中第一次出现处的索引。
        • int lastIndexOf(String str) 返回指定字符在此字符串中最后一次出现处的索引。
        • String concat(String str) 将指定字符串连接/拼接到此字符串的结尾,注意:不会改变原串
        • String[] split(String regex) 根据给定元素来分隔此字符串。
        • String trim() 返回去除首尾空格的字符串
        • byte[] getBytes() 把字符串存储到一个新的 byte 数组中
        • String substring(int beginIndex) 返回一个新子串,从指定下标处开始,包含指定下标
        • String substring(int beginIndex, int endIndex) 返回一个新子串,从执定下标开始,到结束下标为止,但不包含结束下标
        • static String valueOf(int i) 把int转成String
    • Java String的内存机制
      • 方式一
        • String 引用变量名="字符串内容";

          • 

             
            • 查看字符串常量池中是否存在内容与“osEye.net”相同的字符串对象。
            • 若没有，则新创建一个包含该内容的字符串对象，并让引用变量指向该对象。例如，创建字符串s1的时候，字符串常量池中没有，则创建一个新对象，并让引用s1指向该对象。
            • 若已经存在包含该内容的字符串对象，则让字符串引用直接指向该对象。例如，在创建字符串s2的时候，字符串常量池中已经有包含该内容的对象了，所以引用s2直接指向已有的对象。
      • 方式二
        • String 应用变量名=new String(<参数序列>);

          • 

             
            • 首先在堆（不是常量池）中创建一个包含指定内容的字符串对象，并将字符串引用指向该对象。例如上述代码中，使用new创建字符串s3，其会直接在堆中创建一个内容为“osEye.net”的字符串对对象，并将引用s3指向该对象。
            • 去字符串常量池中查看，是否有包含该内容的对象。
            • 若有，则将new出来的字符串对象与字符串常量池中内容相同的对象联系起来。例如，本例中s3所指向的对象与s1所指向的联系起来。
            • 若没有，则在字符串常量池再创建一个包含该内容的字符串对象，并将堆中的对象与字符串常量池中新创建出来的对象联系起来。
      • 总结
        • 字符串引用s1和字符串引用s2所指向的不是同一个对象
        • 字符串引用s1和字符串引用s2在字符串常量池中联系的是同一个对象
    • StringBuilder/StringBuffer
      • 特点
        • 封装了char[]数组
        • 是可变的字符序列
        • 提供了一组可以对字符内容修改的方法
        • 常用append()来代替字符串做字符串连接”+”
        • 内部字符数组默认初始容量是16：super(str.length() + 16);
        • 如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
        • StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全
    • ==和equals的区别
      面试必问
      • 1.当使用= =比较时，如果相比较的两个变量是引用类型，那么比较的是两者的物理地值（内存地址），如果相比较的两个变量都是数值类型，那么比较的是具体数值是否相等。
      • 2.当使用equals()方法进行比较时，比较的结果实际上取决于equals()方法的具体实现
        • 任何类都继承自Object类，因此所有的类均具有Object类的特性，比如String、integer等，他们在自己的类中重写了equals()方法，此时他们进行的是数值的比较，而在Object类的默认实现中，equals()方法的底层是通过==来实现的。
          • 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
          • 情况2：String中的equals方法是被重写过的，因为object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
        • equals()和hashCode()逻辑上要保持一致 要重写全部重写，要不全部不重写
          • 如果不重写：hashCode()的哈希码根据地址值生成 equals()底层使用==比较两个对象的地址值
          • 如果重写了：hashCode()的哈希码根据重写传入的属性值生成 equals()比较的是重写后类型 + 所有属性与属性值
    • StringBuilder和StringBuffer的区别
      • 1.在线程安全上 :
        • –StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
        • –StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
      • 2. 在执行效率上，StringBuilder > StringBuffer > String
      • 3.源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。
        • 小结：
          • （1）如果要操作少量的数据用 String；
          • （2）多线程操作字符串缓冲区下操作大量数据 StringBuffer；
          • （3）单线程操作字符串缓冲区下操作大量数据 StringBuilder。
  • 正则表达式Regex
    • 概述
      • 正确的字符串格式规则。
      • 常用来判断用户输入的内容是否符合格式的要求，注意是严格区分大小写的。
    • 常见语法

      

  • 包装类
    • 概述
      • 包装类是引用类型中的一种，包装类与基本类型一一对应，也有8种
      • Java的数据类型只有两大类：8大基本类型与引用类型
      • 把基本类型进行包装，提供更加完善的功能。
        • 包装类是基本数据类型的扩展
      • 基本类型是没有任何功能的,只是一个变量,记录值,而包装类可以有更加丰富的功能
        • 基本类型只能存对应类型的值
        • 引用数据类型保存的是对象
      • 包装类也是引用类型 默认值是Null
    • 与基本类型的对应关系

      • 

    • 创建方式
      • Integer i=new Integer(5);
      • Integer i=Integer.valueOf(5);
    • Integer
      • Integer 有一种高效的效果(只有Integer有高效效果)，
        • 满足条件 相同数据只存一次，后续使用的都是之前存过的数据。
          • 需要满足三个条件：
            • Interger这个类
            • 使用创建方式是valueOf()
            • 包装类的基本类型再byte基本类型内，
      • parseInt
        • 对象是什么类型的，就可以使用这个类的所有资源
          • parseInt()将String类型的数据转为int类型
          • parseDouble()将String类型的数据转为double类型
    • Number
      • 数字包装类的抽象父类。
      • 提供了各种获取值的方式。
  • 自动装箱和自动拆箱
    • 概述
      • 自动装箱：把 基本类型 包装成对应的 包装类型 的过程
      • 自动拆箱：从包装类型的值，自动变成 基本类型的值
  • BigDecimal
    • BigDecimal：常用来解决精确的浮点数运算不精确的问题
      • 创建对象
        • 方式一 :
          • BigDecimal(double val)
            • 将double转换为BigDecimal,后者是double的二进制浮点值十进制表示形式,有坑!
        • 方式二 :
          • BigDecimal(String val)
            • 将String类型字符串的形式转换为BigDecimal
      • 常用方法
        • Add(BigDecimal bd) : 做加法运算
        • Subtract(BigDecimal bd) : 做减法运算
        • Multiply(BigDecimal bd) : 做乘法运算
        • Divide(BigDecimal bd) : 做除法运算,除不尽时会抛异常
        • Divide(BigDecimal bd,保留位数,舍入方式) : 除不尽时使用
        • setScale(保留位数,舍入方式) : 同上
        • pow(int n) : 求数据的几次幂
    • 创建对象时候要加空字符串