java-常用类

渴望成长

已于 2023-05-01 10:08:01 修改

阅读量472

点赞数

分类专栏：笔记 java基础工具文章标签： java servlet jvm

于 2022-09-13 11:54:23 首次发布

本文链接：https://blog.csdn.net/m0_51779342/article/details/126819800

版权

笔记同时被 3 个专栏收录

36 篇文章 2 订阅

订阅专栏

java基础

20 篇文章 0 订阅

订阅专栏

工具

9 篇文章 0 订阅

订阅专栏

java-常用类

java-常用类

java-常用类

引出----API

一）什么是API

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

Java API是一本程序员的字典 。java中的API指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

二）如何使用API帮助文档

1. API来源

1.1 自己去下载对应离线版本JDK-API

双击打开api

在这里插入图片描述

找到索引选项卡中的输入框

在这里插入图片描述

查看类信息

在这里插入图片描述

1.2 jdk-api在线帮助文档

链接：jdk-api在线帮助文档

在线文档与离线文档差不多

在这里插入图片描述

一、Object类

java.lang.Object类是Java语言中的根类，是所有java类的父类，即所有类都直接或间接的继承自该类。
在对象实例化的时候，最终找的父类就是Object。
Object类中所定义的方法，是所有对象都具备的方法。
Object类型可以存储任何对象。
作为参数，可接受任何对象。
作为返回值，可返回任何对象。

如果一个类没有特别指定父类，那么默认则继承自Object类。

public class MyClass /*extends Object*/ {
  	// ...
}

一）常用方法

Object类中包含的方法有11个，我们主要记录常用的方法：

构造方法

public Object();

子类的构造方法默认访问的是父类的无参构造方法

常用方法

1、 getClass()

public final Class<?> getClass(){...}

返回引用中存储的实际对象类型。
应用：通常用于判断两个引用中实际存储对象类型是否一致。

2、 toString()方法

public String toString();

返回该对象的字符串表示（原始表现形式：对象的类型+@+内存地址值）。

即：getClass().getName() + '@' + Integer.toHexString(hashCode())

toHexString(int i)是Integer类的一个静态方法，它把一个整数转换成一个十六进制表示的字符串，该方法返回的字符串没有意义，建议所有子类都重写该方法

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，我们可以根据程序需求重写（覆盖）该方法。

按需重写

public class Person {  
    private String name;
    private int age;
    /*
    根据对象输出对象的所有属性值
    */
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
    // 省略构造器与getter、setter
}

可以使用快捷键alt+insert选择相应的选项快速重写方法

在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法（即默认调用toString方法）。

3、hashCode()方法

public int hashCode();

返回该对象的十进制的哈希码值。
哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值（可以看做是对象的地址，但其实并不是真实的物理地址，因为对象是存储在JVM中的，我们无法拿到该对象真正的内部地址）。
同一个对象返回的哈希码值相同，不同对象的哈希码值也可能相同
哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回不同哈希码。
一般与equals方法进行搭配使用

作用： 提高具有哈希结构的容器的效率（如HashMap、Hashtable等集合的效率）

4、 equals()方法

public boolean equals(Object obj);

默认实现为(this == obj)，比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

equals重写步骤：

比较两个引用是否指向同一个对象。
判断obj是否为null。
判断两个引用指向的实际对象类型是否一致。
强制类型转换。
依次比较各个属性值是否相同。

public class Student  {
	private String name;
	private int age;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public boolean equals(Object obj) {
		//1判断两个对象是否是同一个引用
		if(this==obj) {
			return true;
		}
		//2判断obj是否null
		if(obj==null) {
			return false;
		}
		//3判断是否是同一个类型,如果参数为空，或者类型信息不一样，则认为不同，可用intanceof替换 
		//if(obj == null || this.getClass()==obj.getClass()) { return false; }
		//intanceof 判断对象是否是某种类型
		if(obj instanceof Student) {
			//4强制类型转换
			Student s=(Student)obj;
			//5比较名称或年龄
			if(this.name.equals(s.getName())&&this.age==s.getAge()) {
				return true;
			}	
		}
		return false;
	}
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println(this.name+"对象被回收了");// 与System.gc()搭配使用
	}
}

