1、正则(了解)

1、基本的正则表达式(看懂即可)
字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
 [abc] a、b 或 c（简单类）
 
  1. String regex = "[abc]";	//[]代表单个字符
    2. 

  2. System.out.println("aa".matches(regex));//false,只限于单个字符
    3. 

  3. System.out.println("b".matches(regex));//true
    4. 

  4. System.out.println("c".matches(regex));//true
    5. 

  5. System.out.println("d".matches(regex));//false
    6. 

  6. System.out.println("1".matches(regex));//false
    7. 

  7. System.out.println("%".matches(regex));//false
 [^abc] 任何字符，除了 a、b 或 c（否定）
 
  1. String regex = "[^abc]";
    2. 

  2. System.out.println("a".matches(regex));//f
    3. 

  3. System.out.println("b".matches(regex));//f
    4. 

  4. System.out.println("c".matches(regex));//f
    5. 

  5. System.out.println("d".matches(regex));//t
    6. 

  6. System.out.println("1".matches(regex));//t
    7. 

  7. System.out.println("%".matches(regex));//t
    8. 

  8. System.out.println("10".matches(regex));//f 因为是两个字符
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
 
  1. String regex = "[a-zA-Z]";
    2. 

  2. System.out.println("a".matches(regex));//t
    3. 

  3. System.out.println("A".matches(regex));//t
    4. 

  4. System.out.println("z".matches(regex));//t
    5. 

  5. System.out.println("Z".matches(regex));//t
    6. 

  6. System.out.println("1".matches(regex));//f
    7. 

  7. System.out.println("%".matches(regex));//f
[0-9] 0到9的字符都包括
 
  1. String regex = "[0-9]";
    2. 

  2. System.out.println("8".matches(regex));//t




  1. System.out.println("a".matches(regex));//f
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
 
  1. String regex = "[a-d[m-p]]";
    2. 

  2. System.out.println("a".matches(regex));//t
    3. 

  3. System.out.println("m".matches(regex));//t
    4. 

  4. System.out.println("e".matches(regex));//f
[a-z&&[def]] d、e 或 f（交集）
 
  1. String regex = "[a-z&&[def]]";//取交集
    2. 

  2. System.out.println("a".matches(regex));//f
    3. 

  3. System.out.println("d".matches(regex));//t
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
 
  1. String regex = "[a-z&&[^bc]]";
    2. 

  2. System.out.println("a".matches(regex));//t
    3. 

  3. System.out.println("b".matches(regex));//f
    4. 

  4. System.out.println("1".matches(regex));//f
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
 
  1. String regex = "[a-z&&[^m-p]]";//a-z,除了m-p
    2. 

  2. System.out.println("m".matches(regex));//f
    3. 

  3. System.out.println("a".matches(regex));//t
    4. 

  4. System.out.println("z".matches(regex));//t
    5. 

  5. System.out.println("n".matches(regex));//f
预定义字符类
. 任何字符
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r] //空格,\t:制表符,\n:换行,\x0B:垂直制表符,\f:翻页,\r:回车
\S 非空白字符：[^\s] 
\w 单词字符：[a-zA-Z_0-9] 
\W 非单词字符：[^\w] 
. 任何字符
 
  1. String regex = "..";
    2. 

  2. System.out.println("a".matches(regex));f
    3. 

  3. System.out.println("ab".matches(regex));t
\d 数字：[0-9]
 
  1. String regex = "\\d";//\代表转义字符,如果想表示\d的话,需要\\d
    2. 

  2. System.out.println("0".matches(regex));t
    3. 

  3. System.out.println("a".matches(regex));f
    4. 

  4. System.out.println("9".matches(regex));t
\D 非数字： [^0-9]
 
  1. String regex = "\\D";//\D表示非字符
    2. 

  2. System.out.println("0".matches(regex));f
    3. 

  3. System.out.println("9".matches(regex));f
    4. 

  4. System.out.println("a".matches(regex));t
\s 空白字符：[ \t\n\x0B\f\r] //空格,\t:制表符,\n:换行,\x0B:垂直制表符,\f:翻页,\r:回车
 
  1. String regex = "\\s";
    2. 

  2. System.out.println(" ".matches(regex));t
    3. 

  3. System.out.println("	".matches(regex)); //一个tab键t
    4. 

  4. System.out.println("    ".matches(regex)); //四个空格f
