正则表达式、Calendar类、SimpleDateFormat类、Date类、BigDecimal类、BigInteger类、System类、Random类、Math类(Java基础知识十四)

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

* A:正则表达式(一个字符串，是规则)
    * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

* B:案例演示
    * 需求：校验qq号码。
        * 1:要求必须是5-15位数字
        * 2:0不能开头
        * 3:必须都是数字
    * a:非正则表达式实现
        * 困难重重 
    * b:正则表达式实现
        * String regex = "[1-9][\\d]{4,14}"; 
        * System.out.println("");

2.字符类演示

* 字符类
    * [abc] a、b 或 c（简单类）；[]代表单个字符
        * System.out.println("a".matches(regex)); //true
    * [^abc] 任何字符，除了 a、b 或 c（否定）;单个的字符，  
    * [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） ，也是单个的字符。
    * [0-9] 0到9的字符都包括。

3.预定义字符类演示

* 预定义字符类
    * . 任何字符。  ..  就代表任何俩个字符
    * \d 数字：[0-9]   
    * \D 非数字的单个字符： [^0-9] 
    * \w 单词字符：[a-zA-Z_0-9]  //所有字母、下划线、数字
    * \W 非单词字符: [^\w]
    * \s 空白字符： [ \t\n\x0B\f\r],前面有一个空格，“\t”制表符,“\n”换行符,"\f"翻页符,\r回车符
    * \S 非单词字符： [^\s]

4.数量词

* Greedy 数量词 
    * X? X，一次或一次也没有;最多一次，可以没有""
    * X* X，零次或多次；0到无穷多次
    * X+ X，一次或多次；一次到多次
    * X{n} X，恰好 n 次 
    * X{n,} X，至少 n 次 
    * X{n,m} X，至少 n 次，但是不超过 m 次

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

* String类的功能：public String[] split(String regex)
        * 按正则表达式的规则分割字符， 返回的是字符串数组。

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

需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
        package cn.it.cast.test;
        import java.util.Arrays;
        public class DemoSpilt {
        /**
         * 遍历一个字符串，里面全部是数字和空格，然后进行排序和重新打印
         */
        public static void main(String[] args) {
            String s = "11 22 55 88 77 55 33";
            String[] arr = s.split(" ");//里面是正则表达式
            int[] iArr = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                iArr[i] = Integer.parseInt(arr[i]);    //Integer类中的parseInt(str)方法，把数字字符串转换成整数类型。
            }
            Arrays.sort(iArr);//Arrays类是用来操作数组的，它中的方法都是静态，可以利用类名.直接调用。sort()方法是用来升序排列的。
            String s2 = iArr2String(iArr);
            System.out.println(s2);
        }
        public static String iArr2String(int[] arr){//int数组转换成字符串方法
            StringBuffer sb =new StringBuffer();
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]+" ");
            }
            String s = sb.toString();
            return s;
        　　｝
        }

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

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

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

* 正则表达式的分组功能
    * 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 
        1     ((A)(B(C))) 
        2     (A 
        3     (B(C)) 
        4     (C) 
        组零始终代表整个表达式。

a:切割
        需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
        public static void demo1() {
        String s = "abcdddefghhhhijkllllmnnnnopq";
        String regex = "(.)\\1+";
        String[] arr = s.split(regex);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            }
        }

        b:替换
        需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
        将字符串还原成:“我要学编程”。
        public static void demo2() {
        String s = "我我我......要...要....学....学学学.....编.....编编...程程..程...";
        String s2 = s.replaceAll("\\.+","" );
        String s3 = s2.replaceAll("(.)\\1", "$1");
        System.out.println(s3);
        }    

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();//尝试将整个区域与模式匹配。

            String regex = "[a-zA-Z]";
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher("c");
            boolean b = m.matches();
            System.out.println(b); //true 

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

* A:正则表达式的获取功能
    * Pattern和Matcher的结合使用
* B:案例演示
* 

        需求：把一个字符串中的手机号码获取出来
        String str = "我的iphone6手机的手机号是：14790082332，我的三星手机的手机号是：18812345678,我的华为的手机的手机号是：18709877890，我的蓝莓手机的手机号是：15623455432";
        String regex = "1[34578]\\d{9}";
        Pattern p = Pattern.compile(regex);//获取正则对象
        Matcher m = p.matcher(str);//获取匹配器
        //boolean b = m.matches();//将整个区域与模式匹配
        while(m.find()){
            system.out.println(m.group());
        }
        //Matcher类中的find()--尝试查找与该模式匹配的输入序列的下一个子序列。返回值类型为boolean
        //group()--返回由以前匹配操作所匹配的输入子序列。返回值类型为String

