Date-DateFormat-Calendar-Math-regex

一.Date类(java.util)
作用:表示时间的类,精确到毫秒,以GMT 1970年1月1日0点0分0秒起算
构造方法:
     Data() ---获取当前时间
     Date(long time)---计算时间,结果为=time+GMT 1970年1月1日0点0分0秒
     注:1s = 1000ms
成员方法:
     getTime():返回long类型,返回自起始时间至设定时间的毫秒数;
     setTime(long time):无返回值,使用给定的时间创建时间对象;
代码1:
  

  import java.util.Date;
     import java.text.DateFormat;
     public class DateDemo{
         public static void main(String[] args){
             //利用有参构造方法设定时间:从起始时间加1s
             Date date = new Date(1000);
             System.out.println(date); //8:00:01

             //利用setTime设定时间:从起始时间加1s
             date.setTime(1000); //8:00:01  问题:为什么不是8:00:02?
             System.out.println(date);

             //利用getTime返回时间.返回值为传入的时间与起始时间差的毫秒数
            long n = date.getTime();
             System.out.println(n);
         }
     }

代码2:
//需求:返回当前时间,并计算其与起始时间的差值(以毫秒为单位)
   

 import java.util.Date;
     import java.text.DateFormat;
     public class DateDemo{
         public static void main(String[] args){
             //利用无参构造得到当前时间
            Date date = new Date();
             System.out.println(date);
             //利用getTime()方法返回与起始时间的差值
            long n = date.getTime();
             System.out.println(n);
         }
     }

二.DateFormat类(java.text) 
简介:抽象类,有4个静态方法(不含重载),可由类直接调用.如果需要处理时间需创建子类(SimpleDateFormat)
作用:格式化并解析日期/时间.完成字符串与日期之间的转换(日期-->文本,文本-->日期)

成员方法:
     format(Date date):返回String类型,把日期转换成字符串;
     parse(String sourece):返回Date类型,字符串转换为日期;
    
     静态方法:
         getAvailableLocable()
         getDateInstance()
         getDateTimeInstance()
         getTimeInstance()
代码1:
//format练习--需求:获取系统当前时间,并以"年-月-日"的形式输出
    

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

     public class TimeTest{
         public static void main(String[] args){
             //获取当前时间
            Date date = new Date();
             //设定日期格式--字符串形式
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
             //将当前日期格式化为设定的格式---字符串(日期-->字符串)
             String dateStr = df.format(date);
             //输出
            System.out.println(dateStr);
         }
     }

代码2:
//parse练习--字符串转为日期
   

 import java.util.Date;
     import java.text.DateFormat;
     import java.text.SimpleDateFormat;
     import java.text.ParseException;
     public class DateDemo{
         public static void main(String[] args){
             //定义日期(字符串形式):2017-09-09 12:38:45
             String myDate = "2017-09-09 12:38:45";

             //利用SimpleDateFormat构造方法,设定参数为需要解析的格式
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             //调用parse()方法解析字符串为日期格式
            Date date = null;
             //需捕获ParseException异常,防止用户输入的与指定格式不符
            try{
                 date = df.parse(myDate);    //parse()返回date类型
            }catch(ParseException pe){    //捕获异常时需要导包!!!!
                 System.out.println("日期格式与指定格式不符!");
             }
             System.out.println(date);
         }
     }

代码3:
//利用parse和format将用户输入的字符串以'x年x月x日'的形式输出
   

 import java.util.Date;
     import java.text.DateFormat;
     import java.text.SimpleDateFormat;
     import java.text.ParseException;
     public class DateDemo{
         public static void main(String[] args){
             //定义日期(字符串形式):2017-09-09 12:38:45
             String myDate = "2017-09-09 12:38:45";

             //利用parse解析为日期格式,参数为需要解析的格式
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             Date date = null;
             try{
                 date = df.parse(myDate);    //parse()返回date类型
            }catch(ParseException pe){    //捕获异常时需要导包!!!!
                 System.out.println("日期格式与指定格式不符!");
                 pe.printStackTrace();
             }

             //转换为'xxx年xx月'的形式输出
            DateFormat df1 = new SimpleDateFormat("yyyy年MM月dd日");
             String myDateCov = df1.format(date);
             System.out.println(myDateCov);

             /*思考:以上转换方式为:输入的字符串---parse()为系统标准日期格式---format()成所需要显示的格式.
             也许可以通过字符串的的替换操作(是不是可以用regex)来完成?*/
         }
     }

