javaSE (四) ：常用类-CSDN博客

本文链接：https://blog.csdn.net/m0_70830675/article/details/137019417

一、Java API概述

● API(Application Programming Interface)应用程序编程接口

是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明

二、Object类

●Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都继承实现这个类的方法。

● 如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

public class Person { ... }

等价于：

public class Person extends Object {

...

}

1、toString方法

● Object类中定义有public String toString()方法，其返回值是 String类型，描述当前对象的有关信息。

● 当需要通过输出语句输出一个对象时,如System.out.println(person），将自动调用该对象类的toString()方法,如果该类中没有重写toString(),那么默认调用Object类中的toString(),默认输出对象hashCode值.

● 可以根据需要在用户自定义类型中重写toString()方法。

比如看下面这个代码，自定义一个Person类中重写了toString（）方法，则可以通过输出语句输出一个对象

public class Person {

       private String name;
       private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    public static void main(String[] args) {
       Person p = new Person("张三",13);
            System.out.println(p);
    }
}

2、equals方法

● Object类中定义有：

● public boolean equals(Object obj)方法,判断对象是否相等的逻辑。

public boolean equals(Object obj) {

return (this == obj);

}

● Object 中的 equals 方法默认使用==比较,比较的是对象地址,这点需要注意.

● JDK提供的一些类，如String，Date等，重写了Object的equals方法，把它改造为比较对象中的内容是否相等。调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象是同一类对象且属性内容相等返回 true 否则返回 false。

比如看下面这个代码，自定义一个Person类中重新定义了equals（）方法，则所引用的对象是同一类对象且属性内容相等返回 true

public class Person {

       private String name;
       private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person other = (Person)obj;
            return name.equals(other.name) && age == other.age;
        }
        return false;
    }
    public static void main(String[] args) {

        Person p1 = new Person("汪洋",13);
        Person p2 = new Person("汪洋",13);
        System.out.println(p1.equals(p2));//输出true
    }
}

三、Arrays类

● java.util.Arrays类用于操作数组工具类，里面定义了常见操作数组的静态方法.

1、equals 方法

比较两个数组对象中元素是否相等.

而数组对象中的equals用来判断与另一个数组对象是否相等。

声明：public static boolean equals(type[]a,type[]a2)

参数的类型可以是原生数据类型和引用类型的任意一种类型

返回：如果两个相等，则返回true，否则返回false

long[] a = {1,2,3,4};
long[] b = {1,2,3,3};
System.out.println(Arrays.equals(a,b));

2、copyOf（）数组复制方法

数组复制，将原数组内容复制到一个指定长度的新数组中

int[] c = new int[5];
       c[0] = 1;
       c[1] = 2;
       c[2] = 3;
       c[3] = 4;
       c[4] = 5;
int[] d = Arrays.copyOf(c,10);
System.out.println(Arrays.toString(d));

3、fill（）填充方法

用指定的值将指定数组中的每个元素填充

int[] e = {1,2,3,4,5};
Arrays.fill(e,0);
System.out.println(Arrays.toString(e));

4、toString(）方法

将数组中的元素内容拼接为一个字符串输出

5、sort排序方法

基本数据类型：

● 作用于数组的所有元素（没有指定区间默认全部排序）

public static void sort(type[] a)

● 作用于数组指定范围内的元素

public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))

将指定的类型数组所有元素按数字升序进行排序。

public class Arrays2 {
    public static void main(String[] args) {
        //对指定的数组进行升序排序
        //  ①没有指定区间
        int[] a = {5, 4, 3, 2, 1};
        Arrays.sort(a);//没有指定区间默认全部排序0——length-1
        System.out.println(Arrays.toString(a));

        //  ②指定区间  Arrays.sort(a,开始排序的位置，结束排序的位置)
        Arrays.sort(a, 0, 3);
        System.out.println(Arrays.toString(a));
     }
}

引用数据类型：

● 自定义对象排序

自定义类实现Comparable接口，转为统一格式