\S 非空白字符：[^\s] 
 
  1. String regex = "\\S";
    2. 

  2. System.out.println(" ".matches(regex));f
    3. 

  3. System.out.println("	".matches(regex));f
    4. 

  4. System.out.println("a".matches(regex));t
\w 单词字符：[a-zA-Z_0-9] 
 
  1. String regex = "\\w";
    2. 

  2. System.out.println("a".matches(regex));t
    3. 

  3. System.out.println("z".matches(regex));t
    4. 

  4. System.out.println("_".matches(regex));t
    5. 

  5. System.out.println("%".matches(regex));f
\W 非单词字符：[^\w] 
 
  1. String regex = "\\W";
    2. 

  2. System.out.println("a".matches(regex));f
    3. 

  3. System.out.println("z".matches(regex));f
    4. 

  4. System.out.println("_".matches(regex));f
    5. 

  5. System.out.println("%".matches(regex));t
Greedy 数量词
X? X，一次或一次也没有
X* X，零次到多次
X+ X，一次到多次
X{n} X，恰好 n 次 
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次 
X? X，一次或一次也没有
 
  1. String regex = "[abc]?";
    2. 

  2. System.out.println("a".matches(regex));t
    3. 

  3. System.out.println("b".matches(regex));t
    4. 

  4. System.out.println("c".matches(regex));t
    5. 

  5. System.out.println("d".matches(regex));f
    6. 

  6. System.out.println("".matches(regex));t
X* X，零次到多次
 
  1. String regex = "[abc]*";
    2. 

  2. System.out.println("".matches(regex));t
    3. 

  3. System.out.println("abc".matches(regex));t
    4. 

  4. System.out.println("a".matches(regex));t
    5. 

  5. System.out.println("aaaa".matches(regex));t
X+ X，一次到多次
 
  1. String regex = "[abc]+";
    2. 

  2. System.out.println("".matches(regex));f
    3. 

  3. System.out.println("a".matches(regex));t
    4. 

  4. System.out.println("aaaaabbbbccccc".matches(regex));t
X{n} X，恰好 n 次 
 
  1. String regex = "[abc]{5}";
    2. 

  2. System.out.println("abcba".matches(regex));t
    3. 

  3. System.out.println("abcbaabcabbabab".matches(regex));f
    4. 

  4. System.out.println("abcb".matches(regex));f
    5. 

  5. System.out.println("abcbaaba".matches(regex));f
X{n,} X，大于等于n次
 
  1. String regex = "[abc]{5,}";//>=5次
    2. 

  2. System.out.println("abcba".matches(regex));t
    3. 

  3. System.out.println("abcbaabcabbabab".matches(regex));t
    4. 

  4. System.out.println("abcb".matches(regex));f
    5. 

  5. System.out.println("abcbaaba".matches(regex));t
X{n,m} X， 大于等于n小于等于m
 
  1. String regex = "[abc]{5,15}";
    2. 

  2. System.out.println("abcba".matches(regex));t
    3. 

  3. System.out.println("abcbaabcabbabab".matches(regex));t
    4. 

  4. System.out.println("abcb".matches(regex));f
    5. 

  5. System.out.println("abcbaabaabcbaaba".matches(regex));f


2、常见对象(Pattern和Matcher的概述)(了解)
* A:Pattern和Matcher的概述
* B:模式和匹配器的典型调用顺序
* 通过JDK提供的API，查看Pattern类的说明