三.Calendar类(java.util)
简介:抽象类,含静态方法,需使用子类对象处理日历.可通过其中的静态方法得到子类对象
定义:public abstract class Calendar extends Object implements Serializable, Cloneable, Comparable<Calendar>{}
子类:GregorianCalendar
作用:
初始化:利用静态方法创建对象 Calendar c = Calendar.getInstance();(返回当前时间,以java.util.GregorianCalendar开头的一大串字符..)
常量(field):
     public static final int YEAR :取得年
     public static final int MONTH :取得月
     public static final int DAY_OF_MONTH :取得日
     public static final int HOUR_OF_DAY :取得小时
     public static final int MINUTE : 取得分
     public static final int SECOND :取得秒
     public static final int MILLISECOND :取得毫秒
成员方法:
     public static Calendar getInstace() : 根据默认时区实例化对象
     public int get(int field):返回给定日历字段的值
     public abstract void add(int field, int amount):为给定的日历字段添加或减去指定的时间量
     public date getTime():获取该日历对象转成的日期对象
     public void set(int field, int value):设置指定字段的值
代码:
    

import java.util.Calendar;
     import java.util.Date;
     public class DateDemo{
         public static void main(String[] args){
             //实例化对象
            Calendar rightNow = Calendar.getInstance();
             //System.out.println(rightNow);

             //getTime()获取日期
            Date myDate = rightNow.getTime();
             System.out.println(myDate);

             //get(int field)返回年份/月份
            int year = rightNow.get(Calendar.YEAR);
             System.out.println(year);
             int mon = rightNow.get(Calendar.MONTH)+1;    //注意:0-11表示12个月,所以需加1才可返回真实月份
            System.out.println(mon);

             //set()设定指定字段的值
            rightNow.set(Calendar.YEAR,2010);
             System.out.println(rightNow.get(Calendar.YEAR));

             rightNow.set(2012,02,02);//2012年3月2号
            System.out.println(rightNow.getTime());
         }
     }

四.System类(java.lang)
定义:public final class System extends Object{}; System类中所有的属性和方法都是静态的,可由类名直接调用
属性: in out err
方法:
public static void exit(int status): 系统退出,0表示正常退出;非0为非正常退出
public static long currentTimeMillis(): 返回以毫秒为单位的当前时间
public static void arraycopy(Object src(源数组名称), int srcPos(源数组开始点), Object dest(目标数组名称), int destPos(目标数组开始点), int length):复制数组
public static Properties getProperties():取得当前系统的全部属性
代码:
//需求:复制数组arraycopy