public class TestStudent {
	public static void main(String[] args) {
		//1getClass方法
		System.out.println("------------1getClass---------");
		Student s1=new Student("aaa", 20);
		Student s2=new Student("bbb",22);
		//判断s1和s2是不是同一个类型
		Class class1=s1.getClass();
		Class class2=s2.getClass();
		if(class1==class2) {
			System.out.println("s1和s2属于同一个类型");
		}else {
			System.out.println("s1和s2不属于同一个类型");
		}

		//2toString方法
		System.out.println("-----------3toString------------");
		System.out.println(s1.toString());
		System.out.println(s2.toString());
        
        System.out.println("-----------2hashCode------------");
		//3hashCode方法
		System.out.println(s1.hashCode());
		
		System.out.println(s2.hashCode());
		Student s3=s1;
		System.out.println(s3.hashCode());
		
		//4equals方法：判断两个对象是否相等
		System.out.println("-----------4equals------------");
		System.out.println(s1.equals(s2));
		
		Student s4=new Student("小明", 17);
		Student s5=new Student("小明",17);
		System.out.println(s4.equals(s5));	
	}
}

注意：

比较运算符“==”的使用
基本类型：比较的是两个数据值是否相同
引用类型：比较的是两个地址值是否相同

比较运算符“instanceof”的使用
格式：对象名 instanceof 类名
判断指定对象名是否是该类或其子类的一个对象，如果是则true，如果不是则false

5、 finalize()方法

protected void finalize();

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。

垃圾对象：无有效引用指向此对象时，为垃圾对象。

垃圾回收：由GC销毁垃圾对象，释放数据存储空间。

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。

手动回收机制：使用System.gc(); 通知JVM执行垃圾回收，什么时候回收并不确定。

使用System.gc()方法手动回收时，并不是直接回收，而是向垃圾回收器发送回收垃圾的请求，垃圾回收器判断该对象是否为垃圾，是就在空闲时回收，不是垃圾就不管

通常System.gc()与finalize()搭配使用
手动执行 gc()方法 通知JVM回收垃圾，JVM什么时候回收垃圾我们并不知道，当JVM真正回收垃圾之前会调用 finalize()方法，此时我们重写的finalize()方法就可以输出我们想要的提示，告诉我们JVM已经回收垃圾了

public class TestFinalize {
	public static void main(String[] args) {
		new Student("aaa", 20);
		new Student("bbb", 20);
		new Student("ccc", 20);
		new Student("ddd", 20);
		new Student("eee", 20);
		//回收垃圾
		System.gc();
		System.out.println("回收垃圾");	
	}
}

（6）clone方法

protected Object clone();

创建并返回此对象的一个副本。

如果该对象的类没有实现Cloneable接口，则当该对象调用clone()方法时会抛出异常：CloneNotSupportedException。
Cloneable接口：使Object.clone()方法可以合法地对该类实例进行按字段复制。
该接口没有方法，是一个标记接口，告诉我们实现了该接口的类就可以实现对象的复制了。

二、Objects类

定义：用来操作对象以及在操作对象之前检查某些条件的实用工具类

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（ -safe 空指针安全的）或null-tolerant（-tolerancey 容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

equals()方法

在之前使用的Object类中也有一个equals方法，作用是判断两个对象是否相等，但是：能做判断的前提是调用此方法的对象不能为空，否则会报空指针异常

