Day14JavaSE——常见类

Day14JavaSE——常见类

正则表达式
Pattern和Matcher类
Math类
Random类
System类
BigDecimal类
Date类
SimpleDateFormat类
Calendar类

正则表达式

正则表达式的概述和简单使用

正则表达式:正确规则的表达式 规则java给我们定的
	是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

案例演示1

/**********************
         * B:案例演示
         * 需求：校验qq号码.
         * 1:要求必须是5-15位数字
         * 2:0不能开头
         * *********************/

非正则表达式实现

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的qq号");
        String qqNum = sc.nextLine();
        boolean b = checkQQNum(qqNum);
        if(b){
            System.out.println("QQ号规则正确");
        }else{
            System.out.println("QQ号规则错误");
        }

    }

    private static boolean checkQQNum(String qqNum) {
        //1、校验长度
        //2、0不能开头
        boolean b = false;
        if (qqNum.length() >= 5 && qqNum.length() <= 15 && !qqNum.startsWith("0")) {
            for (int i = 1; i < qqNum.length(); i++) {
                char ch = qqNum.charAt(i);
                if (ch >= '0' && ch <= '9') {
                    b=true;
                }else{
                    b=false;
                    break;
                }
            }
        }
        return b;
    }
}

正则表达式实现

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        System.out.println("===============正则表达式===============");
        //采用正则表达式方法来校验
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入qq号码，纯数字，不能以0开头，5-15位");
        String s = scanner.nextLine();
        boolean b = checkQQNum(s);
        if(b){
            System.out.println("输入正确");
        }else{
            System.out.println("输入错误");
        }
    }
    private static boolean checkQQNum(String qqNum) {
        //定义正则表达式[1-9][0-9]{4,14}正则表达式
        //java中正则表达式定义在字符串中
        String regx = "[1-9][0-9]{4,14}";
        //判断这个字符串，符不符合，我们定义的正则表达式
        //调用String类的matches()方法
        //boolean matches(String regex)
        // 告知此字符串是否匹配给定的正则表达式
        boolean b = qqNum.matches(regx);
        return b;
    }
}

正则表达式的组成规则

规则字符在java.util.regex Pattern类中
A:字符
	x 字符 x。举例：'a'表示字符a
	\\ 反斜线字符。
	\n 新行（换行）符 ('\u000A') 
	\r 回车符 ('\u000D')
