JAVA Class11

Posted 2020-10-29 Observer

学习内容：

1.正则表达式：

正则表达式是一个字符串，使用单个字符串来描述、用来定义匹配规则，匹配一系列符合某个句法规则的字符串。

在开发中，正则表达式通常被用来检索、替换那些符合某个规则的文本。

（1）常用规则：

字符：x

含义：代表的是字符x

例如：匹配规则为 "a"，那么需要匹配的字符串内容就是 ”a”

字符：\\

含义：代表的是反斜线字符‘\‘

例如：匹配规则为"\\" ，那么需要匹配的字符串内容就是 ”\”

字符：\t

含义：制表符

例如：匹配规则为"\t" ，那么对应的效果就是产生一个制表符的空间

字符：\n

含义：换行符

例如：匹配规则为"\n"，那么对应的效果就是换行,光标在原有位置的下一行

字符：\r

含义：回车符

例如：匹配规则为"\r" ，那么对应的效果就是回车后的效果,光标来到下一行行首

字符类：[abc]

含义：代表的是字符a、b 或 c

例如：匹配规则为"[abc]" ，那么需要匹配的内容就是字符a，或者字符b，或字符c的一个

字符类：[^abc]

含义：代表的是除了 a、b 或 c以外的任何字符

例如：匹配规则为"[^abc]"，那么需要匹配的内容就是不是字符a，或者不是字符b，或不是字符c的任意一个字符

字符类：[a-zA-Z]

含义：代表的是a 到 z 或 A 到 Z，两头的字母包括在内

例如：匹配规则为"[a-zA-Z]"，那么需要匹配的是一个大写或者小写字母

字符类：[0-9]

含义：代表的是 0到9数字，两头的数字包括在内

例如：匹配规则为"[0-9]"，那么需要匹配的是一个数字

字符类：[a-zA-Z_0-9]

含义：代表的字母或者数字或者下划线(即单词字符)

例如：匹配规则为" [a-zA-Z_0-9] "，那么需要匹配的是一个字母或者是一个数字或一个下滑线

预定义字符类：.

含义：代表的是任何字符

例如：匹配规则为" . "，那么需要匹配的是一个任意字符。如果，就想使用 . 的话，使用匹配规则"\\."来实现

预定义字符类：\d

含义：代表的是 0到9数字，两头的数字包括在内，相当于[0-9]

例如：匹配规则为"\d "，那么需要匹配的是一个数字

预定义字符类：\w

含义：代表的字母或者数字或者下划线(即单词字符)，相当于[a-zA-Z_0-9]

例如：匹配规则为"\w "，，那么需要匹配的是一个字母或者是一个数字或一个下滑线

边界匹配器：^

含义：代表的是行的开头

例如：匹配规则为^[abc][0-9]$ ，那么需要匹配的内容从[abc]这个位置开始, 相当于左双引号

边界匹配器：$

含义：代表的是行的结尾

例如：匹配规则为^[abc][0-9]$ ，那么需要匹配的内容以[0-9]这个结束, 相当于右双引号

边界匹配器：\b

含义：代表的是单词边界

例如：匹配规则为"\b[abc]\b" ，那么代表的是字母a或b或c的左右两边需要的是非单词字符([a-zA-Z_0-9])

数量词：X?

含义：代表的是X出现一次或一次也没有

例如：匹配规则为"a?"，那么需要匹配的内容是一个字符a，或者一个a都没有

数量词：X*

含义：代表的是X出现零次或多次

例如：匹配规则为"a*" ，那么需要匹配的内容是多个字符a，或者一个a都没有

数量词：X+

含义：代表的是X出现一次或多次

例如：匹配规则为"a+"，那么需要匹配的内容是多个字符a，或者一个a

数量词：X{n}

含义：代表的是X出现恰好 n 次

例如：匹配规则为"a{5}"，那么需要匹配的内容是5个字符a

数量词：X{n,}

含义：代表的是X出现至少 n 次

例如：匹配规则为"a{5, }"，那么需要匹配的内容是最少有5个字符a

数量词：X{n,m}

含义：代表的是X出现至少 n 次，但是不超过 m 次

例如：匹配规则为"a{5,8}"，那么需要匹配的内容是有5个字符a 到 8个字符a之间

（2）常用方法

