正则表达式_Pattern_Marcher_System类_Date\SimpleDateFormat

最新推荐文章于 2023-09-08 08:02:13 发布

秋天1014童话

最新推荐文章于 2023-09-08 08:02:13 发布

阅读量988

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u013217071/article/details/51598097

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

14.01_常见对象(正则表达式的概述和简单使用)

A:正则表达式
- 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
- 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
B:案例演示
- 需求：校验qq号码.
  - 1:要求必须是5-15位数字
  - 2:0不能开头
  - 3:必须都是数字
- a:非正则表达式实现

/*
     * 需求：校验qq号码.
     * 1:要求必须是5-15位数字
     * 2:0不能开头
     * 3:必须都是数字
     * 校验qq
     * 1,明确返回值类型boolean
     * 2,明确参数列表String qq
     */
    public static boolean checkQQ(String qq) {
        boolean flag = true;                    //如果校验qq不符合要求就把flag置为false,如果符合要求直接返回

        if(qq.length() >= 5 && qq.length() <= 15) {
            if(!qq.startsWith("0")) {
                char[] arr = qq.toCharArray();  //将字符串转换成字符数组
                for (int i = 0; i < arr.length; i++) {
                    char ch = arr[i];           //记录每一个字符
                    if(!(ch >= '0' && ch <= '9')) {
                        flag = false;           //不是数字
                        break;
                    }
                }
            }else {
                flag = false;                   //以0开头,不符合qq标准
            }
        }else {
            flag = false;                       //长度不符合
        }
        return flag;
    }
}

* b:正则表达式实现

    String regex = "[1-9]\\d{4,14}";

14.05_常见对象(正则表达式的分割功能)

A:正则表达式的分割功能
- String类的功能：public String[] split(String regex)
B:案例演示
- 正则表达式的分割功能

public static void main(String[] args) {
        String s = "金丹胖.郭美美.大侠";
        String[] arr = s.split("\\."); //.代表任意字符，要想用“.”切，则需要“\\.”
        for (String string : arr) {
            System.out.println(string);
        }
    }

14.06_常见对象(把给定字符串中的数字排序)

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

public static void main(String[] args) {
        //splitDemo();
        String s="91 27 46 38 50";
        String[] arr = s.split(" ");
        int[] arrInt = new int[arr.length];
        int i=0;
        for (String string : arr) {
            arrInt[i++] = Integer.parseInt(string);         
        }
        Arrays.sort(arrInt);

        StringBuffer sb = new StringBuffer();
        for(int j=0;j< arrInt.length;j++){
            if(j==arrInt.length-1){
                sb.append(arrInt[j]);
            }else{
                sb.append(arrInt[j]+" ");
            }
        }
        System.out.println(sb);
    }

14.07_常见对象(正则表达式的替换功能)

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

14.08_常见对象(正则表达式的分组功能)

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

1     ((A)(B(C))) 
2     (A 
3     (B(C)) 
4     (C) 

组零始终代表整个表达式。

B:案例演示
a:切割
需求：请按照叠词切割： “sdqqfgkkkhjppppkl”;

String s2="sdqqfgkkkhjppppkl";
        String regex2="(.)\\1+";//出现一次或者多次
        String[] arr =s2.split(regex2);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

//叠词：快快乐乐
        String regex = "(.)\\1(.)\\2";  // \\1表示第一组又出现1次，\\2表示第二组又出现1次
        System.out.println("快快乐乐".matches(regex));

        //叠词：高兴高兴
        String regex1 = "(..)\\1(..)\\2";   // \\1表示第一组又出现1次，\\2表示第二组又出现1次
        System.out.println("高兴高兴".matches(regex1));

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

String s3="我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
        String s4=s3.replaceAll("\\.", "");
        System.out.println(s4);

        String s5=s4.replaceAll("(.)\\1+", "$1"); //$1代表第一组的内容
        System.out.println(s5);

14.09_常见对象(Pattern和Matcher的概述)

A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
- 通过JDK提供的API，查看Pattern类的说明
- 典型的调用顺序是
- Pattern p = Pattern.compile(“a*b”);//获取正则表达式
- Matcher m = p.matcher(“aaaaab”);//获取匹配器
- boolean b = m.matches();//判断是否匹配，匹配返回true
  
  上面三句等同于“aaaaab”.matches(“a*b”);

14.10_常见对象(正则表达式的获取功能)

A:正则表达式的获取功能
- Pattern和Matcher的结合使用
B:案例演示
- 需求：把一个字符串中的手机号码获取出来

public static void main(String[] args) {
        String s = "我的手机号码是18812388888，用过13345678910，还用过18510669730";
        String regex="1[3578]\\d{9}";
        Pattern p = Pattern.compile(regex); //获取正则表达式
        Matcher m = p.matcher(s);           //获取匹配器
        while(m.find()){                    //尝试查找与该模式匹配的输入序列的下一个子序列。
            System.out.println(m.group());  //返回由以前匹配操作所匹配的输入子序列
        }
    }
    结果：
18812388888
13345678910
18510669730

14.12_常见对象(Random类的概述和方法使用)

A:Random类的概述
- 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
- public Random()
- public Random(long seed)按照某个种子生成随机数
C:成员方法
- public int nextInt()
- public int nextInt(int n)(重点掌握) 生成0到n-1之间的随机数

14.13_常见对象(System类的概述和方法使用)

A:System类的概述
- System 类包含一些有用的类字段和方法。它不能被实例化。
B:成员方法

*public static void gc() 运行垃圾回收器。其实就是呼叫保洁阿姨，保洁阿姨是类本身的finalize()方法。Object中有finalize()方法：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
* public static void exit(int status)
非0状态是异常终止，退出jvm
* public static long currentTimeMillis()
* 获取当前时间的毫秒值，可以判定程序执行时间
* pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将数组内容拷贝

C:案例演示
- System类的成员方法使用

14.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)

