JAVA語言基礎-面向對象（常見對象：正則表達式）

時間 2019-12-06

原文原文鏈接

14.01_常見對象(正則表達式的概述和簡單使用)

A:正則表達式
- 是指一個用來描述或者匹配一系列符合某個語法規則的字符串的單個字符串。其實就是一種規則。有本身特殊的應用。
- 做用:好比註冊郵箱,郵箱有用戶名和密碼,通常會對其限制長度,這個限制長度的事情就是正則表達式作的
B:案例演示java
- 需求：校驗qq號碼.正則表達式
  - 1:要求必須是5-15位數字
  - 2:0不能開頭
  - 3:必須都是數字
- a:非正則表達式實現sql
- b:正則表達式實現

package com.heima.regex;

public class Demo1_Regex {

	/**
	 * * A:正則表達式
			* 是指一個用來描述或者匹配一系列符合某個語法規則的字符串的單個字符串。其實就是一種規則。有本身特殊的應用。
			* 做用:好比註冊郵箱,郵箱有用戶名和密碼,通常會對其限制長度,這個限制長度的事情就是正則表達式作的
		* B:案例演示
			* 需求：校驗qq號碼.
				* 1:要求必須是5-15位數字
				* 2:0不能開頭
				* 3:必須都是數字
				
			* a:非正則表達式實現
			* b:正則表達式實現
	 */
	public static void main(String[] args) {
		System.out.println(checkQQ("012345"));
		System.out.println(checkQQ("a1b345"));
		System.out.println(checkQQ("123456"));
		System.out.println(checkQQ("1234567890987654321"));
		
		String regex = "[1-9]\\d{4,14}";
		System.out.println("2553868".matches(regex));
		System.out.println("012345".matches(regex));
		System.out.println("2553868abc".matches(regex));
	}
	
	/*
	 * 需求：校驗qq號碼.
	 * 1:要求必須是5-15位數字
	 * 2:0不能開頭
	 * 3:必須都是數字
	 * 校驗qq
	 * 1,明確返回值類型boolean
	 * 2,明確參數列表String qq
	 */
	public static boolean checkQQ(String qq) {
		boolean flag = true;					//若是校驗qq不符合要求就把flag置爲false,若是符合要求直接返回
		
		if(qq.length() >= 5 && qq.length() <= 15) {
			if(!qq.startsWith("0")) {
				char[] arr = qq.toCharArray();	//將字符串轉換成字符數組
				for (int i = 0; i < arr.length; i++) {
					char ch = arr[i];			//記錄每個字符
					if(!(ch >= '0' && ch <= '9')) {
						flag = false;			//不是數字
						break;
					}
				}
			}else {
				flag = false;					//以0開頭,不符合qq標準
			}
		}else {
			flag = false;						//長度不符合
		}
		return flag;
	}
}

14.02_常見對象(字符類演示)

A:字符類
- [abc] a、b 或 c（簡單類）
- [^abc] 任何字符，除了 a、b 或 c（否認）
- [a-zA-Z] a到 z 或 A到 Z，兩頭的字母包括在內（範圍）
- [0-9] 0到9的字符都包括

package com.heima.regex;

public class Demo2_Regex {