* 典型的调用顺序是 
* Pattern p = Pattern.compile("a*b");
* Matcher m = p.matcher("aaaaab");
* boolean b = m.matches();
需求：把一个字符串中的手机号码获取出来
  1. package com.heima.regex;
    2. 

  2. import java.util.regex.Matcher;
    3. 

  3. import java.util.regex.Pattern;
    4. 

  4. public class Demo8_Pattern {
    5. 

  5. 	public static void main(String[] args) {
    6. 

  6. 		//demo1();
    7. 

  7. 		//demo2();
    8. 

  8. 		demo3();
    9. 

  9. 	}
    10. 

  10. 	//匹配查找邮箱
    11. 

  11. 	private static void demo3() {//[1][\\d&&[012678]][\\d]{9}
    12. 

  12. 		String s = "我的邮箱是smhjx2006@163.com,我曾经用过hmsykt2015@sina.com.cn,我还用过hmsykt0902@qq.com";
    13. 

  13. 		//String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配。
    14. 

  14. 		String regex = "\\w+@\\w+(\\.\\w+)+";
    15. 

  15. 		Pattern p = Pattern.compile(regex);
    16. 

  16. 		Matcher matcher = p.matcher(s);
    17. 

  17. 		while(matcher.find()){
    18. 

  18. 			System.out.println(matcher.group());			
    19. 

  19. 		}
    20. 

  20. 	}
    21. 

  21. 	//匹配查找手机号
    22. 

  22. 	private static void demo2() {
    23. 

  23. 		String s = "我的手机是18511866260,我曾用过18987654321,还用过18812345678";
    24. 

  24. 		String regex = "1[3578]\\d{9}";
    25. 

  25. 		
    26. 

  26. 		
    27. 

  27. 		Pattern p = Pattern.compile(regex);
    28. 

  28. 		Matcher m = p.matcher(s);
    29. 

  29. 		
    30. 

  30. 		/*boolean b1 = m.find();
    31. 

  31. 		System.out.println(b1);
    32. 

  32. 		System.out.println(m.group());
    33. 

  33. 		
    34. 

  34. 		boolean b2 = m.find();
    35. 

  35. 		System.out.println(b2);
    36. 

  36. 		System.out.println(m.group());*/
    37. 

  37. 		
    38. 

  38. 		while(m.find())
    39. 

  39. 			System.out.println(m.group());
    40. 

  40. 	}
    41. 

  41. }


3、案例（掌握）
1、我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
  1. package com.heima.test;
    2. 

  2. import java.util.Arrays;
    3. 

  3. public class Test1 {
    4. 

  4. 	/**
    5. 

    6. 

  6. 	 * 分析:
    7. 

  7. 	 * 1,将字符串切割成字符串数组
    8. 

  8. 	 * 2,将字符串转换成数字并将其存储在一个等长度的int数组中
    9. 

  9. 	 * 3,排序
    10. 

  10. 	 * 4,将排序后的结果遍历并拼接成一个字符串
    11. 

  11. 	 */
    12. 

  12. 	public static void main(String[] args) {
    13. 

  13. 		String s = "91 27 46 38 50";
    14. 

  14. 		//1,将字符串切割成字符串数组
    15. 

  15. 		String[] sArr = s.split(" ");//如果按照.切割，必须使用\\.转义
    16. 

  16. 		//2,将字符串转换成数字并将其存储在一个等长度的int数组中
    17. 

  17. 		int[] arr = new int[sArr.length];
    18. 

  18. 		for (int i = 0; i < arr.length; i++) {
    19. 

  19. 			arr[i] = Integer.parseInt(sArr[i]); 	//将数字字符串转换成数字
    20. 

  20. 		}
    21. 

  21. 		
    22. 

  22. 		//3,排序
    23. 

  23. 		Arrays.sort(arr);
    24. 

  24. 		
    25. 

  25. 		//4,将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
    26. 

  26. 		/*String str = "";
    27. 

  27. 		for (int i = 0; i < arr.length; i++) {
    28. 

  28. 			if(i == arr.length - 1) {
    29. 

  29. 				str = str + arr[i];				//27 38 46 50 91
    30. 

  30. 			}else {
    31. 

  31. 				str = str + arr[i] + " ";		//27 38 46 50 
    32. 

  32. 			}
    33. 

  33. 		}
    34. 

  34. 		
    35. 

  35. 		System.out.println(str);*/
    36. 

  36. 		
    37. 

  37. 		StringBuilder sb = new StringBuilder();
    38. 

  38. 		for (int i = 0; i < arr.length; i++) {
    39. 

  39. 			if(i == arr.length - 1) {
    40. 

  40. 				sb.append(arr[i]);
    41. 

  41. 			}else {
    42. 

  42. 				sb.append(arr[i] + " ");
    43. 

  43. 			}
    44. 

  44. 		}
    45. 

  45. 		
    46. 

  46. 		System.out.println(sb);
    47. 

  47. 	}
    48. 

  48. }

2、需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
     将字符串还原成:“我要学编程”。
  1. public static void main(String[] args) {
    2. 

  2. 		String str= "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
    3. 

  3. 		//第一步 去掉所有的.
    4. 

  4. 		String str1 = str.replaceAll("\\.+", "");
    5. 

  5. 		//第二步 叠词去重 \\1+表示第一组(.)中的数据出现1次或多次,翻译过来就是说任意字符出现一次或多次
    6. 

  6. 		String str2 = str1.replaceAll("(.)\\1+", "$1");
    7. 

  7. 		System.out.println(str2);
    8. 

  8. }


