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:
  

  1   import java.util.Date;
  2      import java.text.DateFormat;
  3      public class DateDemo{
  4          public static void main(String[] args){
  5              //利用有參構造方法設定時間:從起始時間加1s
  6              Date date = new Date(1000);
  7              System.out.println(date); //8:00:01
  8 
  9              //利用setTime設定時間:從起始時間加1s
 10              date.setTime(1000); //8:00:01  問題:爲何不是8:00:02?
 11              System.out.println(date);
 12 
 13              //利用getTime返回時間.返回值爲傳入的時間與起始時間差的毫秒數
 14             long n = date.getTime();
 15              System.out.println(n);
 16          }
 17      }

代碼2:
//需求:返回當前時間,並計算其與起始時間的差值(以毫秒爲單位)
   

  1  import java.util.Date;
  2      import java.text.DateFormat;
  3      public class DateDemo{
  4          public static void main(String[] args){
  5              //利用無參構造獲得當前時間
  6             Date date = new Date();
  7              System.out.println(date);
  8              //利用getTime()方法返回與起始時間的差值
  9             long n = date.getTime();
 10              System.out.println(n);
 11          }
 12      }

二.DateFormat類(java.text) 
簡介:抽象類,有4個靜態方法(不含重載),可由類直接調用.若是須要處理時間需建立子類(SimpleDateFormat)
做用:格式化並解析日期/時間.完成字符串與日期之間的轉換(日期-->文本,文本-->日期)

成員方法:
     format(Date date):返回String類型,把日期轉換成字符串;
     parse(String sourece):返回Date類型,字符串轉換爲日期;
    
     靜態方法:
         getAvailableLocable()
         getDateInstance()
         getDateTimeInstance()
         getTimeInstance()
代碼1:
//format練習--需求:獲取系統當前時間,並以"年-月-日"的形式輸出
    

  1 import java.util.Date;
  2      import java.text.DateFormat;
  3      import java.text.SimpleDateFormat;
  4 
  5      public class TimeTest{
  6          public static void main(String[] args){
  7              //獲取當前時間
  8             Date date = new Date();
  9              //設定日期格式--字符串形式
 10             DateFormat df = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
 11              //將當前日期格式化爲設定的格式---字符串(日期-->字符串)
 12              String dateStr = df.format(date);
 13              //輸出
 14             System.out.println(dateStr);
 15          }
 16      }

代碼2:
//parse練習--字符串轉爲日期
   

  1  import java.util.Date;
  2      import java.text.DateFormat;
  3      import java.text.SimpleDateFormat;
  4      import java.text.ParseException;
  5      public class DateDemo{
  6          public static void main(String[] args){
  7              //定義日期(字符串形式):2017-09-09 12:38:45
  8              String myDate = "2017-09-09 12:38:45";
  9 
 10              //利用SimpleDateFormat構造方法,設定參數爲須要解析的格式
 11             DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 12              //調用parse()方法解析字符串爲日期格式
 13             Date date = null;
 14              //需捕獲ParseException異常,防止用戶輸入的與指定格式不符
 15             try{
 16                  date = df.parse(myDate);    //parse()返回date類型
 17             }catch(ParseException pe){    //捕獲異常時須要導包!!!!
 18                  System.out.println("日期格式與指定格式不符!");
 19              }
 20              System.out.println(date);
 21          }
 22      }

代碼3:
//利用parse和format將用戶輸入的字符串以'x年x月x日'的形式輸出
   

  1  import java.util.Date;
  2      import java.text.DateFormat;
  3      import java.text.SimpleDateFormat;
  4      import java.text.ParseException;
  5      public class DateDemo{
  6          public static void main(String[] args){
  7              //定義日期(字符串形式):2017-09-09 12:38:45
  8              String myDate = "2017-09-09 12:38:45";
  9 
 10              //利用parse解析爲日期格式,參數爲須要解析的格式
 11             DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 12              Date date = null;
 13              try{
 14                  date = df.parse(myDate);    //parse()返回date類型
 15             }catch(ParseException pe){    //捕獲異常時須要導包!!!!
 16                  System.out.println("日期格式與指定格式不符!");
 17                  pe.printStackTrace();
 18              }
 19 
 20              //轉換爲'xxx年xx月'的形式輸出
 21             DateFormat df1 = new SimpleDateFormat("yyyy年MM月dd日");
 22              String myDateCov = df1.format(date);
 23              System.out.println(myDateCov);
 24 
 25              /*思考:以上轉換方式爲:輸入的字符串---parse()爲系統標準日期格式---format()成所須要顯示的格式.
 26              也許能夠經過字符串的的替換操做(是否是能夠用regex)來完成?*/
 27          }
 28      }

