Java常用类

知昂可

已于 2024-05-08 21:30:23 修改

阅读量926

点赞数 16

分类专栏： java 文章标签： java 开发语言

于 2024-05-08 21:29:52 首次发布

本文链接：https://blog.csdn.net/pythontxt/article/details/138544845

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

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));
}}