java-日期时间及正则表达式

日期时间

java.util包提供了Date类来封装当前的日期和时间。 Date类提供两个构造函数来实例化Date对象。
第一个构造函数使用当前日期和时间来初始化对象。

Date( )

第二个构造函数接收一个参数，该参数是从1970年1月1日起的微秒数。

Date(long millisec)

实例：

Date d = new Date();
System.out.print(d.toString());
//Fri May 22 09:17:12 CST 2015

创建test类，创建Date对象，打印当前时间

格式化日期

SimpleDateFormat是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat允许你选择任何用户自定义日期时间格式来运行

实例:

      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
      System.out.println("Current Date: " + ft.format(dNow));
      //Current Date: 2015-05-22 09:29:48

printf方法可以很轻松地格式化时间和日期。使用两个字母格式，它以t开头并且以下面表格中的一个字母结尾.

     // 初始化 Date 对象
     Date date = new Date();
     // 使用toString()显示日期和时间
     String str = String.format("Current Date/Time : %tc", date );
     System.out.printf(str);

printf：日期和时间转换字符

字符    描述    
c    完整的日期和时间
F    ISO 8601 格式日期
D    U.S. 格式日期 (月/日/年)
T    24小时时间
r    12小时时间
R    24小时时间，不包含秒
Y    4位年份(包含前导0)
y    年份后2位(包含前导0)
C    年份前2位(包含前导0)
B    月份全称
b    月份简称
n    2位月份(包含前导0)
d    2位日子(包含前导0)
e    2位日子(不包含前导0)
A    星期全称
a    星期简称
j    3位年份(包含前导0)
H    2位小时(包含前导0), 00 到 23
k    2位小时(不包含前导0),  0 到 23
I    2位小时(包含前导0), 01 到 12
l    2位小时(不包含前导0),  1 到 12
M    2位分钟(包含前导0)
S    2位秒数(包含前导0)
L    3位毫秒(包含前导0)
N    9位纳秒(包含前导0)
P    大写上下午标志
p    小写上下午标志
z    从GMT的RFC 822数字偏移
Z    时区
s    自 1970-01-01 00:00:00 GMT的秒数
Q    自 1970-01-01 00:00:00 GMT的毫妙

正则表达式概念

正则表达式定义了字符串的模式。
正则表达式可以用来搜索、编辑或处理文本。
正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。
Java正则表达式和Perl的是最为相似的。

java.util.regex包主要包括以下三个类：

Pattern类：
pattern对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个Pattern对象，你必须首先调用其公共静态编译方法，它返回一个Pattern对象。该方法接受一个正则表达式作为它的第一个参数。
 
Matcher类：
Matcher对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用Pattern对象的matcher方法来获得一个Matcher对象。
 
PatternSyntaxException：
PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。
例如，正则表达式(dog) 创建了单一分组，组里包含"d"，"o"，和"g"。
捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：
((A)(B(C)))
(A)
(B(C))
(C)
可以通过调用matcher对象的groupCount方法来查看表达式有多少个分组。groupCount方法返回一个int值，表示matcher对象当前有多个捕获组。
还有一个特殊的组（组0），它总是代表整个表达式。该组不包括在groupCount的返回值中。

实例：

      // 按指定模式在字符串查找
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";
      // 创建 Pattern 对象
      Pattern r = Pattern.compile(pattern);
      // 现在创建 matcher 对象
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
     //Found value: This order was placed for QT3000! OK?
     //Found value: This order was placed for QT300
     //Found value: 0
 
     //上述代码表示：0下标表示整串字符串，1下标表示最后一个数字0之前的字符串，2位表示最后一个数字，3位表示最后
     //一个数字之后的字符串

匹配规则

/    将下一字符标记为特殊字符、文本、反向引用或八进制转义符。
^    匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。
$    匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。
\S    匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
+    一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。
?    零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。
x|y    匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。
[xyz]    字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
[^xyz]    反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。
[a-z]    字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z]    反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。
\b    匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
\d    数字字符匹配。等效于 [0-9]。
\D    非数字字符匹配。等效于 [^0-9]。
\n    换行符匹配。等效于 \x0a 和 \cJ。
\r    匹配一个回车符。等效于 \x0d 和 \cM。
\w    匹配任何字类字符，包括下划线。 与"[A-Za-z0-9_]"等效。

更多匹配规则，请查阅Java 正则表达式相关文档。

Mather类的方法

1 public int start() 返回以前匹配的初始索引。
2 public int start(int group) 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
3 public int end() 返回最后匹配字符之后的偏移量
4 public int end(int group) 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。

实例：对单词"cat"出现在输入字符串中出现次数进行计数的例子

    private static final String REGEX = "\bcat\b";
    private static final String INPUT ="cat cat cat cattie cat";
    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // 获取 matcher 对象
       int count = 0;
       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }

replaceFirst 和replaceAll 方法

replaceFirst 和replaceAll 方法用来替换匹配正则表达式的文本。不同的是，replaceFirst 替换首次匹配，replaceAll 替换所有匹配。
实例:

    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";
 
    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
   //The cat says meow. All cats say meow.

appendReplacement 和 appendTail 方法

Matcher 类也提供了appendReplacement 和appendTail 方法用于文本替换：

看下面的例子来解释这个功能：

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
   //-foo-foo-foo-