B:字符类
	[abc] a、b 或 c（简单类） 
	[^abc] 任何字符，除了 a、b 或 c（否定） 
	[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
	[0-9] 0到9的字符都包括
C:预定义字符类
	. 任何字符。我的就是.字符本身，怎么表示呢? \.
	\\d 数字：[0-9]
	\\w 单词字符：[a-zA-Z_0-9]
		匹配非半角字符
	\\s 匹配空格字符、、	
D:边界匹配器
	^ 行的开头 
	$ 行的结尾 
	\\b 单词边界
		就是不是单词字符的地方。
		举例：hello world?haha;xixi
E:Greedy 数量词 
	X? X，一次或一次也没有 比如""空串 就是没有
	X* X，零次或多次  大于等于1次 都算多次
	X+ X，一次或多次
	X{n} X，恰好 n 次 
	X{n,} X，至少 n 次 
	X{n,m} X，至少 n 次，但是不超过 m 次 

public class Test {
    public static void main(String[] args) {

        //正则表达式
        System.out.println("===============匹配单个字符===============");
        String regx1 = "a";
        boolean b1 = "aaaa".matches(regx1);
        System.out.println(b1);

        System.out.println("===========匹配表中的任意一个字符===========");
        //匹配类表中的任意一个字符
        String regx2 = "[a,b,c,d]";
        boolean b2 = "c".matches(regx2);
        System.out.println(b2);

        System.out.println("==============匹配26个小写字母==============");
        String regx3 = "[a-z]";
        boolean b3 = "d".matches(regx3);
        System.out.println(b3);

        System.out.println("==============同时匹配多组数据==============");
        //同时匹配多组数据
        String regx4 = "[a-zA-Z0-9]";
        boolean b4 = "d".matches(regx4);
        System.out.println(b4);

        System.out.println("==========匹配除^后面符号以外的字符===========");
        //'^'此符号是不是列表中的符号的意思
        String regx5 = "[^a-z]";//不是小写字母就行
        boolean b5 = "d".matches(regx5);
        System.out.println(b5);

        System.out.println("===============匹配任意字符================");
        //"."特殊字符，匹配单个任意字符
        //".."匹配两个任意字符
        String regx6 = ".";
        boolean b6 = "d".matches(regx6);
        System.out.println(b6);

        System.out.println("================匹配.本身=================");
        //只想匹配"."本身
        String regx7 = "\\.";
        boolean b7 = "d".matches(regx7);
        System.out.println(b7);

        System.out.println("==========匹配“|”本身，用转义字符===========");
        //“|”代表或者，要想代表“|”本身，用转义字符
        String regx8 = "\\|";
        boolean b8 = "d".matches(regx8);
        System.out.println(b8);

        System.out.println("==========匹配大小写字母、数字字符===========");
        //跟[a-zA-Z_0-9]一样
        String regx9 = "\\w";
        boolean b9 = "a".matches(regx9);
        System.out.println(b9);

        System.out.println("=============匹配非半角字符字符=============");
        //匹配非单词字符---->匹配非半角字符
        String regx10 = "\\W";
        boolean b10 = "，".matches(regx10);
        System.out.println(b10);

        System.out.println("================匹配数字字符================");
        //"\\d"跟[0-9]意思一样，匹配数字字符
        String regx11 = "\\d";
        boolean b11 = "d".matches(regx11);
        System.out.println(b11);

        System.out.println("================匹配非数字字符===============");
        //"^\\D"--->"^[0-9]"匹配非数字符号
        String regx12 = "\\D";
        boolean b12 = "d".matches(regx12);
        System.out.println(b12);

        System.out.println("=================匹配空格字符================");
        //"\\s"
        String regx13 = "\\s";
        boolean b13 = " ".matches(regx13);
        System.out.println(b13);

       /* //\n 新行（换行）符 ('\u000A')
        //	\r 回车符 ('\u000D')*/
        System.out.println("=================匹配单词边界================");
        //\\b 单词边界就是不是单词字符的地方
        String regx14 = "\\b";
        boolean b14 = "n".matches(regx14);
        System.out.println(b14);

        System.out.println("--------------匹配多个同一字符----------------");
        //X?        X，一次或一次也没有 比如""空串 就是没有
        //X*        X，零次或多次  大于等于1次 都算多次
        //X+        X，一次或多次
        //X{n}      X，恰好 n 次
        //X{n,}     X，至少 n 次
        //X{n,m}    X，至少 n 次，但是不超过 m 次
    }
}

正则表达式的判断功能

正则表达式的判断功能
	String类的功能：public boolean matches(String regex)

        //校验手机号的规则
        // 都是 1 开头  手机号是11位
        // 手机号的第二位 3 4 5 6 7 8 9

非正则表达式实现

import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入11位电话号码");
        String s = scanner.nextLine();
        boolean b = checkPhoneNum(s);
        if(b){
            System.out.println("输入正确");
        }else{
            System.out.println("输入错误");
        }
    }

    private static boolean checkPhoneNum(String pNum) {
        boolean flag = false;
        if (pNum.length() == 11 && pNum.startsWith("17") || pNum.startsWith("18") || pNum.startsWith("19")) {
            //判断每一位是数字
            for (int i = 0; i < pNum.length(); i++) {
                char ch=pNum.charAt(i);
                if(Character.isDigit(ch)){
                    flag=true;
                }else{
                    flag=false;
                    break;
                }
            }
        }
        return flag;
    }
}

正则表达式实现

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入11位电话号码");
        String s = scanner.nextLine();
        boolean b = checkPhoneNum(s);
        if (b) {
            System.out.println("输入正确");
        } else {
            System.out.println("输入错误");
        }
    }

    private static boolean checkPhoneNum(String s) {
        String regx = "[1][3,5,7,8,9][0-9]{9}";
        boolean b = s.matches(regx);
        return b;
    }
}

正则表达式的分割功能

正则表达式的分割功能  split()方法
	String类的功能：public String[] split(String regex)

import java.util.Arrays;