public class Test {
    public static void main(String[] args) {
        Student s = new Student("张三",20);
        Student s2 = new Student("张三",20);
        boolean equals = s.equals(s2);
        System.out.println(equals); // true
        s2 = null;
        boolean b = s.equals(s2);
        System.out.println(b); // false
        s = null;
        s.equals(s2); // NullPointerException: "s" is null
    }

}
class Student  {
    private String name;
    private int age;
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

如何使空对象调用也能调用equals方法呢？

由于Objects类是空指针安全的，这意味着可以使用空对象调用equals方法

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        Student s = new Student("张三",20);
        Student s2 = new Student("张三",20);
        boolean equals = s.equals(s2);
        System.out.println(equals); // true
         /*   s2 = null;
        boolean b = s.equals(s2);
        System.out.println(b); // false*/
        boolean b1 = Objects.equals(s, s2);
        System.out.println(b1); // false
    }

}
class Student  {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

查看源码

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

可以看到，Objects.equals()首先判断两个对象是否相等，相等则返回true；不相等则判断a对象是否为空，为空则返回false，不为空则调用Object.equals()

其实Objects.equals()与Object.equals()相比只是多了一步判空操作而已

Objects具体方法可以自行查看帮助文档

三、System类

java.lang.System系统类，主要用于获取系统的属性数据和其他操作。

特点：1）不能被实例化 2）成员方法都是静态的

成员变量

public static InputStream in;  “标准”输入流

public static PrintStream out;  “标准”输出流

public static PrintStream err;  “标准”错误输出流

常用方法

方法	描述
`static void gc();`	运行垃圾回收器
`static void exit(int status);`	终止当前正在运行的Java虚拟机，非0的状态码表示异常终止
`static long currentTimeMillis();`	返回以毫秒为单位的当前时间
`static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)；`	将数组中指定的数据拷贝到另一个数组中。

演示：

public static void main(String[] args) throws ParseException {
    int[] i = {0,1,2,3,4,5,6};
    int [] j = new int[i.length];
    /**
     * System.arraycopy(源数组,开始复制的位置,目标数组,开始存放的位置,复制长度)
     * 从指定的源数组中复制一个数组，在指定开始的位置，到目标数组的指定位置。
     * 它是一个使用native修饰的本地方法，本地方法的实现是依靠C语言或c++来实现的，
     * 所以他的效率非常高，Arrays.copyOf()的底层也是使用了该方法
     */
    //从数组i下标为2的位置开始复制三个元素到数组j，从下标为0的位置开始填充
    System.arraycopy(i,2,j,0,3);
    System.out.println(Arrays.toString(j));//以字符串的形式输出数组j
    /**
     * System.currentTimeMillis()：获取当前系统时间，返回的是毫秒数，
     * 可以用来计算一段代码执行的时长
     * 注意：获取的是当前系统时间与1970年01月01日00:00点之间的毫秒差值
     */
    System.currentTimeMillis();//获取当前系统时间
    /**
     * System.exit(0或！0):退出jvm，正常退出提示0，非0表示异常退出
     * 执行该方法，则之后的语句不再执行
     */
    System.exit(0);
    /**
     *  System.gc()：建议垃圾回收器回收无用的对象，就是没有有效引用指向的
     *  对象，他仅仅只是向垃圾回收器提出建议，然后垃圾回收器会判断是否有无用
     *  的对象，要不要回收，使用时要重写finalize（）方法才能看见是否回收了垃圾
     */
    new Demo();//没有引用指向的无用对象
    System.gc();//建议垃圾回收器回收无用的对象
}

@Override
protected void finalize() throws Throwable {//重写finalize方法，做一点提示
    System.out.println("垃圾已回收");
}

四、Math类

概述：java.lang.Math类包含了用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数等。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单

一）常用方法

方法	描述
`int abs();`	返回参数的绝对值（参数类型可以是int、long、float、double）
`double ceil(double d);`	向上取整，返回一个大于或等于参数a的最小整数。即它返回一个整数，这个整数是所有大于等于a的整数中最小的一个。
`double floor(double d);`	向下取整，返回一个小于或等于参数a的最大整数。即它返回一个整数，这个整数是所有小于等于a的整数中最大的一个。
`int max(int a,int b);`	返回最大值（参数类型可以是int、long、float、double）
`int min(int a,int b);`	返回最小值（参数类型可以是int、long、float、double）
`double pow(double a,double b);`	a的b次幂
`double random();`	返回随机数，范围为[0.0,1.0)
`int round();`	返回最接近参数a的整数，该方法等同于Math.floor(a + 0.5)并将结果转换为long或int类型，即四舍五入取整。
`double sqrt(double d);`	返回正确舍入的double值的正平方根

演示：

// 绝对值
double d1 = Math.abs(-5);
System.out.println("Math.abs(-5) = " + d1);//5.0
// 向上取整
double d2 = Math.ceil(-3.3);
double d3 = Math.ceil(5.1);
double d4 = Math.ceil(3.3);
System.out.println("Math.ceil(-3.3) = " + d2);//‐3.0
System.out.println("Math.ceil(5.1) = " + d3);//6.0
System.out.println("Math.ceil(3.3) = " + d4); //4.0
//向下取整
double d5 = Math.floor(3.3);
double d6 = Math.floor(-3.3);
double d7 = Math.floor(5.1);
System.out.println("Math.floor(3.3) = " + d5); //3.0
System.out.println("Math.floor(-3.3) = " + d6); //‐4.0
System.out.println("Math.floor(5.1) = " + d7); // 5.0
// 最大值
int max = Math.max(5, 8);
System.out.println("Math.max(5, 8) = " + max); // 8
// 最小值
int min = Math.min(5, 8);
System.out.println("Math.min(5, 8) = " + min); // 5
// 求次方
double pow = Math.pow(2, 3);
System.out.println("Math.pow(2, 3) = " + pow); // 8.0
// 随机值
int random = (int)(Math.random() * 10 + 1);
System.out.println("Math.random() = " + random); // 1 ~ 10 
// 平方根
double sqrt = Math.sqrt(4);
System.out.println("Math.sqrt(4) = " + sqrt);// 2.0
// 四舍五入
long d8 = Math.round(5.5); //d1的值为6.0
long d9 = Math.round(5.4); //d2的值为5.0
System.out.println("Math.round(5.5) = " + d8);  //6.0
System.out.println("Math.round(5.4) = " + d9);//5.0

猜数字：

package ifDemo; 
/**
 * @create 2020-03-26-10:20
 * 产生一个随机数，玩家猜点数或大小，
 */
import java.util.Scanner;
import java.lang.Math;
public class IfTouZi {
    public static void main(String[] args){
        Scanner input =new Scanner(System.in);//提供一个输入的平台
        int count =(int) (Math.random()*6+1);//产生一个double类型范围在1~6的随机数，强制转换成int类型
       /* System.out.println("买大买小，买定离手：");
        String size = input.next();//键入一个字符串
        if(count >= 4){//摇出的点数大于等于4
            if(size.equals("大")) {
                System.out.println("你买的是" + size + "\t本轮摇出的点数是" + count + "。恭喜你，猜对了！");
            }else{
                System.out.println("你买的是" + size + "\t本轮摇出的点数是" + count + "。很遗憾，猜错了！");
            }
        }else{//摇出的点数小于4
            if(size.equals("小")) {
                System.out.println("你买的是" + size + "\t本轮摇出的点数是" + count + "。恭喜你，猜对了！");
            }else{
                System.out.println("你买的是" + size + "\t本轮摇出的点数是" + count + "。很遗憾，猜错了！");
            }
        }*/
       System.out.println("你有三次机会，请输入你的点数：");
       int a=1;
       int counter = 3;
       while(counter != 0){
           int number = input.nextInt();
            if(number < 7 && number >0){
                if(number == count){
                    System.out.println("恭喜你，猜中了，快去领奖吧！");
                    break;
                }else if(number < count){
                    System.out.println("很遗憾，猜小了。你还有" + (counter-1) + "次机会！！！");
                    counter--;
                    continue;
                }else if(number > count){
                    System.out.println("很遗憾，猜大了。你还有" + (counter-1) + "次机会！！！");
                    counter--;
                    continue;
                }

            }else{
                if(a==1){
                    System.out.println("输入有误！只能输入1~6之间的数，请重新输入：");
                    a++;
                }else{
                    if(a==6){
                        System.out.println("还玩个屁啊，赶紧滚！！！");
                        break;
                    }
                    System.out.println("第"+ a +"输入错误！只能输入1~6之间的数，请重新输入：");
                    a++;
                }
            }

       }

    }
}

五、Random类

概述：java.util.Random类的实例用于生成伪随机数流，此类使用48位的种子，如果用相同的种子创建两个Random实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

方法	描述
`Random();`	创建一个新的随机数生成器，使用的是默认的种子，即当前时间的毫秒值
`Random(long seed);`	使用单个long种子创建一个新的随机数生成器
`int nextInt();`	返回的是一个int范围内的随机整数
`int nextInt(int n);`	返回的是一个[0,n)范围内的随机整数
`double nextDouble();`	返回的是一个0.0和1.0之间的随机double值
`void setSeed(long seed);`	使用单个long种子设置此随机数生成器的种子

演示：

双色球：

public class DoubleBall {
    public static void main(String[] args) {
        int[] redBall = array(33);//1、创建用来存储双色球的数组
        int[] red = suijired(redBall);//2、从数组中随机挑选相应个数的球
        int blue = new Random().nextInt(16) + 1;;
        Arrays.sort(red);
        System.out.println(Arrays.toString(red) + "\t[" + blue + "]");
    }