三.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):設置指定字段的值
代碼:
    

  1 import java.util.Calendar;
  2      import java.util.Date;
  3      public class DateDemo{
  4          public static void main(String[] args){
  5              //實例化對象
  6             Calendar rightNow = Calendar.getInstance();
  7              //System.out.println(rightNow);
  8 
  9              //getTime()獲取日期
 10             Date myDate = rightNow.getTime();
 11              System.out.println(myDate);
 12 
 13              //get(int field)返回年份/月份
 14             int year = rightNow.get(Calendar.YEAR);
 15              System.out.println(year);
 16              int mon = rightNow.get(Calendar.MONTH)+1;    //注意:0-11表示12個月,因此需加1纔可返回真實月份
 17             System.out.println(mon);
 18 
 19              //set()設定指定字段的值
 20             rightNow.set(Calendar.YEAR,2010);
 21              System.out.println(rightNow.get(Calendar.YEAR));
 22 
 23              rightNow.set(2012,02,02);//2012年3月2號
 24             System.out.println(rightNow.getTime());
 25          }
 26      }

四.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

  1 import java.util.Arrays;
  2  public class ArrayCopyDemo{
  3      public static void main(String[] args){
  4          int[] i = {3,4,78,23};
  5          int[] i2 = {2,2,3,4,5};
  6          System.arraycopy(i,1,i2,1,2); //注意目標數組的長度
  7         for(int j = 0;j<i2.length;j++){
  8              System.out.print(i2[j]+"\t");
  9          }
 10          System.out.println("\n"+Arrays.toString(i2));
 11 
 12     }
 13  }
 14 

//需求:取得系統屬性值並計算程序計算耗時

  1 import java.util.Arrays;
  2  public class ProgramTime{
  3      public static void main(String[] args){
  4          //輸出系統所有屬性值
  5         System.out.println(System.getProperties());//注意getProperties()複數形式獲取全部
  6         //輸出java相關的系統屬性值
  7         System.out.println(System.getProperty("java.version"));//getProperty()單數形式獲取指定鍵記錄的系統屬性
  8         //記錄系統當前時間
  9         long start = System.currentTimeMillis();
 10          //運行程序
 11         double[] i = new double[1000];
 12          for(int k = 0; k<i.length;k++){
 13              i[k]=Math.pow(2,k); //使用Math函數,需由Math調用
 14         }
 15          System.out.println(Arrays.toString(i));
 16          //記錄程序結束時系統時間
 17         long end = System.currentTimeMillis();
 18          //輸出程序運行的時間
 19         System.out.println("耗時:"+(end-start));
 20      }
 21  }

五.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;

代碼:
   

  1  import java.util.Random;
  2      public class MathDemo{
  3          public static void main(String[] args){
  4              //floorDiv()對於商向下取整,可傳入int/long兩種類型
  5             int a = 3;
  6              int b =10;
  7              int c = Math.floorDiv(a,b);
  8             System.out.println(c);//0
  9 
 10              //floor():向下取整,僅支持double類型
 11             System.out.println(Math.floor(Math.floorDiv(3,10)));//0.0 //發生了隱式轉換Math.floorDiv(3,10)返回int類型
 12 
 13              //floorMod()對於模數向下取整,可傳入int/long兩種類型
 14             System.out.println(Math.floorMod(4,3));//1
 15              System.out.println(4%3);//1
 16 
 17              //max()/min()返回兩個數中較大/較小的, int long float double
 18              System.out.println(Math.max(3.0,5.3));//5.3
 19              System.out.println(Math.min(3.0,5.3));//3.0
 20 
 21              //pow(double a, double b)返回double類型
 22             System.out.println(Math.pow(3.0,3.0));//27.0
 23 
 24              //random()-產生0-1之間的隨機數,double類型的,不包含1
 25              System.out.println(Math.random());
 26 
 27              //利用java.util.Random類產生三個1-100(含100)的隨機數
 28             Random r = new Random();
 29              for(int j = 0; j<3; j++){
 30                  int i =    r.nextInt(100)+1;//r.nextInt(100)產生0-99的數
 31                 System.out.print(i+"\t");
 32              }
 33 
 34              //round():參數爲double,返回long;參數爲float,返回int
 35              System.out.println("\n=====================");
 36              System.out.println(Math.round(Math.random()*100));
 37 
 38          }
 39      }

    
六.包裝類
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)

代碼:
//需求:將字符串轉爲各基本類型
    

  1 public class StringDemo{
  2          public static void main(String[] args){
  3              //定義字符串"100",利用parseInt()解析爲int值
  4             String str1 = "100";
  5              try{
  6                  int in = Integer.parseInt(str1);
  7                  System.out.println("字符串轉爲整型:"+in);
  8                  System.out.println("字符串轉爲byte型:"+Byte.parseByte(str1));
  9              }catch(NumberFormatException e) {
 10                  System.out.println("數字格式有問題!");
 11                  e.printStackTrace();
 12              }
 13 
 14              //定義字符串"3.14",利用parseDouble()解析爲double類型
 15             String str2 = "3.14";
 16              double dou = Double.parseDouble(str2);    //do爲關鍵字!!
 17              System.out.println("字符串轉爲雙精度浮點型:"+dou);
 18              System.out.println("字符串轉爲單精度浮點型"+Float.parseFloat(str2));
 19 
 20              //定義字符串"true",利用parseBoolean()轉爲布爾型
 21             String str3 = "true";
 22              System.out.println("字符串轉爲布爾型:"+Boolean.parseBoolean(str3));
 23          }
 24      }

   
    

