1. 常用类
1.1 包装类
1.1.1 包装类的分类
1) 针对八种基本数据类型相应的引用类型—包装类
2) 有了类的特点,就可以调用类中的方法。
1.1.2 包装类和基本数据的转换
包装类和基本数据类型的相互转换,这里以int 和 Integer演示。
1) jdk5前的手动装箱和拆箱方式,装箱:基本类型->包装类型,反之,拆箱
2) jdk5 以后(含jdk5)的自动装箱和拆箱方式
3) 自动装箱底层调用的是valueOf方法,比如Integer.valueOf()
4) 其它包装类的用法类似,不一 —举例
案例演示:
package com.zakedu.wrapper;
/**
* @author
* @version 1.0
*/
public class Integer01 {
public static void main(String[] args) {
//演示int <--> Integer 的装箱和拆箱
//jdk5 前是手动装箱和拆箱
//手动装箱 int->Integer
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
//Integer-> int
int i = integer.intValue();
//jdk5 后,就可以自动装箱和自动拆箱
int n2 = 200;
//自动装箱 int->Integer
Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
//自动拆箱 Integer->int
int n3 = integer2; //底层仍然使用的是 intValue()方法
}}
1.1.3 包装类型和String类型的相互转换
public class WrapperVSString{
public static void main(String[]args){
//包装类(Integer)->String
Integer i=100;//自动装箱
//方式1
String str1 =i+"";
//方式2
String str2 =i.toString();
//方式3
String str3 =String.valueOf(i);
//String-> 包装类(Integer)
String str4 ="12345";
Integer i2 =Integer.parseInt(str4);//使用到自动装箱
Integer i3 =new Integer(str4);//构造器
System.out.println("ok~~");
} }
1.1.4 Integer类和Character类的常用方法
public class WrapperMethod{
public static void main(String[]args){
System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是不是小写
System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写
} }
1.1.5 Integer类面试题
public class WrapperExercise02{
public static void main(String[] args) {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //False
//所以,这里主要是看范围-128~127 就是直接返回
/*
//解读
//1. 如果i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
//2. 如果不在-128~127,就直接 newInteger(i)
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
*/
Integer m = 1; //底层 Integer.valueOf(1);-> 阅读源码
Integer n = 1;//底层 Integer.valueOf(1);
System.out.println(m == n); //T
//,否则,就newInteger(xx);
//所以,这里主要是看范围-128~127 就是直接返回
Integer x = 128;//底层 Integer.valueOf(1);
Integer y = 128;//底层 Integer.valueOf(1);
System.out.println(x == y);//False
} }
1.1.6 Intege 类面试题总结
public class WrapperExercise03 {
public static void main(String[] args) {
//示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//F
//示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//F
//示例三
Integer i5 = 127;//底层 Integer.valueOf(127)
Integer i6 = 127;//-128~127
System.out.println(i5 == i6); //T
//示例四
Integer i7 = 128;
Integeri8=128;
System.out.println(i7==i8);//F
//示例五
Integeri9=127;//Integer.valueOf(127)
Integeri10=newInteger(127);
System.out.println(i9==i10);//F
//示例六
Integeri11=127;
inti12=127;
//只有有基本数据类型,判断的是
//值是否相同
System.out.println(i11==i12);//T
//示例七
Integeri13=128;
inti14=128;
System.out.println(i13==i14);//T
} }
1.2 String类
1.2.1 String类的理解和创建对象
代码:
public class String01{
public static void main(String[]args){
//1.String对象用于保存字符串,也就是一组字符序列
//2."jack"字符串常量,双引号括起的字符序列
//3.字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节
//4.String类有很多构造器,构造器的重载
//常用的有String s1=newString();//
//String s2=newString(Stringoriginal);
//String s3=newString(char[]a);
//String s4= newString(char[]a,intstartIndex,intcount)
//Strings5=newString(byte[]b)
//5.String类实现了接口Serializable【String可以串行化:可以在网络传输】
//接口Comparable[String对象可以比较大小]
//6.String是final类,不能被其他的类继承
//7.String有属性privatefinalcharvalue[];用于存放字符串内容
//8.一定要注意:value是一个final类型,不可以修改(需要功力):即value不能指向
//新的地址,但是单个字符内容是可以变化
String name="jack";
name ="tom";
final char[] value={'a','b','c'};
char[] v2={'t','o','m'};
value[0] ='H';
//value =v2; 不可以修改value地址
} }
1.2.2 创建String对象的两种方式
1) 方式一:直接赋值 String s = "zak";
2) 方式二:调用构造器 String s = new String("zak");
1.2.3 两种创建String对象的区别
1.方式一: 先从常量池查看是否有"hello”数据空间,如果有,直接指向;如果没有则重新创建,然后指向。s最终指向的是常量池的空间地址
2. 方式二: 先在堆中创建空间,里面维护了value属性,指向常量池的hello空间。
如果常量池没有"hello",重新创建,如果有,直接通过value指向。最终指向的是堆中的空间地址。
3. 画出两种方式的内存分布图
1.3 字符串的特性
1) String是一个final类,代表不可变的字符序列
2) 字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的.
1.4 String 类的常见方法
1.4.1 说明
String类是保存字符串常量的。每次更新都需要重新开辟空间,效率较低,因此java设计者还提供了StringBuilder 和 StringBuffer 来增强String的功能,并提高效率。
1.4.2 String类的常见方法
1.5 StringBuffer 类
1.5.1 基本介绍
java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删。
很多方法与String相同,但StringBuffer是可变长度的。
StringBuffer是一个容器。
public class StringBuffer01{
public static void main(String[]args){
//解读
//1.StringBuffer的直接父类是AbstractStringBuilder
//2.StringBuffer实现了Serializable,即StringBuffer的对象可以串行化
//3.在父类中AbstractStringBuilder有属性char[]value,不是final
//该value数组存放字符串内容,引出存放在堆中的
//4.StringBuffer是一个final类,不能被继承
//5.因为StringBuffer字符内容是存在char[]value,所有在变化(增加/删除)
//不用每次都更换地址(即不是每次创建新对象),所以效率高于String
StringBuffer stringBuffer = new StringBuffer("hello");
}}
1.5.2 String VS StringBuffer
1) String保存的是字符串常量,里面的值不能更改,每次String类的更新实际上就是更改地址,效率较低 //private final char value[ ];
2) StringBuffer保存的是字符串变量,里面的值可以更改,每次 StringBuffer的更新实际上可以更新内容,不用每次更新地址,效率较高 //char[ ] value; 这个放在堆.
1.5.3 String和StringBuffer相互转换:
public class StringAndStringBuffer{
public static void main(String[]args){
//看String——>StringBuffer
String str ="hellotom";
//方式1使用构造器
//注意:返回的才是StringBuffer对象,对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//看看StringBuffer->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式1使用StringBuffer提供的toString方法
Strings =stringBuffer3.toString();
//方式2:使用构造器来搞定
Strings1 = new String(stringBuffer3);
} }
1.5.4 StringBuffer类常见方法:
public class StringBufferMethod {
public static void main(String[] args) {
StringBuffer s = new StringBuffer("hello");
//增
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰"
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5"
System.out.println(s);//"hello,张三丰赵敏 100true10.5"
//删
/*
* 删除索引为>=start&&<end 处的字符
* 解读: 删除 11~14的字符 [11,14)
*/
s.delete(11, 14);
System.out.println(s);//"hello,张三丰赵敏 true10.5"
//改
s.replace(9, 11, "周芷若");
//解读,使用 周芷若 替换 索引9-11的字符 [9,11)
System.out.println(s);//"hello,张三丰周芷若 true10.5"
//查找指定的子串在字符串第一次出现的索引,如果找不到返回-1
int indexOf = s.indexOf("张三丰");
System.out.println(indexOf);//6
//插
//解读,在索引为9的位置插入"赵敏",原来索引为9的内容自动后移
s.insert(9,"赵敏");
System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
//长度
System.out.println(s.length());//22
System.out.println(s);
} }
1.6 StringBuilder类
1.6.1 基本介绍
1) 一个可变的字符序列。此类提供一个与StringBuffer兼容的 API,但不保证同步(StringBuilder不是线程安全)。该类被设计用作 StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类.因为在大多数实现中,它比 StringBuffer要快。
2) 在 StringBuilder上的主要操作是append和 insert方法,可重载这些方法,以接受任意类型的数据。
代码:
public class StringBuffer01{
public static void main(String[]args){
//解读
//1.StringBuffer的直接父类是AbstractStringBuilder
//2.StringBuffer实现了Serializable,即StringBuffer的对象可以串行化
//3.在父类中AbstractStringBuilder有属性char[]value,不是final
//该value数组存放字符串内容,引出存放在堆中
//4.StringBuffer是一个final类,不能被继承
//5.因为StringBuffer字符内容是存在char[]value,所有在变化(增加/删除)
//不用每次都更换地址(即不是每次创建新对象),所以效率高于String
StringBuffer stringBuffer = new StringBuffer("hello");
} }
1.6.2 StringBuilder常用方法
StringBuilder和 StringBuffer 均代表可变的字符序列,方法是一样的,所以使用和StringBuffer一样.
public class StringBuilder01{
public static void main(String[]args){
//解读
//1. StringBuilder 继承 AbstractStringBuilder 类
//2. 实现了 Serializable ,说明 StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件)
//3. StringBuilder 是 final 类, 不能被继承
//4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder 的 char[] value;
//因此,字符序列是堆中
//5. StringBuilder 的方法,没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用
//StringBuilder
StringBuilder stringBuilder = new StringBuilder();
} }
1.6.3 String、StringBuffer 和 StringBuilder 的比较
1) StringBuilder 和 StringBuffer非常类似,均代表可变的字符序列,而且方法也一样
2) String:不可变字符序列,效率低,但是复用率高。
3) StringBuffer:可变字符序列、效率较高(增删)、线程安全,看源码4)StringBuilder:可变字符序列、效率最高、线程不安全
5) String使用注意说明:
string s="a"; //创建了一个字符串
s+="b"; //实际上原来的"a"字符串对象已经丢弃了,现在又产生了一个字符串s+"b”(也就是"ab")。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的性能=>结论:如果我们对String 做大量修改,不要使用String
1.6.4 String、StringBuffer 和 StringBuilder 的选择
使用的原则,结论:
1. 如果字符串存在大量的修改操作,一般使用 StringBuffer 或StringBuilder
2. 如果字符串存在大量的修改操作,并在单线程的情况,使用 StringBuilder
3. 如果字符串存在大量的修改操作,并在多线程的情况,使用StringBuffer
4. 如果我们字符串很少修改,被多个对象引用,使用String,比如配置信息等
StringBuilder的方法使用和StringBuffer一样,不再说.
1.7 Math 类
1.7.1 基本介绍
Math类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
1.7.2 方法一览(均为静态方法)
应用案例:
public class MathMethod{
public static void main(String[]args){
//看看Math常用的方法(静态方法)
//1.abs绝对值
int abs = Math.abs(-9);
System.out.println(abs);//9
//2.pow 求幂
double pow = Math.pow(2, 4);//2 的 4 次方
System.out.println(pow);//16
//3.ceil 向上取整,返回>=该参数的最小整数(转成double);
double ceil = Math.ceil(3.9);
System.out.println(ceil);//4.0
//4.floor 向下取整,返回<=该参数的最大整数(转成double)
double floor = Math.floor(4.001);
System.out.println(floor);//4.0
//5.round 四舍五入 Math.floor(该参数+0.5)
long round = Math.round(5.51);
System.out.println(round);//6
//6.sqrt 求开方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);//3.0
//7.random 求随机数
// random 返回的是 0<=x<1 之间的一个随机小数即返回一个数 x 2<=x<=7
// 思考:请写出获取 a-b之间的一个随机整数,a,b均为整数 ,比如 a=2,b=7
// 解读 Math.random() * (b-a) 返回的就是 0 <= 数 <=b-a
// (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
// (2) 使用具体的数给小伙伴介绍 a=2 b=7
//(int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
// Math.random()*6 返回的是 0<= x<6 小数
//2 +Math.random()*6 返回的就是 2<=x<8 小数
// (int)(2+Math.random()*6)=2<=x<=7
//(3)公式就是(int)(a+Math.random()*(b-a+1))
for(inti=0;i<100;i++){
System.out.println((int)(2+ Math.random()*(7-2+1)));
}
//max,min返回最大值和最小值
int min = Math.min(1,9);
int max = Math.max(45,90);
System.out.println("min="+min);
System.out.println("max="+max);
} }
1.8 Arrays类
1.8.1 Arrays类常见方法应用案例
Arrays里面包含了一系列静态方法,用于管理或操作数组(比如排序和搜索)。
1) toString返回数组的字符串形式 Arrays.toString(arr)
2) sort排序(自然排序和定制排序)lnteger arr[ = {1,-1,7,0,89};
3) binarySearch 通过二分搜索法进行查找,要求必须排好序int index =Arrays.binarySearch(arr,3);
4) copyOf 数组元素的复制 Integerl newArr = Arrays.copyOf(arr, arr.length);
5) fill 数组元素的填充 Integer[ num = new Integer[1{9.3,2}; Arrays.fill(num, 99);
6) equals 比较两个数组元素内容是否完全一致 boolean equals = Arrays.equals(arr,arr2);
7) asList将一组值,转换成list
List<lnteger> asList = Arrays.asList(2,3,4,5,6,1); System.out.println("asList=" + asList);
import java.util.Arrays;
import java.util.Comparator;
public class ArraysMethod01 {
public static void main(String[] args) {
Integer[] integers = {1, 20, 90};
//遍历数组
//for(int i = 0; i < integers.length; i++) {
//System.out.println(integers[i]);
// }
//直接使用Arrays.toString 方法,显示数组
//System.out.println(Arrays.toString(integers));//
//演示 sort 方法的使用
Integer arr[] = {1,-1, 7, 0, 89};
//进行排序
//解读
//1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
//2. 因为数组是引用类型,所以通过sort排序后,会直接影响到 实参 arr
//3. sort 重载的,也可以通过传入一个接口 Comparator 实现定制排序
//4. 调用 定制排序 时,传入两个参数 (1) 排序的数组 arr
//(2) 实现了Comparator 接口的匿名内部类 , 要求实现 compare方法
//5. 先演示效果,再解释
//6. 这里体现了接口编程的方式 , 看看源码,就明白
//源码分析
//(1) Arrays.sort(arr, new Comparator()
//(2) 最终到 TimSort 类的 private static <T> void binarySort(T[] a, int lo, int hi, int start,
// Comparator<? super T> c)()
//(3) 执行到 binarySort 方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
//匿名内部类的 compare()
//while (left < right) {
// int mid = (left + right) >>> 1;
// if (c.compare(pivot, a[mid]) < 0)
// right = mid;
//else
// }
//(4) new Comparator() {
// left = mid + 1;
// @Override
// public int compare(Object o1, Object o2) {
// Integer i1 = (Integer) o1;
// return i2- i1;
// } }
// Integer i2 = (Integer) o2;
//(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
//会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
//将来的底层框架和源码的使用方式,会非常常见
//Arrays.sort(arr); // 默认排序方法
//定制排序
Arrays.sort(arr,newComparator(){
@Override
public int compare(Objecto1,Objecto2){
Integer i1 =(Integer)o1;
Integer i2 =(Integer)o2;
return i2-i1;
} });
System.out.println("===排序后===");
System.out.println(Arrays.toString(arr));
} }
import java.util.Arrays;
import java.util.Comparator;
public class ArraysSortCustom{
public static void main(String[] args) {
int[] arr = {1,-1, 8, 0, 20};
//bubble01(arr);
bubble02(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int i1 = (Integer) o1;
int i2 = (Integer) o2;
return i2- i1;// return i2- i1;
} });
System.out.println("==定制排序后的情况==");
System.out.println(Arrays.toString(arr));
}
//使用冒泡完成排序
public static void bubble01(int[] arr) {
int temp = 0;
for (int i = 0; i < arr.length- 1; i++) {
for (int j = 0; j < arr.length- 1- i; j++) {
//从小到大
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
} } } }
//结合冒泡 + 定制
public static void bubble02(int[] arr, Comparator c) {
int temp = 0;
for (int i = 0; i < arr.length- 1; i++) {
for (int j = 0; j < arr.length- 1- i; j++) {
//数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
if (c.compare(arr[j], arr[j + 1]) > 0) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
} } } } }
import java.util.Arrays;
import java.util.List;
public class ArraysMethod02 {
public static void main(String[] args) {
Integer[] arr = {1, 2, 90, 123, 567};
// binarySearch 通过二分搜索法进行查找,要求必须排好
// 解读
//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的,不能使用binarySearch
//3. 如果数组中不存在该元素,就返回 return-(low+1); //keynotfound.
int index = Arrays.binarySearch(arr, 567);
System.out.println("index=" + index);
//copyOf 数组元素的复制
// 老韩解读
//1. 从 arr 数组中,拷贝 arr.length个元素到 newArr数组中
//2. 如果拷贝的长度 >arr.length 就在新数组的后面 增加 null
//3. 如果拷贝长度 <0 就抛出异常NegativeArraySizeException
//4. 该方法的底层使用的是 System.arraycopy()
Integer[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));
//ill 数组元素的填充
Integer[] num = new Integer[]{9,3,2};
//解读
//1. 使用 99 去填充 num数组,可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num 数组填充后==");
System.out.println(Arrays.toString(num));
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//解读
//1. 如果arr 和 arr2 数组的元素一样,则方法true;
//2. 如果不是完全一样,就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 将一组值,转换成list
//解读
//1. asList 方法,会将 (2,3,4,5,6,1)数据转成一个 List 集合
//2. 返回的 asList 编译类型 List(接口)
//3. asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的
//静态内部类 privatestatic classArrayList<E> extendsAbstractList<E>
// implements RandomAccess, java.io.Serializable
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList="+asList);
System.out.println("asList的运行类型"+asList.getClass());
} }
1.9 System类
1.9.1 System类常见方法和案例
1) exit 退出当前程序
2) arraycopy:复制数组元素,比较适合底层调用,一般使用
Arrays.copyOf完成复制数组.
int[ ] src = {1,2,3};
int[ ]dest = new int[3];
System.arraycopy(src, O, dest, 0.3);
3) currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
4) gc:运行垃圾回收机制 System.gc( ) ;
import java.util.Arrays;
public class System_ {
public static void main(String[] args) {
//exit 退出当前程序
// System.out.println("ok1");
//解读
//1. exit(0) 表示程序退出
//2. 0 表示一个状态 , 正常的状态
//System.exit(0);//
//System.out.println("ok2");
//arraycopy :复制数组元素,比较适合底层调用,
// 一般使用Arrays.copyOf 完成复制数组
int[ ] src={1,2,3};
int[ ] dest = new int[3];// dest 当前是 {0,0,0}
//解读
//1. 主要是搞清楚这五个参数的含义
//源数组
// *@param src thesourcearray.
// srcPos:从源数组的哪个索引位置开始拷贝
// *@param srcPos startingpositioninthesourcearray.
// dest:目标数组,即把源数组的数据拷贝到哪个数组
// *@param dest thedestinationarray.
// destPos:把源数组的数据拷贝到目标数组的哪个索引
// *@param destPos startingpositioninthedestinationdata.
// length:从源数组拷贝多少个数据到目标数组
// *@param length the number of array elements to be copied.
System.arraycopy(src,0,dest,0,src.length);
//int[]src={1,2,3};
System.out.println("dest="+Arrays.toString(dest));//[1,2,3]
//currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
//解读:
System.out.println(System.currentTimeMillis());
} }
1.10 BigInteger和BigDecimal类
1.10.1 BigInteger 和 BigDecimal介绍
应用场景:
1) Biglnteger适合保存比较大的整型
2) BigDecimal适合保存精度更高的浮点型(小数)
public class BigInteger_{
public static void main(String[]args){
//当我们编程中,需要处理很大的整数,long不够用
//可以使用BigInteger的类来搞定
// longl=23788888899999999999999999999l;
// System.out.println("l="+l);
BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
BigInteger bigInteger2 = new BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
System.out.println(bigInteger);
//解读
//1.在对BigInteger进行加减乘除的时候,需要使用对应的方法,不能直接进行+-*/
//2.可以创建一个要操作的BigInteger然后进行相应操作
BigInteger add = bigInteger.add(bigInteger2);
System.out.println(add);//
BigInteger subtract =bigInteger.subtract(bigInteger2);
System.out.println(subtract);//减
BigInteger multiply =bigInteger.multiply(bigInteger2);
System.out.println(multiply);//乘
BigInteger divide =bigInteger.divide(bigInteger2);
System.out.println(divide);//除
} }
import java.math.BigDecimal;
public class BigDecimal_ {
public static void main(String[] args) {
//当我们需要保存一个精度很高的数时,double 不够用
//可以是 BigDecimal
// double d = 1999.11111111111999999999999977788d;
// System.out.println(d);
BigDecimal bigDecimal = new BigDecimal("1999.11");
BigDecimal bigDecimal2 = new BigDecimal("3");
System.out.println(bigDecimal);
//解读
//1. 如果对 BigDecimal 进行运算,比如加减乘除,需要使用对应的方法
//2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
System.out.println(bigDecimal.add(bigDecimal2));
System.out.println(bigDecimal.subtract(bigDecimal2));
System.out.println(bigDecimal.multiply(bigDecimal2));
//System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常 ArithmeticException
//在调用divide 方法时,指定精度即可.BigDecimal.ROUND_CEILING
//如果有无限循环小数,就会保留 分子 的精度
System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
}}