java_14正则表达式Pattern,Matcher,Math，Random，System，BigInteger，BigDecimal,Date,SimpleDateFormat，Calendar
s’d2019.2.16 14：54 天气热
正则表达式：
*定义：一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。
*作用：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个长度的事情就是正则表达式做的。
14.01_常见对象-（字符类）
字符类
- [abc] a,b,或c（简单类）
- [^abc] 任意字符，除了a,b或c（否定）
- [a-z A-Z] a到z或A到Z，两头的字母包括在内（范围）
- [0-9] 0到9的字符都包括
实现代码
package com.heima.Regex;
public class demo2T_Regex {
public static void main(String[] args) {
demo1();
System.out.println("----------");
demo2();
System.out.println("----------");
demo3();
System.out.println("----------");
demo4();
}
private static void demo4() {
String regex = "[0-9]";
System.out.println("1".matches(regex));
System.out.println("0".matches(regex));
System.out.println("d".matches(regex));
System.out.println("9".matches(regex));
}
private static void demo3() {
String regex = "[a-zA-Z]";
System.out.println("a".matches(regex));
System.out.println("z".matches(regex));
System.out.println("A".matches(regex));
System.out.println("1".matches(regex));
}
private static void demo2() {
String regex = "[^abc]";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("d".matches(regex));
System.out.println("1".matches(regex));
}
private static void demo1() {
String regex = "[abc]";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("d".matches(regex));
System.out.println("10".matches(regex));
}
}
程序结果：
true
true
false
false
false
false
true
true
true
true
true
false
true
true
false
true
14.02_常见对象（预定义字符）
A:预定义字符类
-
. 任何字符
-
\d 数字：**[0-9]*
-
\D 非数字 [^0-9]
-
s 空白字符 [ \t \n \r \x0B \f ]
- \t 的意思是 ：水平制表符。将当前位置移到下一个tab位置。
- \r 的意思是： 回车。将当前位置移到本行的开头。
- \n 的意思是：回车换行。将当前位置移到下一行的开头。
- \f的意思是：换页。将当前位置移到下一页的开头。
-
\S 非空白字符 [^\s]
-
\w 单词字符：[a-z A-Z 0-9]
-
\W 非单词字符：[^\w]
实现代码：
package com.heima.Regex;
public class regex3_Regex {
public static void main(String[] args) {
demo1();
System.out.println("----------");
demo2();
System.out.println("----------");
demo3();
System.out.println("----------");
demo4();
System.out.println("----------");
demo5();
System.out.println("----------");
demo6();
System.out.println("----------");
demo7();
System.out.println("----------");
demo8();
}
private static void demo8() {
String regex = "\\W"; //非单词字符（除了字母，数字）
System.out.println("a".matches(regex)); //false
System.out.println("Z".matches(regex)); //false
System.out.println("_".matches(regex)); //false
System.out.println("0".matches(regex)); //false
System.out.println("%".matches(regex)); //true
}
private static void demo7() {
String regex = "\\w"; //单词字符（数字和字母）
System.out.println("a".matches(regex)); //true
System.out.println("Z".matches(regex)); //true
System.out.println("_".matches(regex)); //true
System.out.println("0".matches(regex)); //true
System.out.println("%".matches(regex)); //false
}
private static void demo6() {
String regex = "\\S"; //非空白字符
System.out.println(" ".matches(regex)); //false
System.out.println(" ".matches(regex));//table//false
System.out.println("a".matches(regex)); //true
}
private static void demo5() {
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 demo4() {
String regex = "\\D"; //非数字字符
System.out.println("9".matches(regex)); //false
System.out.println("0".matches(regex)); //false
System.out.println("a".matches(regex)); //true
}
private static void demo3() {
String regex = "\\d"; //数字字符
System.out.println("9".matches(regex)); //true
System.out.println("0".matches(regex)); //true
System.out.println("a".matches(regex)); //false
}
private static void demo2() {
demo3();
}
private static void demo1() {
String regex = "."; //一个点代表一个任意字符
System.out.println("a".matches(regex)); //true
System.out.println("ab".matches(regex)); //false
}
}
程序结果：
true
false
true
true
false
true
true
false
false
false
true
true
true
false
false
false
true
true
true
true
true
false
false
false
false
false
true
14.03_常见对象（数量词）
- 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 {
public static void main(String[] args) {
demo1();
System.out.println("-----------------");
demo2();
System.out.println("-----------------");
demo3();
System.out.println("-----------------");
demo4();
System.out.println("-----------------");
demo5();
System.out.println("-----------------");
demo6();
}
private static void demo6() {
String regex = "[abc]{5,10}"; //至少5次，不超过10次，包含头也包含尾
System.out.println("aaaaa".matches(regex)); //true
System.out.println("abcabc".matches(regex)); //true
System.out.println("abcaaaaaaaaaa".matches(regex)); //false
System.out.println("aaaaaaaaaaa".matches(regex)); //false
System.out.println("dddd0".matches(regex)); //false
}
private static void demo5() {
String regex = "[abc]{5,}"; //至少5次
System.out.println("aaaaa".matches(regex)); //true
System.out.println("abcabc".matches(regex)); //true
System.out.println("abca".matches(regex)); //false
System.out.println("aaaa".matches(regex)); //false
System.out.println("dddd".matches(regex)); //false
}
private static void demo4() {
String regex = "[abc]{1}"; //恰好一次
System.out.println("".matches(regex)); //false
System.out.println("a".matches(regex)); //true
System.out.println("ac".matches(regex)); //false
System.out.println("aa".matches(regex)); //false
}
private static void demo3() {
String regex = "[abc]+"; //1次或（到）多次
System.out.println("".matches(regex)); //false
System.out.println("a".matches(regex)); //true
System.out.println("abc".matches(regex)); //true
System.out.println("aa".matches(regex)); //true
System.out.println("ddd".matches(regex)); //false
}
private static void demo2() {
String regex = "[abc]*"; //零次或（到）多次
System.out.println("".matches(regex)); //true
System.out.println("a".matches(regex)); //true
System.out.println("abc".matches(regex)); //true
System.out.println("aa".matches(regex)); //true
System.out.println("ddd".matches(regex)); //false
}
private static void demo1() {
String regex = "[abc]?"; //出现一次或者一次也没有，针对于[abc]而言，对其他字符不行
System.out.println("".matches(regex)); //true
System.out.println("a".matches(regex)); //true
System.out.println("d".matches(regex)); //false
System.out.println("aa".matches(regex)); //false
}
}
程序结果：
true
true
false
false
true
true
true
true
false
false
true
true
true
false
false
true
false
false
true
true
false
false
false
true
true
false
false
false
14.05_常见对象(正则表达式的分割功能)
新知识梗概：
正则表达式的分割功能
String类的功能：public String[] split(String regex)
根据匹配给定的正则表达式来拆分此字符串
返回类型：String[ ]
代码练习
package com.heima.Regex;
public class demo5_Regex {
public static void main(String[] args) {
String s = " aaa bbb ccc ddd";
String []arr1 = s.split(" "); //空格作为正则表达式
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
System.out.println("-------");
String s2 = "aaa.bbb.ccc.ddd"; //"."作为正则表达式
String regex = "\\."; //“\\”是转义符
String []arr2 = s2.split(regex);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]);
System.out.println();
}
}
}
程序结果：
aaa
bbb
ccc
ddd
aaa
bbb
ccc
ddd
14.06_常见对象（常见对象(正则表达式的替换功能)）
知识：正则表达式的替换功能
实现方法：String类的功能：public String replaceAll(String regex,String replacement) 将regex匹配的字符全部替换为replacement
代码练习；
package com.heima.Regex;
public class demo8_regex {
public static void main(String[] args) {
String s1 = "wo321yao4cheng6132wei21hei233ma65644chengx2vyuan"; //数字字母混合字符串
String regex = "\\d"; // "\\d" 代表数字字符串
String s2 = s1.replaceAll(regex, ""); //将数字字符全部替换为空字符
System.out.println(s2);
}
}
程序结果：
woyaochengweiheimachengxvyuan
14.07_常见对象（正则表达式的分组功能）
*知识：
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B©)) 中，存在四个这样的组：
*
1 ((A)(B©))
2 (A)
3 (B©)
4 ©
组零始终代表 整个表达式。
public class demo9_regex {
public static void main(String[] args) {
//叠词 快快乐乐，高高兴兴
String regex = "(.)\\1(.)\\2"; //(.)\\1代表第一组又出现一次，(.)\\2代表第二组又出现一次
System.out.println("快快乐乐".matches(regex));
System.out.println("快快快乐".matches(regex));
System.out.println("高高兴兴".matches(regex));
System.out.println("----------");
//叠词 快乐快乐，高兴高兴
String regex2 = "(..)\\1"; // 表示任意两个字符成一组，第一组再出现一次
System.out.println("快快乐乐".matches(regex2));
System.out.println("快乐快乐".matches(regex2));
System.out.println("高高兴兴".matches(regex2));
}
}
程序结果：
true
false
true
false
true
false
(练习）
程序练习题1 ：把给定字符串中的数字字符排需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91*”
1.分析：
（1）将字符串切割成单个数字字符
实现方法：String类 中的split（）方法
（2）将字符数组的元素转换为int类型存储在int数组中（因为字符类型元素排序是根据第一个数字字符排序的（如100 会小于80））
实现方法： Intager包装类中的parseInt() 方法
（3）将数组进行排序
实现方法： 可以用选择排序或者冒泡排序
或者Arrays中的sort()方法
（4）将Int数组中元素拼接成字符串
实现方法： String 的空串进行拼接（由于是不可变字符序列，会造成很多垃圾）
StringBuilder 进行拼接（可变字符串）
实现代码：
package com.heima.text;
import java.util.Arrays;
public class text {
public static void main(String[] args) {
String s = "91 27 46 38 50"; //原始字符串
//1.将字符串切割成成字符数组,split()
String regex = "\\s";
String[] arr1 = s.split(regex);
//2.将字符数组中的字符串转换成数字，再存储在一个等长度的int类型数组中,parseInt()
int[] arr2 = new int[arr1.length]; //创建一个等长度的int类型数组
for (int i = 0; i < arr2.length; i++) {
arr2[i] = Integer.parseInt(arr1[i]);
}
//3.将数组进行排序，sort（）
Arrays.sort(arr2);
//4.将int类型数组转换成字符串,append()
StringBuilder sb = new StringBuilder(); //新建一个可变字符串类对象
for (int i = 0; i < arr2.length; i++) {
if(i == arr2.length-1) {
sb.append(arr2[i]);
}else {
sb.append(arr2[i] + " ");
}
}
//5.打印
System.out.println(sb);
}
}
}
}
代码结果：
27 38 46 50 91
14.08_(正则表达式的分组功能)
- 案例演示
- A :切割
需求：请按照叠词切割： “sdqqfgkkkhjppppkl”;
代码实现
public class demo9_regex {
public static void main(String[] args) {
String s1 = "sdqqfgkkkhjppppkl";
String regex = "(.)\\1+"; //代表第一组出现一次到多次
String []arr1 = s1.split(regex);
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
}
}
程序结果：
sd
fg
hj
kl
案例演示
-
B:替换
需求：我我…我…我.要…要要…要学…学学…学.编…编编.编.程.程.程…程
将字符串还原成:“我要学编程”。分析：
（1）将字符串以"“空字符代替”."成 我我我我要要要要学学学学编编编编程程程程
（2）将 我我我我要要要要学学学学编编编编程程程程 成 我要学编程
代码实现
public class demo9_regex {
public static void main(String[] args) {
String s1 = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
System.out.println(s1);
System.out.println("----------");
String regex = "\\.+"; //代表.字符出现一次到多次
String s2 = s1.replaceAll(regex, "");
System.out.println(s2);
System.out.println("-----------");
String regex2 = "(.)\\1+"; // 代表任意字符出现一次或者多次
String s3 = s2.replaceAll(regex2, "$1"); //$1代表第一组内容
System.out.println(s3);
}
}
程序结果：
我我…我…我.要…要要…要学…学学…学.编…编编.编.程.程.程…程
我我我我要要要要学学学学编编编编程程程程
我要学编程
14.09_常见对象(Pattern和Matcher的概述)
java.util.regex.Pattern
Pattern
正则表达式的编译表示形式。
指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
因此，典型的调用顺序是
Pattern p = Pattern.compile(“a*b”); // 获取正则表达式的Pattern模式实例
Matcher m = p.matcher(“aaaaab”); //获取指定输入与模式的匹配器
boolean b = m.matches(); // 将字符串与正则表达式进行匹配
在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句
boolean b = Pattern.matches(“a*b”, “aaaaab”);
等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。
此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。
public final class Matcher
通过解释 Pattern 对 character sequence 执行匹配操作的引擎。
通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：
-
matches 方法尝试将整个输入序列与该模式匹配。
-
lookingAt 尝试将输入序列从头开始与该模式匹配。
-
find 方法扫描输入序列以查找与该模式匹配的下一个子序列。
其中的方法及功能：
（1）Pattern中的compile(String regex)
返回类型：static Pattern
将给定的正则表达式编译到模式中
（2）Pattern 中的matcher(CharSequence input)
返回类型 :Matcher
创建匹配给定输入与此模式的匹配器。
(3)Matcher 中的 matches()
尝试将整个区域与模式匹配。
14.10_常见对象(正则表达式的获取功能)
- A:正则表达式的获取功能
- Pattern和Matcher的结合使用
- B:案例演示
- 需求：把一个字符串中的手机号码获取出来
作用：可以在一堆字符串中获取到手机号码或者邮箱等，可用于商业广告的发送（垃圾广告，但是也会有人阅读，是比较廉价有效的推广方式之一）
分析：
（1）创建手机号码正则表达式
（2）创建匹配器
（3）利用Matcher中的find()方法
作用：到指定字符串中挨个找符合规则的字符串
返回类型：boolean
（4）用Matcher中的group（）
作用：返回以前所匹配到的子序列
返回类型：String
（5）利用while循环获取全部（find相当于有一个指针，自动随着检索而自增）
- 需求：把一个字符串中的手机号码获取出来
代码实现：
package com.heima.Regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class demo_10 {
public static void main(String[] args) {
String s = "我现在的号码是13556540583，以前的号码是15521113987，还用过号码13426954875";
String regex = "1[234578]\\d{9}"; //手机号码的正则表达式
Pattern p = Pattern.compile(regex); //获取正则表达式模式
Matcher m = p.matcher(s); //获取指定输入字符串与该模式的匹配器
while(m.find()) { //挨个字符进行拼配
System.out.println(m.group()); //匹配上就进行打印
}
}
}
程序结果：
13556540583
15521113987
13426954875
14.11_常见对象(Math类概述和方法使用)
学习知识：
A:Math类概述
* Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
B:成员方法
* public static int abs(int a)
* //取绝对值，返回int类型
* public static double ceil(double a)
* //天花板，向上取整，返回一个double类型
* public static double floor(double a)
* //地板，向下取整，返回一个double类型
* public static int max(int a,int b)； min求最小值
* //返回两个数最大值，可以为int,long.float.double类型
* public static double pow(double a,double b)
* //前数为底，后数为指数,返回一个double类型数
* public static double random()（包含头不包含尾）
* //返回一个0.0-1.0之间的随机小数，包括0.0，不包括1.0
* public static int round(float a)； double
* //四舍五入,数据类型可以为double或者float
* public static double sqrt(double a)
* //取平方根，参数类型double
代码练习：
package com.heima.Math;
public class demo1 {
public static void main(String[] args) {
//输出圆周率,字段
System.out.println(Math.PI);
System.out.println("_____");
//取绝对值，返回int类型
System.out.println(Math.abs(-10));
System.out.println(Math.abs(10));
System.out.println("_____");
//天花板，向上取整，返回一个double类型
System.out.println(Math.ceil(12.3));
System.out.println(Math.ceil(11.99));
System.out.println("_____");
//地板，向下取整，返回一个double类型
System.out.println(Math.floor(12.3));
System.out.println(Math.floor(11.99));
System.out.println("_____");
//返回两个数最大值，可以为int,long.float.double类型
System.out.println(Math.max(10, 20));
System.out.println(Math.max(1.5, 4.5));
System.out.println(Math.max(7.8f, 4.5f));
System.out.println(Math.max(720L, 45L));
System.out.println("_____");
//返回两个数最小值，可以为int,long.float.double类型
System.out.println(Math.min(10, 20));
System.out.println(Math.min(1.5, 4.5));
System.out.println(Math.mim(7.8f, 4.5f));
System.out.println(Math.min(720L, 45L));
System.out.println("_____");
//前数为底，后数为指数,返回一个double类型数
System.out.println(Math.pow(2, 3));
System.out.println("_____");
//返回一个0.0-1.0之间的随机小数，包括0.0，不包括1.0
System.out.println(Math.random());
System.out.println("_____");
//四舍五入,数据类型可以为double或者float
System.out.println(Math.round(4.4F));
System.out.println(Math.round(5.8));
//取平方根
System.out.println("_____");
System.out.println(Math.sqrt(64));
System.out.println(Math.sqrt(2));
System.out.println(Math.sqrt(3));
}
}
程序结果：
3.141592653589793
10
10
13.0
12.0
12.0
11.0
20
4.5
7.8
720
10
1.5
4.5
45
8.0
0.9621352321896282
4
6
8.0
1.4142135623730951
1.7320508075688772
14.12_常见对象(Random类的概述和方法使用)
A:Random类的概述
*此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
- 此类的实例用于生成伪随机数流
- B:构造方法
- public Random()
- public Random(long seed)
- C:成员方法 int nextInt(int n)
返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。 - public int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值 - public int nextInt(int n)(重点掌握)
package com.heima.otherclass;
import java.util.Random;
public class demo2_Random {
public static void main(String[] args) {
Random r = new Random(); //无参构造，根据纳秒值作为种子，种子以纳秒变化，每次运行结果不一样
for (int i = 0; i < 10; i++) {
System.out.println(r.nextInt());
}
System.out.println("_______");
Random r2 = new Random(1000); //有参构造，根据指定种子进行算随机数的，种子一定， 第一次运行结果跟第二次一样
int a = r2.nextInt();
int b = r2.nextInt();
System.out.println(a);
System.out.println(b);
}
}
14.13_常见对象(System类的概述和方法使用)
-
A:System类的概述
- public final class System extends Object
- System 类包含一些有用的类字段和方法。它不能被实例化。
-
B:成员方法
- public static void gc() // 运行垃圾回收器（相当于你扔了垃圾后喊保洁阿姨） 运行处于挂起终止状态的所有对象的终止方法。
- 调用该方法说明 Java 虚拟机做了一些努力运行已被丢弃对象的 finalize 方法，但是这些对象的 finalize 方法至今尚未运行。当控制权从方法调用中返回时，Java 虚拟机已经尽最大努力去完成所有未执行的终止方法。
其中:finalize() //相当于呼喊保洁阿姨过来清理垃圾
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
调用 System.runFinalization() 实际上等效于调用：
Runtime.getRuntime().runFinalization()
-
public static void exit(int status) //终止当前正在运行的 Java 虚拟机。
参数用作状态码；根据惯例，非 0 的状态码表示异常终止,0代表正常终止 -
public static long currentTimeMillis() // 返回1970.1.1起以毫秒为单位的当前时间。
-
pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) // 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量
代码练习：
package com.heima.otherclass;
public class Demo_System {
public static void main(String[] args) {
demo1();
System.out.println("_____________");
//demo2();
//System.out.println("_____________");
demo3();
System.out.println("_____________");
demo4();
}
private static void demo4() {
int []src = {11,22,33,44,55 }; // 原数组
int []dest = new int[7]; //目标数组
System.out.println("数组赋值前：");
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
System.out.println("数组复制后：");
System.arraycopy(src, 0, dest, 0, 5);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
private static void demo3() {
long start = System.currentTimeMillis(); //起始时间
System.out.println(start);
for (int i = 0; i < 10; i++) {
System.out.println("我是黑马");
}
long end = System.currentTimeMillis(); //结束时间
System.out.println(end);
long time = end - start; //循环运行时间1s = 1000ms
System.out.println(time);
}
private static void demo2() {
System.exit(0); //0为正常终止，退出jvm
System.out.println("我是彬哥"); //退出jvm后，程序不往下执行
}
private static void demo1() {
for (int i = 0; i < 10; i++) {
new Demo(); //当垃圾数量较多时，会自动调用finalize
System.gc(); //运行垃圾回收器，相当于呼喊保洁阿姨
}
}
}
class Demo {
@Override
protected void finalize() {
System.out.println("垃圾被清扫了");
}
}
程序结果：
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
垃圾被清扫了
1540864961234
我是黑马
我是黑马
我是黑马
我是黑马
我是黑马
我是黑马
我是黑马
我是黑马
我是黑马
我是黑马
结束时间：
1540864961235
运行时间：
1
数组赋值前：
0
0
0
0
0
0
0
数组复制后：
11
22
33
44
55
0
0
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)
返回包含 (this / val) 后跟 (this % val) 的两个对象元素的 BigInteger 的数组。
代码练习：
package com.heima.otherclass;
import java.math.BigInteger;
public class Demo_Biginteger {
public static void main(String[] args) {
//int a = 12345678912; //超出int存储范围
//long b = 12345678912; //超出long的存储范围
BigInteger bt1 = new BigInteger("456");
BigInteger bt2 = new BigInteger("123");
System.out.println("两个bigInteger数为:"+ bt1 +"和" + bt2);
BigInteger bt3 = bt1.add(bt2); //加
System.out.println("两者之和：" + bt3);
System.out.println("_________");
BigInteger bt7 = bt1.subtract(bt2); //减
System.out.println("两者之差：" + bt7);
System.out.println("_________");
BigInteger bt4 = bt1.divide(bt2); //除
System.out.println("两者之商：" + bt4);
System.out.println("_________");
BigInteger bt5 = bt1.multiply(bt2); //积
System.out.println("两者之积：" + bt5);
System.out.println("_________");
BigInteger []bt6 = bt1.divideAndRemainder(bt2); //求余和除数(商)
System.out.println("两者的商以及余数：" );
for (int i = 0; i < bt6.length; i++) {
System.out.println(bt6[i]);
}
}
}
程序结果：
两个bigInteger数为:456和123
两者之和：579
两者之差：333
两者之商：3
两者之积：56088
两者的商以及余数：
3
87
14.15_常见对象(BigDecimal类的概述和方法使用)
- A:BigDecimal的概述
- 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
- 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
- 不可变的、任意精度的有符号十进制数。
- B:构造方法
- public BigDecimal(String val)
拓展：BigDecimal.valueof(double sal) - 使用 Double.toString(double) 方法提供的 double 规范的字符串表示形式将 double 转换为 String。
- 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)*
代码练习：
package com.heima.otherclass;
import java.math.BigDecimal;
public class Demo_BigDecimal {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("2.2"); //通过构造中数字字符串传入，开发中推荐，不丢失精度
BigDecimal bd2 = new BigDecimal("1.1");
System.out.println(bd1.subtract(bd2));
BigDecimal bd3 = BigDecimal.valueof(8.8); //通过调用静态方法，其实底层也是new去创建对象，这种方式也推荐
BigDecimal bd4 = BigDecimal.valueof(2.2);
System.out.println(bd3.subtract(bd4));
System.out.println("________");
System.out.println(bd1.add(bd2));
System.out.println(bd3.add(bd4));
System.out.println("________");
System.out.println(bd1.divide(bd2));
System.out.println(bd3.divide(bd4));
System.out.println("________");
System.out.println(bd1.multiply(bd2));
System.out.println(bd3.multiply(bd4));
}
}
14.16_常见对象(Date类的概述和方法使用)(掌握)
A:Date类的概述
* 类 Date 表示特定的瞬间，精确到毫秒。
- B:构造方法
- public Date()
- 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
- public Date(long date)
- 分配 Date 对象并初始化此对象，
- 以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
- C:成员方法
-
public long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 -
public void setTime(long time)
setTime(long time)
设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。 -
拓展： （1）肯汤逊的小故事
1969年8月，贝尔实验室的程序员肯汤普逊利用妻儿离开一个月的机会，
开始着手创造一个全新的革命性的操作系统，
他使用B编译语言在老旧的PDP-7机器上开发出了Unix的一个版本。
随后，汤普逊和同事丹尼斯里奇改进了B语言，开发出了C语言，
重写了UNIX，新版于1971年发布。
1970年1月1日 算 UNIX 和 C语言 生日。
最初计算机操作系统是32 位，而时间也是用 32 位表示。
32 位能表示的最长时间是 68 年，而实际上到 2038年 01 月 19 日 03 时 14 分 07
秒，便会到达最大时间，过了这个时间点，所 有 32 位操作系统时间便会变 为
10000000 00000000 00000000 00000000也就是1901年 12月 13 日 20时 45 分 52 秒，这样便会出现时间回归的现象，很多软件便会运 行异常了。
因为用32 位来表示时间的最大间隔是 68 年，而最早出现的 UNIX 操作系统考虑到计算
机产生的年代和应用的时限综合取了 1970 年 1 月 1 日作为 UNIX TIME 的纪元时间 ( 开始
时间 ) ，而 java 自然也遵循了这一约束。至于时间回归的现象相信随着64 为操作系统 的产生逐渐得到解决，因为用 64 位操作
系统可以表示到 292,277,026,596年 12月 4 日 15时 30 分 08 秒（2）System.out.println(new Date(0))，打印出来的时间是8点而非0点，
原因是存在系统时间和本地时间的问题，其实系统时间依然是0点，只不过我的电脑时区
设置为东8区，故打印的结果是8点。
-
package com.heima.otherclass;
import java.util.Date;
public class Demo_Dare {
public static void main(String[] args) {
Date d1 = new Date(); //创建对象，存储当前系统时间
System.out.println("无参数的时间：");
System.out.println(d1);
System.out.println("有参数的时间：");
Date d2 = new Date(1000); //参数为毫秒值，显示从1970年1月1日00：00：00以来的毫秒值
System.out.println(d2);
Date d3 = new Date();
/*long t = d3.getTime();
System.out.println(t);*/
System.out.println("从1970.1.1到程序运行时的毫秒值为：");
System.out.println(d3.getTime()); //获取从1970.1.1起的毫秒值
System.out.println();
d1.setTime(1000); //设置d1 为1970.1.1+对应参数毫秒值的时间
System.out.println(d1);
}
}
程序结果：
无参数的时间：
Thu Nov 01 10:50:36 CST 2018
有参数的时间：
Thu Jan 01 08:00:01 CST 1970
从1970.1.1到程序运行时的毫秒值为：
1541040636981
无参数的时间的Date对象d1被修改后的值为：
Thu Jan 01 08:00:01 CST 1970
14.17_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)(掌握)
** A:DateFormat类的概述
* DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat(包括了父类所有的方法)
- B:SimpleDateFormat构造方法
- public SimpleDateFormat()
- public SimpleDateFormat(String pattern)
- C:成员方法
- public final String format(Date date)
将一个 Date 格式化为日期/时间字符串。 - public Date parse(String source)
解析字符串的文本，生成 Date。
代码练习：
- public final String format(Date date)
package com.heima.otherclass;
import java.text.DateFormat;
import java.text.FieldPosition;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo_SimpleDateFormat {
public static void main(String[] args) throws ParseException {
Date d = new Date(); //获取当前系统时间
System.out.println("当前系统时间：");
System.out.println(d); //显示当前时间
//demo1();
demo2(d);
demo3(d);
String t = "2018年11月1日 12:04:08"; //当前时间的数字字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); //创建自定义日期格式化类对象
System.out.println("自定义时间的自定义格式化表示：");
Date d2 = sdf.parse(t); //将时间字符串转换为日期对象,这里会抛出异常，因为避免字符串不符合格式
System.out.println(d2);
}
private static void demo3(Date d) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); //创建自定义日期格式化类对象
System.out.println("自定义日期格式化类对象表示当前时间");
System.out.println(sdf.format(d));
}
private static void demo2(Date d) {
SimpleDateFormat sdf = new SimpleDateFormat(); //创建固定好的日期格式化类对象
System.out.println("日期格式化后的当前时间：");
System.out.println(sdf.format(d));
}
/*private static void demo1() {
DateFormat df = new DateFormat(); //抽象类不能被实例化
DateFormat df2 = DateFormat.getDateInstance(); //相当于是父类引用指向之类对象，该方法底层实现创建对象，返回一个子类对象
}*/
}
程序结果：
当前系统时间：
Thu Nov 01 12:17:57 CST 2018
日期格式化后的当前时间：
18-11-1 下午12:17
自定义日期格式化类对象表示当前时间
2018年11月01日 12:17:57
自定义时间的自定义格式化表示：
Thu Nov 01 12:04:08 CST 2018
14.18_常见对象(你来到这个世界多少天案例)(掌握)
题目：
算一下你来到这个世界多少天?
1.分析：
(1)将出生日期和当前时间存储在String字符串中
(2)创建日期格式化类对象
(3)将日期字符串转化为日期对象
(4)求出两个时间的毫秒值并相减，获得生存的毫秒数
(5)算出生存天数和年数并打印
代码实现：
package Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class text1 {
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in); //创建键盘录入对象
System.out.println("请输入你的名字：");
String name = sc.nextLine();
System.out.println("请输入你的出生日期(格式为：yyyy年MM月dd日):");
String birthday = sc.nextLine(); //出生时间
System.out.println("请输入当前日期(格式为：yyyy年MM月dd日):");
String today = sc.nextLine(); //当前日期
SimpleDateFormat stf = new SimpleDateFormat("yyyy年MM月dd日"); //创建日期格式化对象
Date d1 = stf.parse(birthday); //转化
Date d2 = stf.parse(today);
System.out.println("你的名字：" + name);
System.out.println("出生日期为：" + stf.format(d1));
System.out.println("当前时间为：" + stf.format(d2));
long livingtime = d2.getTime() - d1.getTime(); //获取生存的毫秒数
System.out.println("生存的毫秒数为：" + livingtime);
int livingday = (int)(livingtime /1000/60/60/24); //获取生存天数
System.out.println("生存天数为：" + livingday ); //获取生存年数
int livingyear = livingday /365; //获取生存年数
System.out.println("生存年数：" + livingyear);
}
}
程序结果：
请输入你的名字：
binge
请输入你的出生日期(格式为：yyyy年MM月dd日):
1998年6月10日
请输入当前日期(格式为：yyyy年MM月dd日):
2018年11月2日
你的名字：binge
出生日期为：1998年06月10日
当前时间为：2018年11月02日
生存的毫秒数为：643680000000
生存天数为：7450
生存年数：20
14.19_常见对象(Calendar类的概述和获取日期的方法)(掌握)
*A:Calendar类的概述
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
- B:成员方法
- public static Calendar getInstance()
- public int get(int field)
14.20_常见对象(Calendar类的add()和set()方法)(掌握)‘
A:成员方法
* public void add(int field,int amount)
* public final void set(int year,int month,int date)
代码练习：
package com.heima.otherclass;
import java.util.Calendar;
/*
* A:Calendar类的概述
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
* B:成员方法
* public static Calendar getInstance()
* public int get(int field)
A:成员方法
* public void add(int field,int amount)
* public final void set(int year,int month,int date)
* B:案例演示
* Calendar类的成员方法使用
*/
public class Demo_Calendar {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
text(c);
c.add(c.YEAR, -1); //对特定字段向前减或者向后加
System.out.println("将年数向前减去1后：" + c.get(Calendar.YEAR));
c.set(Calendar.MONTH, 8); //修改特定字段
System.out.println("将月数设置为9月后："+(c.get(Calendar.MONTH)+1));
c.set(2000, 8, 8); //修改年月日成特定的日期
System.out.println("修改后的日期是：" + c.get(Calendar.YEAR)+"年 "+get_Num(c.get(Calendar.MONTH)+1)+"月 "+get_Num(c.get(Calendar.DAY_OF_MONTH))
+"日 " + get_WEEK(c.get(Calendar.DAY_OF_WEEK)));
}
private static void text(Calendar c ) {
System.out.println(c);
System.out.println("当前瞬间与日历字段：" + c);
System.out.println(c.get(Calendar.YEAR)); //通过字段获取年
System.out.println(c.get(Calendar.MONTH)+1); //通过字段获取月，但是月是从0开始的
System.out.println(c.get(Calendar.DAY_OF_MONTH)); //通过字段获取月中第几天
System.out.println(get_WEEK(c.get(Calendar.DAY_OF_WEEK))); //通过字段获取星期，第一天是星期日，第七天是星期六
System.out.println("今天的日期是：" + c.get(Calendar.YEAR)+"年 "+get_Num(c.get(Calendar.MONTH)+1)+"月 "+get_Num(c.get(Calendar.DAY_OF_MONTH))
+"日 " + get_WEEK(c.get(Calendar.DAY_OF_WEEK)));
}
//写一个方法按中国逻辑获取星期（查表法）
/*
分析：
1.返回类型String，参数类型int
2将星期存储在字符数组中
3通过参数匹配获取星期
*/
public static String get_WEEK(int week) {
String[] arr = {"","星期天","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[week];
}
//规范日期的月份以及天数的表示
/*
* 分析：
* 返回类型String
* 参数类型int
* 是个位数前面加0，否则不操作
*/
public static String get_Num(int num) {
return num > 9 ? "" + num :"0" + num; //条件表达式返回特定格式
}
}
程序结果：
当前瞬间与日历字段：java.util.GregorianCalendar[time=1541481786513,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=“Asia/Shanghai”,offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2018,MONTH=10,WEEK_OF_YEAR=45,WEEK_OF_MONTH=2,DAY_OF_MONTH=6,DAY_OF_YEAR=310,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=1,HOUR_OF_DAY=13,MINUTE=23,SECOND=6,MILLISECOND=513,ZONE_OFFSET=28800000,DST_OFFSET=0]
2018
11
6
星期二
今天的日期是：2018年 11月 06日 星期二
将年数向前减去1后：2017
将月数设置为9月后：9
修改后的日期是：2000年 09月 08日 星期五
14.21_常见对象(如何获取任意年份是平年还是闰年)(掌握)
代码实现：
package Test;
import java.util.Calendar;
import java.util.Scanner;
/*
A:案例演示
需求：键盘录入任意一个年份，判断该年是闰年还是平年
分析：
1.键盘录入一个String类型的年份，转化为int类型
2创建Calendar对象
3，将Calendar时间设置为键盘录入年份的3月1日
4，将DAY_OF_MONTH -1回到2月最后一天
5，获取2月的最后一天.判断是不是29天
6,输出看看是不是闰年
*/
public class text_Calendar {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //创建键盘录入对象
System.out.println("请输入年份：判断是不是闰年？");
//int year = sc.nextInt();//接收int型年份
String line = sc.nextLine(); //接收String 类型的输入的年份
int year = Integer.parseInt(line); //将字符串转换为数字
System.out.println("输入的年份是闰年吗？"+get_Year(year));
}
private static boolean get_Year(int year) {
// TODO Auto-generated method stub
Calendar c = Calendar.getInstance(); //创建Calendar对象
c.set(Calendar.YEAR, year);
c.set(year, 2, 1);
c.add(Calendar.DAY_OF_MONTH, -1); //将日数减去1
return c.get(Calendar.DAY_OF_MONTH) == 29; //判断是不是闰年
}
}
程序结果：
请输入年份：判断是不是闰年？
2088
输入的年份是闰年吗？true
C:面试题
* byte b = 10;
* b++; //底层会自动进行强制类型转换 b = (byte)(b+1)
* b = b + 1; //当byte与interesting进行运算的时候，会提升为int类型，两个int运算结果也是int
* 问哪句会报错,为什么
02.23_Java语言基础(赋值运算符的面试题)(掌握)
- A:案例演示
- 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
- short s=1;s = s+1; //short与int进行运算会自动转换为int，结果也是int
- short s=1;s+=1; // 相当于s = (short)(s+1)