	/**
	 * [abc] a、b 或 c（簡單類） 
		[^abc] 任何字符，除了 a、b 或 c（否認） 
		[a-zA-Z] a 到 z 或 A 到 Z，兩頭的字母包括在內（範圍） 
		[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]（減去） 

	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		//demo5();
		//demo6();
		String regex = "[a-z&&[^m-p]]";
		System.out.println("m".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("n".matches(regex));
	}

	private static void demo6() {
		String regex = "[a-z&&[^bc]]";
		System.out.println("a".matches(regex));
		System.out.println("b".matches(regex));
		System.out.println("1".matches(regex));
	}

	private static void demo5() {
		String regex = "[a-z&&[def]]";						//取交集
		System.out.println("a".matches(regex));
		System.out.println("d".matches(regex));
	}

	private static void demo4() {
		String regex = "[a-d[m-p]]";
		System.out.println("a".matches(regex));
		System.out.println("m".matches(regex));
		System.out.println("n".matches(regex));
	}

	private static void demo3() {
		String regex = "[a-zA-Z]";
		System.out.println("a".matches(regex));
		System.out.println("A".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("Z".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("%".matches(regex));
	}

	private static void demo2() {
		String regex = "[^abc]";
		System.out.println("a".matches(regex));
		System.out.println("b".matches(regex));
		System.out.println("c".matches(regex));
		System.out.println("d".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("%".matches(regex));
		System.out.println("10".matches(regex));		//10表明1字符和0字符,不是單個字符
	}

	private static void demo1() {
		String regex = "[abc]";					//[]表明單個字符
		System.out.println("a".matches(regex));
		System.out.println("b".matches(regex));
		System.out.println("c".matches(regex));
		System.out.println("d".matches(regex));
		System.out.println("1".matches(regex));
		System.out.println("%".matches(regex));
	}

}

14.03_常見對象(預約義字符類演示)

A:預約義字符類
- . 任何字符。
- \d 數字：[0-9]
- \w 單詞字符：[a-zA-Z_0-9]

package com.heima.regex;

public class Demo3_Regex {

	/**
	 * 	. 任何字符
		\d 數字：[0-9] 
		\D 非數字： [^0-9] 
		\s 空白字符：[ \t\n\x0B\f\r] 
		\S 非空白字符：[^\s] 
		\w 單詞字符：[a-zA-Z_0-9] 
		\W 非單詞字符：[^\w] 

	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		//demo5();
		//demo6();
		String regex = "\\W";
		System.out.println("a".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("_".matches(regex));
		System.out.println("%".matches(regex));
	}

	private static void demo6() {
		String regex = "\\w";
		System.out.println("a".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("_".matches(regex));
		System.out.println("%".matches(regex));
	}

	private static void demo5() {
		String regex = "\\S";
		System.out.println(" ".matches(regex));
		System.out.println("	".matches(regex));
		System.out.println("a".matches(regex));
	}

	private static void demo4() {
		String regex = "\\s";
		System.out.println(" ".matches(regex));
		System.out.println("	".matches(regex)); 				//一個tab鍵
		System.out.println("    ".matches(regex)); 				//四個空格
	}

	private static void demo3() {
		String regex = "\\D";
		System.out.println("0".matches(regex));
		System.out.println("9".matches(regex));
		System.out.println("a".matches(regex));
	}

	private static void demo2() {
		String regex = "\\d";					//\表明轉義字符,若是想表示\d的話,須要\\d
		System.out.println("0".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("9".matches(regex));
	}

	private static void demo1() {
		String regex = "..";
		System.out.println("a".matches(regex));
		System.out.println("ab".matches(regex));
	}

}

14.04_常見對象(數量詞)

A:Greedy 數量詞
- X? X，一次或一次也沒有
- X* X，零次或屢次
- X+ X，一次或屢次
- X{n} X，剛好 n 次
- X{n,} X，至少 n 次
- X{n,m} X，至少 n 次，可是不超過 m 次

package com.heima.regex;

public class Demo4_Regex {

	/**
	 * Greedy 數量詞 
		X? X，一次或一次也沒有 
		X* X，零次或屢次 
		X+ X，一次或屢次 
		X{n} X，剛好 n 次 
		X{n,} X，至少 n 次 
		X{n,m} X，至少 n 次，可是不超過 m 次 
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		//demo5();
		String regex = "[abc]{5,15}";
		System.out.println("abcba".matches(regex));
		System.out.println("abcbaabcabbabab".matches(regex));
		System.out.println("abcb".matches(regex));
		System.out.println("abcbaabaabcbaaba".matches(regex));
	}

	public static void demo5() {
		String regex = "[abc]{5,}";
		System.out.println("abcba".matches(regex));
		System.out.println("abcbaabcabbabab".matches(regex));
		System.out.println("abcb".matches(regex));
		System.out.println("abcbaaba".matches(regex));
	}

	public static void demo4() {
		String regex = "[abc]{5}";
		System.out.println("abcba".matches(regex));
		System.out.println("abcbaabcabbabab".matches(regex));
		System.out.println("abcb".matches(regex));
		System.out.println("abcbaaba".matches(regex));
	}

	public static void demo3() {
		String regex = "[abc]+";
		System.out.println("".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("aaaaabbbbccccc".matches(regex));
	}

	public static void demo2() {
		String regex = "[abc]*";
		System.out.println("".matches(regex));
		System.out.println("abc".matches(regex));
		System.out.println("a".matches(regex));
	}

	public static void demo1() {
		String regex = "[abc]?";
		System.out.println("a".matches(regex));
		System.out.println("b".matches(regex));
		System.out.println("c".matches(regex));
		System.out.println("d".matches(regex));
		System.out.println("".matches(regex));
	}

}

14.05_常見對象(正則表達式的分割功能)

A:正則表達式的分割功能
- String類的功能：public String[] split(String regex)
B:案例演示
- 正則表達式的分割功能

package com.heima.regex;

public class Demo5_Split {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s = "金三胖.郭美美.李dayone";
		String[] arr = s.split("\\.");				//經過正則表達式切割字符串
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		System.out.println("11111111111111111");
	}

}

14.06_常見對象(把給定字符串中的數字排序)

A:案例演示
- 需求：我有以下一個字符串:」91 27 46 38 50」，請寫代碼實現最終輸出結果是：」27 38 46 50 91」

14.07_常見對象(正則表達式的替換功能)

A:正則表達式的替換功能
- String類的功能：public String replaceAll(String regex,String replacement)
B:案例演示
- 正則表達式的替換功能

package com.heima.regex;

public class Demo6_ReplaceAll {

	/**
	 * * A:正則表達式的替換功能
	 * String類的功能：public String replaceAll(String regex,String replacement)
	 */
	public static void main(String[] args) {
		String s = "wo111ai222heima";
		String regex = "\\d";			//\\d表明的是任意數字
		
		String s2 = s.replaceAll(regex, "");
		System.out.println(s2);
	}

}