public class Test2 {
    public static void main(String[] args) {
        /*正则表达式的分割字符串功能，获取到的内容放在数组中  split()方法
        String类的功能：public String[] split(String regex)*/
        //案例演示：年龄范围"18-24"
        String name="小刘=小郑=小英";
        String s = name.substring(0,name.lastIndexOf("="));
        System.out.println(s);
        String s1 = name.substring(name.indexOf("=") + 1, name.lastIndexOf("="));
        String s2 = name.substring(name.lastIndexOf("="));
        System.out.println(s2);
        System.out.println("============用正则表达式分割===========");
        String[] split = name.split("=");
        System.out.println(Arrays.toString(split));

        String name2 = "张三=555asdfaasdfa李四=asdfasdfAFDFd66366王五=赵六";
        String[] s3 = name2.split("[=0-9a-zA-Z]+");
        System.out.println(Arrays.toString(s3));
    }
}

正则表达式的替换功能

正则表达式的替换功能
         String类的功能：public String replaceAll(String regex,String replacement)

public class Test3 {
    public static void main(String[] args) {
        String str="特朗普和奥巴马是美国总统";
        String s = str.replace("特朗普", "***").replace("奥巴马","***");
        System.out.println(s);
        System.out.println("===================================");
        //根据正则表达式替换
        String str1="特朗普和奥巴马是美国总统";
        String s1 = str1.replaceAll("特朗普|奥巴马", "+");
        System.out.println(s1);
        String name2 = "张三=555asdfaasasdfadfa李四=asdfasdfAFWWWsefDFd66366王五=赵六";
        String s2 = name2.replaceAll("[=0-9a-zA-Z]+", " ");
        System.out.println(s2);
    }
}

把给定字符串中的数字排序

需求：我有如下一个字符串:”91 27 46 38 50”
        请写代码实现最终输出结果是：”27 38 46 50 91”

import java.util.Arrays;

public class HomeWork {
    public static void main(String[] args) {
        //笔记上14.06题做了
        /*需求：我有如下一个字符串:”91 27 46 38 50”
        请写代码实现最终输出结果是：”27 38 46 50 91”*/
        String str="91 27 46 38 50";
        //先把字符串分割成字符串数组
        String[] s = str.split(" ");
        System.out.println(Arrays.toString(s));
        //用Integer将字符串搞成int数组，并排序
        int[] intArr = new int[s.length];
        for (int i = 0; i < s.length; i++) {
            intArr[i]=Integer.parseInt(s[i]);
        }
        Arrays.sort(intArr);
        System.out.println(Arrays.toString(intArr));
        StringBuilder sb = new StringBuilder();
        //排序完了将int数组变成字符串拼接字符串
        for (int i = 0; i < intArr.length; i++) {
            sb.append(intArr[i]).append(" ");
        }
        System.out.println(sb.toString());
        //去除末尾的空格
        //String类中的trim()方法
        //trim()    返回字符串的副本，忽略前导空白和尾部空白
        String str1 = sb.toString().trim();
        System.out.println(str1);
    }
}

Pattern和Matcher类

Pattern和Matcher的概述

模式和匹配器的典型调用顺序
	通过JDK提供的API，查看Pattern类的说明

	典型的调用顺序是 
	Pattern p = Pattern.compile("a*b");
	Matcher m = p.matcher("aaaaab");
	boolean b = m.matches();

public class Test1 {
    public static void main(String[] args) {
        //Pattern和Matcher的概述
        /********************************************************************
         * Pattern模式器，封装一个正则表达式
         * 指定为字符串的正则表达式必须首先被编译为此类的实例。
         * 然后，可将得到的模式用于创建 Matcher 对象
         * 依照正则表达式，该对象可以与任意字符序列匹配。
         * Matcher匹配器，将封装好正则表达式与待匹配字符进行匹配
         * 通过模式器封装一个正则表达式
         * 通过模式器，获取一个匹配器Matcher，并把待匹配的字符串传入
         * 调用匹配器中的匹配方法，进行匹配 
         * ******************************************************************/
        Pattern p = Pattern.compile("a*b");
        Matcher m = p.matcher("aaaaab");
        boolean b = m.matches();
        //如果仅仅只是想看字符串是否和正则表达式匹配，只需要调用String类中的matches方法
        boolean s="aaaaab".matches("a*b");
        System.out.println(s);
        //但是有时还有另外的需求，那么String类中的方法就不足以完成我们的需求
        //而Java提供的Pattern和Matcher类，针对正则提供了更加丰富的需求
    }
}