重写compareTo方法，用来指定排序规则，可以指定用类中哪个属性作为排序的项，这个方法在sort底层调用

public class Student implements Comparable<Student>{

    private int id;
    private String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    //用来指定排序规则，可以指定用类中哪个属性作为排序的项,这个方法在sort底层调用
    @Override
    public int compareTo(Student o) {
       // return this.id - o.id;//  小于0 等于0 大于0
       // return this.name.compareTo(o.name); 正序排序
        return o.name.compareTo(this.name);//倒序排序
    }
    public static void main(String[] args) {
        Student s1 = new Student(1,"张三1");
        Student s2 = new Student(2,"张三2");
        Student s3 = new Student(3,"张三3");
        Student s4 = new Student(4,"张三4");
        Student s5 = new Student(5,"张三5");

        Student[] students = new Student[5];
                  students [0] = s2;
                  students [1] = s1;
                  students [2] = s4;
                  students [3] = s5;
                  students [4] = s3;

         Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

}

输出结果：

[Student{id=5, name='张三5'}, Student{id=4, name='张三4'}, Student{id=3, name='张三3'}, Student{id=2, name='张三2'}, Student{id=1, name='张三1'}]

3、binarySearch二分搜索算法搜索指定数组

public static int binarySearch(type[] a, type key)

● 参数：

a - 要搜索的数组。

key - 要搜索的值。

● 前提是必须要有序，先对数组进行排序

● 如果key在数组中，则返回搜索值的索引；否则返回负数,表示不存在

public class Arrays2 {
    public static void main(String[] args) {
//binarySearch() 二分搜索算法查找指定的位置元素，如果未找到显示负数，前提是必须有序
        int b [] = {2,3,4,5,1};
        Arrays.sort(b);//{1,2,3,4,5}
        int index = Arrays.binarySearch(b,1);
        System.out.println(index);
    }
}

四、基本数据类型包装类

1、基本数据类型包装类的含义

● Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基本数据类型对应的类统称为包装类.

● 包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

对于包装类来说，这些类的用途主要包含两种：

● 作为和基本数据类型对应的类类型存在。

● 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

2、包装类常用属性方法

● 以下方法以java.lang.Integer为例

public static final int MAX_VALUE 最大的int型数（231-1）

public static final int MIN_VALUE 最小的int型数（-231）

构造方法

Integer(int a);

Integer(String a);

静态方法

非静态方法

static int compareTo(Integer a);

boolean equals(Object);

int max(int a,int b);

int min(int a,int b);

转换方法

①包装类型转为基本类型

②基本类型转包装类型

3、自动拆箱和自动装箱

①自动拆箱：引用类型转为基本类型

会默认调用intValue（）方法

public class IntegerDemo1 {
    public static void main(String[] args) {
        Integer a = new Integer(10);
        Integer b = new Integer(10);
        //自动拆箱：引用类型转为基本类型
        //int c = a.intValue();
        int c = a;//自动拆箱 会默认自动的调用intValue()方法
    }
}

②自动装箱：基本类型转为引用类型

会默认调用valueOf()方法

public class IntegerDemo1 {
    public static void main(String[] args) {
        //自动装箱：基本类型型转为引用类型
             /*在自动装箱时，会默认调用valueOf()方法
               在valueOf()中如果基本类型值在-128——+127之间，会从缓存中的数组中直接取出一个Integer对象，减少创建次数
               如果两个值相等，获取的是同一个对象
               基本类型值如果不在 -128——+127 区间，每次都会创建一个新Integer对象返回 */
        int x = 1000;
        //Integer yy = Integer.valueOf(x);
        Integer y = x;
        Integer z = x;
        System.out.println(y==z);//x=10 true x=128 false
        System.out.println(y.equals(z));//true
    }
}

五、String类/StringBuffer类/StringBuilder类

1、String类

● String类概述

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字符串都是String类的实例.

①有两种创建形式

第一种: String s = "abc";

先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向改地址即可,不用重新创建.

第二种: String s = new String("abc");

一概在堆中创建新对象，值存储在堆内存的对象中。

public class String1 {
    public static void main(String[] args) {
         /*
    java.lang.String:
    java中所有字符串都是此类的实例 比如："abc","哈哈","33234$"
    "abc":字符串对象 底层是一个char数组 private final char value[];
    字符串的创建方式分为两种：
    ①String s = "abc";
     创建时，先去字符串常量池中，查找有没有相同值的对象如果没有就创建一个字符串对象，并返回地址
    如果字符串常量中已经存储，不用再创建新的，直接返回已存在的对象的地址
    ②String s1 = new String("abc");
     new每次都是在堆中创建新的字符串对象
     */
        String s = "abc";
        String ss = "abc";
        System.out.println(s==ss);//true
        System.out.println(s.equals(ss));//true

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1==s2);//false
        System.out.println(s1.equals(s2));//true
    }
}