(.)\\1+:


 (.) 第一个字符是任意字符，并且我把它放到组里面，方便以后直接调用这个组


1+:刚才那个字符出现1次或者多次


$1:调用刚才定义的组


什么是组？？？怎么数？


组：就是一个括号括起来的东西


怎么数从左往右数(


2、Math(看到方法名知道意思即可)

1、Math中的常量
E，PI
比任何其他值都更接近 e（即自然对数的底数）的 double 值。

2、Math中的方法
abs()绝对值
ceil 大于等于参数的最小整数，返回double
floor 小于等于参数的最大整数，返回double
round() 四舍五入
random() 随机数
max(x,y) 获取两个数中的最大值

//求绝对值
pubilc static int abs(int num)
public long abs(long num)
public float abs(float num)
pbulic double abs(doble num)

//ceil:天花板
public static double ceil(double num)//返回大于等于参数的最小整数 ,返回值是double 类型
//floor ：底板
public static double floor(double num)//返回小于等于参数的最大整数 ,返回值是double 类型
//round ：四舍五入
public static int round(float num)//
public static long round(double num)//四舍五入

//最大值
public static double max(double num1, double num2);
public static float max(float num1, float num2)
public static int max(int num1, int num2)
public static long max(long num1, long num2)

//随机数
public static double random();


3、System(了解)

1 public static void gc() 调用后执行垃圾回收
2 public static void exit(int status) 非0表示异常退出，1表示正常退出
3 public static long currentTimeMillis() 获取当前时间的毫秒值(掌握)
4 pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组拷贝

4、BigInteger类的概述和方法使用（了解）

* A:BigInteger的概述
* 可以让超过Integer范围内的数据进行运算
* 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)
案例:
  1. package com.heima.otherclass;
    2. 

    3. 

  3. import java.math.BigInteger;
    4. 

    5. 

  5. public class Demo4_BigInteger {
    6. 

    7. 

  7. 	public static void main(String[] args) {
    8. 

  8. 		//long num = 123456789098765432123L;
    9. 

  9. 		//String s = "123456789098765432123";
    10. 

  10. 		
    11. 

  11. 		BigInteger bi1 = new BigInteger("100");
    12. 

  12. 		BigInteger bi2 = new BigInteger("2");
    13. 

  13. 		
    14. 

  14. 		System.out.println(bi1.add(bi2)); 				//+
    15. 

  15. 		System.out.println(bi1.subtract(bi2));			//-
    16. 

  16. 		System.out.println(bi1.multiply(bi2)); 			//*
    17. 

  17. 		System.out.println(bi1.divide(bi2));    		///(除)
    18. 

  18. 		
    19. 

  19. 		BigInteger[] arr = bi1.divideAndRemainder(bi2);	//取除数和余数
    20. 

  20. 		
    21. 

  21. 		for (int i = 0; i < arr.length; i++) {
    22. 

  22. 			System.out.println(arr[i]);
    23. 

  23. 		}
    24. 

  24. 	}
    25. 

    26. 

  26. }

5、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)
* D:案例演示
* BigDecimal类的构造方法和成员方法使用
案例:
  1. package com.heima.otherclass;
    2. 

    3. 

  3. import java.math.BigDecimal;
    4. 

    5. 

  5. public class Demo5_BigDecimal {
    6. 

    7. 

  7. 	/**
    8. 

  8. 		十进制表示1/3
    9. 

  9. 		0.3333333333333333333333333333333333333333 
    10. 

  10. 			 */
    11. 

  11. 	public static void main(String[] args) {
    12. 

  12. 		//System.out.println(2.0 - 1.1);
    13. 

  13. 		/*BigDecimal bd1 = new BigDecimal(2.0);		//这种方式在开发中不推荐,因为不够精确
    14. 

  14. 		BigDecimal bd2 = new BigDecimal(1.1);
    15. 

  15. 		
    16. 

  16. 		System.out.println(bd1.subtract(bd2));*/
    17. 

  17. 		
    18. 

  18. 		/*BigDecimal bd1 = new BigDecimal("2.0");		//通过构造中传入字符串的方式,开发时推荐
    19. 

  19. 		BigDecimal bd2 = new BigDecimal("1.1");
    20. 

  20. 		
    21. 

  21. 		System.out.println(bd1.subtract(bd2));*/
    22. 

  22. 		
    23. 

  23. 		BigDecimal bd1 = BigDecimal.valueOf(2.0);	//这种方式在开发中也是推荐的
    24. 

  24. 		BigDecimal bd2 = BigDecimal.valueOf(1.1);
    25. 

  25. 		
    26. 

  26. 		System.out.println(bd1.subtract(bd2));
    27. 

  27. 	}
    28. 

    29. 

  29. }