    private static int[] suijired(int[] len) {
        int[] a = new int[6];
        //3、创建一个标识数组，判断是否有重复的数,当选择一个数时，下标对应的内容变为ture
        boolean[] flag = new boolean[33];
        for (int i = 0; i < a.length; i++) {
            int j;
            do {
                j = new Random().nextInt(len.length) + 1; // 系统产生一个随机数1‐len.length之间的。

            }while (flag[j-1]);
                a[i] = len[j];
                flag[j-1] = true;
        }
        return a;
    }
    private static int[] array(int len) {
        int[] arr = new int[len];
        for (int i = 0; i < arr.length; i++) {
            arr[i] += i + 1;
        }
        return arr;
    }
}

六、Arrays类

概述：java.util.Arrays 是针对数组进行操作的工具类，此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

常用方法

public static String toString(Object[] a); 把Object类型的数组转换为字符串

注意：Arrays类的toString方法可以把任意类型的数组转换为字符串，底层是StringBuilder拼接

示例：
  // 定义int 数组
        int[] arr = {2, 4, 3, 5, 6, 8, 7, 9};
        // 打印数组,输出地址值
        System.out.println(arr); // [I@58372a00
        // 数组内容转为字符串
        String s = Arrays.toString(arr);
        // 打印字符串,输出内容
        System.out.println(s); // [2, 4, 3, 5, 6, 8, 7, 9]

Arrays.toString():
	public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

public static void sort(int[] a); 把int类型的数组按数字升序进行排序

注意：Arrays类的sort方法可以把任意类型的数据按数字升序进行排序

示例：
        int[] arr = {2, 4, 3, 5, 6, 8, 7, 9};
        System.out.println("排序前：" + Arrays.toString(arr)); //[2, 4, 3, 5, 6, 8, 7, 9]
        // 数组排序
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr)); //[2, 3, 4, 5, 6, 7, 8, 9]