②构造方法

public String()

public String(String s)

public String(byte[] bytes)把字节数组转为字符串

public String(char[] chars)把char数组转为字符串

public class String3 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s1 = new String();
        String s2 = new String("abc");
        //比如微信聊天输入
       /* String s3 = "你好";
        byte[] bytes = s3.getBytes();//编码  把字符转为字节数组（数字）
        System.out.println(Arrays.toString(bytes));

        String s4 = new String(bytes);//解码  把字节数组转为字符
        System.out.println(s4);
        */

        String s3 = "你好";
        byte[] bytes = s3.getBytes("GBK");//编码  把字符转为字节数组（数字）
        System.out.println(Arrays.toString(bytes));

        String s4 = new String(bytes,"GBK");//解码  把字节数组转为字符
        System.out.println(s4);
       
        String s4 = "你好abc";
        char [] chars = s4.toCharArray();
        Arrays.sort(chars);
        String s5 = new String(chars);
        System.out.println(s5);

    }
}

③判断功能

boolean equals(Object obj);比较字符串对象中内容是否相等

boolean equalsIgnoreCase(String str);比较字符串对象中内容是否相等，忽略大小写

boolean contains(String str);判断字符串中是否包含指定的子串

boolean isEmpty();判断字符串值是否为“”

boolean startsWith(String prefix);判断是否以指定的字符串开头

boolean endsWith(String suffix);判断是否以指定的字符串结尾

public class String5 {
    public static void main(String[] args) {
        String s1 = new String("abcd");
        String s2 = new String("abcD");
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true
        System.out.println(s1.contains("ab"));//true
        System.out.println(s1.isEmpty());//false
        System.out.println(s1.startsWith("ac"));//false
        System.out.println(s1.endsWith("cd"));//true
    }
}

④获取功能

int length();获取字符串长度

char charAt(int index);获取指定位置上的字符

int indexOf(String str);返回的字符串首次出现的位置

int indexOf(String str,int fromIndex);从指定的位置开始查找，返回的指定字符串首次出现的位置

int lastIndexOf("c");从后向前查找，返回的指定字符串首次出现的位置

String substring(int start);从指定的开始位置开始截取一个字符串副本到完

String substring(int start,int end);从指定的开始位置开始截取一个字符串副本到指定位置(不包含结束位置)

public class String6 {
    public static void main(String[] args) {
        String s1 = "abcdefgcd";
                 //  012345678
        System.out.println(s1.length());

        System.out.println(s1.charAt(4));
        for(int i = 0;i<s1.length();i++){
            System.out.println(s1.charAt(i));
        }//每个位置上的字符进行遍历

        System.out.println(s1.indexOf("cd"));
        System.out.println(s1.indexOf("c",3));

        System.out.println(s1.lastIndexOf("c"));
        System.out.println(s1.lastIndexOf("c",6));

        String s2 = s1.substring(3);
        String s3 = s1.substring(0,6);
        System.out.println(s2);
        System.out.println(s3);
    }
}

⑤转换功能

byte[] getBytes();将字符串转为byte数组

char[] toCharArray();将字符串转为字符数组

static String valueOf(char[] chs);将传入的char数组转为字符串类型

