Java10---------常用类StringBuffer类、Arrays类、包装类、Math类、random类、System类

最新推荐文章于 2022-08-24 00:45:46 发布

哦?

最新推荐文章于 2022-08-24 00:45:46 发布

阅读量314

点赞数 1

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_44241861/article/details/107684084

版权

Java基础专栏收录该内容

25 篇文章 0 订阅

订阅专栏

StringBuffer类

从String类的引入

以下代码会创建几个对象？ ------------5个对象

		String str="abc"; //"abc"
        str+="ccc"; //ccc //abcccc
        str+="dddd"; //"ddddd"   abccccddddd

【分析】：首先字符常量池创建对象abc，再创建ccc 为拼接后的结果创建对象abcccc ；将str的引用指向abcccc 的地址；

我们如果对字符串进行拼接操作，每次拼接都会构建一个新的String对象，既耗时又浪费空间。而StringBuffer就可以解决这个问题，它是线程安全的可变字符序列。相当于一个字符容器，你可以不断的往容器中追加字符，在大量拼接字符串时，就可以使用长度可变的字符容器

StringBuffer类的构造方法

public StringBuffer(): 无参构造方法,构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象

StringBuffer的成员方法：

public int capacity()：返回当前容量——理论值
public int length()：返回长度（字符数）——实际值
注意：容器的长度length表示实际字符的个数，容量capacity表示容器的属性值（例如一个水杯容量500ml，装入100ml的水，容量依旧为500ml，长度就是100ml）

public class test1 {
    public static void main(String[] args) {
        //创建一个空的字符容器。
        StringBuffer ss=new StringBuffer();
        //获取容器的容量 一旦超过容量，可以自动扩容。
        System.out.println(ss.capacity());//16
        ss.append("1");//向容器中追加数据
        System.out.println(ss.capacity());//16
        //获取容器包含实际字符数：求容器的长度
        System.out.println(ss.length());//1
        ss.append("sssssssssssssssssssssssssssssss");//31个字符s
        //获取容器的容量 一旦超过容量，可以自动扩容。
        System.out.println(ss.capacity());//34
        System.out.println(ss.length());//32
        //构建容器时，可以指定这个字符容器的容量
        StringBuffer ss1=new StringBuffer(100);
        // 构建容器时，可以往容器中放入字符串
        StringBuffer ss2=new StringBuffer("aaa");
        }
        }

StringBuffer的功能

容器对象实现某种功能返回字符串缓冲区本身是指：不创建新的对象返回的还是原来的那个容器对象，地址值不变。
只有截取功能与toString功能返回的类型是字符串，地址值改变。

添加功能

public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

   //append("abc"); 往容器中追加数据，返回的还是原来的那个容器对象。
        StringBuffer ss3=ss2.append("ssssss");
        System.out.println(ss3 == ss2);//true

       // append :向容器中追加多种类型数据,可以采用链式不断追加数据
        //拼串时使用字符串缓存区的append而不使用加号，不创建新对象并且可以拼接各种类型的字符串
        StringBuffer ss4=ss3.append("aa").append(122).append(true).append(new char[]{'1', '2', '3'});
        
         //StringBuffer重写了Object类的toString方法，不打印地址值，而是将所有数据整合为字符串的形式返回
        System.out.println(ss4);//aaassssssaa122true123

		//StringBuffer 里面的数据也是编有索引的。
        StringBuffer sb = new StringBuffer("abc");
        //在索引1处插入eee 返回原对象
        sb.insert(1, "eee");
        System.out.println(sb);aeeebc

删除功能

public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

接上段代码：

 		//删除索引为0的字符
        System.out.println(sb.deleteCharAt(0));//eeebc
        //根据起始索引和终止索引，删除容器中的一部分内容，返回的还是容器本身。
        System.out.println(sb.delete(0, 2));//ebc  索引位置的查找包左不包右
        //返回的还是容器本身 地址值不变
       // System.out.println(sb==sb.delete(0,1));//true

替换功能

public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换

//根据起始索引和终止索引，替换容器中的一部分内容。返回的还是容器本身。
        System.out.println(sb.replace(0, 2, "scq"));//scqc 索引位置的查找包左不包右

查找功能

