Day14Java基础学习

最新推荐文章于 2021-03-01 15:18:01 发布

小小飞鱼喵

最新推荐文章于 2021-03-01 15:18:01 发布

阅读量1.2k

点赞数

分类专栏：基础知识点

本文链接：https://blog.csdn.net/weixin_44400192/article/details/104163750

版权

基础知识点专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Day14

常见对象（正则表达式的概述和简单使用）
（1）正则表达式
*是指一个用来描述或者匹配一系列符合某个语法规则的字符串。其实就是一种规则。有自己特殊的应用。
作用：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个限制长度的事情就是正则表达式做的。
（2）案例演示
需求：校验qq号码
1）要求必须是5-15位数字
2） 0不能开头
3）必须都是数字
*非正则表达式的实现
*正则表达式的实现

package com.heima.regex;

public class Demo1_Regex {
	/*
	 * 需求：校验qq号码
	1）	要求必须是5-15位数字
	2）	0不能开头
	3）	必须都是数字

	 */

	public static void main(String[] args) {
		System.out.println(checkQQ("01234556"));
		System.out.println(checkQQ("ab1234556"));
		System.out.println(checkQQ("1234556"));
		
		String regex = "[1-9]\\d{4,14}";   	//正则表达式方法
		System.out.println("2553868".matches(regex));
		System.out.println("0553868".matches(regex));
	}
   /*1:明确返回值类型boolean
    * 2:明确参数列表String qq
    */
	public static boolean checkQQ(String qq) {   //构造普通方法
		boolean flag = true;			//如果校验qq不符合要求，就把flag置为false,如果符合要求直接返回ture
		
		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;
			}
		}else {
			flag = false;
		}
		return flag;
	}
}

常见对象（字符类演示）
（1）字符类：
[abc] a、b或c(简单类）
[^abc] 任何字符，除了a、b或c（否定）
[a-zA-z] a到z或A到Z，两头的字母包括在内（范围）

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) {
		String regex = "[a-z&&[^m-p]]";  //a到z,而非m到p：[a-lq-z] （减去）
		System.out.println("a".matches(regex));
		System.out.println("m".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("c".matches(regex));
		
	}

	private static void Demo6() {
		String regex = "[a-z&&[^bc]]";  //a到z,除了b和c:[ad-z] （减去）
		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));
		System.out.println("m".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));
		System.out.println("x".matches(regex));
		System.out.println("z".matches(regex));
		System.out.println("1".matches(regex));
	}

	private static void Demo3() {
		String regex = "[a-zA-Z]"; //a到z或A到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为两个字符，输出false
	}

	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));
	}

}

常见对象（预定义字符类演示）
（1）预定义字符类
.任何字符
\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) {
		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));     //true
		System.out.println("	".matches(regex));  //一个tab键,true
		System.out.println("    ".matches(regex));	//四个空格,false,代表四个字符
	}

	private static void Demo3() {
		String regex = "\\D";
		System.out.println("0".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));
	}

	private static void Demo1() {
		String regex = ".";  //一个点代表一个字符，两个代表两个
		System.out.println("a".matches(regex));
		System.out.println("ab".matches(regex));
		System.out.println("aw".matches(regex));
	}

}

常见对象（数量词）
（1） 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) {
		String regex = "[abc]{5,15}";
		System.out.println("abcba".matches(regex)); //true
		System.out.println("abcabcabcabcabc".matches(regex));//true
		System.out.println("abcb".matches(regex));//false
		System.out.println("abcbaaaaaaaasdaaassa".matches(regex));//false
	}

	private static void demo5() {
		String regex = "[abc]{5,}";
		System.out.println("abcba".matches(regex)); //true
		System.out.println("abcabcabcabcabc".matches(regex));//true
		System.out.println("abcb".matches(regex));//false
	}

	private static void demo4() {
		String regex = "[abc]{5}";
		System.out.println("abcba".matches(regex)); //true
		System.out.println("abcabcabcabcabc".matches(regex));//false
		System.out.println("abcb".matches(regex));//false
	}

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

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

	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)); //出现别的字符，false
		System.out.println("".matches(regex)); //啥也没有，一次也没有，为true
	}

}

常见对象（正则表达式的分割功能）
（1）正则表达式的分割功能
String类的功能：public String[] split(String regex)
（2）案例演示
正则表达式的分割功能


package com.heima.regex;

public class Demo5_Split {

