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在线帮助文档
在线文档与离线文档差不多
一、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