14.15_常见对象(BigDecimal类的概述和方法使用)

A:BigDecimal的概述
- 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
- 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
- 不可变的、任意精度的有符号十进制数。
B:构造方法
- public BigDecimal(String val) 开发时推荐（比较准确）、或者使用BigDecimal.valueOf（double值）;
C:成员方法
- public BigDecimal add(BigDecimal augend)
- public BigDecimal subtract(BigDecimal subtrahend)
- public BigDecimal multiply(BigDecimal multiplicand)
- public BigDecimal divide(BigDecimal divisor)
D:案例演示
- BigDecimal类的构造方法和成员方法使用

14.16_常见对象(Date类的概述和方法使用)(掌握)

A:Date类的概述
- 类 Date 表示特定的瞬间，精确到毫秒。
B:构造方法
- public Date()
- public Date(long date)
C:成员方法
- public long getTime()

Date d2 = new Date();
        System.out.println(d2.getTime());   //通过时间对象获取毫秒值
        System.out.println(System.currentTimeMillis());//通过系统类的方法获取当前时间毫秒值
        //1465268214758
        //1465268214759

* public void setTime(long time)

d2.setTime(1000);
System.out.println(d2); //通过时间对象获取毫秒值

14.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)

public static void main(String[] args) throws ParseException {
        Date d =  new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日 HH:mm:ss");
        System.out.println(sdf.format(d));

        //将时间字符串转为日期对象
        String s = "2016年06月07日 11:12:09";
        SimpleDateFormat sdf1 = new SimpleDateFormat("YYYY年MM月dd日 HH:mm:ss");
        Date d1 = sdf1.parse(s);    //加异常：parseException
        System.out.println(d1);
    }

14.18_常见对象(你来到这个世界多少天案例)(掌握)

A:案例演示
- 需求：算一下你来到这个世界多少天?

public static void main(String[] args) throws ParseException {
        //得到生日与当前日期字符串，转化为Date对象，得到相差的毫秒值，从而得到对应天数
        String birthday = "1992年11月08日";
        String today = "2016年06月07日";
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日");
        Date d1 = sdf.parse(birthday);
        Date d2 = sdf.parse(today);
        long time = d2.getTime()-d1.getTime();
        System.out.println(time/1000/60/60/24);
    }

14.19_常见对象(Calendar类的概述和获取日期的方法)(掌握)

A:Calendar类的概述
- Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
B:成员方法
- public static Calendar getInstance()
- public int get(int field)

package com.heima.otherclass;

import java.util.Calendar;

public class Demo9_Calendar {

    /**
     * * A:Calendar类的概述
            * Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
        * B:成员方法
            * public static Calendar getInstance()
            * public int get(int field)
        * C:成员方法
            * public void add(int field,int amount)
            * public final void set(int year,int month,int date)
        * D:案例演示
            * 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, 8);

        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)));
    }

    public static void demo1() {
        Calendar c = Calendar.getInstance();            //父类引用指向子类对象
        //System.out.println(c);
        System.out.println(c.get(Calendar.YEAR));       //通过字段获取年
        System.out.println(c.get(Calendar.MONTH));      //通过字段后期月,但是月是从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 week
     */

    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;
    }
}

14.20_常见对象(Calendar类的add()和set()方法)(掌握)

A:成员方法
- public void add(int field,int amount)//对指定字段进行加减
- public final void set(int year,int month,int date)//修改指定字段
B:案例演示
- Calendar类的成员方法使用

14.21_常见对象(如何获取任意年份是平年还是闰年)(掌握)

A:案例演示
- 需求：键盘录入任意一个年份，判断该年是闰年还是平年

package com.heima.test;

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

public class Test3 {

    /**
     * * A:案例演示
     * 需求：键盘录入任意一个年份，判断该年是闰年还是平年
     * Calendar c = Calendar.getInstance();
     * 
     * 分析:
     * 1,键盘录入年Scanner
     * 2,创建Calendar c = Calendar.getInstance();
     * 3,通过set方法设置为那一年的3月1日
     * 4,将日向前减去1
     * 5,判断日是多少天,如果是29天返回true否则返回false
     */
    public static void main(String[] args) {
        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) {
        //2,创建Calendar c = Calendar.getInstance();
        Calendar c = Calendar.getInstance();
        //设置为那一年的3月1日
        c.set(year, 2, 1);
        //将日向前减去1
        c.add(Calendar.DAY_OF_MONTH, -1);
        //判断是否是29天
        return c.get(Calendar.DAY_OF_MONTH) == 29;
    }

}