Java基础14----正则表达式Math类System类BigInteger日期类

Posted 2022-10-30 冬有雪

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java基础14----正则表达式Math类System类BigInteger日期类相关的知识，希望对你有一定的参考价值。

一、PatternMatcher

1.正则表达式的使用

作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
示例：校验QQ

package com.geekds.regex;

public class Regex_Test 
    public static void main(String[] args) 
        /*
         * 校验qq
         * 1，要求必须5-15位数字
         * 2，0不开头
         * 3，都必须是数字
         * 
         * 返回值类型：boolean
         * 参数列表：String qq
         */

        String s = "12345";
        System.out.println(checkQQ(s));
        System.out.println(checkQQ("2390098098780987"));

        String regex = "[0-9]\\\\d4,14";
        System.out.println("235423".matches(regex));
        System.out.println(s.matches(regex));
        System.out.println("02342".matches(regex));
    

    //非正则表达式实现
    public static boolean checkQQ(String qq) 
        boolean flag = true;//如果不符合要求，返回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;
            
        else 
            flag = false;
        

        return flag;

2.常见对象（字符类）

[abc] a、b 或 c（简单类
[^abc] 任何字符，除了 a
[a-zA-Z] a到 z 或 A到 Z
[0-9] 0到9的字符都包括

看示例：

package com.geekds.regex;