public static int binarySearch(int[] a,int key); 使用二分搜索法（折半检索、二分查找）来搜索指定的int类型的数组，以获得指定的值

注意：Array类的binarySearch方法可以用来搜索任意类型的数组
前提：数组元素有序
方式：先把数组折半，每次都查找中间的那个元素，再进行比较，大于中间数则用中间值加一除以二再比较，直至两数相等 
注意：要查找的数组必须是有序的，否则查找结果不准确

int[] arr = {2, 4, 3, 5,1, 6, 8, 7, 9};
System.out.println("排序前：" + Arrays.toString(arr)); //[2, 4, 3, 5, 6, 8, 7, 9]
int i = Arrays.binarySearch(arr, 3);
System.out.println("排序前查找：" + i); // -6
Arrays.sort(arr);
System.out.println("排序后：" + Arrays.toString(arr)); //[2, 3, 4, 5, 6, 7, 8, 9]
int i1 = Arrays.binarySearch(arr, 3);
System.out.println("排序后查找：" + i1); // 2

static <T> List<T> asList(T... a) : 将数组转化为List集合
static boolean equals(char[] a,char[] a2): 如果两个数组相等，则返回true

七、BigInteger类

概述：不可变的任意精度的整数。可以让超过Long范围内的数据进行运算。表示任意长度，其实采用的是字符串形式存储

科学计算（超大数据参与运算时）建议使用此类

不能直接使用+-*/号运算，要使用其特有的计算方法