6、Date类的概述和方法使用(掌握)

A:Date类的概述(是java.util包下的,别导错了)
* 类 Date 表示特定的瞬间，精确到毫秒。 
B:构造方法
* public Date()
* public Date(long date)
C:成员方法
* public long getTime()
* public void setTime(long time)

D:练习
     1、通过Date日期对象获取毫秒值
          Date date = new Date();
          long time = date.getTime();
     2、通过毫秒值创造Date日期对象
                    long time = 1222L;//毫秒值
                    Date date = new Date(time);

7、SimpleDateFormat类实现日期和字符串的相互转换(掌握)

* A:DateFormat类的概述
* DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
* B:SimpleDateFormat构造方法
* public SimpleDateFormat()
* public SimpleDateFormat(String pattern)
* C:成员方法
* public final String format(Date date)
* public Date parse(String source)
  1. 	public static void main(String[] args)throws Exception {
    2. 

  2. 		/*
    3. 

  3. 		 * 把日期对象转换成字符串
    4. 

  4. 		 */
    5. 

  5. 		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    6. 

  6. 		String strDate = format.format(new Date());
    7. 

  7. 		System.out.println(strDate);
    8. 

  8. 		
    9. 

  9. 		/*
    10. 

  10. 		 * 把字符串转换成日期对象
    11. 

  11. 		 */
    12. 

  12. 		SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    13. 

  13. 		Date date = f.parse("2016-04-28 23:19:34:716");
    14. 

  14. 		System.out.println(date);
    15. 

  15. 	}



*D：算一下你来到这个世界多少天?
  1. package com.heima.test;
    2. 

    3. 

  3. import java.text.ParseException;
    4. 

  4. import java.text.SimpleDateFormat;
    5. 

  5. import java.util.Date;
    6. 

    7. 

  7. public class Test2 {
    8. 

    9. 

  9. 	/**
    10. 

  10. 	 * * A:案例演示
    11. 

  11. 	 * 需求：算一下你来到这个世界多少天?
    12. 

  12. 	 * 分析:
    13. 

  13. 	 * 1,将生日字符串和今天字符串存在String类型的变量中
    14. 

  14. 	 * 2,定义日期格式化对象
    15. 

  15. 	 * 3,将日期字符串转换成日期对象
    16. 

  16. 	 * 4,通过日期对象后期时间毫秒值
    17. 

  17. 	 * 5,将两个时间毫秒值相减除以1000,再除以60,再除以60,再除以24得到天
    18. 

  18. 	 * @throws ParseException 
    19. 

  19. 	 */
    20. 

  20. 	public static void main(String[] args) throws ParseException {
    21. 

  21. 		//1,将生日字符串和今天字符串存在String类型的变量中
    22. 

  22. 		String birthday = "1983年07月08日";
    23. 

  23. 		String today = "2015年9月22日";
    24. 

  24. 		//2,定义日期格式化对象
    25. 

  25. 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
    26. 

  26. 		//3,将日期字符串转换成日期对象
    27. 

  27. 		Date d1 = sdf.parse(birthday);
    28. 

  28. 		Date d2 = sdf.parse(today);
    29. 

  29. 		//4,通过日期对象后期时间毫秒值
    30. 

  30. 		long time = d2.getTime() - d1.getTime();
    31. 

  31. 		//5,将两个时间毫秒值相减除以1000,再除以60,再除以60,再除以24得到天
    32. 

  32. 		System.out.println(time / 1000 / 60 / 60 / 24 );
    33. 

  33. 	}
    34. 

    35. 

  35. }


8、Calendar类的概述和获取日期的方法(掌握)

* A:Calendar类的概述
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
* B:成员方法
* public static Calendar getInstance()
* public int get(int field)
* public void add(int field,int amount)
* public final void set(int year,int month,int date)

3、注意事项
1、get(Calendar.MONTH)的值的范围是0-11，不是1-12
    

//外国人的1是中国的7

       //外国人的0-6是中国的周1-5

       int week =  calendar.get(Calendar.DAY_OF_WEEK)==1?7: calendar.get(Calendar.DAY_OF_WEEK)-1;