public class Regex_CommonUse 

    /**
     * @param args
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub

        //[]代表单个字符
        String regex = "[geekds.com]";
        System.out.println(".".matches(regex));

        //^代表除了[]中的字符
        String regex1 = "[^geekds.com]";
        System.out.println(".".matches(regex1));

        //[a-zA-Z]代表所有小写字母和所有大写字母
        String regex2 = "[a-zA-Z]";
        System.out.println("Z".matches(regex2));

        //[a-c[m-x]]代表a-z 或者  m-x
        String regex3 = "[a-c[m-x]]";
        System.out.println("d".matches(regex3));

        //g,e,k,d或s，交集
        String regex4 = "[a-z&&[geekds]]";

        //a-z，除了b和c
        String regex5 = "[a-z&&[^bc]]";

        //a-z，除了m-p
        String regex6 = "a-z&&[^m-p]";

3.常见对象（预定义字符类）

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

示例：

package com.geekds.regex;

public class Regex_Test2 

    /**
     * 预定义字符
     * . 任意字符
     * \\d 数字：[0-9]
     * \\D 非数字：[^0-9]
     * \\s 空白字符：[ \\t\\n\\x0B\\f\\r]，\\x0B是DOS系统中的数值制表符，\\f是DOS系统的翻页
     * \\S 非空白字符：[^\\s]
     * \\w 单词字符：[a-zA-Z_0-9]
     * \\W 非单词字符：[^\\w]   
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        String regex = "\\\\s";
        System.out.println("    ".matches(regex));//tab键

        String regex2 = "\\\\w";
        System.out.println("_".matches(regex2));
        System.out.println("0".matches(regex2));

4.常见对象（数量词）

Greedy 数量词
* X? X，一次或一次也没有
* X* X，零次或多次
* X+ X，一次或多次
* Xn X，恰好 n 次
* Xn, X，至少 n 次
* Xn,m X，至少 n 次，但是不超过 m 次

示例：

package com.geekds.regex;

public class Regex_Greedy 

    /**
     * X? X,一次或一次也没有
     * X* X,零次或多次
     * X+ X,一次或多次
     * Xn X,恰好n次
     * Xn, X,至少n次
     * Xn,m X,至少n次，但不超过m次
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        String regex = "[d]3,5";//包含头，也包含尾
        String regex2 = ".2,4";
        System.out.println("ddddd".matches(regex));
        System.out.println("..".matches(regex2));

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

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

示例：

package com.geekds.regex;

public class String_split_method 

    /**
     * String类的split(String regex)方法，通过正则表达式切割字符串，返回String数组
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        String s = "geekds.com www.geekds.com";
        String[] arr = s.split(".");//不能直接用 .  ，因为 . 代表任意字符
        String[] arr2 = s.split("\\\\.");//非要用 . ，需要进行转义，

        for (int i = 0; i < arr2.length; i++) 
            System.out.println(arr2[i]);

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

package com.geekds.test;

import java.util.Arrays;

public class String_Sort 

    /**
     * 将字符串“124，543，2，65，1234，6098”，转换为排序后的字符串
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        String s = "124，543，2，65，1234，6098";
        String[] str = s.split("，");//将字符串转换为字符数组
        int[] arr = new int[str.length];//定义一个等长的int数组存储上面的一堆切割后的字符串
        for (int i = 0; i < str.length; i++) 
            arr[i] = Integer.parseInt(str[i]);//使用Integer的parseInt方法将数字字符串转换为数字，存到int数组中
        

        Arrays.sort(arr);//使用Arrays进行排序

        //将排序后的结果遍历并拼接成一个字符串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) 
            if(i == arr.length - 1) 
                sb.append(arr[i]);
            else 
                sb.append(arr[i] + "，");
            
        

        System.out.println(sb);//直接输出默认调用StringBuilder的toString()方法

7. 正则表达式的替换功能和正则表达式的分组功能

1）正则表达式的替换功能

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

2）正则表达式的分组功能

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

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

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

示例：

package com.geekds.regex;

public class Regex_Repeat 

    /**
     * 分组的好处，可以将这一组再获取一次
     * 按照叠词切割
     */
    public static void main(String[] args) 
        repeat_Word();
        qieGe();

        //需求：按照叠词替换“你你好，我是是三三体...星人，我带着着着和平平平平而来！！！！”
        String s = "你你好，我是是三三体...星人，我带着着着和平平平平而来！！！";
        String s2 = s.replaceAll("\\\\.+", "");
        String s3 = s2.replaceAll("！+", "！");
        String s4 = s3.replaceAll("(.)\\\\1+", "$1");
        System.out.println(s3);
        System.out.println(s4);
    

    private static void qieGe() 
        System.out.println("-------------------");
        //需求：按照叠词切割“gnsooodsfsssbdeeoasdjjjjjjj”;
        String s2 = "gnsooodsfsssbdeeoasdjjjjjjj";
        String regex = "(.)\\\\1+";   // + 代表第一组出现一次或多次
        String[] arr = s2.split(regex);
        for (int i = 0; i < arr.length; i++) 
            System.out.println(arr[i]);
        
    

    private static void repeat_Word() 
        //叠词1
        String regex = "(.)\\\\1(.)\\\\2"; // \\\\1代表第一组又出现一次，\\\\2代表第二组又出现一次
        System.out.println("帅帅东东".matches(regex));
        System.out.println("cc侯侯".matches(regex));
        System.out.println("abab".matches(regex));
        System.out.println("------------------");
        //叠词2
        String regex2 = "(..)\\\\1";
        System.out.println("帅董帅董".matches(regex2));

8.常见对象（Pattern和Matcher的概述）

模式和匹配器的典型调用顺序
示例：

package com.geekds.regex;

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