正则表达式的获取功能

public class Test2 {
    public static void main(String[] args) {
        /**
        需求：获取下面这个字符串中由三个字符组成的单词 正则表达式 \\b[a-z]{3}\\b
        da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?*/
        System.out.println("==============传统方式做==============");
        String str="da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
        String s = str.replaceAll("\\,|\\?+", " ");
        System.out.println(s);
        String[] s1 = s.split("\\s+");
        System.out.println(Arrays.toString(s1));
        for (int i = 0; i < s1.length; i++) {
            if(s1[i].length()==3){
                System.out.print(s1[i]+" ");
            }
        }
        System.out.println();
        System.out.println("========采用Pattern&Matcher方式做======");
        //定义一个正则表达式
        //\\b为检测单词边界
        String regx="\\b[a-z]{3}\\b";
        //1、把正则表达式封装到模式器中
        Pattern p = Pattern.compile(regx);
        //2、通过模式器，获取匹配器，传入我们要操作的
        Matcher m = p.matcher(str);
        /* boolean find()
          尝试查找与该模式匹配的输入序列的下一个子序列。 */
        /* String group()
          返回由以前匹配操作所匹配的输入子序列。 */
        //先调用find()来找有没有符合正则的，如果有再调用group ()把他截取出来
        while(m.find()){
            String s2 = m.group();
            System.out.print(s2+" ");
        }
    }
}

爬虫案例

public class Test3 {
    public static void main(String[] args) {
        //爬虫就是用正则表达式写的
        String str="<li><a target=\"_blank\" href=\"http://m.weibo.com/web/cellphone.php#iphone\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪微博</a></li>\n" +
                "\n" +
                "<li><a target=\"_blank\" href=\"http://news.sina.com.cn/m/sinanews.html\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪新闻</a></li>\n" +
                "<li><a target=\"_blank\" href=\"http://finance.sina.com.cn/mobile/comfinanceweb.shtml\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪财经</a></li>\n" +
                "<li><a target=\"_blank\" href=\"http://m.sina.com.cn/m/sinasports.shtml\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪体育</a></li>\n" +
                "\n" +
                "<li><a target=\"_blank\" href=\"http://edu.sina.com.cn/app/download.shtml\" suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪升学帮</a></li>\n" +
                "<li><a target=\"_blank\" href=\"http://licaishi.sina.com.cn/html5/act/ganggu/index.html\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪港股通</a></li>\n" +
                "\t\t\t\t\t\t\t\t\t\t\t\n" +
                "<li><a target=\"_blank\" href=\"http://blog.sina.com.cn/lm/z/app/\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪博客</a></li>\n" +
                "\n" +
                "<li><a target=\"_blank\" href=\"http://tianqitong.sina.cn/\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">天气通</a></li>\n" +
                "\n" +
                "<li><a target=\"_blank\" href=\"http://games.sina.com.cn/o/kb/12392.shtml\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪游戏</a></li>\n" +
                "<li><a target=\"_blank\" href=\"http://zhongce.sina.com.cn/about/app\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\">新浪众测</a></li>\n" +
                "<li><a target=\"_blank\" href=\"http://mail.sina.com.cn/client/mobile/index.php?suda-key=mail_app&suda-value=login\"  suda-uatrack=\"key=index_new_menu&value=sina_apps_list_click\" style=\"padding-right:12px\">新浪邮箱客户端</a></li>\n";
        //1、写出他的正则表达式
        String regx = "((ht|f)tps?:)\\/\\/[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]";
        //2、将正则表达式封装
        Pattern p = Pattern.compile(regx);
        //3、通过模式器获取匹配器，传入我们要操作的数据
        Matcher m = p.matcher(str);
        while(m.find()){
            String group = m.group();
            System.out.println(group);
        }
    }
}

Math类