static String valueOf(int a);将传入的参数转为字符串类型

String toLowerCase();将英文字母转为小写

String toUpperCase();将英文字母转为大写

String concat(String str);拼接指定的字符串内容到原字符串末尾，返回一个新的字符串对象

Stirng[] split(分割符);将一个字符串用指定的分隔符拆分成一个字符串数组

public class String7 {
    public static void main(String[] args) {
        String s = String.valueOf(1000);//将传入的参数转为字符串类型
        System.out.println(s.charAt(1));
        int a = Integer.parseInt(s);//又将字符串转为int类型

        String s1 = String.valueOf("abc".toCharArray());//先将字符串转为数组
        System.out.println(s1);

        String s2 = "account=admin;account=123;account=456";
        System.out.println(s2.toLowerCase());
        System.out.println(s2.toUpperCase());

        String s3 = s2.concat("aaa");//s+="aaa"
        System.out.println(s3);
    }
}

⑥替换功能

String replace(char old,char new);
String replace(String old,String new);用新内容替换字符串中指定的字符串
replaceAll(String regex, String replacement);用新的内容替换字符串中正则表达式匹配的字符串
replaceFirst(String regex, String replacement);用新的内容替换字符串中正则表达式匹配的字符串，只替换第一个

⑦去除字符串两空格

String trim()

public class String8 {
    public static void main(String[] args) {
        String s = " abce7fgh8e";
        System.out.println(s.replace("7","A"));//abceAfgh8e
        System.out.println(s.replaceAll("\\d","A"));//abceAfghAe
        System.out.println(s.replaceFirst("\\d","A"));//abceAfgh8e

        System.out.println(s.length());//11
        System.out.println(s.trim().length());//10

    }
}

2、StringBuffer类

● StringBuffer类概述

因为String声明的字符串对象值一旦给定就不能再改变了，每次拼接，都会构建一个新的String 对象，既耗时，又浪费空间。而StringBuffer是内容可以改变的字符串，就可以解决这个问题（线程安全的可变字符序列）

①构造方法

public StringBuffer()

public StringBuffer(String str)

②添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

③删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,int end)

④替换功能

public StringBuffer replace(int start,int end,String str)

⑤反转功能

public StringBuffer reverse()

⑥截取功能

public String substring(int start)

public String substring(int start,int end)

public class StringBuffer1 {
    public static void main(String[] args) {
       StringBuffer s1 = new StringBuffer("abcd");//创建 内容长度+16的char数组
       StringBuffer s2 = new StringBuffer();//空参的构造方法，指定底层数组长度为16
       StringBuffer s3 = new StringBuffer(10);//指定数组容量
             s1.append("abcd");
             s1.append("efg");
             s1.append("hijk");
             s1.append("aaaa");
        s1.insert(1,"A");//向指定位置上插入指定的字符串
        s1.deleteCharAt(1);//删除指定位置上的字符
        s1.delete(0,3);//删除指定区间元素（包括开始不包括结尾）
        s1.replace(0,3,"AAA");//替换字符串
        s1.reverse();//反转字符
        System.out.println(s1);
    }
}

● 截取功能和前面几个功能的不同

返回值类型是String类型，本身没有发生改变

● StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程安全的

3、StringBuilder类

适用于单线程下在字符缓冲区进行大量操作的情况

public class StringBuilder1 {
    public static void main(String[] args) {
      
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder("abcd");
        StringBuilder s3 = new StringBuilder(10);
                      s3.append("");
                      s3.insert(1,"");
    }
}

4、三者比较

● String：是字符常量,适用于少量的字符串操作的情况

● StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

● StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

5、正则表达式

相应的规则：

[0-9] [1-9][357][a-z][A-z0-9] * + {n} {n,} {n,m}

\d匹配数字 \D匹配非数字

\w匹配数字字母下划线 \W非数字字母下划线

\s匹配空格字符 \S非空格字符

|逻辑或

.匹配任意字符，使用时需要转义

[\\u4e00-\\u9fa5] 匹配汉字

