08 正则表达式，Math类，Random，System类，BigInteger，BigDecimal，Date，DateFormat，Calendar

正则表达式：
    是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规
则。有自己特殊的应用。

public class Demo2_Regex {

    public static void main(String[] args) {
        /*字符类
        [abc] a、b 或 c（简单类）
        [^abc] 任何字符，除了 a、b 或 c（否定）
        [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
        [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
        [a-z&&[def]] d、e 或 f（交集）
        [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
        [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
        预定义字符类
        . 任何字符（与行结束符可能匹配也可能不匹配）
        d 数字：[0-9]  
        D 非数字： [^0-9]
        s 空白字符：[ 	
x0Bf
]
        S 非空白字符：[^s]
        w 单词字符：[a-zA-Z_0-9]
        W 非单词字符：[^w]
        
        Greedy 数量词
        X? X，一次或一次也没有
        X* X，零次或多次
        X+ X，一次或多次
        X{n} X，恰好 n 次
        X{n,} X，至少 n 次
        X{n,m} X，至少 n 次，但是不超过 m 次


*/
        String regex = "\d";  // 数字
        System.out.println("0".matches(regex));
        
        String string = "1230.000.000";
        String[] arr = string.split("\.");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

import java.util.Arrays;

public class Test1 {

    public static void main(String[] args) {
        // 有如下一个字符串:”91 27 46 38 50”，
//        请写代码实现最终输出结果是：”27 38 46 50 91”
        String string = "91 27 46 38 50";
        String[] arr = string.split(" ");
        
        int[] iArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            iArr[i] = Integer.parseInt(arr[i]);
        }
        // 排序
        Arrays.sort(iArr);
        
        // 拼接成字符串
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < iArr.length; i++) {
            if(i == iArr.length-1) {
                stringBuilder.append(iArr[i]);
            }else {
                stringBuilder.append(iArr[i]+" ");
            }
        }
        System.out.println(stringBuilder);
    }

}

替换全部replaceAll:

    String string = "2012.12.12";
        String regex = "\.";
        
        String string2 = string.replaceAll(regex, "/"); //替换全部
        System.out.println(string2); // 2012/12/12

分组：

public class Demo4_Regex {

    public static void main(String[] args) {
        // 分组
        // 按照叠词切割： "sdqqfgkkkhjppppkl";
        String regex = "(.)\1+";
        String string = "sdqqfgkkkhjppppkl";
        String[] arr = string.split(regex);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]); // sdfghjkl
        }
        //需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..

程
//        将字符串还原成:“我要学编程”
        String string2 = "我我....我...我.要...要要...要学....学学..学.编..编编.编.

程.程.程..程";
        String string3 = string2.replaceAll("\.+", "");
        String string4 = string3.replaceAll("(.)\1+", "$1"); // $1 第一组中的内容
        System.out.println(string4); // 我要学编程
    }

}

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo5_Pattern {

    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("a*b"); //获取正则表达式
        Matcher matcher = pattern.matcher("aaaab");//获取匹配器
        boolean b = matcher.matches(); //是否匹配
        
        System.out.println(b);
        
        System.out.println("aaaab".matches("a*b"));
        
        // 找所有数组
        String string = "qwewqe12312eqwdq42341weee11w12";
        Pattern pattern2 = Pattern.compile("\d+");
        Matcher matcher2 = pattern2.matcher(string);
        
        while(matcher2.find())
            System.out.println(matcher2.group());
    }

}

Math类概述

    * Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
成员方法
    * public static int abs(int a)  绝对值
    * public static double ceil(double a) 向上取整 10.2 -> 11.0
    * public static double floor(double a) 向下取整
    * public static int max(int a,int b) min自学
    * public static double pow(double a,double b) a的b次方
    * public static double random() [0.0 ~1.0)的小数
    * public static int round(float a) 四舍五入
    * public static double sqrt(double a) 根号a

Random：

import java.util.Random;

public class Demo1_Random {

    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextInt());
        
        Random random2 = new Random(1000);  // 随机种子
        System.out.println(random2.nextInt()); //每次运行的结果相同
        
        System.out.println(random.nextInt(100)); // [0~100)
    }

}