public class Test1 {
    public static void main(String[] args) {
        //Math类
         /*  A:
        Math类概述
        Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。*/

        double pi = Math.PI;
        System.out.println(pi);
        System.out.println(Math.E);
        System.out.println(Math.abs(-1));
        System.out.println(Math.max(20, 100));
        System.out.println(Math.max(Math.max(20, 100), 3000));
        System.out.println(Math.min(30, 12));
        System.out.println((int)Math.ceil(3.1));
        System.out.println(Math.floor(2.9));
        System.out.println(Math.round(3.4666));
        System.out.println(Math.pow(2, 3));
        //5的平方根
        System.out.println(Math.sqrt(5));
        //8的立方根
        System.out.println(Math.pow(8,1/3.0));

    }
}

Random类

public class Test {
    public static void main(String[] args) {
        //生成随机数据
        //创建一个新的随机数生成器
        Random r = new Random();
        for (int i1 = 0; i1 < 10; i1++) {
            int i = r.nextInt();//生成随机整数的范围是int范围
            System.out.println(i);
        }
        //Math.random()
        for (int i1 = 0; i1 < 10; i1++) {
            int i = r.nextInt(10);//生成随机整数的范围是int范围
            System.out.println(i);
        }
        //生成1--100之间的随机数
        for (int i1 = 0; i1 < 10; i1++) {
            int a=(int)Math.random()*100+1;
            System.out.println(a);
        }

        //生成1--100之间的随机数
        for (int i1 = 0; i1 < 10; i1++) {
            int i = r.nextInt(100+1);//生成随机整数的范围是int范围
            System.out.println(i);
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        /* Random()
          创建一个新的随机数生成器。
          Random(long seed)
          使用单个 long 种子创建一个新的随机数生成器。
          */
        Random random = new Random();
        for (int i = 0; i < 5; i++) {
            int num=random.nextInt(10);
            System.out.println(num);
        }

        System.out.println("==============================");
        //根据传入的参数种子，计算随机数，种子一定，产生的值一样
        Random random1 = new Random(1L);
        for (int i = 0; i < 5; i++) {
            int i1 = random1.nextInt(10);
            System.out.println(i1);
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        /*void nextBytes(byte[] bytes)
        * 生成随机字节并将其置于用户提供的byte数组中*/
        byte[] bytes = new byte[10];
        Random random = new Random();
        //给一个字节数组里面随机填充一些数据
        random.nextBytes(bytes);
        System.out.println(Arrays.toString(bytes));
    }
}

System类

public class Test1 {
    public static void main(String[] args) {
        //System类包含一些有用的类字段和方法，他不能被实例化，所有的方法都是静态的，所以使用类名可直接调用
        /*************************************************
         * 流：读写数据用的
         * static PrintStream    err    “标准”错误输出流。
         * static InputStream   in    “标准”输入流。
         * static PrintStream   out    “标准”输出流。
        * ************************************************/
        //in
        //public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。
        // 通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
        /*public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入
        InputStream in = System.in;*/
        InputStream in = System.in;
        Scanner scanner = new Scanner(in);
        //链式编程
        System.out.println("========================================");
        PrintStream out = System.out;
        out.println("abc");



        //out
        //public static final PrintStream out“标准”输出流。此流已打开并准备接受输出数据。
        // 通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。
        PrintStream out1 = System.out;

        //System.out.println();
        //打印出来的内容是红色的
        System.err.println("abcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        //System.out.println(1/0);
    }
}

public class Test2 {
    public static void main(String[] args) {
        //gc() 运行垃圾回收器
        //JVM的垃圾回收不需要我们人为干预，它有自己的垃圾回收算法
        //public static void gc()
        /*调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。
        当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间。*/
        Scanner sc = new Scanner(System.in);
        sc.close();
        byte[] b=new byte[20];
        b=null;//人为置null也是为了让垃圾回收器尽快回收
        //手动调用垃圾回收器回收
        System.gc();
    }
}

public class Test3 {
    public static void main(String[] args) {
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
        //退出JVM
        //0 正常退出
        //非0 强制退出
        System.exit(0);
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
        System.out.println("aaaaaaaaaaa");
    }
}

public class Test4 {
    public static void main(String[] args) {
        //static long currentTimeMillis()       返回以毫秒为单位的当前时间
        //1s=1000ms
        //计算机元年1970.1.1 00:00:00:00----------------2020-05-03 11:14:30
        //计算从计算机元年到计算机当前计算机时间所间隔的毫秒值
        long l = System.currentTimeMillis();
        System.out.println(l);
        System.out.println("==============举例子==============");
        long st = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - st) / 1000 + "s");
    }
}

public class Test5 {
    public static void main(String[] args) {
        //获取电脑上的配置的环境变量的值
        String java_home = System.getenv("JAVA_HOME");
        System.out.println(java_home);

        System.out.println("================================");
       /* Properties properties = System.getProperties();
        System.out.println(properties);*/
        // user.dir = E:\IdeaProjects\20200503 - 常用类 - 上午

        String property = System.getProperty("user.dir");
        System.out.println(property);
    }
}

BigDecimal类

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

public class Test1 {
    public static void main(String[] args) {
        System.out.println("========================================");
        BigDecimal a = new BigDecimal("1.22654654354");
        BigDecimal b = new BigDecimal("2.543516654654365436543564354354365436543654365436543654");

        BigDecimal multiply = a.multiply(b);
        System.out.println(multiply.toString());
        //相加
        BigDecimal add = a.add(b);
        System.out.println(add);

        System.out.println(a.subtract(b));
        System.out.println("========================================");
        BigDecimal c = new BigDecimal("10");
        BigDecimal d = new BigDecimal("2");
        //如果能整除，就直接用方法除
        System.out.println(c.divide(d));
        System.out.println("========================================");
        //如果不能整除，我们得声明小数点后面保留多少位，以及取舍模式
        //  public BigDecimal divide (BigDecimal divisor,int scale, int roundingMode)
        // scale 小数点后面保留几位
        BigDecimal e = new BigDecimal("10");
        BigDecimal f = new BigDecimal("3");
        BigDecimal r = e.divide(f,50,BigDecimal.ROUND_HALF_DOWN);
        System.out.println(r);

        System.out.println(1==0.9);
        System.out.println(1==0.99999999999999999999999999999999999);
    }
}

Date类

public class Test1 {
    public static void main(String[] args) {
        //Date 日期类      类 Date 表示特定的瞬间，精确到毫秒
        //年份 y 由整数 y - 1900 表示。
        //月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。
        //日期（一月中的某天）按通常方式由整数 1 至 31 表示。

        //称为“历元（epoch）”，即1970.1.1  00:00:00
        /*Date()
        * 分配Date对象并初始化此对象，以表示分配它的时间*/
        Date date = new Date();
        //Sun May 03 13:50:08 CST 2020
        //此方法重写了toString 输出时，会输出当前的日期，按照西方的格式输出
        System.out.println(date);

        System.out.println("===============================");
        /*Date(long date)
         * 分配Date对象并初始化此对象，以表示分配它的时间*/
        //给计算机元年增加相应的毫秒值
        Date date1 = new Date(10000 * 60 * 60 * 60);
        System.out.println(date1);

    }
}

public class Test2 {
    public static void main(String[] args) {
        Date date = new Date();
        //获取从1970 年 1 月 1 日 00:00:00 到现在的日期日期，所间隔的毫秒值
        long time = date.getTime();
        System.out.println(time);
        //获取从1970 年 1 月 1 日 00:00:00 到现在的日期日期，所间隔的毫秒值
        long l=System.currentTimeMillis();
        System.out.println(l);

        System.out.println("==========================");
        Date date1 = new Date();
        //给计算机元年增加相应的毫秒值
        //相当于new Date(1000*60*60*24)
        date1.setTime(1000*60*60*24);
        System.out.println(date1);
    }
}

public class Test3 {
    public static void main(String[] args) {
        Date date = new Date();
        //int year = date.getYear();
        //System.out.println(year);
        //过时的方法调用时，方法上会划有一条横线，不推荐使用，因为有更好的替代
        int month = date.getMonth();
        System.out.println(month);
        int day = date.getDay();
        System.out.println(day);
        int hours = date.getHours();
        System.out.println(hours);
        System.out.println(date.getMinutes());
        System.out.println(date.getSeconds());
    }
}

Date与long的转换

public class Test4 {
    public static void main(String[] args) {
        //Date---->long
        Date date = new Date();
        long time = date.getTime();
        //long---->Date
        Date date1 = new Date(1000L);
        //方法2
        Date date2 = new Date();
        date2.setTime(20000L);
    }
}

标注一个类过时

@Deprecated //标注这个类过时了
class MyUtils {
    @Deprecated //使用这个注解可以标注这个方法过时了
    public void add(){}