①数字类

正则表达式(Regular Expression),简称regex

正则表达式是一种规则（模式）匹配语法

可以使他一些正则表达式中定义的特殊符号来定义一种规则，然后此规则去匹配某个字符串

如果字符串与规则相匹配返回true，否则返回false

比如：验证一个字符串是否是中国大陆地区的手机号格式？可以使用正则表达式，定义一个规则去匹配即可（长度11位开头是不是1 判断第二位判断之后的每位是数字）

public class RegExDemo1 {
    public static void main(String[] args) {
      
        String s = "15328887574";
        System.out.println(s.matches("[0-9]*"));//允许出现0次或多次数字
        System.out.println(s.matches("[0-9]+"));//允许出现一次或多次数字
        System.out.println(s.matches("1[0-9]{3}"));//只能是n次
        System.out.println(s.matches("[0-9]{3,}"));//至少是n次
        System.out.println(s.matches("[0-9]{3,6}"));//至少n次，不大于m次
        System.out.println(s.matches("[357]{3,6}"));
        System.out.println(s.matches("\\d{3,6}"));//\d == [0-9]匹配数字  \D 匹配非数字

        System.out.println(s.matches("1[3578]\\d{9}"));//手机号验证
        System.out.println(s.matches("[1-9]\\d{4,11}"));//QQ号验证
    }
}

①字符类

比如：验证一个字符串是否是邮箱格式？

public class RegExDemo2 {
    public static void main(String[] args) {
       
      //    匹配邮箱格式
        String s = "qwe2434@qq.com";
        System.out.println(s.matches("[a-z]*"));
        System.out.println(s.matches("[A-Z]*"));
        System.out.println(s.matches("[a-zA-Z]*"));
        System.out.println(s.matches("[0-9A-Z]*"));
        System.out.println(s.matches("\\w*"));
        System.out.println(s.matches("[\\u4e00-\\u9fa5]*"));//匹配中文
        System.out.println(s.matches("[\\w\\s]*"));
        //邮箱格式 xxxxxx@xx.com   com.cn
        System.out.println(s.matches("\\w{6,10}@[0-9A-z]{2,5}\\.(com|com\\.cn)"));


    }
}

六、Math类/Random类

1、Math类

● java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。

abs 绝对值

sqrt 平方根

pow(double a, double b) a的b次幂

max(double a, double b)

min(double a, double b)

random() 返回 0.0 到 1.0 的随机数

long round(double a) double型的数据a转换为long型（四舍五入）

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.PI);//π
        System.out.println(Math.abs(-3));//取绝对值
        System.out.println(Math.sqrt(9));//开方(运行出来是double类型)
        System.out.println(Math.pow(2,3));//次方
        System.out.println(Math.floor(9.9));//向下取整
        System.out.println(Math.ceil(9.1));//向上取整
        System.out.println(Math.max(10,5));
        System.out.println(Math.random());//返回0-1之间的随机数，可能会等于0，小于1
    }
}

2、Random类

● Random类概述

此类用于产生随机数

● 构造方法

public Random()

● 成员方法

public int nextInt()

public int nextInt(int n)

import java.util.Arrays;
import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextBoolean());
        System.out.println(random.nextDouble());
        System.out.println(random.nextInt());
        System.out.println(random.nextInt(35)+1);
        System.out.println(random.nextLong());

        byte[] bytes = new byte[5];
        random.nextBytes(bytes);

        System.out.println(Arrays.toString(bytes));
    }
}

七、Date类/Calendar类/ SimpleDateFormat类

1、Date类

● 使用Date类代表当前系统时间

Date d = new Date();

Date d = new Date(long d);

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        System.out.println(date.getYear()+1900);//2024 方法上有删除线，表示此方法已弃用，有新的类代表，但也可以使用
        System.out.println(date.getMonth()+1);
        System.out.println(date.getDate());
        System.out.println(date.getHours());
        System.out.println(date.getMinutes());
        System.out.println(date.getSeconds());

        System.out.println(date.getTime());//时间戳,从1900年到现在有多少毫秒
        Date date1 = new Date();
        System.out.println(date1.getTime()-date.getTime());//测试刚才这段程序运行的时间

        Date date2 = new Date(1323434436657L);//将指定Long类型的时间戳转为日期格式
        System.out.println(date2);

    }
}