System类：

概述
    * System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法
    * public static void gc()   运行垃圾回收器
        public class Demo2_System {
        
            public static void main(String[] args) {
                new Demo();
                System.gc(); // 会调用finalize
            }
        
        }
        class Demo{
        
            @Override
            protected void finalize() {
                System.out.println("垃圾清扫了");
                
            }
            
        }

   
    * public static void exit(int status) 退出jvm  非0状态是异常退出
    * public static long currentTimeMillis() 当前时间的毫秒值
    * pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos,
int length) 将数组内容拷贝


BigInteger：
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) 取商 余数


BigDecimal：
能精确的表示、计算浮点数

import java.math.BigDecimal;

public class Demo3_BigDecimal {

    public static void main(String[] args) {
        System.err.println(2.0-1.1); // 0.8999999999999999
        
        BigDecimal bigDecimal = new BigDecimal(2.0);
        BigDecimal bigDecimal1 = new BigDecimal(1.1);
        System.out.println(bigDecimal.subtract(bigDecimal1)); //

0.899999999999999911182158029987476766109466552734375
        
        BigDecimal bigDecima2 = new BigDecimal("2.0");
        BigDecimal bigDecimal3 = new BigDecimal("1.1");
        System.out.println(bigDecima2.subtract(bigDecimal3));//0.9
        
        BigDecimal b1 = BigDecimal.valueOf(2.0);
        BigDecimal b2 = BigDecimal.valueOf(1.1);
        System.out.println(b1.subtract(b2)); // 0.9
    }

}

Date：

import java.util.Date;

public class Demo4_Data {

    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);//Thu Oct 25 17:30:18 CST 2018
        
        Date date2 = new Date(0);
        System.out.println(date2);//Thu Jan 01 08:00:00 CST 1970
        
        System.out.println(date.getTime());//1540459922769
        System.out.println(System.currentTimeMillis());//1540459922794
        
        date.setTime(1000);
        System.out.println(date);//Thu Jan 01 08:00:01 CST 1970
    }

}

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽
象类，所以使用其子类SimpleDateFormat

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo5_SimpleDateFormat {

    public static void main(String[] args) {
        Date date = new Date(0);
        SimpleDateFormat sdf = new SimpleDateFormat();
        System.out.println(sdf.format(date));//70-1-1 上午8:00
        
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");//创建

日期格式化类对象
        System.out.println(sdf1.format(date));//1970/01/01 08:00:00 // 将日期对象转

换为字符串
        
        String string = "2000年12月12日01:01:00";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年HH月dd日

hh:mm:ss");
        try {
            Date date2 = simpleDateFormat.parse(string); //将时间字符串转换成日

期对象
            System.out.println(date2); //Wed Jan 12 12:01:00 CST 2000
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
    }

}

import java.util.Calendar;

public class Demo6_Calendar {

    public static void main(String[] args) {
        //  Calendar 类是一个抽象类，
//        它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换

提供了一些方法，
//        并为操作日历字段（例如获得下星期的日期）提供了一些方法。
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH)); //从0开始
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//从星期日开始
        
        Calendar calendar2 = Calendar.getInstance();
        System.out.println(calendar2.get(Calendar.YEAR));//2018
        calendar2.add(Calendar.YEAR, 1);
        System.out.println(calendar2.get(Calendar.YEAR));//2019
        calendar2.add(Calendar.YEAR, -1);
        System.out.println(calendar2.get(Calendar.YEAR));//2018
        
        calendar2.set(Calendar.YEAR, 2000); //设置指定字段
        System.out.println(calendar2.get(Calendar.YEAR));//2000
    }

}

判断闰年：

import java.util.Calendar;
import java.util.Scanner;

public class Test1 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份:");
        String string = scanner.nextLine();
        int year = Integer.parseInt(string);
        
        boolean b = getYear(year);
        System.out.println(b);
    }

    private static boolean getYear(int year) {
        // 判断是否是闰年
        Calendar calendar = Calendar.getInstance();
        calendar.set(year, 2, 1); //设置为这年的3.1
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        return calendar.get(Calendar.DAY_OF_MONTH)==29;
    }

}