    public void add2() {

    }

    @Deprecated
    public void add3() {

    }
}

SimpleDateFormat类

可以把一个日期对象格式化成一个文本(字符串) , 也可以把一个日期字符串解析成一个日期对象

public class Test1 {
    public static void main(String[] args) throws ParseException {
        //按照默认模式格式化日期
        // Sun May 03 14:36:36 CST 2020
        //这种看着不习惯
        //我们可以通过一个格式日期的类SimpleDateFormat，把日期变成我们想要的格式
        //使用空参构造，按照默认格式，来格式化
        System.out.println("=================================");
        //按照指定格式来格式化日期
        Date date = new Date();
        SimpleDateFormat sp = new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss");
        String s = sp.format(date);
        System.out.println(s);
        
        System.out.println("=================================");
        // public Date parse(String dateStr):
        // 把一个日期字符串解析成一个日期对象 注意要以指定格式解析
        String dateStr="2020-01-10 14:20:30";
        SimpleDateFormat sp1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //把日期字符串解析成日期对象
        Date parse = sp1.parse(dateStr);
        System.out.println(parse);
    }
}

public class Test2 {
    public static void main(String[] args) {
        //按照我们指定要的格式来格式化日期
        Date date = new Date();
        /* *y 年
         *M 月
         *d 天
         *H 时
         *m 分
         *s 秒*/

        //创建格式化日期类的对象，并指定格式   拼接符自己指定
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒:S毫秒 E z Z");
        //格式化日期
        String dateStr2 = simpleDateFormat1.format(date);
        System.out.println(dateStr2);
    }
}

public class Test3 {
    public static void main(String[] args) throws ParseException {
        //把一个日期字符串，格式化成一个日期对象。String----Date   Date---->String
        //日期字符串
        String dateStr="2020-01-10 14:20:30";
        //注意：格式和日期字符串的格式要对应，负责解析失败
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //把日期字符串解析成日期对象 //ParseException解析异常
        Date date = simpleDateFormat.parse(dateStr);
        System.out.println(date);
    }
}

public class Test4 {
    public static void main(String[] args) throws ParseException {
        String s = DateUtils.formatDate(new Date(), "yyyy-MM-dd");
        System.out.println(s);

        Date date = DateUtils.parseDateStr("2020年10月10日", "yyyy年MM月dd日");
        System.out.println(date);
    }
}

class DateUtils{
    private DateUtils() {
    }