2、日期处理过程中能使用Calendar就不使用Date

  1. import java.util.Calendar;
    2. 

    3. 

  3. public class CalendarDemo {
    4. 

  4. 	public static void main(String[] args) {
    5. 

    6. 

  6. 		Calendar c = Calendar.getInstance(); // 父类引用指向子类对象
    7. 

    8. 

  8. 		/*
    9. 

  9. 		 * get方法测试
    10. 

  10. 		 */
    11. 

  11. 		System.out.println(c.get(Calendar.YEAR)); // 通过字段获取年
    12. 

  12. 		System.out.println(c.get(Calendar.MONTH)); // 通过字段后期月,但是月是从0开始编号的
    13. 

  13. 		System.out.println(c.get(Calendar.DAY_OF_MONTH));// 月中的第几天
    14. 

  14. 		System.out.println(c.get(Calendar.DAY_OF_WEEK));// 周日是第一天,周六是最后一天
    15. 

  15. 		/*
    16. 

  16. 		 * add方法测试
    17. 

  17. 		 */
    18. 

  18. 		c.add(Calendar.MONTH, -1); // 对指定的字段进行向前减或向后加
    19. 

  19. 		printTime(c);
    20. 

  20. 		/*
    21. 

  21. 		 * set方法测试
    22. 

  22. 		 */
    23. 

  23. 		c.set(Calendar.YEAR, 2000); // 修改指定字段
    24. 

  24. 		c.set(2000, 7, 8);
    25. 

  25. 		printTime(c);
    26. 

  26. 	}
    27. 

    28. 

  28. 	/**
    29. 

  29. 	 * 打印年月日 星期
    30. 

  30. 	 * @param c
    31. 

  31. 	 */
    32. 

  32. 	public static void printTime(Calendar c) {
    33. 

  33. 		int year = c.get(Calendar.YEAR);
    34. 

  34. 		int month = c.get(Calendar.MONDAY)+1;
    35. 

  35. 		int day = c.get(Calendar.DAY_OF_MONTH);
    36. 

  36. 		int week = c.get(Calendar.DAY_OF_WEEK)==1?7: c.get(Calendar.DAY_OF_WEEK)-1;
    37. 

  37. 		System.out.println(year+"年"+month+"月"+day+"日星期"+week);
    38. 

  38. 	}
    39. 

  39. }


           C 案例键盘录入任意一个年份，判断该年是闰年还是平年（掌握）
  1. package com.heima.test;
    2. 

    3. 

  3. import java.util.Calendar;
    4. 

  4. import java.util.Scanner;
    5. 

    6. 

  6. public class Test3 {
    7. 

    8. 

  8. 	/**
    9. 

  9. 	 * * A:案例演示
    10. 

  10. 	 * 需求：键盘录入任意一个年份，判断该年是闰年还是平年
    11. 

  11. 	 * Calendar c = Calendar.getInstance();
    12. 

  12. 	 * 
    13. 

  13. 	 * 分析:
    14. 

  14. 	 * 1,键盘录入年Scanner
    15. 

  15. 	 * 2,创建Calendar c = Calendar.getInstance();
    16. 

  16. 	 * 3,通过set方法设置为那一年的3月1日
    17. 

  17. 	 * 4,将日向前减去1
    18. 

  18. 	 * 5,判断日是多少天,如果是29天返回true否则返回false
    19. 

  19. 	 */
    20. 

  20. 	public static void main(String[] args) {
    21. 

  21. 		Scanner sc = new Scanner(System.in);
    22. 

  22. 		System.out.println("请输入年份,判断该年份是闰年还是平年:");
    23. 

  23. 		//int year = sc.nextInt();
    24. 

  24. 		
    25. 

  25. 		String line = sc.nextLine();				//录入数字字符串
    26. 

  26. 		int year = Integer.parseInt(line);			//将数字字符串转换成数字
    27. 

  27. 		boolean b = getYear(year);					//这里输入的是年份
    28. 

  28. 		System.out.println(b);
    29. 

  29. 	}
    30. 

    31. 

  31. 	private static boolean getYear(int year) {
    32. 

  32. 		//2,创建Calendar c = Calendar.getInstance();
    33. 

  33. 		Calendar c = Calendar.getInstance();
    34. 

  34. 		//设置为那一年的3月1日
    35. 

  35. 		c.set(year, 2, 1);
    36. 

  36. 		//将日向前减去1
    37. 

  37. 		c.add(Calendar.DAY_OF_MONTH, -1);
    38. 

  38. 		//判断是否是29天
    39. 

  39. 		return c.get(Calendar.DAY_OF_MONTH) == 29;
    40. 

  40. 	}
    41. 

    42. 

  42. }