常用方法

方法	描述
`BigInteger(String val);`	将大整数的十进制字符串表示形式转换为大整数
`BigInteger add(BigInteger val);`	加法运算
`BigInteger subtract(BigInteger val);`	减法运算
`BigInteger multiply(BigInteger val);`	乘法运算
`BigInteger divide(BigInteger val);`	除法运算
`BigInteger[] divideAndRemainder(BigInteger val);`	返回包含商(this/val)和余数(this%val)的两个BigInteger的数组

Integer integer = Integer.MAX_VALUE; // 获取int最大值
Long l = Long.MAX_VALUE; // 获取long最大值
int i = integer + 1; // int最大值 + 1
long l1 = l + 1; // long最大值 + 1
System.out.println("integer = " + integer);
System.out.println("integer + 1 = " + i);
System.out.println("l = " + l); // int整数溢出
System.out.println("l + 1 = " + l1);// long整数溢出
// 使用大整数进行运算
BigInteger bigInteger = new BigInteger(String.valueOf(integer)).add(new BigInteger("1"));
BigInteger bigInteger1 = new BigInteger(String.valueOf(l)).add(new BigInteger("1"));
System.out.println( bigInteger); 
System.out.println(bigInteger1);

八、BigDecimal类

概述：由于在运算时，float和double类型很容易丢失精度，所以，为了能精确地表示和计算浮点数，Java提供了BigDecimal类。不可变的、任意精度的有符号十进制数。表示任意精度，采用字符串形式存储

财务会计运算要使用此类

常用方法

方法名	描述
`BigDecimal(String val)`	将BigDecimal的字符串表示形式转换为BigDecimal
`BigDecimal add(BigDecimal bd)`	加法运算
`BigDecimal subtract(BigDecimal bd)`	减法运算
`BigDecimal multiply(BigDecimal bd)`	乘法运算
`BigDecimal divide(BigDecimal bd)`	除法运算
`BigDecimal divide(BigDecimal divisor,int scale,int roundingMode);`	返回一个BigDecimal，其值为(this/divisor)，其标度为指定标度

参数：

divisor - 此BigDecimal要除以的值

scale - 要返回的BigDecimal商的标度（小数位数）

roundingMode - 要应用的舍入模式，常用模式为RoundingMode.HALF_UP（四舍五入）

示例：**

double d1=1.0;
double d2=0.9;
System.out.println(d1-d2);

double result=(1.4-0.5)/0.9;
System.out.println(result);
//BigDecimal,大的浮点数精确计算
BigDecimal bd1=new BigDecimal("1.0");
BigDecimal bd2=new BigDecimal("0.9");
//减法
BigDecimal r1=bd1.subtract(bd2);
System.out.println(r1);

//加法
BigDecimal r2=bd1.add(bd2);
System.out.println(r2);

//乘法
BigDecimal r3=bd1.multiply(bd2);
System.out.println(r3);

//除法
BigDecimal r4=new BigDecimal("1.4")
    .subtract(new BigDecimal("0.5"))
    .divide(new BigDecimal("0.9"));
System.out.println(r4);

BigDecimal r5=new BigDecimal("20").divide(new BigDecimal("3"),20, RoundingMode.CEILING);
System.out.println(r5);

九、DecimalFormat类

概述：java.text.DecimalFormat是NumberFormat的一个具体子类，用于格式化十进制数字

常用方法

方法	描述
`DecimalFormat();`	使用默认模式和默认语言环境的符号创建一个DecimalFormat，即默认每隔三个就分组，小数点保留3位
`DecimalFormat(String pattern);`	使用给定的模式和默认语言环境的符号创建一个DecimalFormat
`String format(double number);`	把数字按照给定的模式转换为一个字符串
`void setMaximumFractionDigits(int newValue)`	设置保留小数位的最大个数。
`void setMaximumIntegerDigits(int newValue)`	设置整数部分最大位数。(正常情况不使用)
`Number parse(String source)throws ParseException`	解析给定字符串开头的文本，生成一个数值
`void setRoundingMode(RoundingMode roundingMode)`	设置此十进制格式中使用的`舍入模式`