	public static void main(String[] args) {
		String s = "金三胖.郭美美.李dayone";
		//String[] arr = s.split(".");  //.代表任意字符,用其去切啥也得不到
		String[] arr = s.split("\\.");  //\\.表示用正则表达式切割字符串
		
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		System.out.println("1111111111111");

	}

}

常见对象（把给定字符串的数字排序）
（1）案例演示
需求：我有如下一个字符串：”91 27 46 38 50”,请写代码实现最终输出结果为：“27 38 46 50 91”


package com.heima.test;

import java.util.Arrays;

public class Test1 {
	/*
	 * 需求：我有如下一个字符串：”91 27 46 38 50”,请写代码实现最终输出结果为：“27 38 46 50 91”
	 * 
	 * 分析：
	 * 1：将字符串切割成字符串数组
	 * 2：将字符串转换成数字，并将其存储在一个等长度的int数组中
	 * 3：排序
	 * 4：将排序后的结果遍历，并拼接成一个字符串
	 */

	public static void main(String[] args) {
		String s = "91 27 46 38 50";
		//1:将字符串切割成字符串数组
		String[] sArr = s.split(" ");
		// 2：将字符串转换成数字，并将其存储在一个等长度的int数组中
		int[] arr = new int[sArr.length];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = Integer.parseInt(sArr[i]);  //将数字字符串转换成数字
		}
		 //3：排序
		Arrays.sort(arr);
		
		//4:将排序后的结果遍历，并拼接成一个字符串
		/*String str = " ";          //string方法，容易产生很多垃圾
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length - 1) { 
			str = str + arr[i];
		}  else {
			str = str + arr[i] + " ";
		}
	}
		System.out.println(str);*/
		
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length - 1) { 
			sb.append(arr[i]);
		}  else {
			sb.append(arr[i] + " ");
		}
	}
		System.out.println(sb);
	}
}

常见对象（正则表达式的替换功能）
（1）正则表达式的替换功能
String类的功能：public String replaceAll(String regex,String replacement)
（2）案例演示
正则表达式的替换功能

package com.heima.regex;

public class Demo6_ReplaceAll {
	/*
	 * （1）	正则表达式的替换功能
		String类的功能：public String replaceAll(String regex,String replacement)
	 */
	public static void main(String[] args) {
		String s = "wo1ai2heima";
		String regex = "\\d";   //\\d代表的是任意数字
		String s2 = s.replaceAll(regex,""); //找到数字之后都用空串替换掉
		System.out.println(s2);
	}
}

