pattern类和matcher类，math类，Random类，Date类，SimpleDateFormat类，calender类

课堂笔记2020.05.03 day14

pattern类和matcher类

1. 模式器：正则表达式的编译（也就是将正则表达是封装起来）。

   Pattern p = Pattern.compile(“a*b”);

   • 对正则表达式编译为此类的实例，就是模式器

   Matcher m = p.matcher(“aaaaab”);

   • 通过调用模式的matcher方法，从模式创建匹配器。（也称为利用模式器创建一个matcher类的对象）

   boolean b = m.matches();

   • 对象调方法判断是否匹配

2. Matcher是匹配器。

3. 特点：封装以后不仅可以判断是否有这个规则的表达式，还可以调用其他方法

4. matches():尝试将整个序列与此模式匹配。

5. find()方法：扫描输入的序列，寻找与模式匹配的下一个子序列。

6. group()方法：返回由find寻找到的子序列。

   public class Test8 {
       public static void main(String[] args) {
   
           String s="jk 345 sfsakafhafjin 789 6jka987 lsj";
           Pattern p = Pattern.compile("\\b[0-9]{3}\\b");
           Matcher m = p.matcher(s);
   //        匹配整个序列是否满足模式
           boolean b = m.matches();
           System.out.println(b);
   //        寻找并输出符合规则的子序列
           while (m.find()){
               String group = m.group();
               System.out.println(group);
           }
       }
   }
   

math类

1. 包含基本的数学方法，所有的方法都是静态的，直接类名调方法就可以。

   常用方法：

   • abs(int a);取绝对值
   • ceil（double a）:向上取正
   • floor（double a）:向下取正
   • max(int a,int b):获取两个数的最大值
   • min(int a,int b)：获取两个数的最小值
   • random（）：随机生成double类型的数从【0，1）

   字段

   • PI:圆周率
   • E:自然底数

Random类

1. 此类产生随机数：

   • 方法
     • nextInt（）:没有参数，表示的是int范围的随机数。
     • nextInt(int a):给定范围的随机数。
     • nextByte(byte[ ] arr ):随机生成字节并将其置于用户提供的空数组中。

2. 构造方法

   • Random():空参构造
   • Random(long seed):给定种子，每次生成的随机数是固定的。

import java.util.Arrays;
import java.util.Random;

public class Test9 {
    public static void main(String[] args) {
        Random r = new Random();
        //没有给定种子，每次随机数都在变
        for (int i = 0; i < 10; i++) {
//            生成0到指定范围的数.
            int j = r.nextInt(10);
            System.out.println(j);
        }
        for (int j = 0; j < 10; j++) {
//            每次随机生成0-1之间的数
            double v = r.nextDouble()*100+1;
//            随机生成0-100的整数
            int s = (int) (r.nextDouble()*100+1);
            System.out.println(v);
            System.out.println(s);
            System.out.println("============");
//            给定种子，每次生成的随机数是固定的
            Random r1 = new Random(7);
            for (int i = 0; i < 10; i++) {
                int i1 = r1.nextInt(100);
                System.out.println(i1);
            }
            byte []arr=new byte[10] ;
            for (int i = 0; i < 10; i++) {
//                随机生成byte类型的字节，并将字节存入到空数组中。
                r1.nextBytes(arr);
            }
            System.out.println(Arrays.toString(arr));
        }
    }
}

System类

1. System包含一些有用的类字段和方法

2. 字段：

   • in：标准的输入流
   • out:标准的输出流
   • err:标准错误输出流（将输出的字变成红色，以便提醒用户）

3. 方法；

   • gc():调用垃圾回收器，催促垃圾尽早回收。垃圾回收器会根据算法尽快回收（人为的将引用置空【null】，也可以让垃圾回收器尽早回收垃圾）
   • exit（int status）:推出Java虚拟机。0为正常退出，1为强制退出。

BigDecimal类

1. 在一些精度较高的运算时，double和float类型会丢失精度。为了准确表示Java提供了BigDecimal类
2. 构造方法：
   • BigDecimal（double a）:将double类型转换成精确的BigDecimal类型
3. 方法：
   • add(BigDecimal a):
   • multiply(BigDecimal a):
   • subtract(BigDecimal a):
   • divide(BigDecimal a,int scale,int roundingmode):scale:小数点保留几位，roundingmode:取舍模式。
     • 除法运算不能得到整数，就要给出保留的小数位和取舍模式。

public class demo1 {
    public static void main(String[] args) {
        BigDecimal s = new BigDecimal(10);
        BigDecimal s2 = new BigDecimal(3);
//        s2--->被除的对象, 20-->保留的位数,RoundingMode.DOWN--->取舍模式
        BigDecimal sum=s.divide(s2, 20,RoundingMode.DOWN);
        System.out.println(sum);
    }
}

4. 取舍模式;
   • ROUND_CEILING:接近正无穷大的舍入模式。如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同；如果为负，则舍入行为与 ROUND_DOWN 相同。注意，此舍入模式始终不会减少计算值。
   • ROUND_FLOOR:接近负无穷大的舍入模式。如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同；如果为负，则舍入行为与 ROUND_UP 相同。注意，此舍入模式始终不会增加计算值
   • ROUND_HALF_UP:向最近接的数字舍入。

Date类

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

2. 构造方法public Date();

   public Date(long date);把一个long类型的毫秒值转换成一个日期对象。