int indexOf (String str) 从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
int indexOf (String str,int fromIndex) 从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
int lastIndexOf (String str) 从后往前找
int lastIndexOf (String str,int fromIndex)

  //查找容器中该字符串第一次出现的索引，如果查找不到返回-1
        System.out.println(sb.indexOf("e"));//0

反转功能

public StringBuffer reverse(): 字符串反转

//反转,返回的还是容器本身
System.out.println(sb.reverse());//cqcs

截取功能

1.public String substring(int start): 从指定位置截取到末尾
2. public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

截取功能的注意事项

返回值类型不再是StringBuffer本身，而是一个字符串

        //根据起始索引和 终止索引，截取容器中一部分内容返回，注意返回的是String类型 使用字符串类接收
        // 注意：substring返回的是一个字符串类型，不对原对象sb做出任何改变
        String s1=sb.substring(0, 2);
        System.out.println(sb);//cqcs 没有改变
        System.out.println(s1);//cq 索引位置的查找包左不包右

StringBuffer和String的相互转换

String --> StringBuffer

通过构造方法
通过append()方法空容器添加字符串
通过insert()方法空容器在0位置插入字符串

		 String str="beauty";
		 
        //方式一:通过StringBuffer的构造方法传入字符串，转换为StringBuffer类型
        StringBuffer ss1 = new StringBuffer(str);
        
        //方式二：通过StringBuffer的append方法追加字符串，就将一个字符串转换为StringBuffer类型
        StringBuffer ss2=new StringBuffer().append(str);
        System.out.println(ss2);//beauty 
        
        //方式三：通过StringBuffer的insert方法按照指定位置插入字符串，将一个字符串转换为StringBuffer类型
        StringBuffer ss3=new StringBuffer().insert(0,str);
        //toString方法返回值是一个字符串类型并将返回值打印出来，
        //但是ss3本身是一个StringBuffer类型，没有改变
        System.out.println(ss3);//beauty 是一个字符串

StringBuffer --> String

使用substring方法
通过String 类构造方法
通过toString()方法

		//方式一： StringBuffer的toString方法是所有数据整合以字符串的形式返回
        String str1=ss3.toString();
        
        //方式二：StringBuffer的substring方法根据索引值
        // 截取容器一部分内容或者全部，以字符串的形式返回
        String str2=ss3.substring(0);//截取全部
        System.out.println(str2);//beauty

        //方式三：String 类中有一个构造方法 直接将容器转换为字符串
        String str4=new String(ss3);

小练习：
一、把数组转成字符串
int[] arr = {1, 2, 3};
输出结果： “[1, 2, 3]”

  int[] arr = {1,2};
        //方法一：
        //StringBuffer ss6=new StringBuffer();
        //System.out.println(new StringBuffer().append('[').append(1).append(',').append(2).append(']'));

//方法二：
//注意： StringBuffer的构造方法中输入字符串类型来当做字符串容器，
//其余类型例如字符型均会转为数值作为定义容器容量的值
        int[] arr = {1,2};
        StringBuffer str=new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1)
            str=str.append(arr[i]).append(']');
            else str=str.append(arr[i]).append(',');
        }
        System.out.println(str);
    }
}

二、字符串的反转
键盘录入"abc"
输出结果：“cba”

//对一个字符串进行反转,toString()返回一个字符串类型 sout下默认可以不写
		 //System.out.println(new StringBuffer("abc").reverse());//cba
        System.out.println(new StringBuffer("abc").reverse().toString());//cba

StringBuffer和StringBuilder的区别

StringBuffer

StringBuffer （单线程）线程安全的字符序列，效率低
适用于多线程下大量数据，效率低，线程安全；

StringBuilder

StringBuffer （多线程）线程不安全的字符序列，效率高
此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
适用于单线程下大量数据，效率高，线程非安全；

String和StringBuffer分别作为参数传递

String类虽然是引用类型，但是创建的对象字符串，长度一旦被定义就不可以改变，是一个常量，所以在做传递的时候，完全可以将其看成基本数据类型数据进行传递，属于值传递。会这把字符串的值传递过去
StringBuffer类作为参数传递是引用类型传递，形参的改变会影响实参。