（a）matches()，返回布尔值

public class Test {
    public static void main(String[] args) {
        String s = "13566667894";
        System.out.println(s.matches("1[3-9][0-9]{9}"));
         }
}

（b）split()，返回String数组

public class Test {
    public static void main(String[] args) {
        String ip = "192.168.0.1";
        String p = "\\.";
        String[] nip = ip.split(p);
        for(int i=0;i<nip.length;i++) {
            System.out.println(nip[i]);
        }
    }

}

（c）replaceAll()，返回String

public class Test {
    public static void main(String[] args) {
        String os = "a123456ccc";
        String rs = "[0-9]";
        String ne = os.replaceAll(rs, "*");
        System.out.println(ne);
    }
}

2.Date类

import java.util.Date;
public class Test {
    public static void main(String[] args) throws ParseException {
        long l = System.currentTimeMillis();//返回自1970/1/1/00：00:00到现在过了多少毫秒
        Date d1 = new Date();
        Date d2 = new Date(52900000001L);//可以将指定数值转换为日期
        System.out.println(d2);
        long l2 = d1.getTime();
        System.out.println(l);
        System.out.println(l2);
    }

}

日期格式化

按照指定格式输出日期：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        SimpleDateFormat s2 = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
        Date d3 = new Date();
        System.out.println(s1.format(d3));
        System.out.println(s2.format(d3));
        Date d4 =s2.parse("2188年8月9日 11:50:36");
        System.out.println(d4);
    }

}

3.Calendar类

抽象类，不可直接实例化，成员变量多是静态的，可通过类直接调用

import java.util.Calendar;
public class Test {
    public static void main(String[] args) throws ParseException {
        Calendar c = Calendar.getInstance();//抽象类，可通过方法实例化
        System.out.println(c);
        int y = c.get(Calendar.YEAR);//成员变量通过类直接调用
        int m = c.get(Calendar.MONTH)+1;//0-11代表1-12月
        int d = c.get(Calendar.DATE);
        int w = c.get(Calendar.DAY_OF_WEEK)-1;//周日是第一天
  int hh = c.get(Calendar.HOUR);
        int mm = c.get(Calendar.MINUTE);
        int ss = c.get(Calendar.SECOND);
        System.out.println(y+"年"+m+"月"+d+"日"+"星期"+w);
    }

}

add()与set()方法

 

import java.util.Calendar;
import java.util.Date;
public class Test1 {
    public static void main(String[] args) throws ParseException {    
        Calendar c = Calendar.getInstance();
        c.add(Calendar.YEAR, 1);//设置偏移量，即在当前基础上+1
        c.set(Calendar.YEAR, 1998);//设置具体数值
        Date d = c.getTime();//转为Date对象
    }
}

 

日期差计算：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Test {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = s1.parse("1993-07-25");
        long l =System.currentTimeMillis()-d1.getTime();
        System.out.println(l/1000/60/60/24+"天");
        Date d2 = s1.parse("2020-1-1");
        long f = System.currentTimeMillis()-d2.getTime();
        System.out.println(Math.abs((f/1000/60/60/24))+"天");    
    }
}

编组输出：

 

捕获组：
String pattern = "(\\D*)(\\d+)(.*)"; //一个括号一个组，共有3个捕获组
创建 Pattern 对象 
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(line);
m.group();//返回String
group()等价于group(0)匹配所有捕获组组的字符串
group(1),匹配第一个捕获组的所有字符串
group(2),匹配第二个捕获组的所有字符串，以此类推

 

import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Test {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        System.out.println("请输入字符串");
        String ss = s.next();
        char[]c = ss.toCharArray();
        Pattern p1 = Pattern.compile("[A-Z]");
        Pattern p2 = Pattern.compile("[a-z]");
        Pattern p3 = Pattern.compile("([^a-z A-Z])");
        Matcher m1 = p1.matcher(ss);
        Matcher m2 = p2.matcher(ss);
        Matcher m3 = p3.matcher(ss);
        while(m1.find()) {//返回布尔值
            sb.append(m1.group().toLowerCase());
        }
        while(m2.find()) {
            sb.append(m2.group().toUpperCase());
        }
        while(m3.find()) {
            sb.append(m3.group().replace(m3.group(), "*"));
        }