public class Pattern_Demo 

    /**
     *   典型的调用顺序是 
         Pattern p = Pattern.compile("a*b");
         Matcher m = p.matcher("aaaaab");
         boolean b = m.matches();
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        Pattern p = Pattern.compile("a*b"); //将给定的正则表达式编译到模式中。
        Matcher m = p.matcher("aaaaab");    //创建匹配给定输入与此模式的匹配器。
        boolean b = m.matches();    //编译给定正则表达式并尝试将给定输入与其匹配
        System.out.println(b);

        System.out.println("aaaaab".matches("a*b"));//与上面功能相同

9. 正则表达式的获取功能

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

示例：

package com.geekds.regex;


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

public class Pattern_Demo2 

    /**
     * 需求：获取手机号码
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        String s = "my phone number:17890008000, once used 18800008888";
        //手机号码的正则表达式
        String regex = "1[78]\\\\d9";   
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s);
        boolean b = m.matches();
    //  boolean b1 = m.find();
        System.out.println(b);
    //  System.out.println(b1);

    //  String s1 = m.group();
    //  System.out.println(s1);

        while(m.find()) //找符合正则表达式规则的字符串
            System.out.println(m.group());  //获取找到的字符串

二、Math类的使用

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
*成员方法
- 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)

示例：

package com.geekds.otherclass;

public class Math_Methods 

    /**
     * Math中所有的方法都是静态的，构造方法也私有，不让其他类创建本类对象
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        System.out.println(Math.E);
        System.out.println(Math.PI);
        System.out.println(Math.abs(-2016));    //取绝对值
        System.out.println(Math.ceil(20.16));//返回大于该值的double整数，该值大于等于参数，并等于某个整数。
        System.out.println(Math.ceil(-20.16));
        System.out.println(Math.floor(20.17));//返回小于该值的double 值，该值小于等于参数，并等于某个整数。
        System.out.println(Math.floor(-20.17));
        System.out.println(Math.max(8000,8009));
        System.out.println(Math.min(123, 321));
        System.out.println(Math.pow(5.3, 4.0)); //5.3是底数，4.0是指数，求5.3的4次方
        System.out.println(Math.random());// 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。前闭后开
        System.out.println(Math.round(9.8));//四舍五入
        System.out.println(Math.round(9.1));
        System.out.println(Math.sqrt(9));//开平方
        System.out.println(Math.sqrt(3));

三、Random类的方法和使用

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

构造方法

public Random()
public Random(long seed)

成员方法
* public int nextInt()
* public int nextInt(int n)(重点掌握)

示例：

package com.geekds.otherclass;

import java.util.Random;

public class Random_Methods 

    /**
     * Random类，生成伪随机数
     * 默认使用纳秒值生成随机数
     * 传入值是使用long种子生成随机数
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        Random r = new Random(90);//使用单个 long 种子创建一个新的随机数生成器。
        int a = r.nextInt();//每次运行产生的随机数相同
        System.out.println(a);

        System.out.println("------------------");
        Random r2 = new Random();//根据系统的纳秒值生成随机数，每次生成的值都不相同
        for (int i = 0; i < 5; i++) 
            System.out.println(r2.nextInt());
        

        System.out.println("-------------------");
        Random r3 = new Random();
        for (int i = 0; i < 10; i++) 
            System.out.println(r3.nextInt(100));//返回的值区间是[0,100)

四、System类的方法使用

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

成员方法

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)

示例：

package com.geekds.otherclass;

public class System_Methods 

    /**
     * System都是静态方法
     * System.in    //标准输入流，默认指向键盘
     * System.out   //标准输出流，默认指向控制台
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        //systemGc();
        //systemExit();
        System.out.println("--------------");
        systemCurrentTimeMillis();

        int[] src = 123,456,78,9012,345;
        int[] dest = new int[6];
        //在集合中把原数组中的内容复制到新数组用的就是这个方法 
        System.arraycopy(src, 3, dest, 2, 2);//复制数组中的指定元素到另一数组

        for (int i = 0; i < src.length; i++) 
            System.out.println(src[i]);
        
        for (int i = 0; i < dest.length; i++) 
            System.out.println(dest[i]);
        
    

    private static void systemCurrentTimeMillis() 
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) 
            System.out.print("*");

        

        long endTime = System.currentTimeMillis();
        long l = endTime - startTime;
        System.out.println();
        System.out.println(l);
    

    private static void systemExit() 
        System.out.println("----------");
        System.exit(0);
        System.out.println("!!!!!!!!!!!!!!");
    

    private static void systemGc() 
        for (int i = 0; i < 10; i++) 
            new Demo();
            System.gc();
        
    



class Demo 

    @Override
    protected void finalize() 
        // TODO Auto-generated method stub
        System.out.println("garbage clean");

五、BigInteger和BigDecimal类的概述和方法使用

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)

package com.geekds.otherclass;

import java.math.BigInteger;

public class BigInteger_Methods 
    /*
     * 使用BigInteger存储很大的整数
     */
    public static void main(String[] args) 
        //long num = 12311111111131111112333L;
        String s = "123666666555555511131111112333";
        BigInteger bg = new BigInteger(s);
        BigInteger bg2 = new BigInteger("333");
        System.out.println(bg.add(bg2));
        System.out.println(bg.subtract(bg2));
        System.out.println(bg.multiply(bg2));
        System.out.println(bg.divide(bg2));
        System.out.println("---------------------");
        //返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
        System.out.println(bg.divideAndRemainder(bg2));
        BigInteger[] arr = bg.divideAndRemainder(bg2);

        for (int i = 0; i < arr.length; i++) 
            System.out.println(arr[i]);