public class MyTest {
    public static void main(String[] args) {
        String str = "abc";
        change(str);
        System.out.println(str);//abc 
        StringBuffer sb = new StringBuffer("Hello");
        change(sb);
        sb.reverse();
        System.out.println(sb);  //呵呵哈哈olleH
    }
    //引用类型作为参数传递，形参的改变会影响实参。
    private static void change(StringBuffer sb) {
        sb.append("哈哈").append("呵呵");
    }

    //注意：String 类型作为参数传递，属于值传递。会这把字符串的值传递过去
    private static void change(String str) {
        str+="你好";
        System.out.println(str); //abc你好
    }
}

Arrays类

针对数组进行操作的工具类。提供了排序，查找等功能。

Aarrays的成员方法

public static String toString(int[] a) ：把数组中的元素，转换成一个漂亮字符串。

int[] arr={10,20,30};
String s = Arrays.toString(arr);
 System.out.println(s);//[10,20,30]

二分查找前：数组元素必须有序
public static void sort(int[] a) ：排序
public static int binarySearch(int[] a,int key) ：二分法查找指定byte类型数组中的元素位置

   int[] arr = {20, 20, 6, 8, 9, 1, 2, 3, 4, 90, 100, 3, 0, -1, -2, 6, 9};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //[-2, -1, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 9, 20, 20, 90, 100]
        
        //二分查找:数组元素必须有序
        char[] chars={'a','b','a','c'};
        Arrays.sort(chars);//sort方法返回为空 ,但是对于原数组已经排列。
        System.out.println(chars); //aabc
        System.out.println(Arrays.binarySearch(chars, 'a')); //1 返回中间的索引

static boolean equals(int[] a, int[] a2) ：比较两个数组的长度与各个数组的元素对应位置是否相同

//定义两个数组元素相同，数组长度相同，但是元素对应位置不同，所以两个数组不相等
int[] arr = {20, 20, 6, 8};
int[] arr2 = {6, 20, 20, 8}; 
//比较两个数组中的元素是否一样。
 boolean b = Arrays.equals(arr, arr2);
 System.out.println(b);//false 

int[] arr =null;
int[] arr2=null;//arr与arr2的地址值均为null 因此相等
System.out.println(Arrays.equals(arr, arr2));//true

static int[] copyOf(int[] original, int newLength) ：复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
static int[] copyOfRange(int[] original, int from, int to)：复制旧数组中的指定范围间的几个元素到新数组中

     int[] arr = {20, 20, 6, 8,20,30,50,60};
       // 从0开始复制旧数组 指定新数组长度
        int[] ints = Arrays.copyOf(arr, 3);
        //打印数组直接调用toStrng方法 不需要再遍历
        System.out.println(Arrays.toString(ints));//[20, 20, 6]
        //3 起始索引，6 终止索引 含头不含尾
        int[] ints1 = Arrays.copyOfRange(arr, 3, 6);
        System.out.println(Arrays.toString(ints1));//[8, 20, 30]  索引包左不包右

包装类

为什么会有基本类型包装类？

为了对基本数据类型进行更多的操作，Java就针对每一种基本数据类型提供了对应的类类型；

常用操作:

用于基本数据类型与字符串之间的转换；

基本类型和包装类的对应：
在这里插入图片描述

所有的基本类型转换为包装类型之后操作类似，这里以int<——>Integer为例：

Integer类

一、两个构造方法