14.08_常見對象(正則表達式的分組功能)

A:正則表達式的分組功能
- 捕獲組能夠經過從左到右計算其開括號來編號。例如，在表達式 ((A)(B(C))) 中，存在四個這樣的組：

1     ((A)(B(C))) 
2     (A 
3     (B(C)) 
4     (C) 

組零始終表明整個表達式。

B:案例演示 a:切割需求：請按照疊詞切割： "sdqqfgkkkhjppppkl"; b:替換需求：我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程將字符串還原成:「我要學編程」。

package com.heima.regex;

public class Demo7_Regex {

	/**
	 * * A:正則表達式的分組功能
			* 捕獲組能夠經過從左到右計算其開括號來編號。例如，在表達式 ((A)(B(C))) 中，存在四個這樣的組： 
		* 
				1     ((A)(B(C))) 
				2     (A 
				3     (B(C)) 
				4     (C) 
			
				組零始終表明整個表達式。
		B:案例演示
			a:切割
				需求：請按照疊詞切割： "sdqqfgkkkhjppppkl";
			b:替換
				需求：我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程
				將字符串還原成:「我要學編程」。
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		
		/*
		 * 需求：我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程
				將字符串還原成:「我要學編程」。
		 */
		String s = "我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程";
		String s2 = s.replaceAll("\\.+", "");
		String s3 = s2.replaceAll("(.)\\1+", "$1");	//$1表明第一組中的內容
		System.out.println(s3);
	}

	public static void demo2() {
		//需求：請按照疊詞切割： "sdqqfgkkkhjppppkl";
		String s = "sdqqfgkkkhjppppkl";
		String regex = "(.)\\1+";					//+表明第一組出現一次到屢次
		String[] arr = s.split(regex);
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

	public static void demo1() {
		//疊詞 快快樂樂,高高興興
		/*String regex = "(.)\\1(.)\\2";					//\\1表明第一組又出現一次	\\2表明第二組又出現一次
		System.out.println("快快樂樂".matches(regex));
		System.out.println("快樂樂樂".matches(regex));
		System.out.println("高高興興".matches(regex));
		System.out.println("死啦死啦".matches(regex));*/
		
		//疊詞 死啦死啦,高興高興
		String regex2 = "(..)\\1";
		System.out.println("死啦死啦".matches(regex2));
		System.out.println("高興高興".matches(regex2));
		System.out.println("快快樂樂".matches(regex2));
	}

}

14.09_常見對象(Pattern和Matcher的概述)

A:Pattern和Matcher的概述
B:模式和匹配器的典型調用順序編程
- 經過JDK提供的API，查看Pattern類的說明數組
- 典型的調用順序是dom
- Pattern p = Pattern.compile("a*b");
- Matcher m = p.matcher("aaaaab");
- boolean b = m.matches();

14.10_常見對象(正則表達式的獲取功能)

A:正則表達式的獲取功能
- Pattern和Matcher的結合使用
B:案例演示
- 需求：把一個字符串中的手機號碼獲取出來

package com.heima.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo8_Pattern {

	/**
	 * Pattern p = Pattern.compile("a*b");
		 Matcher m = p.matcher("aaaaab");
		 boolean b = m.matches();
		 
		* A:正則表達式的獲取功能
			* Pattern和Matcher的結合使用
		* B:案例演示
			* 需求：把一個字符串中的手機號碼獲取出來
	 */
	public static void main(String[] args) {
		//demo1();
		String s = "個人手機是18511866260,我曾用過18987654321,還用過18812345678";
		String regex = "1[3578]\\d{9}";
		
		
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(s);
		
		/*boolean b1 = m.find();
		System.out.println(b1);
		System.out.println(m.group());
		
		boolean b2 = m.find();
		System.out.println(b2);
		System.out.println(m.group());*/
		
		while(m.find())
			System.out.println(m.group());
	}

	public static void demo1() {
		Pattern p = Pattern.compile("a*b");					//獲取到正則表達式
		Matcher m = p.matcher("aaaaab");					//獲取匹配器
		boolean b = m.matches();							//看是否能匹配,匹配就返回true
		
		System.out.println(b);
		
		System.out.println("aaaaab".matches("a*b"));  		//與上面的結果同樣
	}

}

14.11_常見對象(Math類概述和方法使用)

A:Math類概述
- Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數。
B:成員方法
- public static int abs(int a)
- public static double ceil(double a)
- public static double floor(double a)
- public static int max(int a,int b) min自學
- public static double pow(double a,double b)
- public static double random()
- public static int round(float a) 參數爲double的自學
- public static double sqrt(double a)

package com.heima.otherclass;

public class Demo1_Math {

	/**
	 * @param args
	 * * A:Math類概述
		* Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數。 
	* B:成員方法
		* public static int abs(int a)
		* public static double ceil(double a)
		* public static double floor(double a)
		* public static int max(int a,int b) min自學
		* public static double pow(double a,double b)
		* public static double random()
		* public static int round(float a) 參數爲double的自學
		* public static double sqrt(double a)
	 */
	public static void main(String[] args) {
		System.out.println(Math.PI);
		System.out.println(Math.abs(-10));  			//取絕對值
		
		//ceil天花板
		/*
		 * 13.0
		 * 12.3
		 * 12.0
		 */
		System.out.println(Math.ceil(12.3));			//向上取整,可是結果是一個double
		System.out.println(Math.ceil(12.99));
		
		System.out.println("-----------");
		//floor地板
		/*
		 * 13.0
		 * 12.3
		 * 12.0
		 */
		System.out.println(Math.floor(12.3));			//向下取整,可是結果是一個double
		System.out.println(Math.floor(12.99));
		
		//獲取兩個值中的最大值
		System.out.println(Math.max(20, 30));
		
		//前面的數是底數,後面的數是指數
		System.out.println(Math.pow(2, 3));				//2.0 ^ 3.0
		
		//生成0.0到1.0之間的因此小數,包括0.0,不包括1.0
		System.out.println(Math.random());
		
		//四捨五入
		System.out.println(Math.round(12.3f));
		System.out.println(Math.round(12.9f));
		
		//開平方
		System.out.println(Math.sqrt(4));
		System.out.println(Math.sqrt(2));
		System.out.println(Math.sqrt(3));
	}

}

14.12_常見對象(Random類的概述和方法使用)

A:Random類的概述
- 此類用於產生隨機數若是用相同的種子建立兩個 Random 實例，
- 則對每一個實例進行相同的方法調用序列，它們將生成並返回相同的數字序列。
B:構造方法
- public Random()
- public Random(long seed)
C:成員方法
- public int nextInt()
- public int nextInt(int n)(重點掌握)

package com.heima.otherclass;

import java.util.Random;

public class Demo2_Random {

	/**
	 * * A:Random類的概述
			* 此類用於產生隨機數若是用相同的種子建立兩個 Random 實例，
			* 則對每一個實例進行相同的方法調用序列，它們將生成並返回相同的數字序列。
		* B:構造方法
			* public Random()
			* public Random(long seed)
		* C:成員方法
			* public int nextInt()
			* public int nextInt(int n)(重點掌握)
	 */
	public static void main(String[] args) {
		Random r = new Random();
		/*int x = r.nextInt();
		
		System.out.println(x);*/
		
		for(int i = 0; i < 10; i++) {
			//System.out.println(r.nextInt());
			System.out.println(r.nextInt(100));			//要求掌握,生成在0到n範圍內的隨機數,包含0不包含n
		}
		
		/*
		 * -1244746321
			1060493871
			
			-1244746321
			1060493871

		 */
		/*Random r2 = new Random(1001);
		
		int a = r2.nextInt();
		int b = r2.nextInt();
		
		System.out.println(a);
		System.out.println(b);*/
	}

}

14.13_常見對象(System類的概述和方法使用)

A:System類的概述
- System 類包含一些有用的類字段和方法。它不能被實例化。
B:成員方法
- public static void gc()
- public static void exit(int status)
- public static long currentTimeMillis()
- pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
C:案例演示
- System類的成員方法使用

package com.heima.otherclass;

public class Demo3_System {

	/**
	 * * A:System類的概述
			* System 類包含一些有用的類字段和方法。它不能被實例化。 
		* B:成員方法
			* public static void gc()
			* public static void exit(int status)
			* public static long currentTimeMillis()
			* pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
		* C:案例演示
			* System類的成員方法使用
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		
		int[] src = {11,22,33,44,55};
		int[] dest = new int[8];
		for (int i = 0; i < dest.length; i++) {
			System.out.println(dest[i]);
		}
		
		System.out.println("--------------------------");
		System.arraycopy(src, 0, dest, 0, src.length);		//將數組內容拷貝
		
		for (int i = 0; i < dest.length; i++) {
			System.out.println(dest[i]);
		}
	}

	public static void demo3() {
		long start = System.currentTimeMillis();		//1秒等於1000毫秒
		for(int i = 0; i < 1000; i++) {
			System.out.println("*");
		}
		long end = System.currentTimeMillis();			//獲取當前時間的毫秒值
		
		System.out.println(end - start);
	}

	public static void demo2() {
		System.exit(1);							//非0狀態是異常終止,退出jvm
		System.out.println("11111111111");
	}

	public static void demo1() {
		for(int i = 0; i < 100; i++) {
			new Demo();
			System.gc();						//運行垃圾回收器,至關於呼喊保潔阿姨
		}
	}

}

class Demo {									//在一個源文件中不容許定義兩個用public修飾的類

	@Override
	public void finalize() {
		System.out.println("垃圾被清掃了");
	}							
	
}

14.14_常見對象(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)

package com.heima.otherclass;

import java.math.BigInteger;

public class Demo4_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)
	 */
	public static void main(String[] args) {
		//long num = 123456789098765432123L;
		//String s = "123456789098765432123";
		
		BigInteger bi1 = new BigInteger("100");
		BigInteger bi2 = new BigInteger("2");
		
		System.out.println(bi1.add(bi2)); 				//+
		System.out.println(bi1.subtract(bi2));			//-
		System.out.println(bi1.multiply(bi2)); 			//*
		System.out.println(bi1.divide(bi2));    		///(除)
		
		BigInteger[] arr = bi1.divideAndRemainder(bi2);	//取除數和餘數
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

14.15_常見對象(BigDecimal類的概述和方法使用)

A:BigDecimal的概述jvm
- 因爲在運算的時候，float類型和double很容易丟失精度，演示案例。
- 因此，爲了能精確的表示、計算浮點數，Java提供了BigDecimalide
- 不可變的、任意精度的有符號十進制數。函數
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類的構造方法和成員方法使用

package com.heima.otherclass;

import java.math.BigDecimal;

public class Demo5_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/3
		0.3333333333333333333333333333333333333333 
			 */
	public static void main(String[] args) {
		//System.out.println(2.0 - 1.1);
		/*BigDecimal bd1 = new BigDecimal(2.0);		//這種方式在開發中不推薦,由於不夠精確
		BigDecimal bd2 = new BigDecimal(1.1);
		
		System.out.println(bd1.subtract(bd2));*/
		
		/*BigDecimal bd1 = new BigDecimal("2.0");		//經過構造中傳入字符串的方式,開發時推薦
		BigDecimal bd2 = new BigDecimal("1.1");
		
		System.out.println(bd1.subtract(bd2));*/
		
		BigDecimal bd1 = BigDecimal.valueOf(2.0);	//這種方式在開發中也是推薦的
		BigDecimal bd2 = BigDecimal.valueOf(1.1);
		
		System.out.println(bd1.subtract(bd2));
	}

}

14.16_常見對象(Date類的概述和方法使用)(掌握)

A:Date類的概述
- 類 Date 表示特定的瞬間，精確到毫秒。
B:構造方法
- public Date()
- public Date(long date)
C:成員方法
- public long getTime()
- public void setTime(long time)

package com.heima.otherclass;

import java.util.Date;

public class Demo6_Date {

	/**
	 * * A:Date類的概述是util包下的,不能導入sql包的
			* 類 Date 表示特定的瞬間，精確到毫秒。 
		* B:構造方法
			* public Date()
			* public Date(long date)
		* C:成員方法
			* public long getTime()
			* public void setTime(long time)
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		Date d1 = new Date();	
		d1.setTime(1000);								//設置毫秒值,改變時間對象
		System.out.println(d1);
	}

	public static void demo2() {
		Date d1 = new Date();	
		System.out.println(d1.getTime());				//經過時間對象獲取毫秒值
		System.out.println(System.currentTimeMillis());	//經過系統類的方法獲取當前時間毫秒值
	}

	public static void demo1() {
		Date d1 = new Date();					//若是沒有傳參數表明的是當前時間
		System.out.println(d1);
		
		Date d2 = new Date(0);					//若是構造方法中參數傳爲0表明的是1970年1月1日
		System.out.println(d2);					//經過毫秒值建立時間對象
	}

}

14.17_常見對象(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)

package com.heima.otherclass;

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

public class Demo7_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)
	 * @throws ParseException 
	 */
	public static void main(String[] args) throws ParseException {
		//demo1();
		//demo2();
		//demo3();
		
		//將時間字符串轉換成日期對象
		String str = "2000年08月08日 08:08:08";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		Date d = sdf.parse(str);						//將時間字符串轉換成日期對象
		System.out.println(d);
	}

	public static void demo3() {
		Date d = new Date();							//獲取當前時間對象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//建立日期格式化類對象
		System.out.println(sdf.format(d));				//將日期對象轉換爲字符串
	}

	public static void demo2() {
		Date d = new Date();							//獲取當前時間對象
		SimpleDateFormat sdf = new SimpleDateFormat();	//建立日期格式化類對象
		System.out.println(sdf.format(d));	 			//88-6-6 下午9:31
	}

	public static void demo1() {
		//DateFormat df = new DateFormat();				//DateFormat是抽象類,不容許實例化
		//DateFormat df1 = new SimpleDateFormat();
		DateFormat df1 = DateFormat.getDateInstance();	//至關於父類引用指向子類對象,右邊的方法返回一個子類對象
	}

}

14.18_常見對象(你來到這個世界多少天案例)(掌握)

A:案例演示
- 需求：算一下你來到這個世界多少天?

package com.heima.test;

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

public class Test2 {

	/**
	 * * A:案例演示
	 * 需求：算一下你來到這個世界多少天?
	 * 分析:
	 * 1,將生日字符串和今天字符串存在String類型的變量中
	 * 2,定義日期格式化對象
	 * 3,將日期字符串轉換成日期對象
	 * 4,經過日期對象後期時間毫秒值
	 * 5,將兩個時間毫秒值相減除以1000,再除以60,再除以60,再除以24獲得天
	 * @throws ParseException 
	 */
	public static void main(String[] args) throws ParseException {
		//1,將生日字符串和今天字符串存在String類型的變量中
		String birthday = "1983年07月08日";
		String today = "2088年6月6日";
		//2,定義日期格式化對象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
		//3,將日期字符串轉換成日期對象
		Date d1 = sdf.parse(birthday);
		Date d2 = sdf.parse(today);
		//4,經過日期對象後期時間毫秒值
		long time = d2.getTime() - d1.getTime();
		//5,將兩個時間毫秒值相減除以1000,再除以60,再除以60,再除以24獲得天
		System.out.println(time / 1000 / 60 / 60 / 24 );
	}

}

14.19_常見對象(Calendar類的概述和獲取日期的方法)(掌握)

A:Calendar類的概述
- Calendar 類是一個抽象類，它爲特定瞬間與一組諸如 YEAR、MONTH、DAYOFMONTH、HOUR 等日曆字段之間的轉換提供了一些方法，併爲操做日曆字段（例如得到下星期的日期）提供了一些方法。
B:成員方法
- public static Calendar getInstance()
- public int get(int field)

package com.heima.otherclass;

import java.util.Calendar;

public class Demo8_Calendar {

	/**
	 * * A:Calendar類的概述
			* Calendar 類是一個抽象類，它爲特定瞬間與一組諸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日曆字段之間的轉換提供了一些方法，併爲操做日曆字段（例如得到下星期的日期）提供了一些方法。
		* B:成員方法
			* public static Calendar getInstance()
			* public int get(int field)
	 */
	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();		//父類引用指向子類對象
		//System.out.println(c);					//證實重寫了toString方法打印了對象中全部的屬性
		System.out.println(c.get(Calendar.YEAR));  	//經過字段獲取對應的值
		System.out.println(c.get(Calendar.MONTH));
	}

}

14.20_常見對象(Calendar類的add()和set()方法)(掌握)

A:成員方法
- public void add(int field,int amount)
- public final void set(int year,int month,int date)
B:案例演示
- Calendar類的成員方法使用

package com.heima.otherclass;

import java.util.Calendar;

public class Demo9_Calendar {

	/**
	 * * A:Calendar類的概述
			* Calendar 類是一個抽象類，它爲特定瞬間與一組諸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日曆字段之間的轉換提供了一些方法，併爲操做日曆字段（例如得到下星期的日期）提供了一些方法。
		* B:成員方法
			* public static Calendar getInstance()
			* public int get(int field)
		* C:成員方法
			* public void add(int field,int amount)
			* public final void set(int year,int month,int date)
		* D:案例演示
			* Calendar類的成員方法使用
	 */
	public static void main(String[] args) {
		//demo1();
		Calendar c = Calendar.getInstance();			//父類引用指向子類對象
		//c.add(Calendar.MONTH, -1);					//對指定的字段進行向前減或向後加
		//c.set(Calendar.YEAR, 2000);					//修改指定字段
		c.set(2000, 7, 8);
		
		System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 
				+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
	}

	public static void demo1() {
		Calendar c = Calendar.getInstance();			//父類引用指向子類對象
		//System.out.println(c);
		System.out.println(c.get(Calendar.YEAR));		//經過字段獲取年
		System.out.println(c.get(Calendar.MONTH));		//經過字段後期月,可是月是從0開始編號的
		System.out.println(c.get(Calendar.DAY_OF_MONTH));//月中的第幾天
		System.out.println(c.get(Calendar.DAY_OF_WEEK));//週日是第一天,週六是最後一天
		
		System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 
				+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
	}
	
	/*
	 * 將星期存儲表中進行查表
	 * 1,返回值類型String
	 * 2,參數列表int week
	 */
	
	public static String getWeek(int week) {
		String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
		
		return arr[week];
	}
	
	/*
	 * 若是是個數數字前面補0
	 * 1,返回值類型String類型
	 * 2,參數列表,int num
	 */
	public static String getNum(int num) {
		/*if(num > 9) {
			return "" + num;
		}else {
			return "0" + num;
		}*/
		return num > 9 ? "" + num : "0" + num;
	}
}

14.21_常見對象(如何獲取任意年份是平年仍是閏年)(掌握)

A:案例演示
- 需求：鍵盤錄入任意一個年份，判斷該年是閏年仍是平年

package com.heima.test;

import java.util.Calendar;
import java.util.Scanner;

public class Test3 {

	/**
	 * * A:案例演示
	 * 需求：鍵盤錄入任意一個年份，判斷該年是閏年仍是平年
	 * Calendar c = Calendar.getInstance();
	 * 
	 * 分析:
	 * 1,鍵盤錄入年Scanner
	 * 2,建立Calendar c = Calendar.getInstance();
	 * 3,經過set方法設置爲那一年的3月1日
	 * 4,將日向前減去1
	 * 5,判斷日是多少天,若是是29天返回true不然返回false
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("請輸入年份,判斷該年份是閏年仍是平年:");
		//int year = sc.nextInt();
		
		String line = sc.nextLine();				//錄入數字字符串
		int year = Integer.parseInt(line);			//將數字字符串轉換成數字
		boolean b = getYear(year);
		System.out.println(b);
	}

	private static boolean getYear(int year) {
		//2,建立Calendar c = Calendar.getInstance();
		Calendar c = Calendar.getInstance();
		//設置爲那一年的3月1日
		c.set(year, 2, 1);
		//將日向前減去1
		c.add(Calendar.DAY_OF_MONTH, -1);
		//判斷是不是29天
		return c.get(Calendar.DAY_OF_MONTH) == 29;
	}

}