常见对象（正则表达式的分组功能）
（1）正则表达式的分组功能
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B©))中，存在四个这样的组：
((A)(B©))
(A
(B©)
©
组零始终代表整个表达式。
（2）案例演示
a. 切割
需求：请按照叠词切割：“sdqqfgkkkhjppppkl”
b. 替换
需求：我我. . . .我. . .我. 要. . .要要. . .要学. . . .学学. .学. 编. .编编.编.程.程. 程…程.
将字符串还原成：”我要学编程”

package com.heima.regex;

public class Demo7_Regex {
	/*
	 * （1）	正则表达式的分组功能
	捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B(C)))中，存在四个这样的组：
	1.   ((A)(B(C)))
	2.   (A
	3.   (B(C))
	4.   (C)
	组零始终代表整个表达式。
	（2）	案例演示
	a.	切割
	需求：请按照叠词切割："sdqqfgkkkhjppppkl"
	b.	替换
	需求：我我. . . .我. . .我. 要. . .要要. . .要学. . . .学学. .学. 编. .编编.编.程.程. 程..程.
	将字符串还原成：”我要学编程”
	 */

	public static void main(String[] args) {
		/*替换
		需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程.
		将字符串还原成：”我要学编程”
		 */
		String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程.";
		String s2 = s.replaceAll("\\.+","");
		System.out.println(s2);
		String s3 = s2.replaceAll("(.)\\1+","$1"); //$1指获取到第一组的数据
		System.out.println(s3);
	}

	private static void demo() {
		/*切割
		需求：请按照叠词切割："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]);
		}
	}

	private static void demo2() {
		//叠词 死啦死啦，恭喜恭喜
		String regex = "(..)\\1";
		System.out.println("死啦死啦".matches(regex));
		System.out.println("gxgx".matches(regex));
		System.out.println("快快来了".matches(regex));
	}

	private static void demo1() {
		//叠词 快快乐乐，高高兴兴
		String regex = "(.)\\1(.)\\2";  // \\1代表让第一组(.)又出现一次;\\2代表第二组又出现一次
		System.out.println("快快乐乐".matches(regex));
		System.out.println("高高希希".matches(regex));
		System.out.println("哈喽哈喽".matches(regex));
	}

}

常见对象（Pattern和Matcher的概述）
（1） Pattern和Matcher的概述
（2）模式和匹配器的典型调用顺序
*通过JDK提供的API，查看Pattern类的说明

*典型的调用顺序是

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

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();

	 */

	public static void main(String[] args) {
		 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")); //与上面的四行代码结果相同

	}

}

常见对象（正则表达式的获取功能）
（1）正则表达式的获取功能
Pattern和Matcher的结合使用
（2）案例演示
需求：把一个字符串中的手机号码获取出来。

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();

	 */

	public static void main(String[] args) {
		String s = "我的手机号码是18988888888,曾经用过18987654321,还用过18812345678";
		
		String regex = "1[3578]\\d{9}";   			//手机号码的正则表达式
		/*Pattern p = Pattern.compile(regex);			
	 	Matcher m = p.matcher(s);
	 	boolean b = m.matches();
	 	
	 	System.out.println(b);*/
		
		Pattern p = Pattern.compile(regex);			
	 	Matcher m = p.matcher(s);
	 	/*boolean b1 = m.find();
	 	System.out.println(b1);
	 	String s1 = m.group();
	 	System.out.println(s1);*/
	 	
	 	while(m.find())                  //找到就是true,就可以输出
	 		System.out.println(m.group());
		
	}
}

常见对象（Math类概述和方法使用）
（1） Math类概述
Math类包含用于执行基本数学运算的方法，如初等指数，对数，平方根和三角函数。
（2）成员方法

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 {
	/*
	 * （1）	Math类概述
	Math类包含用于执行基本数学运算的方法，如初等指数，对数，平方根和三角函数。
	（2）	成员方法
	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天花板
		System.out.println(Math.ceil(12.3));   //向上寻找，结果为double值,得13.0
		System.out.println(Math.ceil(12.99));	//13.0
		//floor地板
		System.out.println(Math.floor(12.3));   //向下寻找，结果为double值,得12.0
		System.out.println(Math.floor(12.93));   //向下寻找，结果为double值,得12.0
		
		//max获取两个值中的最大值
		System.out.println(Math.max(21,34));
		
		//pow前面的数为底数，后面的数为指数
		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(2.3f));
		
		//sqrt开方
		System.out.println(Math.sqrt(2));
		
	}

}

常见对象（Random类的概述和方法使用）
（1） Random类的概述
此类用于产生随机数如果用相同的种子创建两个Random实例；
则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
（2）构造方法
public int nextInt()
public int netxInt(int n)

package com.heima.otherclass;

import java.util.Random;

public class Demo2_Random {
	/*（1）	Random类的概述
	此类用于产生随机数如果用相同的种子创建两个Random实例；
	则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
	（2）	构造方法
	public int nextInt()
	public int netxInt(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));  //nextInt(n)表示输出0到n之间的随机数，包括0，不包括n
			
		}
		
		Random r2 = new Random (1000);  //指定了种子
		
		int a = r2.nextInt();
		int b = r2.nextInt();
		
		System.out.println(a);
		System.out.println(b);

	}

}

常见对象（System类的概述和方法使用）
（1） System类的概述
System类包含一些有用的类字段和方法。它不能被实例化。
（2）成员方法
public static void gc()
public static void exit(int status)
public static long currentTimeMillis()
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
（3）案例演示：System类的成员方法使用

package com.heima.otherclass;

public class Demo3_System {
	/*
	 * （1）	System类的概述
	System类包含一些有用的类字段和方法。它不能被实例化。
	（2）成员方法
	public static void gc()
	public static void exit(int status)
	public static long currentTimeMillis()
	public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
	（3）案例演示：System类的成员方法使用

	 */

	public static void main(String[] args) {
		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.arraycopy(src, 0, dest, 0, src.length); //将数组内容拷贝，src被拷贝数组，dest要拷贝到的地方
		for (int i = 0; i < dest.length; i++) {
			System.out.println(dest[i]);	//拷贝后
			
		}
		
	}

	private static void demo3() {
		long start = System.currentTimeMillis();  //获取当前时间的毫秒值
		for(int i = 0;i < 1000;i++) {
			System.out.println("*");
		}
		long end = System.currentTimeMillis();
		
		System.out.println(end - start);
	}

	private static void demo2() {
		System.exit(0);    			 //非0状态是异常终止，推出jvm
		System.out.println("111111111");  //不会输出了，因为上一行语句已经推出了java虚拟机
	}

	private static void demo1() {
		for(int i = 0; i < 100; i++) {
			new Demo();
			System.gc();  //运行垃圾回收器，相当于呼喊保洁阿姨
		}
	}

}
 class Demo {   //在一个源文件中，不允许定义两个用public修饰的类
	 public void finalize() {
		 System.out.println("垃圾被清扫了");
	 }
 }

常见对象（BigInteger类的概述和方法使用）
（1） BigInteger类的概述
可以让超过Integer范围的数据进行运算
（2）构造方法
public BigInteger add(BigInteger val)
（3）成员方法
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 {
	/*
	 * （1）	BigInteger类的概述
	可以让超过Integer范围的数据进行运算
	（2）	构造方法
	public BigInteger add(BigInteger val)
	（3）	成员方法
	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 = 12345678908765432123L;  //长度超过
		//String s = "12345678908765432123";   //在字符串中不会报错
		
		BigInteger bil = new BigInteger("100");
		BigInteger bi2 = new BigInteger("2");
		
		System.out.println(bil.add(bi2));    //+
		System.out.println(bil.subtract(bi2));    //-
		System.out.println(bil.multiply(bi2));    //*
		System.out.println(bil.multiply(bi2));    //*
		System.out.println(bil.divide(bi2));    //除
		
		BigInteger [] arr = bil.divideAndRemainder(bi2); //取除数和余数
		for (int i = 0; i < arr.length; i++) {   
			System.out.println(arr[i]);
		}
	}

}

常见对象（BigDecimal类的概述和方法使用）
（1） BigDecimal类的概述
由于在运算的时候，float类型和double很容易丢失精度，演示案例。
所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

不可变的、任意精度的有符号十进制数。
（2）构造方法
public BigDecimal (String val)
（3）成员方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
（4）案例演示
BigDecimal类的构造方法和成员方法的使用

package com.heima.otherclass;

import java.math.BigDecimal;

public class Demo5_BigDecimal {
	/*
	 * （1）	BigDecimal类的概述
	由于在运算的时候，float类型和double很容易丢失精度，演示案例。
	所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
	
	不可变的、任意精度的有符号十进制数。
	（2）	构造方法
	public BigDecimal (String val)
	（3）	成员方法
	public BigDecimal add(BigDecimal augend)
	public BigDecimal subtract(BigDecimal subtrahend)
	public BigDecimal multiply(BigDecimal multiplicand)
	public BigDecimal divide(BigDecimal divisor)
	（4）	案例演示
	BigDecimal类的构造方法和成员方法的使用
	 
	例子： 十进制表示1/3，0.333333333333333333333333333333

	 */

	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));
	
	}

}