Integer( int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。使用与 parseInt 方法（对基数为 10 的值）相同的方式将该字符串转换成 int 值。

  //把int类型的值，包装成引用类型。
        Integer integer = new Integer(100);
        //要的这个字符串，字面上是一个数字的字符串。
        Integer integer2 = new Integer("200");

Integer的应用：

1：将100转换成二进制 , 八进制 , 十六进制；:

		  int num = 100;
        String s = Integer.toBinaryString(num);//1100100
        String s1 = Integer.toOctalString(num);//144
        String s2 = Integer.toHexString(num);//64

2：判断一个数是否在 int 的范围内；

 if(25252525>=Integer.MIN_VALUE&& 25252525<=Integer.MAX_VALUE){
            System.out.println("在int范围内");
        }

3：String和int类型的相互转换

int --> String

a: 和""进行拼接 : String str=100+"";
b: public static String valueOf(int i) : String s = String.valueOf(100);
c: int – Integer – String: String s=new Integer(100).toString();

string—>int：

a:String – Integer – intValue(); int i=new Integer("100").intValue();
b:public static int parseInt(String s) ： int ii=Integer.parseInt("100"); //常用

4：Java中的装箱和拆箱；

自动装箱：把基本类型转换为包装类类型；就是调用Integer.valueOf(num);

 Integer numInteger=new Integer(100);//创建新对象
 Integer numInteger1=100; //直接将数值传过去
 //手动装箱
 Integer numInteger3=Integer.valueOf(100);

自动拆箱：把包装类类型转换为基本类型；就是调用intValue方法

// Ingeter对象相加发生自动拆箱，将对象numInteger、numInteger1拆为基本类型100、100再相加
int result=numInteger+numInteger1;
 //手动拆箱：就是调用intValue方法
int result1=numInteger.intValue()+numInteger1.intValue();

以下代码实现了几个过程？

Integer ii = 100; //自动装箱
//先自动拆箱为基本数据类型与200相加，加完后将基本数据类型300再赋给Integer引用类型ii，实现自动装箱
ii += 200; 自动拆箱，自动装箱。

5: Integer重写了toString方法(把Integer类型数据转换为字符串)

Integer numInteger=300;
String str=numInteger.toString();
System.out.println(str+"aaa");//300aaa

6: Integer重写了 equals(比包装的两个值是否相等 )方法

Integer a=new Integer(1);
Integer b=new Integer(1);
System.out.println(a.equals(b));//true

来看一个现象：当一个值在[-128,127]之间，两个Integer类型的对象地址值就相等，超过这个范围地址值不相等；

	    Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6);//  false
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);//true

【分析】：自动装箱就是调用valueof方法，valueof方法使用IntegerCache这个静态内部类，当IntegerCache类加载就执行这个类的静态代码块，在cache缓存中创建256个对象，基本数据类型在-128—127之间从缓存的对象中找到基本数据类型对应索引的对象地址，并返回这个地址；基本数据类型不在这个范围，会new一个新对象，因此地址不同

小练习：把给定字符串中的数字排序
我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

  String s5="91   27 46 38 50 5 300 1 100 3 200";
  //1.以字符串中的空格来分割，返回一个字符串数组；
  //空格不只一个 因此要+号
        String[] s6=s5.split(" +");

        //2. 字符串数组转换为整形数组
        int[] s7=new int[s6.length];//定义整形数组，长度为字符串数组长度
        for (int i = 0; i < s6.length; i++) {
            s7[i]=Integer.parseInt(s6[i]); // 字符串转换为整形
        }

        String ss="";
        Arrays.sort(s7); //对整形数组排序
        for (int i = 0; i < s7.length; i++) {
            ss+=s7[i]+" ";
        }
        System.out.println(ss.trim());//去掉右端空格


执行结果：
1 3 5 27 38 46 50 91 100 200 300

Character类

		Character a = new Character('A');  //自动装箱
        char c = a.charValue(); //手动拆箱
        Character a1 = Character.valueOf('a'); //手动装箱

        System.out.println(Character.isLowerCase('a')); //true
        boolean a2 = Character.isUpperCase('A');
        boolean digit = Character.isDigit('9');
        System.out.println(Character.isSpaceChar(' '));//true

Math类

该类是一个工具类，因此它的很多方法和字段都是静态的，我们只需要使用类名就可以调用；
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数；

成员变量：

public static final double E : 自然底数
public static final double PI: 圆周率

System.out.println(Math.PI);
System.out.println(Math.E);

成员方法

public static int abs(int a) 取绝对值
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static int max(int a,int b) 获取最大值
public static int min(int a, int b) 获取最小值
public static double pow(double a,double b) 获取a的b次幂
public static double random() 获取随机数返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
public static int round(float a) 四舍五入
public static double sqrt(double a)获取正平方根

	   System.out.println(Math.abs(-1));//1
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.floor(3.1));//3.0
        System.out.println(Math.random());
        System.out.println(Math.max(3.1, 36.2));//36.2
        System.out.println(Math.max(Math.max(3.1, 36.2),36));//36.2
        System.out.println(Math.min(3.3, 68));//3.3

        System.out.println(Math.pow(3, 3));//27
        System.out.println(Math.sqrt(4));//2.0
        System.out.println(Math.round(3.5));//4

        System.out.println(Math.pow(8, 1/3.0));//2.0  8开立方一定要写为浮点数