    //格式化日期
    public static String formatDate(Date date, String formater) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formater);
        String str = simpleDateFormat.format(date);
        return str;
    }

    //解析日期
    public static Date parseDateStr(String dateStr, String formater) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(formater);
        Date date = simpleDateFormat.parse(dateStr);
        return date;
    }
}

案例演示:	需求：算一下你来到这个世界多少天?
分析:
 * 		a: 键盘录入一个生日(日期字符串)
 * 		b: 把这个日期字符串对象解析成一个日期对象
 * 		c: 获取b中的日期对象对应的毫秒值
 * 		d: 获取当前系统时间对应的毫秒值
 * 		e: 使用d中的毫秒值 - c中的毫秒值
 * 		f: 把e中的差值换算成对应的天  差值/1000/60/60/24
 * 		g: 输出

public class HomeWork {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的生日,输入格式为“年-月-日");
        String s = sc.nextLine();
        System.out.println("出生到几天已经" + checkGrown(s) + "天了");
    }

    private static long checkGrown(String s) throws ParseException {
        long b = new SimpleDateFormat("yyyy-MM-dd").parse(s).getTime();
        long now = System.currentTimeMillis();
        System.out.println(b);
        System.out.println(now);
        long p=(long) (now-b)/1000/60/60/24;
        return p;
    }
}

Calendar类

Calendar 类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象
	它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 
	等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
	public static Calendar getInstance()	使用默认时区和语言环境获得一个日历对象
	public int get(int field)		获得给定日历字段对应的值 field通过Calendar提供的字段来拿