由于在运算的时候，float类型和double很容易丢失精度，所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal。

构造方法

public BigDecimal(String val)

成员方法

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

package com.geekds.otherclass;

import java.math.BigDecimal;

public class Decimal_Use 

    /**
     * 更精确的存储小数
     * 有以下方法：
     * add()
     * subtract()
     * multiply()
     * divide()
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        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 bd3 = new BigDecimal("2.0");//开发时推荐通过构造中传入字符串的方式
        BigDecimal bd4 = new BigDecimal("1.1");
        System.out.println(bd3.subtract(bd4));

        //也可以用BigDecimal的valueOf方法,此方法里面穿的不是字符串
        BigDecimal bd5 = BigDecimal.valueOf(2.0);
        BigDecimal bd6 = BigDecimal.valueOf(1.1);
        System.out.println(bd5.subtract(bd6));

六、Date类的概述和方法使用

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

构造方法
* public Date()
* public Date(long date)

成员方法
* public long getTime()
* public void setTime(long time)

示例：

package com.geekds.otherclass;

import java.util.Date;


public class Date_Use 

    /**
     * Date类，里面的很多方法已过时了
     * 导包时注意是util包下的，不是sql包下的。
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        Date d = new Date();//代表当前时间，
        System.out.println(d);

        Date d1 = new Date(0);//如果构造方法中参数传为0，代表1970年1月1日，由于我处于东8区看，所以显示的08：00：00
        System.out.println(d1);//通过毫秒值创建时间对象

        //32位操作系统可以计时多少年
        System.out.println(Integer.MAX_VALUE / (365 * 24 * 3600));
        System.out.println(1970 + 68);

        System.out.println(d.getTime());//获取当前时间毫秒值
        System.out.println(System.currentTimeMillis());

        d1.setTime(2000);   //设置毫秒值
        System.out.println(d1);

七、SimpleDateFormat类实现日期和字符串的相互转换(掌握)

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

SimpleDateFormat构造方法

public SimpleDateFormat()
- public SimpleDateFormat(String pattern)

成员方法

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

示例：

package com.geekds.otherclass;

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

public class DateFormat_SimpleDateFormat 
    public static void main(String[] args) throws ParseException 
        dateFormat();

        simpleDateFormat();

        //将时间字符串转换为日期对象
        String s = "2016年7月17日 23时2分60秒";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年M月dd日 HH时m分s秒");
        Date d = sdf.parse(s); //将时间字符串转换为日期对象
        System.out.println(d);
    

    private static void simpleDateFormat() 
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//创建日期格式化对象，大MM小dd大H
        SimpleDateFormat sdf2 = new SimpleDateFormat("y/M/d H:m:s");//这样写与上面一样
        System.out.println(sdf.format(d));
    

    private static void dateFormat() 
        /*
         * DateFormat是抽象类，不允许实例化
         */
        DateFormat df = DateFormat.getInstance();//相当于父类引用指向子类对象，右边的方法返回子类对象
        System.out.println(df);

示例2：

package com.geekds.otherclass;

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