Random类

构造方法
无参构造Random() ：创建一个新的随机数生成器
有参构造Random(long seed) ：使用单个 long 种子创建一个新的随机数生成器
两个构造的区别：无参构造程序再次运行时产生的随机数会发生变化，而程序再次运行时有参构造产生的随机数不会发生变化；
成员方法
public int nextInt()//没有参数表示的随机数范围是int类型的范围[-2^31 , 2^31-1]
public int nextInt(int n)//可以指定一个随机数范围
void nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的空的 byte 数组中。

无参构造Random() ：

  Random random = new Random();
  int num = random.nextInt(10); //随机生成0-9的一个随机数
  System.out.println(num);  //9 
   double v = random.nextDouble();  //产生双精度类型的浮点数,范围在0-1
   System.out.println(v);  //0.7575059280727998
   boolean b = random.nextBoolean(); //产生布尔类型的随机数
   System.out.println(b);// true
   
   byte[] bytes = new byte[10];
   random.nextBytes(bytes); // 生成10个随机字节并将其置于用户提供的空的 bytes 数组中。
   System.out.println(Arrays.toString(bytes));  //[-51, -38, -53, -67, 127, -62, 68, 45, -25, 29]

有参构造Random(Long seed) ：再次执行此代码生成的随机数不变

//给了种子，就会根据种子算出一些随机数，你每次重新运行，生成的随机数就不变了。
        Random random = new Random(10L);
        //生成2次在0-9的随机数
        for (int i = 0; i < 2; i++) {
            int i1 = random.nextInt(10);
            System.out.println(i1);
        }
    }
}

输出结果：
3
0

System类

System 类在java.lang包下，包含一些有用的类字段和方法，它不能被实例化；查看API，发现该类是一个被final修饰的类，也就是不能被继承；

成员字段：
static PrintStream err——"标准"错误输出流
static InputStream in—— "标准"输入流(此流已打开并准备提供输入数据；通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源)
static PrintStream out—— "标准"输出流(此流已打开并准备接受输出数据；通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。)
成员方法：
public static void gc()—— 调用垃圾回收器【调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存；当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间】
public static void exit(int status)——退出java虚拟机，0为正常退出，非0为异常退出；
public static long currentTimeMillis()——获取当前时间的毫秒值；

 	 	InputStream in = System.in;
        PrintStream out = System.out;
        out.println("abc");
        System.out.println(200);

        System.out.println("=============================");
        System.err.println("错误信息"); //打印出来的字体报红

执行结果如下：
在这里插入图片描述

		//exit(0); 退出虚拟机
        System.out.println("abcb");
        System.out.println("abcb");
        //0 正常退出 非0 强制退出  打印两边abcd就退出，后续代码不会再打印
        System.exit(0);
        System.out.println("abcb");
        System.out.println("abcb");
        System.out.println("abcb");
        System.out.println("abcb");

在这里插入图片描述

测试一个for循环的运行了多长时间：

     long timeMillis = System.currentTimeMillis();
        //测试循环的耗时
        for (int i = 0; i < 500000; i++) {}
        long timeMillis2 = System.currentTimeMillis();
        System.out.println("耗时"+(timeMillis2-timeMillis)+"毫秒");

执行结果：
耗时3毫秒

运行垃圾回收器，回收垃圾

System.gc();

String property = System.getProperty("java.version"); //获取java版本
String property1 = System.getProperty("java.class.path");//获取环境变量

BigDecimal类

BigDecimal的概述
由于在运算的时候，float类型和double很容易丢失精度，为了能精确的表示、计算浮点数，Java提供了BigDecimal
不可变的、任意精度的有符号十进制数。

构造方法
public BigDecimal(String val)

成员方法

public BigDecimal add(BigDecimal augend)//加
public BigDecimal subtract(BigDecimal subtrahend)//减
public BigDecimal multiply(BigDecimal multiplicand)//乘
public BigDecimal divide(BigDecimal divisor)//除法
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//scale 小数点后面保留几位
	// roundingMode 取舍模式 比如四舍五入