Calendar类的概述和获取日期的方法

public class Test1 {
    public static void main(String[] args) {
        /*Calendar 类是一个抽象类，不能直接new对象，
        可以通过他的一个静态成员方法getInstance()来获取他的对象
        用来替代Date类中过时的方法*/
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);

        System.out.println("===========用get方法获取电脑的时间===========");
        /* int get(int field)
          返回给定日历字段的值。 */
        int year = instance.get(Calendar.YEAR);
        //月份是从0开始数的
        int month = instance.get(Calendar.MONTH);
        int day = instance.get(Calendar.DAY_OF_MONTH);

        int hour = instance.get(Calendar.HOUR_OF_DAY);
        int minute = instance.get(Calendar.MINUTE);
        int second = instance.get(Calendar.SECOND);
        System.out.println(year+"-"+(month+1)+"-"+day+" "+hour+":"+minute+":"+second);
        System.out.println("=========用gettime方法获取电脑的时间=========");
        //这是用Calender的gettime方法获取的时间
        //不过获取的时间格式是规定格式
        System.out.println(instance.getTime());

        System.out.println("==========用set方法设置电脑的时间============");
        /*用gettime方法获取电脑的时间*/
        Calendar i2 = Calendar.getInstance();
        i2.set(1996,11,14,02,00,00);
        System.out.println(i2.get(Calendar.YEAR)+"-"+month+"-"+day+" "+hour+":"+minute+":"+second);
    }
}

Calendar类的add()和set()方法

public class Test2 {
    public static void main(String[] args) {
        /*abstract  void add(int field, int amount)
          根据日历的规则，为给定的日历字段添加或减去指定的时间量*/
        //给某个日期字段加上或减去相应的时间量
        Calendar i = Calendar.getInstance();
        //加一年
        i.add(Calendar.YEAR,1);
        //加两个月
        i.add(Calendar.MONTH,2);
        //减一天，传入负数就是减
        i.add(Calendar.DAY_OF_MONTH,-5);
        System.out.println(i.getTime());
    }
}

如何获取任意年份的2月份有多少天

public class Question {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = s.nextInt();
        //创建Calender对象
        Calendar instance = Calendar.getInstance();
        //将输入的年份设置在该年的3月1号
        instance.set(year,2,1);
        //3月1日减一天就能得到2月
        instance.add(Calendar.DAY_OF_MONTH,-1);
        //获取二月的天数
        int day=instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年2月有"+day);
        //补充:判断是不是一个闰年
        if(year%4==0&&year%100!=0||year%400==0){
            System.out.println(year+"是闰年");
        }else{
            System.out.println(year+"是平年");
        }
    }
}

补充: BigInteger概述

可以让超过long范围内的数据进行运算

public class Test1 {
    public static void main(String[] args) {
        //获取Long的最大值
        long maxValue=Long.MAX_VALUE;
        System.out.println(maxValue);
        //我们要算long范围的值

        //使用BigInteger完成
        BigInteger a = new BigInteger(maxValue+" ");
        BigInteger b = new BigInteger("1");
        BigInteger add = a.add(b);
        System.out.println(add);
    }
}
{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = s.nextInt();
        //创建Calender对象
        Calendar instance = Calendar.getInstance();
        //将输入的年份设置在该年的3月1号
        instance.set(year,2,1);
        //3月1日减一天就能得到2月
        instance.add(Calendar.DAY_OF_MONTH,-1);
        //获取二月的天数
        int day=instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年2月有"+day);
        //补充:判断是不是一个闰年
        if(year%4==0&&year%100!=0||year%400==0){
            System.out.println(year+"是闰年");
        }else{
            System.out.println(year+"是平年");
        }
    }
}

补充: BigInteger概述

可以让超过long范围内的数据进行运算

public class Test1 {
    public static void main(String[] args) {
        //获取Long的最大值
        long maxValue=Long.MAX_VALUE;
        System.out.println(maxValue);
        //我们要算long范围的值

        //使用BigInteger完成
        BigInteger a = new BigInteger(maxValue+" ");
        BigInteger b = new BigInteger("1");
        BigInteger add = a.add(b);
        System.out.println(add);
    }
}