public class SimpleDateFormat_Test2 

    /**
     * @param args
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException 
        // TODO Auto-generated method stub
        String birthday = "1800年01月01日 00:00:00";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

        Date d1 = sdf.parse(birthday);//将日期字符串转换为日期对象
        Date d = new Date();//获取今天的日期对象

        System.out.println(d);
        System.out.println(d1);
        System.out.println("-0------------------------");

        long l = d.getTime() - d1.getTime();
        System.out.println(l / 3600000 / 24 / 365 + "年");

1. 算一下你来到这个世界多少天?

package com.geekds.otherclass;

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

public class SimpleDateFormat_Test 

    /**
     * 练习：你来到世界多少天？
     * 分析：
     * 1.将生日字符串和今天字符串存储在String类型的变量中
     * 2.定义日期格式化对象
     * 3.将日期字符串转换成日期对象
     * 4.通过日期对象获取时间毫秒值
     * 5.将两个时间毫秒值相减，除以1000，变成秒，再除以3600，变成小时，再除以24，得到天数
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException 
        // TODO Auto-generated method stub
        String birthday = "1990年08月09日";
        String today = "2016年07月17日";

        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 * 3600 * 24));

八、Calendar类的概述和获取日期的方法(掌握)

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

成员方法

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

Calendar类的add()和set()方法

成员方法

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

示例：

package com.geekds.otherclass;

import java.util.Calendar;


public class Calendar_Use 

    /**
     * @param args
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        Calendar c = Calendar.getInstance();//父类引用指向子类对象，getInstance()的作用是使用默认时区和语言环境获得一个日历。
    //  System.out.println(c);

        System.out.println(c.get(Calendar.YEAR));//通过字段获取年
        System.out.println(c.get(Calendar.MONTH) + 1);//通过字段获取月，但是月是从0开始编号的
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一天

        System.out.println("------------------");
        //获取今天的日期和星期
        System.out.println(c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH) + 1) + "月" + c.get(Calendar.DAY_OF_MONTH) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
        //写成2016年07年18日星期一，如果月和日时<=9的数，前面就补0
        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)));

        System.out.println("-------------------");
        //Calendar的add和set方法
        c.add(Calendar.YEAR, 9);//对指定的字段进行加或减
        c.add(Calendar.MONTH, -2);
        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)));

        System.out.println("----------------------");
        c.set(Calendar.YEAR, 3016);//对相应的字段进行修改
        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)));

        c.set(3017, 01, 01);//修改年月日，也可以改年月日时分秒
        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，星期六是第七天，索引是7，索引0空着
    public static String getWeek(int week) 
        String[] arr = "","星期日","星期一","星期二","星期三","星期四","星期五","星期六";
        return arr[week];
    

    写成2016年07年18日星期一，如果月和日时<=9的数，前面就补0
    public static String getNum(int num) 
        return num > 9 ? "" + num : "0" + num;//返回值是String，所以中间用“” + num

2. 如何获取任意年份是平年还是闰年

package com.geekds.otherclass;

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

public class Averageyear_Leapyear 

    /**
     * 判断是闰年还是平年
     */
    public static void main(String[] args) 
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.println("Please input year:");
        String line = sc.nextLine();
        int i = Integer.parseInt(line);
        boolean b = getYear(i);

        System.out.println(b);
    

    private static boolean getYear(int i) 
        // TODO Auto-generated method stub
        Calendar c = Calendar.getInstance();
        c.set(i, 2, 1); //设置时间为这年的3月1日
        c.add(Calendar.DAY_OF_MONTH, -1);//将时间减1天得到2月的最后一天
        return c.get(Calendar.DAY_OF_MONTH) == 29;

以上是关于Java基础14----正则表达式Math类System类BigInteger日期类的主要内容，如果未能解决你的问题，请参考以下文章

Java学习总结——（常用类，正则表达式，集合(List，Set) 迭代器）

前端（十四）—— JavaScript基础：NumberDate类字符串数组Math类正则

Java基础17-随机数正则表达式

java -- MathBigIntegerBigDecimal类和基本类型的包装类正则表达式

CALL/APPLY一些编程基础以及一些基础知识正则

JAVA-基础-常用API(StringBuffer类,正则表达式)