BigDecimal bigDecimal1 = new BigDecimal(3.33333333);
BigDecimal bigDecimal2 = new BigDecimal(3);
BigDecimal bigDecimal3=bigDecimal1.multiply(bigDecimal2);//9.999999989999999616685499859158881008625030517578125
//字符串打印结果
System.out.println(bigDecimal3.toString());
BigDecimal c = new BigDecimal("10");
BigDecimal d = new BigDecimal("3");
//10除3  小数点后50位，向下取整
BigDecimal divide=c.divide(d,50,BigDecimal.ROUND_FLOOR);
System.out.println(divide);//3.33333333333333333333333333333333333333333333333333

//无限接近两数相等
System.out.println(1==0.99999999999999999);//true  小数点后17位为true

Date 类

Date类的概述
类 Date 表示特定的瞬间，精确到毫秒。

构造方法
public Date()
public Date(long date) //把一个long类型的毫秒值转换成一个日期对象

成员方法

public long getTime():	获取一个日期对象对象毫秒值
public void setTime(long time):	给一个日期对象设置上指定的毫秒值 
例：date.setTime(1000 * 60 * 60) ;

 // 类 Date 表示特定的瞬间，精确到毫秒。
        Date date1 = new Date();
        //获取当前时间
        System.out.println(date1);//Sun Aug 02 11:29:17 CST 2020

        //获取从 1970 年 1 月 1 日 00:00:00 到现在 所间隔的毫秒值:两种方法 使用long接收
        long time =date1.getTime();
        long l = System.currentTimeMillis();

        //分配 Date 对象并初始化此对象，以表示自从 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
        //给 1970 年 1 月 1 日 00:00:00 计算机元年加上相应的时间量。
        Date datee=new Date(1000*60*60);
        System.out.println(datee);//Thu Jan 01 09:00:00 CST 1970

        //settime 设置时间
        Date dateone=new Date();
        dateone.setTime(1000*60*60);
        System.out.println(dateone);//Thu Jan 01 09:00:00 CST 1970

Long类型数据和Date类型数据的转换：

Date ---- long 的转换
调用getTime方法
long — Date 的转换
可以使用构造方法
setTime(long time)

// 毫秒值转date对象   long----->Date
        //方式一： 1000*60的毫秒值转为date对象
        Date datetwo = new Date(1000*60);
        System.out.println(datetwo);//Thu Jan 01 09:00:00 CST 1970
        //方式二： 使用settime来将毫秒值转换为date对象
        datetwo.setTime(1000*60);//settime返回为空
        System.out.println(datetwo);//Thu Jan 01 09:00:00 CST 1970

//日期date对象转毫秒值 Date----->long
        long timetwo=datetwo.getTime();

SimpleDateFormat类

SimpleDateFormat 类是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

构造方法:
public SimpleDateFormat()：使用默认的模式来创建一个SimpleDateFormat对象
public SimpleDateFormat(String pattern)：使用指定的模式（规则比如yyyy:MM:dd HH:mm:ss）来创建一个SimpleDateFormat对象
规则的定义:
y 年
M 月
d 天
H 时
m 分
s 秒
成员方法:
public String format(Date date): 把一个日期对象格式化成一个字符串
public Date parse(String dateStr):把一个日期字符串解析成一个日期对象注意要以指定格式解析

 //把日期对象转换为日期字符串:Date---->String 使用方法为 format(date);
        // SimpleDateFormat:格式化日期的一个类，自定义日期格式，进行格式化
        SimpleDateFormat dateFormat=new SimpleDateFormat("YYYY-MM-dd HH-mm-ss");
        //format(date); 把日期对象date格式化成一个字符串
        String dateformat=dateFormat.format(datetwo);
        System.out.println(dateformat);//1970-01-01 08-01-00

        //日期字符串转日期对象:String---->Date 使用方法为parse(str);
        // 注意：日期字符串和指定的格式要对应才可以转换成功
        String str="2020-01-01 16:30:30";
        SimpleDateFormat dateFormatone = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //把日期字符串，解析成日期对象。
        Date datethree=dateFormatone.parse(str);
        System.out.println(datethree);//Wed Jan 01 16:30:30 CST 2020