七.正則表達式(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,年月日之間用"-"鏈接

  1 import java.util.regex.Pattern;
  2  import java.util.regex.Matcher;
  3  public class RegexDemo01{
  4      public static void main(String[] args){
  5          checkDate("1989-09-09");
  6          checkDate("0989-09-09");
  7 
  8     }
  9      public static void checkDate(String  str){
 10          //定義驗證規則,並實例化Pattern對象
 11         Pattern p = Pattern.compile("1\\d{3}-\\d{2}-\\d{2}");
 12          //驗證傳入的字符串是否合法
 13         Matcher m = p.matcher(str);
 14          //執行驗證
 15         if(m.matches()){
 16              System.out.println("日期合法~");
 17          }else{
 18              System.out.println("日期非法!");
 19          }
 20      }
 21  }
 22 

代碼2:
//需求:驗證手機號是否合法:
//驗證手機號是否合法:
//規則:1：要求爲11位數字;2：第1位爲1，第2位爲三、四、五、七、8中的一個，後面9位爲0到9之間的任意數字。

  1 import java.util.regex.Pattern;
  2  import java.util.regex.Matcher;
  3  public class RegexDemo02{
  4      public static void main(String[] args){
  5          checkPhoneNum("123456789009");
  6          checkPhoneNum("18920172017");
  7      }
  8      //定義checkPhoneNum方法
  9     public static void checkPhoneNum(String str){
 10          //定義驗證規則,並實例化Pattern對象
 11         Pattern p = Pattern.compile("1[34578]\\d{9}");
 12          //調用Pattern的matcher()方法,驗證傳入的字符串是否符合規則
 13         Matcher m = p.matcher(str);
 14          //調用Matcher的matches()方法執行驗證,並輸出驗證結果
 15         if(m.matches()){
 16              System.out.println("手機號正確~");
 17          }else{
 18              System.out.println("手機號不正確!");
 19          }
 20      }
 21  }

代碼3:
//需求:驗證QQ號是否合法
//規則:1:要求必須是5-15位數字;2:0不能開頭

  1 import java.util.regex.Pattern;
  2  import java.util.regex.Matcher;
  3  public class RegexDemo03{
  4      public static void main(String[] args){
  5          checkQ("77202604");
  6          checkQ("07202604");
  7      }
  8      //定義checkQ方法
  9     public static void checkQ(String str){
 10          Matcher m = Pattern.compile("[^0]\\d{4,14}").matcher(str);
 11          if(m.matches()){
 12              System.out.println("QQ號正確");
 13          }else{
 14              System.out.println("qq號錯誤");
 15          }
 16 
 17     }
 18  }
 19 

代碼4:
//需求:驗證郵箱是否合法

  1 import java.util.regex.*;
  2  public class RegexDemo04{
  3      public static void main(String[] args){
  4          //定義一個字符串集合,用來存儲電子郵件地址
  5         String[] mails = {"www@yahoo.com","huguangqin@163.com","laohu@tj.edu.cn"};
  6          //定義正則
  7         Pattern p = null;
  8          try{
  9              p = Pattern.compile("\\w{3,20}@\\w+\\.(com|org|net|cn|gov)");
 10          }catch(PatternSyntaxException pse){
 11              System.out.println("正則表達式腳本錯誤!");
 12          }
 13          Matcher matcher = null;
 14          for(String mail : mails){
 15              if(matcher == null){
 16                  matcher = p.matcher(mail);
 17              }else{
 18                  matcher.reset(mail);
 19              }
 20          String result = mail + (matcher.matches()?"是":"不是")+"一個有效的電子郵件!";
 21          System.out.println(result);
 22          }
 23      }
 24  }

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:
//字符串拆分和替換
   

  1  import java.util.regex.PatternSyntaxException;
  2      public class RegexDemo08{
  3          public static void main(String[] args){
  4              String str1 = "A1B22C333D4444E55555F";
  5              String regexStr = null;//若是try塊之外要用到該變量,必須定義在外面
  6             try{
  7              //rplaceAll()--把全部的數字替換爲"_"
  8              System.out.println(str1.replaceAll("\\d+","_"));
  9              //replaceFirst()--把第一次出現的數字+字母替換爲"@"
 10              System.out.println(str1.replaceFirst("[0-9][a-zA-Z]","@"));
 11              //matches--匹配,返回布爾值
 12             System.out.println("1989.07.10".matches("\\d{4}\\.\\d{2}\\.[0-9]{2}"));//true
 13              //split()--經過字母分割開
 14             regexStr = "[a-zA-Z]+";
 15              }catch(PatternSyntaxException e){
 16                  System.out.println("正則腳本有誤");
 17                  e.printStackTrace();
 18              }
 19              String[] str2 = str1.split(regexStr);
 20              for(int i = 0; i < str2.length; i++){    //字符串數組也是數組,數組只具備length屬性,而非length()方法
 21                 System.out.print(str2[i]+"\t");
 22              }
 23          }
 24      }