import java.util.Arrays;
 public class ArrayCopyDemo{
     public static void main(String[] args){
         int[] i = {3,4,78,23};
         int[] i2 = {2,2,3,4,5};
         System.arraycopy(i,1,i2,1,2); //注意目标数组的长度
        for(int j = 0;j<i2.length;j++){
             System.out.print(i2[j]+"	");
         }
         System.out.println("
"+Arrays.toString(i2));

    }
 }

//需求:取得系统属性值并计算程序计算耗时

import java.util.Arrays;
 public class ProgramTime{
     public static void main(String[] args){
         //输出系统全部属性值
        System.out.println(System.getProperties());//注意getProperties()复数形式获取所有
        //输出java相关的系统属性值
        System.out.println(System.getProperty("java.version"));//getProperty()单数形式获取指定键记录的系统属性
        //记录系统当前时间
        long start = System.currentTimeMillis();
         //运行程序
        double[] i = new double[1000];
         for(int k = 0; k<i.length;k++){
             i[k]=Math.pow(2,k); //使用Math函数,需由Math调用
        }
         System.out.println(Arrays.toString(i));
         //记录程序结束时系统时间
        long end = System.currentTimeMillis();
         //输出程序运行的时间
        System.out.println("耗时:"+(end-start));
     }
 }

五.Math类(java.lang)
静态方法:
abs():取绝对值,返回值类型由参数(int long double float)决定;
ceil(double a):向上取整,比参数大的最小整数,返回double类型;

floor(double a):向下取整,比参数小的最大整数,返回double类型;
floorDiv():地板除,对于商向下取整;返回值类型由参数(int long)决定;需捕获AirthMeticException;java8新特性
floorMod():地板模,对于模向下取整;返回值类型由参数(int long)决定;需捕获AirthMeticException;java8新特性(感觉跟%运算一样,不晓得为什么增加这个功能);

max():比较两个 double/float/int/long 类型,并返回最大值
min():比较两个 double/float/int/long 类型,并返回最小值
pow(double a,double b):a的b次幂,返回double类型
random():得到0.0-1.0之间的随机小数,不包含1.0,无参数,返回double类型;
round():四舍五入,参数为double,返回long;参数为float,返回int;

代码:
   

 import java.util.Random;
     public class MathDemo{
         public static void main(String[] args){
             //floorDiv()对于商向下取整,可传入int/long两种类型
            int a = 3;
             int b =10;
             int c = Math.floorDiv(a,b);
            System.out.println(c);//0

             //floor():向下取整,仅支持double类型
            System.out.println(Math.floor(Math.floorDiv(3,10)));//0.0 //发生了隐式转换Math.floorDiv(3,10)返回int类型

             //floorMod()对于模数向下取整,可传入int/long两种类型
            System.out.println(Math.floorMod(4,3));//1
             System.out.println(4%3);//1

             //max()/min()返回两个数中较大/较小的, int long float double
             System.out.println(Math.max(3.0,5.3));//5.3
             System.out.println(Math.min(3.0,5.3));//3.0

             //pow(double a, double b)返回double类型
            System.out.println(Math.pow(3.0,3.0));//27.0

             //random()-产生0-1之间的随机数,double类型的,不包含1
             System.out.println(Math.random());

             //利用java.util.Random类产生三个1-100(含100)的随机数
            Random r = new Random();
             for(int j = 0; j<3; j++){
                 int i =    r.nextInt(100)+1;//r.nextInt(100)产生0-99的数
                System.out.print(i+"	");
             }

             //round():参数为double,返回long;参数为float,返回int
             System.out.println("
=====================");
             System.out.println(Math.round(Math.random()*100));

         }
     }

    
六.包装类
1.字符串转为基本类型:
Boolen类:String-->boolean,利用Boolean类中的public static Boolen parseBoolean(String s)静态方法
Byte类:public static Byte parseByte(String s)
Character类:无解析方法
Double类:public static Double parseDouble(String s)
Float类:public static Float parseFloat(String s)
Integer类:public static Integer parseInt(String s) 字符串转为数字时,字符串内容必须全为数字,不能包含空格及其它
Long类:public static Long parseLong(String s)
Short类:public static Short parseShort(String s)

代码:
//需求:将字符串转为各基本类型
    

public class StringDemo{
         public static void main(String[] args){
             //定义字符串"100",利用parseInt()解析为int值
            String str1 = "100";
             try{
                 int in = Integer.parseInt(str1);
                 System.out.println("字符串转为整型:"+in);
                 System.out.println("字符串转为byte型:"+Byte.parseByte(str1));
             }catch(NumberFormatException e) {
                 System.out.println("数字格式有问题!");
                 e.printStackTrace();
             }

             //定义字符串"3.14",利用parseDouble()解析为double类型
            String str2 = "3.14";
             double dou = Double.parseDouble(str2);    //do为关键字!!
             System.out.println("字符串转为双精度浮点型:"+dou);
             System.out.println("字符串转为单精度浮点型"+Float.parseFloat(str2));

             //定义字符串"true",利用parseBoolean()转为布尔型
            String str3 = "true";
             System.out.println("字符串转为布尔型:"+Boolean.parseBoolean(str3));
         }
     }

   
    

七.正则表达式(java.util.regex)
java提供了java.util.regex包,包含了Matcher和Pattern两个类,供开发人员使用.java中具体的表达式操作类是通过这两个类来完成的.
Matcher类:
     定义: public final class Matcher extends Object implements MatchResult{}
     常用方法:
     public boolean matches()--执行验证;
     public String replaceAll(String replacement)--字符串替换
Pattern类:
     定义:public final class Pattern extends Object implements Serializable{}
     常用方法:
     public static Pattern compile(String regex)--指定正则规则(要取得Pattern类实例,必须调用compile方法)
     public Matcher matcher(charsequence input)--返回Matcher类实例
     public String[] split(charsequence input)--字符串拆分
代码1:
//需求:验证日期是否合法:
//规则:类似1983-09-06.年份第一个数必须为1,年月日之间用"-"连接

import java.util.regex.Pattern;
 import java.util.regex.Matcher;
 public class RegexDemo01{
     public static void main(String[] args){
         checkDate("1989-09-09");
         checkDate("0989-09-09");

    }
     public static void checkDate(String  str){
         //定义验证规则,并实例化Pattern对象
        Pattern p = Pattern.compile("1\d{3}-\d{2}-\d{2}");
         //验证传入的字符串是否合法
        Matcher m = p.matcher(str);
         //执行验证
        if(m.matches()){
             System.out.println("日期合法~");
         }else{
             System.out.println("日期非法!");
         }
     }
 }

代码2:
//需求:验证手机号是否合法:
//验证手机号是否合法:
//规则:1：要求为11位数字;2：第1位为1，第2位为3、4、5、7、8中的一个，后面9位为0到9之间的任意数字。

import java.util.regex.Pattern;
 import java.util.regex.Matcher;
 public class RegexDemo02{
     public static void main(String[] args){
         checkPhoneNum("123456789009");
         checkPhoneNum("18920172017");
     }
     //定义checkPhoneNum方法
    public static void checkPhoneNum(String str){
         //定义验证规则,并实例化Pattern对象
        Pattern p = Pattern.compile("1[34578]\d{9}");
         //调用Pattern的matcher()方法,验证传入的字符串是否符合规则
        Matcher m = p.matcher(str);
         //调用Matcher的matches()方法执行验证,并输出验证结果
        if(m.matches()){
             System.out.println("手机号正确~");
         }else{
             System.out.println("手机号不正确!");
         }
     }
 }

代码3:
//需求:验证QQ号是否合法
//规则:1:要求必须是5-15位数字;2:0不能开头

import java.util.regex.Pattern;
 import java.util.regex.Matcher;
 public class RegexDemo03{
     public static void main(String[] args){
         checkQ("77202604");
         checkQ("07202604");
     }
     //定义checkQ方法
    public static void checkQ(String str){
         Matcher m = Pattern.compile("[^0]\d{4,14}").matcher(str);
         if(m.matches()){
             System.out.println("QQ号正确");
         }else{
             System.out.println("qq号错误");
         }

    }
 }

代码4:
//需求:验证邮箱是否合法

import java.util.regex.*;
 public class RegexDemo04{
     public static void main(String[] args){
         //定义一个字符串集合,用来存储电子邮件地址
        String[] mails = {"www@yahoo.com","huguangqin@163.com","laohu@tj.edu.cn"};
         //定义正则
        Pattern p = null;
         try{
             p = Pattern.compile("\w{3,20}@\w+\.(com|org|net|cn|gov)");
         }catch(PatternSyntaxException pse){
             System.out.println("正则表达式脚本错误!");
         }
         Matcher matcher = null;
         for(String mail : mails){
             if(matcher == null){
                 matcher = p.matcher(mail);
             }else{
                 matcher.reset(mail);
             }
         String result = mail + (matcher.matches()?"是":"不是")+"一个有效的电子邮件!";
         System.out.println(result);
         }
     }
 }

String类(java.lang)对正则的支持:包括三个方法
     public String replaceAll(String regex, String replacement){}
     public String replaceFirst(String regex, String replacement){}
     public String[] split(String regex){}
     public String[] split(String regex, int limit){}
     public Boolean matches(String regex){}

代码5:
//字符串拆分和替换
   

 import java.util.regex.PatternSyntaxException;
     public class RegexDemo08{
         public static void main(String[] args){
             String str1 = "A1B22C333D4444E55555F";
             String regexStr = null;//如果try块以外要用到该变量,必须定义在外面
            try{
             //rplaceAll()--把所有的数字替换为"_"
             System.out.println(str1.replaceAll("\d+","_"));
             //replaceFirst()--把第一次出现的数字+字母替换为"@"
             System.out.println(str1.replaceFirst("[0-9][a-zA-Z]","@"));
             //matches--匹配,返回布尔值
            System.out.println("1989.07.10".matches("\d{4}\.\d{2}\.[0-9]{2}"));//true
             //split()--通过字母分割开
            regexStr = "[a-zA-Z]+";
             }catch(PatternSyntaxException e){
                 System.out.println("正则脚本有误");
                 e.printStackTrace();
             }
             String[] str2 = str1.split(regexStr);
             for(int i = 0; i < str2.length; i++){    //字符串数组也是数组,数组只具有length属性,而非length()方法
                System.out.print(str2[i]+"	");
             }
         }
     }