8、今天必须掌握的内容。以及常见的笔试题和面试题(学完这个就可以放心学习后面的知识了)

1、基本的正则表达式和数量词要能看懂
2、获取当前时间的毫秒值的两种方式
3、日期格式化类的使用(日期转字符串，字符串转日期)
    日期转字符串   String str = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(new Date());
    字符串转日期   Date date =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").parse("2018-09-09 11:11:11:111");
4、笔试题：判断平年闰年
5、笔试题：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
     将字符串还原成:“我要学编程
    思路：1、去掉所有的...reaplaceAll("\\.","");
               2、替换叠词 replaceAll("(.)\\1+","$1")
6、我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
7、写一个正则表达式，可以匹配尾号5连的手机号。
规则: 第1位是1，第二位可以是数字358其中之一，后面6位任意数字，最后5位为任意相同的数字，
第1位是1，第二位可以是数字358其中之一，后面6位任意数字，最后5位为任意相同的数字
  1. package com.heima.stringStringBuilderStringBuffer;
    2. 

  2. /**
    3. 

  3.  *  写一个正则表达式，可以匹配尾号5连的手机号。
    4. 

  4.  *  规则: 第1位是1，第二位可以是数字3458其中之一，后面6位任意数字，最后5位为任意相同的数字。
    5. 

  5.  *  例如：18601088888、13912366666
    6. 

  6.  * @author JX
    7. 

  7.  *
    8. 

  8.  */
    9. 

  9. public class Test3 {
    10. 

  10. 	public static void main(String[] args) {
    11. 

  11. 		String regex = "[1][3458]\\d{4}(\\d)\\1{4}";
    12. 

  12. 		String phone1 = "18601088888";
    13. 

  13. 		String phone2 = "13912366666";
    14. 

  14. 		System.out.println(phone1.matches(regex));
    15. 

  15. 		System.out.println(phone2.matches(regex));		
    16. 

  16. 	}
    17. 

  17. }

8、模拟用户注册
        1、用户录入手机号
        2、校验用户录入的手机号,1、长度是否11位，2、是否全是数字
        3、将手机号后四位截取出来通过Random类加密，生成一个0-99999之间的数字作为验证码打印到控制台
  1.     /**
    2. 

  2. 	 * 8、模拟用户注册 1、用户录入手机号 2、校验用户录入的手机号,1、长度是否11位，2、是否全是数字
    3. 

  3. 	 * 3、将手机号后四位截取出来通过Random类加密，将加密后的数字作为校验码打印在控制台
    4. 

  4. 	 * 
    5. 

  5. 	 * @param args
    6. 

  6. 	 */
    7. 

  7. 	public static void main(String[] args) {
    8. 

  8. 		Scanner sc = new Scanner(System.in);
    9. 

  9. 		System.out.println("请输入手机号");
    10. 

  10. 		String phone = sc.nextLine();
    11. 

    12. 

  12. 		//校验成功
    13. 

  13. 		if(phone.length()==11 && phone.matches("[0-9]{11,}")){
    14. 

  14. 			String num = phone.substring(7);//后四位
    15. 

  15. 			Random r = new Random(Long.parseLong(num));
    16. 

  16. 			int yzm = r.nextInt(100000);//验证码
    17. 

  17. 			System.out.println("验证码是:"+yzm);
    18. 

  18. 		}else{
    19. 

  19. 			System.out.println("请输入正确的手机号");
    20. 

  20. 		}
    21. 

    22. 

    23. 

  23. 	}

9、用正则判断一个数字(该数字的长度至少为7)的末尾是不是相同的7位数
  1. public class Test {
    2. 

  2. 	public static void main(String[] args) {
    3. 

  3. 		System.out.println("7777777".matches(".*(\\d)\\1{6}"));
    4. 

  4. 	}
    5. 

  5. }











