Java编程基础15——正则表达式&常用工具类

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

• A:正则表达式

  • 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
  • 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的

• B:案例演示

  • 需求：校验qq号码.

    • 1:要求必须是5-15位数字
    • 2:0不能开头
    • 3:必须都是数字
  • a:非正则表达式实现
  • b:正则表达式实现

2_字符类演示

• A:字符类

  • [abc] a、b 或 c（简单类）
  • ¹ 任何字符，除了 a、b 或 c（否定）
  • [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
  • [0-9] 0到9的字符都包括

3_预定义字符类演示

• A:预定义字符类

  • . 任何字符。
  • d 数字：[0-9]
  • w 单词字符：[a-zA-Z_0-9]

4_数量词

• A:Greedy 数量词

  • X? X，一次或一次也没有
  • X* X，零次或多次
  • X+ X，一次或多次
  • X{n} X，恰好 n 次
  • X{n,} X，至少 n 次
  • X{n,m} X，至少 n 次，但是不超过 m 次

5_正则表达式的分割功能

• A:正则表达式的分割功能

  • String类的功能：public String[] split(String regex)

• B:案例演示

  • 正则表达式的分割功能

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

• A:案例演示

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

7_正则表达式的替换功能

• A:正则表达式的替换功能

  • String类的功能：public String replaceAll(String regex,String replacement)

• B:案例演示

  • 正则表达式的替换功能

8_正则表达式的分组功能

• A:正则表达式的分组功能

  • 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

• 1     ((A)(B(C))) 
  2     (A 
  3     (B(C)) 
  4     (C) 
  
  组零始终代表整个表达式。

• B:案例演示
  a:切割

  需求：请按照叠词切割： "sdqqfgkkkhjppppkl";

  b:替换

  需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
  将字符串还原成:“我要学编程”。

9_Pattern和Matcher的概述

• A:Pattern和Matcher的概述

• B:模式和匹配器的典型调用顺序

  • 通过JDK提供的API，查看Pattern类的说明
  • 典型的调用顺序是
  • Pattern p = Pattern.compile("a*b");
  • Matcher m = p.matcher("aaaaab");
  • boolean b = m.matches();

10_正则表达式的获取功能

• A:正则表达式的获取功能

  • Pattern和Matcher的结合使用

• B:案例演示

  • 需求：把一个字符串中的手机号码获取出来

11_Math类概述和方法使用

• A:Math类概述

  • Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

• B:成员方法

  • 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) min自学
  • public static double pow(double a,double b)
  • public static double random()
  • public static int round(float a) 参数为double的自学
  • public static double sqrt(double a)

public static void main(String[] args) {
    System.out.println(Math.PI);
    System.out.println(Math.abs(-10));    //取绝对值
    
    System.out.println(Math.ceil(12.01));//获取向上取整，但是结果是一个double值
    System.out.println(Math.ceil(12.99));
    
    System.out.println(Math.floor(12.01));//获取向下取整，但是结果也是一个double值
    System.out.println(Math.floor(12.99));
    
    System.out.println(Math.max(20,    30));//取最大值
    System.out.println(Math.min(20,    30));//取最小值
    
    System.out.println(Math.pow(2, 3)); //2.0的3次方
    
    System.out.println(Math.random());//生成0.0到1.0之间的所有小数，包括0.0，不包括1.0
    
    System.out.println(Math.round(12.3f));//四舍五入
    
    System.out.println(Math.sqrt(2));//开平方
}

12_Random类的概述和方法使用

• A:Random类的概述

  • 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
  • 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

• B:构造方法

  • public Random()
  • public Random(long seed)

• C:成员方法

  • public int nextInt()
  • public int nextInt(int n)(重点掌握)

import java.util.Random;
public class Other_Random_2 {
    public static void main(String[] args) {
        Random r = new Random();
        /*int x = r.nextInt();
        System.out.println(x);
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt());
            System.out.println(r.nextInt(100));
        }
        */
        
        Random r2 = new Random(1000);
        int a = r2.nextInt();
        int b = r2.nextInt();
        
        System.out.println(a);
        System.out.println(b);
    }
}

13_System类的概述和方法使用

• A:System类的概述

  • System 类包含一些有用的类字段和方法。它不能被实例化。

• B:成员方法

  • public static void gc()
  • public static void exit(int status)
  • public static long currentTimeMillis()
  • pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

• C:案例演示

  • System类的成员方法使用

public class Other_System_3 {
    public static void main(String[] args) {
//        demo1();
//        demo2();
//        demo3();
        demo4();
    }

    private static void demo4() {
        int[] src = {11,22,33,44,55,66,77,88,99};
        int[] dest = new int[10];
        
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
        System.out.println("-----------------------");
        System.arraycopy(src, 0, dest, 0, src.length);        //将数组内容拷贝
        
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }

    private static void demo3() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            System.out.println("*");
        }
        long end = System.currentTimeMillis();        //获取当前时间的毫秒值        
        System.out.println(end - start);
    }

    private static void demo2() {
        System.exit(0);                //非0状态是异常终止，退出jvm
        System.out.println("1111111");
    }

    private static void demo1() {
        for (int i = 0; i < 100; i++) {
            new Demo();
            System.gc();                            //运行垃圾回收器
        }
    }
}

