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位为3、4、5、7、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      }