11.Math类概述和方法使用

* A:Math类概述
    * Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 
* B:成员方法
    * public static int abs(int a)  //取绝对值，返回值类型：参数是什么类型就返回什么类型
    * public static double ceil(double a) //12.33---->13.0，返回值类型：double
    * public static double floor(double a) //12.33---->12.0，返回值类型：double
    * public static int max(int a,int b) min自学 //，返回值类型：参数是什么类型的就返回什么类型的
    * public static double pow(double a,double b)//前面的数是底数，后面的数是指数，例如2^3，2的三次方，返回类型为double
    * public static double random() //0.0 -- 1.0之间的随机数，包含头不包含尾，返回类型为double
    * public static int round(float a) //参数为double的自学，就是四舍五入,返回类型为int
    * public static double sqrt(double a) //开平方，返回类型为double。

12.Random类的概述和方法使用

* A:Random类的概述
     * 使用时，需要导包，
    * 1.Random r = new Random();//无种子，返回随机的数
    *   System.out.println(r.nextInt());//输出的是：int范围内的随机数，
    *   System.out.println(r.nextInt(100));//输出的是：0-100之间的随机数，包含头不包含尾。
    * 2.Random r = new Random(1000);//有种子，
    *   System.out.println(r.nextInt());//输出的结果是：相同的在int范围内的随机数，利用循环，可以看出每次结果都相同，
    *   System.out.println(r.nextInt(10));//输出的结果：0-10中的随机数，每次结果也都相同。
    * 此类用于产生随机数，如果用相同的种子创建两个 Random 实例（对象），
    * 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
* B:构造方法
    * public Random()
    * public Random(long seed)
* C:成员方法
    * public int nextInt()       //输出int范围的随机数，不能超过其范围
    * public int nextInt(int n)  //重点掌握，输出0-n中的随机数，包含头不包含尾

13.System类的概述和方法使用

* A:System类的概述
    * System 类包含一些有用的类字段和方法。它不能被实例化（即不能被创建对象），它中的方法全可以用类名.调用。 
* B:成员方法
    * public static void gc() //运行垃圾回收器。
    * public static void exit(int status) //终止当前正在运行的 Java 虚拟机。
    * public static long currentTimeMillis() //返回以毫秒为单位的当前时间。可以计算某个程序执行所需的时间。
* C:案例演示
    * System类的成员方法使用
    * 直接用类名.调用。

14.BigInteger类的概述和方法使用

* A:BigInteger的概述
    * 可以让超过Integer范围内的数据进行运算，
    * BigInteger b = new BigInteger("12345");//创建对象并赋值
* 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)得到 商和余数，放入数组中。

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)//除，如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。
* D:案例演示
    * BigDecimal类的构造方法和成员方法使用
    * BigDecimal b3 = new BigDecimal(2.1);
        * 开发用下面的： 
    * 1.BigDecimal b3 = new BigDecimal("2.1");
    * 2.BigDecimal b5 = BigDecimal.valueOf(2.1);//valueOf()是静态方法，可以用类名.调用。

16.Date类的概述和方法使用

* A:Date类的概述
    * 类 Date 表示特定的瞬间，精确到毫秒。 
    * 1.Date d1 = new Date();//创建当前时间对象
    *   System.out.println(d1);//结果是：Mon Mar 23 00:31:12 CST 2015，获取当前时间，
    * 2.Date d2 = new Date(1000);//根据指定的毫秒值创建时间对象，
    *   System.out.println(d2);//结果是：Thu Jan 01 08:00:01 CST 1970，分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
* B:构造方法
    * public Date()//当前的时间
    * public Date(long date)//毫秒值+1970年的时间
* C:成员方法
    * public long getTime()//获取当前时间的毫秒值
    * public void setTime(long time)//设置当前时间的毫秒值
        * 获取当前时间对象的毫秒值得俩种方法：
    * 1.System.out.println(d1.getTime());
    * 2.System.out.println(System.currentTimeMillis());

17.SimpleDateFormat类实现日期和字符串的相互转换