特殊模式字符(`占位符`)

符号	位置	描述
0	数字	阿拉伯数字，如果实际长度小于预期长度则缺的位置补0
#	数字	阿拉伯数字，如果实际长度小于预期长度则缺的位置不显示
.	数字	小数分隔符或货币小数分隔符
,	数字	分组分隔符
%	前缀或后缀	乘以100并显示为百分数
\u2030	前缀或后缀	乘以1000并显示为千分数
\u00A4	前缀或后缀	货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。
-	前缀	缺省负数
E	数字	分割科学技术法中的尾数和指数。在前缀和后缀中无需添加引号
;	子模式边界	分隔正数和负数子模式

示例：

占位符 0 ：
// 1、当0的个数比参数实际位数多时，整数部分在最前面补0，小数部分在最后面补0
System.out.println(new DecimalFormat("00.0").format(3.14));//结果：03.1
System.out.println(new DecimalFormat("0.000").format(3.14)); //结果： 3.140
System.out.println(new DecimalFormat("00.000").format(3.14));//结果：03.140
// 2、当0的个数比实际位数少时，整数部分不变，小数部分丢弃多余的位数
System.out.println(new DecimalFormat("0.000").format(13.14)); //结果： 13.140
System.out.println(new DecimalFormat("000.0").format(13.14));//结果：013.1
System.out.println(new DecimalFormat("00.000").format(13.14));//结果：13.140

占位符 # ：
// 1、当#的个数比参数实际位数多时，结果不变
System.out.println(new DecimalFormat("##.#").format(3.14));//结果：3.1
System.out.println(new DecimalFormat("#.###").format(3.14)); //结果： 3.14
System.out.println(new DecimalFormat("##.###").format(3.14));//结果：3.14
// 2、当#的个数比实际位数少时，整数部分不变，小数部分丢弃多余的位数
System.out.println(new DecimalFormat("#.###").format(13.14)); //结果：13.14
System.out.println(new DecimalFormat("###.#").format(13.14));//结果：13.1

分组分隔符 ，：
// ,  分组分隔符 只看逗号之后的占位符数，有几个占位符就是以几个来分隔
System.out.println(new DecimalFormat(",####").format(1234567));//结果：123,4567
System.out.println(new DecimalFormat("#,###").format(1234567)); //结果： 1,234,567
System.out.println(new DecimalFormat("##,###").format(1234567));//结果：1,234,567
System.out.println(new DecimalFormat("#,#").format(1234567)); //结果：1,2,3,4,5,6,7
System.out.println(new DecimalFormat(",00000000").format(1234567));//结果：01234567

百分号 % ：
 // 前缀
System.out.println(new DecimalFormat("%###").format(0.12));//结果：%12
System.out.println(new DecimalFormat("%000").format(0.12));//结果：%012
// 后缀
System.out.println(new DecimalFormat("###%").format(0.12));//结果：12%
System.out.println(new DecimalFormat("000%").format(0.12));//结果：012%

千分数 \u2030 ：
System.out.println(new DecimalFormat("0.0\u20300").format(0.012));//12.00‰

货币符号 \u00A4 ：
System.out.println(new DecimalFormat(",000.00¤").format(123.5));//123.50¥
System.out.println(new DecimalFormat(",000.00\u00A4").format(6.5));//006.50¥

科学计数法 E ：
System.out.println(new DecimalFormat("0E0").format(123456.55555));//1E5

科学计数法注意事项：

使用科学计数法，首先保证E前面有0或者#，否则就不是科学计数法。
E后面必须是0，0的个数对后面的显示是有影响的，多余就会填充0.
E前面只有一个#，得到的结果肯定是.开头的结果。
E前面#与0的总个数决定后面的指数，具体：总个数和指数比较，如果指数的值大于总个数，那么得到的指数的值是个数的倍数；如果指数的值小于等于总个数，那么得到的指数的值等于总个数；
整个模式中的0的总个数决定最后输出结果的位数，并且与0的位置无关。
如果整数部分需要保留几位数，就使用几个0。

应用场景

（1）实现四舍五入保留n位小数