小练习：

需求：算一下你来到这个世界多少天 ?
分析 :

a: 键盘录入一个生日(日期字符串)
b: 把这个日期字符串对象解析成一个日期对象
c: 获取b中的日期对象对应的毫秒值
d: 获取当前系统时间对应的毫秒值
e: 使用d中的毫秒值 - c中的毫秒值
f: 把e中的差值换算成对应的天差值/1000/60/60/24
g: 输出

//方法一：           
       Scanner scanner = new Scanner(System.in);
        System.out.println("input date: ");
        String datestr=scanner.nextLine();
        SimpleDateFormat format=new SimpleDateFormat("yyyy-mm-dd HH-mm-ss");
        Date date2=format.parse(datestr);//把日期字符串转换为日期对象
        long time2=date2.getTime();//获取日期对象的毫秒值
        long time3=System.currentTimeMillis();//获取当前系统的毫秒值
        long time4=time3-time2;
        System.out.println(time4/1000/60/60/24);//计算活了多少天


//方法二：JDK1.8 提供的关于日期的类：LocalDate
        LocalDate birthday = LocalDate.of(1997, 10, 30);
        LocalDate now=LocalDate.now();
        Period period=Period.between(birthday, now);
        int years = period.getYears();
        int months = period.getMonths();
        int days = period.getDays();
        //表示从出生到现在已经活了22年9个月3天
        System.out.println(years);//22
        System.out.println(months);//9
        System.out.println(days);//3

Calendar类

许多Date类中的过时方法都在该类里面有对应的相同功能的方法；
Calendar 类是一个抽象类，不能直接new对象，可以通过它的一个静态成员方法 getInstance() 来获取它的对象；
它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法；

成员方法：

public static Calendar getInstance() ——使用默认时区和语言环境获得一个日历对象
public int get(int field) ——获得给定日历字段对应的值 field通过Calendar提供的字段来拿
public abstract void add(int field, int amount) ——根据日历的规则，为给定的日历字段添加或减去指定的时间量
public final void set(int year, int month, int date)——将给定的日历字段设置为给定值

 //表示时间的Calendar类
        Calendar rightnow=Calendar.getInstance();
        //获取今天的时间
        int Year=rightnow.get(Calendar.YEAR);
        int hour = rightnow.get(Calendar.HOUR);
        int minute = rightnow.get(Calendar.MINUTE);
        int s = rightnow.get(Calendar.SECOND);
        int month=rightnow.get(Calendar.MONTH);
        //因为月份是从0开始表示的，因为现在的月份输出为7
        System.out.println(month);//7

        //Calendar设置对应的日期。
        Calendar instance = Calendar.getInstance();
        instance.set(Calendar.YEAR,2018);
        instance.set(Calendar.MONTH,10);
        instance.set(Calendar.DAY_OF_MONTH,10);
        System.out.println(instance.get(Calendar.YEAR));//2018
        //给对应的日期。添加或减去相应的时间量 你传入负数，就是减去。
        Calendar instance1 = Calendar.getInstance();
        //金年的基础上减去两年
        instance1.add(Calendar.YEAR,-2);
        System.out.println(instance1.get(Calendar.YEAR));//2018

需求：键盘录入任意一个年份，获取任意一年的二月有多少天
分析:
把这个日期设置为这一年的3月1号
然后再减去1天。再获取这一天所在月的天数

//方法一：
        Calendar instance2 = Calendar.getInstance();
        //设置为今年的3月1日，月份从0开始，因此为2
        instance2.set(Calendar.YEAR,2,1);
        instance2.add(Calendar.DAY_OF_MONTH,-1);
        System.out.println(instance2.get(Calendar.DAY_OF_MONTH));//28

//方法二：
        LocalDate of = LocalDate.of(2020,01,01);
        //判断是否是闰年
        System.out.println(of.isLeapYear());//true

BigInteger类

该类可以让超过Integer范围内的数据进行运算；

构造方法
public BigInteger(String val)

成员方法

public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)

 	    BigInteger a = new BigInteger(Long.MAX_VALUE + "");
        BigInteger b = new BigInteger(Long.MAX_VALUE + "");
        BigInteger add=a.add(b);
        System.out.println(add);//18446744073709551614