3. 成员方法：

   • getTime():获取一个日期对象的毫秒值，返回类型long类型

   • setTime():给一个日期对象设上毫秒值。

public class demo2 {
    public static void main(String[] args) {
        Date date = new Date();
//        获取当前时间的毫秒值
        long time = date.getTime();

        System.out.println(time);
//        long类型转换date类型
        date.setTime(time);
        System.out.println(date);
//        date类型转换成long类型
       long time2= date.getTime();
        System.out.println(time2);
    }
}

SimpleDateFormat类

1. 可以把一个日期对象格式化成一个文本（字符串），也可以把一个日期字符串解析成一个日期对象。

2. 构造方法：

   • public SimpleDateFormat():使用默认的模式来创建一个SimpleDateFormat对象
   • public SimpleDateFormat(String pattern):使用指定的模式（规则比如"yyyy:MM:dd HH:mm:ss"）来创建一个SimpleDateFormat对象。

3. 成员方法

   • public String format(Date date): 把一个日期对象格式化成一个字符串
   • public Date parse(String dateStr): 把一个日期字符串解析成一个日期对象 注意要以指定格式解析

public class demo3 {
    public static void main(String[] args) throws ParseException {
//        创建一个日期格式的对象，
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
//        获取当前日期
        Date date = new Date();
//        将当前日期转换成指定格式
        String s1 = s.format(date);
        System.out.println(s1);
        System.out.println("============");
//        创建要输入的日期字符串
        String d="1996-09-25-13-34-56";
//        将日期字符串转换成Date类型
        Date date1 = s.parse(d);
        System.out.println(date1);
    }
}

• 日期格式的字母含义：

字母	日期或时间元素	表示	示例
G	Era 标志符	Text	AD
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul; 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
h	am/pm 中的小时数（1-12）	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	时区	RFC 822 time zone	-0800

案例：计算自己出生多少天了

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

//计算自己出生了多少天了
public class Test1 {
    public static void main(String[] args) throws ParseException {
//        创建日期格式化对象
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        获取当前日期对象
        Date date = new Date();
//        当前日期对象转换成毫秒值
        long time = date.getTime();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄--yyyy-MM-dd HH:mm:ss");
        String s = sc.nextLine();
//        将字符串日期利用日期格式化对象转成Date类型
        Date date1 = format.parse(s);
//        获取生日的毫秒值
        long time1 = date1.getTime();
//       计算毫秒值的差
        long sum=time-time1;
        int day= (int) (sum/1000/60/60/24);
        System.out.println("你已经生活了"+day+"天");
    }
}

calender类

1. 它是一个抽象类，为一些特定的瞬间与日日历字段之间的转换提供了方法。不能直接new对象，需要使用getInstance静态方法来获取一个calender对象。

2. 字段

   • YEAR:年份字段
   • MONTH:月份字段
   • DATE:一个月中的某天
   • DAY_OF_MONTH:一个月中的某天
   • DAY_OF_WEEK:一周中的某天
   • DAY_OF_WEEK_IN_MONTH:当前月中的第几个星期
   • DAY_OF_YEAR:一年中的第几天
   • HOUR:指的是上午或者下午的小时
   • HUOR_OF_DAY:一天中的小时
   • SECOND:秒字段
   • time:以毫秒为单位表示时间的偏移

3. 方法：

   • getInstance():使用默认时间和地区获取当前日历，返回一个Calender对象，这也是创建Calender对象的方法。
   • set( YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE):设置字段值。可以一次设置年，月，日，时，分，秒，设置多个参数
   • set(Calender.YEAR,2000):设置年字段值，也可以单个字段设置
   • get(Calender.YEAR):获取年字段值
   • add(Calender.DAY_OF_WEEK，1) :根据日历规则，对给定的字段添加或者减去指定的时间量（一周的某天加上一天）
   • add(Calender.YEAR，-1) :根据日历规则，对给定的字段添加或者减去指定的时间量（年字段退后一年）

输入年份，计算这年是否是闰年
import java.util.Calendar;
import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = sc.nextInt();
//        Calender是抽象类，采用静态方法getInstance()创建对象instance
        Calendar instance = Calendar.getInstance();
//        对象调方法设置字段值，括号里面是字段设置
      /*  instance.set(Calendar.YEAR, year);
        instance.set(Calendar.MONTH, 2);
        instance.set(Calendar.DAY_OF_MONTH, 1);*/
        instance.set(year,2,1);
//        向后退一天，因为只有add方法，那就加上-1天
        instance.add(Calendar.DAY_OF_MONTH, -1);
//        获取计算完后的天数
        int day = instance.get(Calendar.DAY_OF_MONTH);
//        System.out.println(day);
        if (day==29){
            System.out.println("今年是闰年");
        }else {
            System.out.println("今年是平年");
        }
    }
}

BigInteger类

1. 可以给超过long范围的数据进行运算

2. 构造方法
   public BigInteger(String val)

3. 成员方法
   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 bi1=new BigInteger(“100”);
   BigInteger bi2=new BigInteger(“2”);

   System.out.println(bi1.add(bi2)); //+
   System.out.println(bi1.subtract(bi2)); //-
   System.out.println(bi1.multiply(bi2)); //*
   System.out.println(bi1.divide(bi2)); //(除)

   BigInteger[] arr=bi1.divideAndRemainder(bi2); //取除数和余数
   for(int i=0;i<arr.length;i++){
   System.out.println(arr[i]);
   }