* A:DateFormat类的概述
    * DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
    * format(Date d)方法将一个 Date 格式化为日期/时间字符串。参数为Date 类型，
    * 
    * 把时间对象转换成字符串：
    * Date d1 = new Date();//创建当前时间对象，
    * 1.DateFormat df = DateFormat.getDateInstance();//返回DateFormat的子类对象,标准格式
    *     System.out.println(df.format(d1));//2015-3-23，
    *     
    * 2.SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
    *    System.out.println(sdf.format(d1));//2015年03月23日10:06:48
    * 把字符串转换成时间对象：
    * String str = "2015年3月23日10:22:32";
    * SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
    * Date d = sdf.parse(str);//把字符串转换成对应日期对象
    * System.out.println(d);//Mon Mar 23 10:22:32 CST 2015    
* B:SimpleDateFormat构造方法
    * public SimpleDateFormat()
    * public SimpleDateFormat(String pattern)
* C:成员方法
    * public final String format(Date date)
    * public Date parse(String source)//从给定字符串的开始解析文本，以生成一个日期。

18.日期工具类的编写和测试案例

1.日期工具类的编写
        package cn.itcast.kind;
        import java.text.ParseException;
        import java.text.SimpleDateFormat;
        import java.util.Date;
        public class DemoUtil {
            private DemoUtil(){};
        /*
         * 把时间对象转换成字符串；
         * 返回值类型：String
         * 参数列表：Date d ,String format();
         * */
        public static String date2String(Date d,String format){
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            return sdf.format(d);
        }
        /*
         * 把字符串转换成时间对象
         * 返回值类型：Date
         * 参数列表：String str , String format
         * */
        public static Date string2Date(String str,String format) throws     ParseException{
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            return sdf.parse(str);
            }
        }
        2.日期工具类的测试
        package cn.it.cast.test;
        import java.text.ParseException;
        import java.util.Date;
        import cn.itcast.kind.DemoUtil;
        public class UtilDemo {
            public static void main(String[] args) throws ParseException {
                Date d = new Date();
                String str = DemoUtil.date2String(d, "yyyy年MM月dd日");
                System.out.println(str);

                String str1 = "2015年3月23日";
                Date d1 = DemoUtil.string2Date(str1, "yyyy年MM月dd日");
                System.out.println(d1);
            }
        }

19.你来到这个世界多少天案例

需求：算一下你来到这个世界多少天?
        public static void main(String[] args) throws ParseException {
        //1,定义两个字符串,分别是出生那天和今天
            String birthday = "1992年5月4日";
            String today = "2015年3月22日";
        //2,将字符串转换成日期对象
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
            Date d1 = sdf.parse(birthday);
            Date d2 = sdf.parse(today);
        //3,求出时间对象的毫秒值,相减
            long time = d2.getTime() - d1.getTime();
            long day = time / 1000 / 60 / 60 / 24;
            System.out.println(day);
        }

20.Calendar类的概述和获取日期的方法

* A:Calendar类的概述
    * Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
* B:成员方法
    * public static Calendar getInstance()
        * Calendar c = Calendar.getInstance();//创建子类对象，因为父类不能被实例化
    * public int get(int field)

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

* A:成员方法
    * public void add(int field,int amount)
    * public final void set(int year,int month,int date)//设置年月日的值
* B:案例演示
    * Calendar类的成员方法使用

22.如何获取任意年份的2月份有多少天

需求：键盘录入任意一个年份，获取任意一年的二月有多少天
        package cn.it.cast.test;
        import java.util.Calendar;
        public class DemoCalendar {
            public static void main(String[] args) {
            System.out.println(getNumber(2015));
            System.out.println(getYear(2014));
            }
        /**
         * 获取某年的2月多少天
         * 1,返回值类型,int类型
         * 2,参数列表,int year
         */
        public static int getNumber(int year){
            Calendar c = Calendar.getInstance();
            c.set(year, 2,1);
            c.add(Calendar.DAY_OF_MONTH, -1);
            return c.get(Calendar.DAY_OF_MONTH);
        }
        /**
         * 获取某年是否是闰年
         * 1,返回值类型,boolean类型
         * 2,参数列表,int year
         */
        public static boolean getYear(int year){
            Calendar c = Calendar.getInstance();
            c.set(Calendar.DAY_OF_MONTH,2,1);
            if (c.get(Calendar.DAY_OF_MONTH)==28){
                return true;
            }else{
                return false;
            }
          }
        }