2、Calendar类

● Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

Calendar c1 = Calendar.getInstance();

c1.get(Calendar. YEAR);

import java.util.Calendar;

public class CalenderDemo {
    public static void main(String[] args) {
        Calendar calender = Calendar.getInstance();
        System.out.println(calender);
        calender.set(2024,4,1);
        System.out.println(calender.get(Calendar.YEAR));
        System.out.println(calender.get(Calendar.MONTH));
        System.out.println(calender.get(Calendar.DAY_OF_MONTH));
        System.out.println(calender.get(Calendar.DAY_OF_WEEK));
        System.out.println(calender.get(Calendar.DAY_OF_YEAR));
        System.out.println(calender.get(Calendar.WEEK_OF_YEAR));
        System.out.println(calender.get(Calendar.HOUR_OF_DAY));
        System.out.println(calender.getTimeInMillis());//从1900年到现在有多少毫秒

    }
}

3、SimpleDateFormat日期格式化类

● 构造方法

SimpleDateFormat(格式); // yyyy-MM-dd

● 日期转字符串

Date now=new Date();

myFmt.format(now);

● 字符串转日期

myFmt.parse(“2018-02-10”);

字符串日期格式与指定格式必须一致

例如:String s = “2018-03-15”;

new SimpleDateFormat(“yyyy-MM-dd”)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //把字符串日期转为Date对象
        String s = "2003-02-01";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(s);
        System.out.println(date.getYear()+1900);
        //把日期对象转为指定格式的字符串
        Date date1 = new Date();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");//2024年04月01日 21:52:48 星期一
        String s1 = sdf1.format(date1);
        System.out.println(s1);

    }
}

八、BigInteger/BigDecimal

1、Biglnteger类

● 在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。

● 我们都知道 Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。

● BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。

● BigInteger类位于java.math包中

● 构造方法

BigInteger(String val) /BigInteger(byte[] val) ...

● 基本运算方法

add()，subtract()，multiply()，divide()

import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger bigInteger1 = new BigInteger("11111111111111111111111");
        BigInteger bigInteger2 = new BigInteger("99999999999999999999999");

        BigInteger bigInteger3 = bigInteger1.multiply(bigInteger2);
        System.out.println(bigInteger1);
        System.out.println(bigInteger2);
        System.out.println(bigInteger3);
    }
}

2、BigDecimal类

● 在计算机中float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。

● 根本原因是:十进制浮点值没有完全相同的二进制表示形式;十进制浮点值的二进制表示形式不精确,只能无限接近于那个值.

System.out.println((0.1 + 0.2)==0.3);//结果是?

输出结果：

0.6599999999999999

但是，在项目中，我们不可能让这种情况出现，特别是金融项目，因为涉及金额的计算都必须十分精确，你想想，如果你的支付宝账户余额显示 193.99999999999998，那是一种怎么样的体验？

• Java在java.math包中提供的API类BigDecimal

• 构造方法

BigDecimal(String val)

• 基本运算方法

add()，subtract()，multiply()，divide()

import java.math.BigDecimal;
import java.math.BigInteger;

public class BigDecimalDemo {
    public static void main(String[] args) {
        System.out.println(0.3+0.36);
        BigDecimal bigDecimal1 = new BigDecimal("0.3");
        BigDecimal bigDecimal2 = new BigDecimal("0.36");
        System.out.println(bigDecimal1.add(bigDecimal2));

        BigDecimal bigDecimal3 = new BigDecimal("10");
        BigDecimal bigDecimal4 = new BigDecimal("3");
        System.out.println(bigDecimal3.divide(bigDecimal4,3,1));//除法，需要注意无限循环，需要给定保留的小数位数，以及舍入模式
    }
}