day14_API第四天的更多相关文章

  1. 构建一个基本的前端自动化开发环境 —— 基于 Gulp 的前端集成解决方案（四）

    通过前面几节的准备工作,对于 npm / node / gulp 应该已经有了基本的认识,本节主要介绍如何构建一个基本的前端自动化开发环境. 下面将逐步构建一个可以自动编译 sass 文件.压缩 ja ...

  2. 《Django By Example》第四章 中文 翻译 （个人学习，渣翻）

    书籍出处:https://www.packtpub.com/web-development/django-example 原作者:Antonio Melé (译者注:祝大家新年快乐,这次带来<D ...

  3. 如何一步一步用DDD设计一个电商网站（四）—— 把商品卖给用户

    阅读目录 前言 怎么卖 领域服务的使用 回到现实 结语 一.前言 上篇中我们讲述了“把商品卖给用户”中的商品和用户的初步设计.现在把剩余的“卖”这个动作给做了.这里提醒一下,正常情况下,我们的每一步业 ...

  4. 从0开始搭建SQL Server AlwaysOn 第四篇（配置异地机房节点）

    从0开始搭建SQL Server AlwaysOn 第四篇(配置异地机房节点) 第一篇http://www.cnblogs.com/lyhabc/p/4678330.html第二篇http://www ...

  5. MVVM设计模式和WPF中的实现（四）事件绑定

    MVVM设计模式和在WPF中的实现(四) 事件绑定 系列目录: MVVM模式解析和在WPF中的实现(一)MVVM模式简介 MVVM模式解析和在WPF中的实现(二)数据绑定 MVVM模式解析和在WPF中 ...

  6. “四核”驱动的“三维”导航 -- 淘宝新UI（需求分析篇）

    前言 孔子说:"软件是对客观世界的抽象". 首先声明,这里的"三维导航"和地图没一毛钱关系,"四核驱动"和硬件也没关系,而是为了复杂的应用而 ...

  7. 【翻译】MongoDB指南/CRUD操作（四）

    [原文地址]https://docs.mongodb.com/manual/ CRUD操作(四) 1 查询方案(Query Plans) MongoDB 查询优化程序处理查询并且针对给定可利用的索引选 ...

  8. HTML 事件(四) 模拟事件操作

    本篇主要介绍HTML DOM中事件的模拟操作. 其他事件文章 1. HTML 事件(一) 事件的介绍 2. HTML 事件(二) 事件的注册与注销 3. HTML 事件(三) 事件流与事件委托 4.  ...

  9. 【原】AFNetworking源码阅读（四）

    [原]AFNetworking源码阅读(四) 本文转载请注明出处 —— polobymulberry-博客园 1. 前言 上一篇还遗留了很多问题,包括AFURLSessionManagerTaskDe ...

随机推荐

  1. [issue] dyld`dyld_fatal_error: -> 0x120015088 <+0>: brk #0x3

    iOS "dyld`dyld_fatal_error: -> 0x12000d088 <+0>: brk #0x3"错误 根据上面的博客里的方法二 尝试解决方法二 ...

  2. django admin下拉列表不显示值，显示为object的处理

    问题:模板中创建form表单中的下拉列表, 前台打开页面显示object,而不是值,如图: 尝试了多种办法无果,最后解决了,处理办法是修改models.py,原来的model: class Techn ...

  3. JDBC连接sql server数据库及其它

    JDBC连接sql server数据库的步骤如下: 1.加载JDBC驱动程序: 在连接数据库之前,首先要加载想要连接的数据库的驱动到JVM(Java虚拟机), 这通过java.lang.Class类的 ...

  4. 20161026__Oracle10g_DataGuard

    1. orcl.__db_cache_size=180355072 orcl.__java_pool_size=4194304 orcl.__large_pool_size=4194304 orcl. ...

  5. java中获取ServletContext常见方法

    http://blog.sina.com.cn/s/blog_3fe961ae0100wjnf.html 1.在javax.servlet.Filter中直接获取 ServletContext con ...

  6. ocLazyLoad angular 按需加载

    ionic 框架 1.引用 index.html 加载 <script type="text/javascript" src="lib/oclazyload/ocL ...

  7. office openxml学习（一）

    以前用过,aspose.dll处理word ,excel,之后发现 npoi,使用了一段时间,总觉得是第三方,不明白底层的实现,直到最近发现了office openxml ,其实这个技术,很久以前就有 ...

  8. C#中文和UNICODE编码转换

    C#中文和UNICODE编码转换 //中文轉為UNICODE string str = "中文"; string outStr = ""; if (!strin ...

  9. gz

    不准备的话,是真的会滚粗的. leetcode  还是重新做起来叭. 那么就开始咯 8.22 leetcode 144 Binary Tree Preorder Traversal 二叉树的前序遍历 ...

  10. jQuery：常用方法一览

    Attribute:$(”p”).addClass(css中定义的样式类型); 给某个元素添加样式$(”img”).attr({src:”test.jpg”,alt:”test Image”}); 给 ...