常见对象（Date类的概述和方法使用）
（1） Date类的概述
类 Date 表示特定的瞬间，精确到毫秒
（2）构造方法
public Date()
public Date(long date)
（3）成员方法
public long getTime()
public void setTime(long time)


package com.heima.otherclass;

import java.util.Date;

public class Demo6_Date {
	/*
	 * （1）	Date类的概述(util包下的)
	类 Date 表示特定的瞬间，精确到毫秒
	（2）	构造方法
	public Date()
	public Date(long date)
	（3）	成员方法
	public long getTime()
	public void setTime(long time)
	 */

	public static void main(String[] args) {
		Date d1 = new Date();
		d1.setTime(1000);    	//设置毫秒值，改变时间对象
		System.out.println(d1);
	}

	private static void demo2() {
		Date d1 = new Date();
		System.out.println(d1.getTime());	//通过时间对象获取毫秒值
		System.out.println(System.currentTimeMillis()); //通过系统类的方法获取当前时间毫秒值
	}

	private static void demo1() {
		Date d1 = new Date();		//如果没有参数代表的是当前时间
		System.out.println(d1);
		
		Date d2 = new Date(0);   	//	如果构造方法中参数传为0，代表的时1970年1月1日
		System.out.println(d2);		//通过毫秒值创建时间对象
	}

}