// 四舍五入保留3位小数
double num = 11.256;
DecimalFormat df = new DecimalFormat("###.###");
//指定RoundingMode
df.setRoundingMode(RoundingMode.HALF_UP);
String str = df.format(num);
System.out.println(str);//11.256
double formatNum = Double.parseDouble(str);
System.out.println(formatNum);//11.256


// 四舍五入保留3位小数
double num = 11.256;
DecimalFormat df = new DecimalFormat("000.000");
//指定RoundingMode
df.setRoundingMode(RoundingMode.HALF_UP);
String str = df.format(num);
System.out.println(str);//011.256
double formatNum = Double.parseDouble(str);
System.out.println(formatNum);//11.256

（2）把数字转换为货币的格式

System.out.println(new DecimalFormat(",000.00¤").format(123.5));//123.50¥
System.out.println(new DecimalFormat(",000.00\u00A4").format(6.5));//006.50¥

（3）显示数字的百分比

System.out.println(new DecimalFormat("小明做题正确率：.##%").format(0.845));//结果：小明做题正确率：84.5%

（4）设置特定的符号

// 四舍五入保留2位小数
DecimalFormat df = new DecimalFormat();
DecimalFormatSymbols symbols = df.getDecimalFormatSymbols(); //获取设置符号的对象
symbols.setGroupingSeparator('-'); // 设置分组符
symbols.setDecimalSeparator('@'); // 设置小数分隔符
df.setDecimalFormatSymbols(symbols); // 将设置符号的对象传回来
df.setGroupingSize(3); // 设置分组长度，与setGroupingUsed(true)搭配使用
df.setGroupingUsed(true); // 设置是否可以分组
System.out.println(df.format(123456.78)); // 123-456@78

常用RoundingMode

UP 始终对非零舍弃部分前面的数字加 1，即如果被舍弃的数不是0，则该数前一位加一

// 四舍五入保留2位小数
DecimalFormat df = new DecimalFormat("0.00");
//指定RoundingMode
df.setRoundingMode(RoundingMode.UP);
System.out.println(df.format(1.3333));// 1.34
System.out.println(df.format(1.3));// 1.30

DOWN 直接截断，舍弃掉后面的数

// 四舍五入保留2位小数
DecimalFormat df = new DecimalFormat("0.00");
//指定RoundingMode
df.setRoundingMode(RoundingMode.DOWN);
System.out.println(df.format(1.3333));// 1.33
System.out.println(df.format(1.3));// 1.30

HALF_UP 四舍五入，当被舍弃的数>=5时，则该数前一位加一，否则直接舍弃掉后面的数

        // 四舍五入保留2位小数
        DecimalFormat df = new DecimalFormat("0.00");
        //指定RoundingMode
        df.setRoundingMode(RoundingMode.HALF_UP);
        System.out.println(df.format(1.3353));// 1.34
        System.out.println(df.format(1.3343));// 1.33
        System.out.println(df.format(1.3));// 1.30

HALF_DOWN 五舍六入，被舍弃的数大于5，则该数前一位加一，否则直接舍弃掉后面的数

注意：由于精度问题，当被舍弃的值等于5时，其实就是四舍五入

// 四舍五入保留2位小数
DecimalFormat df = new DecimalFormat("0.00");
//指定RoundingMode
df.setRoundingMode(RoundingMode.HALF_DOWN);
System.out.println(df.format(1.3353));// 1.34
System.out.println(df.format(1.3363));// 1.34
System.out.println(df.format(1.3343));// 1.33
System.out.println(df.format(1.3));// 1.30

HALF_EVEN ：DecimalFormat默认的RoundingMode为RoundingMode.HALF_EVEN，四舍六入，五分向相邻的偶数舍入。

注意：由于精度问题，当被舍弃的值等于5时，其实就是四舍五入

例：

// 四舍五入保留2位小数
DecimalFormat df = new DecimalFormat("0.00");
//指定RoundingMode
df.setRoundingMode(RoundingMode.HALF_EVEN);
System.out.println(df.format(1.3353));// 1.34
System.out.println(df.format(1.3453));// 1.35
System.out.println(df.format(1.3343));// 1.33
System.out.println(df.format(1.3));// 1.30