class Demo {            //在一个源文件中不允许定义两个用public修饰的类
    public void finalize() {
        System.out.println("被清扫了");
    }
}

14_BigInteger类的概述和方法使用

• A:BigInteger的概述

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

• B:构造方法

  • public BigInteger(String val)

• C:成员方法

  • 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)

import java.math.BigInteger;
public class Other_BigInteger_4 {
    public static void main(String[] args) {
//        long num = 155565456465465465545;
//        String s = "155565456465465465545";
        
        BigInteger bi1 = new BigInteger("100");
        BigInteger bi2 = new BigInteger("3");
        
        System.out.println(bi1.add(bi2));        // +
        System.out.println(bi1.subtract(bi2));    // -
        System.out.println(bi1.multiply(bi2));    // x
        System.out.println(bi1.divide(bi2));    // /
        
        BigInteger[] arr = bi1.divideAndRemainder(bi2);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

15_BigDecimal类的概述和方法使用

• A:BigDecimal的概述

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

• B:构造方法

  • public BigDecimal(String val)

• C:成员方法

  • public BigDecimal add(BigDecimal augend)
  • public BigDecimal subtract(BigDecimal subtrahend)
  • public BigDecimal multiply(BigDecimal multiplicand)
  • public BigDecimal divide(BigDecimal divisor)

• D:案例演示

  • BigDecimal类的构造方法和成员方法使用

import java.math.BigDecimal;
public class Other_BigDecimal_5 {
    public static void main(String[] args) {
//        System.out.println(2.0 - 1.1);
        
/*        BigDecimal bd1 = new BigDecimal(2.0);//不推荐，还是不够精确
        BigDecimal bd2 = new BigDecimal(1.1);
        System.out.println(bd1.subtract(bd2));*/
        
/*        BigDecimal bd1 = new BigDecimal("2.0");//通过构造中传入字符串的方式，开发时推荐
        BigDecimal bd2 = new BigDecimal("1.1");
        System.out.println(bd1.subtract(bd2));*/
        
        BigDecimal bd1 = BigDecimal.valueOf(2.0);//这种方法开发中也是推荐的
        BigDecimal bd2 = BigDecimal.valueOf(1.1);
        System.out.println(bd1.subtract(bd2));
    }
}

16_Date类的概述和方法使用*

• A:Date类的概述

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

• B:构造方法

  • public Date()
  • public Date(long date)

• C:成员方法

  • public long getTime()
  • public void setTime(long time)

import java.util.Date;
public class Other_6_Date {
    public static void main(String[] args) {
//        demo1();
//        demo2();
        Date d1 = new Date();
        d1.setTime(1000);            //设置毫秒值，改变时间对象
        System.out.println(d1);
    }

    private static void demo2() {
        Date d1 = new Date();
        System.out.println(d1.getTime());    //通过时间对象获取毫秒值
        System.out.println(System.currentTimeMillis());//通过系统类的方法获取当前时间毫秒值
    }

    private static void demo1() {
        Date d1 = new Date();        //没有传参数代表当前时间
        System.out.println(d1);
        
        Date d2 = new Date(0);        //0代表Thu Jan 01 08:00:00 CST 1970
        System.out.println(d2);        //通过毫秒值创建时间对象
    }
}

17_SimpleDateFormat类实现日期和字符串的相互转换*

• A:DateFormat类的概述

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

• B:SimpleDateFormat构造方法

  • public SimpleDateFormat()
  • public SimpleDateFormat(String pattern)

• C:成员方法

  • public final String format(Date date)
  • public Date parse(String source)

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

public class Other_7_DateFormat {
    public static void main(String[] args) throws ParseException {
//        demo1();
//        demo2();
        
        //将时间字符串转换成日期对象
        String str = "2000年08月08日 08:08:08";
        SimpleDateFormat sdf = new SimpleDateFormat("y年M月d日 HH:mm:ss");
        Date d = sdf.parse(str);                //将时间字符串转换成日期对象 Ctrl+1抛出异常
        System.out.println(d);
    }

    private static void demo2() {
        Date d = new Date();        //获取当前时间对象
        SimpleDateFormat sdf = new SimpleDateFormat("y年M月d日 HH:mm:ss");        //创建日期格式化类对象
        System.out.println(sdf.format(d));            //将日期对象转换为字符串
    }

    private static void demo1() {
        //DateFormat df = new DateFormat();                 //是抽象类，不允许实例化
        //DateFormat df = new SimpleDateFormat();
        DateFormat df1 = DateFormat.getDateInstance();    //相当于父类引用指向子类对象，右边的方法返回一个子类
    }
}

18_你来到这个世界多少天案例*

• A:案例演示

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

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Other_8_test {
    public static void main(String[] args) throws ParseException {
/*        分析
        1.将生日字符串和今天字符串存在String类型的变量中
        2.定义日期格式化对象
        3.将日期字符串转换成日期对象
        4.通过日期对象后期时间毫秒值
        5.将两个时间毫秒值相减除以1000，再除以60，再除以60，再除以24得到天*/
        //1
        String birthday = "1998年12月12日";
        String today = "2018年9月17日";
        //2
        SimpleDateFormat sdf = new SimpleDateFormat("y年M月d日");
        //3
        Date d1 = sdf.parse(birthday);
        Date d2 = sdf.parse(today);
        //4
        long time = d2.getTime() - d1.getTime();
        //5
        System.out.println(time / 1000 / 60 / 60 / 24 / 365);
    }
}

19_Calendar类的概述和获取日期的方法*

• A:Calendar类的概述

  • Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

• B:成员方法

  • public static Calendar getInstance()
  • public int get(int field)

import java.util.Calendar;
public class Other_Calendar_9 {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();        //父类引用指向子类对象
//        System.out.println(c);
        System.out.println(c.get(Calendar.YEAR));//通过字段获取年
        System.out.println(c.get(Calendar.MONDAY));//通过字段获取月，从0开始
        System.out.println(c.get(Calendar.DAY_OF_MONTH));//获取日
        System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一    
        
        System.out.println(c.get(Calendar.YEAR) + "年" + getNum(c.get(Calendar.MONTH) + 1) + "月" + 
        getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
    }
/*    
    将星期存储表中，进行查表
    1.返回值类型String
    2.参数列表int*/    
    public static String getWeek(int week) {
        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return arr[week];
    }
    
/*    将个位数字补0
    1.返回值类型String
    2.参数列表int num*/
    public static String getNum(int num) {
/*        if(num > 9) {
            return "" + num;
        }else {
        return "0" + num;
        }*/    
        return num > 9 ? "" + num : "0" + num;
    }
}

20_Calendar类的add()和set()方法*

• A:成员方法

  • public void add(int field,int amount)
  • public final void set(int year,int month,int date)

• B:案例演示

  • Calendar类的成员方法使用

    public static void main(String[] args) {
//        demo1();
        Calendar c = Calendar.getInstance();        //父类引用指向子类对象
        c.add(Calendar.MONTH, -1);                    //对指定的字段进行加减操作
        c.set(Calendar.YEAR, 2000);                    //修改指定字段
        c.set(2000, 7, 18);
        System.out.println(c.get(Calendar.YEAR) + "年" + getNum(c.get(Calendar.MONTH) + 1) + "月" + 
        getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
        
    }

21_如何获取任意年份是平年还是闰年*

• A:案例演示

  • 需求：键盘录入任意一个年份，判断该年是闰年还是平年

import java.util.Calendar;
import java.util.Scanner;
public class Other_10_test {
    public static void main(String[] args) {    
/*        分析
        1.键盘录入年Scanner
        2.创建Calendar c = Calendar.getInstance();
        3.通过set方法设置为那一年的3月1日
        4.将日向前减去1
        5.判断日是多少天，如果是29天返回true，否则false*/
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入年份，判断该年份是闰年还是平年：");
//            int year = sc.nextInt();
            
            String line = sc.nextLine();            //录入数字字符串
            int year = Integer.parseInt(line);        //将数字字符串转换成数字
            Boolean b = getYear(year);
            System.out.println(b);    
    }
    private static Boolean getYear(int year) {
        Calendar c = Calendar.getInstance();//第二步
        c.set(year, 2, 1); //第三步，设置为那一年的3月1日
        c.add(Calendar.DAY_OF_MONTH, -1);//将日向前减去1
        return c.get(Calendar.DAY_OF_MONTH) == 29;//判断是否为29
    }
}

---

1. abc ↩