常见对象（SimpleDateFormat类实现日期和字符串的相互转换）
（1） DateFormat类的概述
DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用子类SimpleDateFormat.
（2） SimpleDateFormat构造方法
public SimpleDateFormat()
public SimpleDateFormat(String pattern)
（3）成员方法
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 {
	/*
	 * （1）	DateFormat类的概述
	DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用子类SimpleDateFormat.
	（2）	SimpleDateFormat构造方法
	public SimpleDateFormat()
	public SimpleDateFormat(String pattern)
	（3）	成员方法
	public final String format(Date date)
	public Date parse(String source)

	 */
	public static void main(String[] args) throws ParseException {
		
		//将时间字符串转换成日期对象
		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);
	
	}

	private static void demo3() {
		Date d = new Date(); 		//获取当前时间对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); //创建日期格式化类对象
		System.out.println(sdf.format(d));//将日期对象转换成字符串
	}

	private static void demo2() {
		Date d = new Date(); 		//获取当前时间对象
		SimpleDateFormat sdf = new SimpleDateFormat();
		System.out.println(sdf.format(d));
	}

	private static void demo1() {
		//DateFormat df = new DateFormat();  //DateFormat是抽象类，不允许实例化
		//DateFormat df1 = new SimpleDateFormat();
		DateFormat df1 = DateFormat.getDateInstance();  //相当于分类引用指向子类对象，右边的方法返回一个子类对象
	}

}

常见对象（你来到这个世界多少天案例）
（1）案例演示：你来到这个世界多少天？


package com.heima.test;

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


public class Test2 {
	/*
	 * （1）	案例演示：你来到这个世界多少天？
	 * 分析：
	 * 1:将生日字符串和今天字符串存在String类型的变量中
	 * 2：定义日期格式化对象
	 * 3：将日期字符串转换成日期对象
	 * 4：通过日期对象后期时间毫秒值
	 * 5：将两个时间毫秒值相减除以1000，再除以60，再除以60，再除以24得到天
	 */
	public static void main(String[] args) throws ParseException {
		//1:将生日字符串和今天字符串存在String类型的变量中
		String birthday = "1996年05月07日";
		String today = "2020年02月03日";
		//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 / 365);	
	}
}

常见对象（Calendar类概述和获取日期的方法）
（1） Calendar类的概述
Calendar类是一个抽象类，它为特定瞬间与一组诸如 YEAR、 MONTH、 DAY_OF_MONTH、 HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
（2）成员方法
public static Calendar getInstance()
public int get (int field)

package com.heima.otherclass;

import java.util.Calendar;

public class Demo8_Calender {
	/*
	* （1）	Calendar类的概述
	Calendar类是一个抽象类，它为特定瞬间与一组诸如 YEAR、 MONTH、 DAY_OF_MONTH、 HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
	（2）	成员方法
	public static Calendar getInstance()
	public int get (int field)

	 */

	public static void main(String[] args) {
		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];
	}

	/*
	 *如果是个位数字，数字前面补零
	 *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;
}
}

常见对象（Calendar类的add()和set()方法）
（1）成员方法
public void add(int field,int amount)
public final void set(int year,int month,int date)
（2）案例演示
Calendar类的成员方法使用

package com.heima.otherclass;

import java.util.Calendar;

public class Demo8_Calender {
	/*
	* （1）	Calendar类的概述
	Calendar类是一个抽象类，它为特定瞬间与一组诸如 YEAR、 MONTH、 DAY_OF_MONTH、 HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
	（2）	成员方法
	public static Calendar getInstance()
	public int get (int field)

	 */

	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();  //父类引用指向子类对象
		//c.add(Calendar.YEAR, 1);         	  //对指定字段进行向前减或向后加
		//c.set(Calendar.YEAR,2000);  		  //修改指定字段
		c.set(2000,8,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)));
		
	}
	private static void deno1() {
		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];
	}

	/*
	 *如果是个位数字，数字前面补零
	 *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;
}
}

常见对象（如何获取任意年份是平年还是闰年）
（1）案例演示
需求：键盘录入任意一个年份，判断该年是闰年还是平年）

package com.heima.test;

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

public class test3 {
		/*
		 * 需求：键盘录入任意一个年份，判断该年是闰年还是平年
		 * Calendar c = Calendar.getInstance();
		 * 
		 * 分析：
		 * 1：键盘录入年Scanner
		 * 2:创建Calendar对象
		 * 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对象
			Calendar c = Calendar.getInstance();
			//通过set方法设置为那一年的3月1日
			c.set(year,2,1);
			c.add(Calendar.DAY_OF_MONTH,-1);
			return c.get(Calendar.DAY_OF_MONTH) == 29;
		}

}

小小飞鱼喵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day14Java基础学习

Day14常见对象（正则表达式的概述和简单使用）（1）正则表达式*是指一个用来描述或者匹配一系列符合某个语法规则的字符串。其实就是一种规则。有自己特殊的应用。作用：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个限制长度的事情就是正则表达式做的。（2）案例演示需求：校验qq号码1）要求必须是5-15位数字2） 0不能开头3）必须都是数字*非正则表达式的实现...
复制链接

扫一扫