JavaSE学习总结（十）常用类（下）/正则表达式/Math/Random/System/BigDecimal/Date/SimpleDateFormat/Calendar/BigInteger
常用类（下）
一、正则表达式
（一）概述
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
先举个例子来理解正则表达式：
案例演示
需求：校验qq号码.
1:要求必须是5-15位数字
2:0不能开头
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
String regex="[1-9][0-9]{4,14}";//QQ号码的正则表达式
Scanner sc = new Scanner(System.in);
System.out.println("注册——请输入符合规则的QQ号码：");
String s = sc.nextLine();
boolean matches = s.matches(regex);//判断此字符串是否匹配给定的正则表达式
if(matches){
System.out.println("输入的QQ号码符合规则");
}else{
System.out.println("输入的QQ号码不符合规则");
}
}
}
（二）正则表达式的组成规则
以下规则字符在java.util.regex.Pattern类中
1.字符
x 即字符 x。举例：‘a’表示字符a
\ 反斜线字符。
\n 新行（换行）符 (’\u000A’)
\r 回车符 (’\u000D’)
2.字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z，两头的字母也包括在内
[0-9] 0到9的字符都包括
3.预定义字符类
. 即任何字符。
那么.字符本身，怎么表示呢? .
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]包括下划线
4.边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi （空格问号分号都是单词边界）
5.Greedy 数量词
X? X出现一次或一次也没有 比如""空串 就是没有
X* X出现零次或多次 （大于等于1次 都算多次）
X+ X出现一次或多次
X{n} X出现恰好 n 次
X{n,} X出现至少 n 次
X{n,m} X出现至少 n 次，但是不超过 m 次
案例演示
public class MyTest1 {
public static void main(String[] args) {
String regex = "a";
regex = "[abcdef]"; //允许出现列表中的某一个字符
regex = "[a-z]";//允许出现26个小写字母的任意一个
regex = "[A-Za-z]";//允许出现大小写字母任意一个
regex = "[0-9]";//允许出现0-9任意一个
regex = "[a-zA-Z0-9]";//允许出现大小写字母或0-9任意一个
regex = "[^0-9]"; //^不允许出现列表中的任意一个
regex = ".";//通配单个任意字符
regex = "\\.";// \\转义字符 \\.这个意思就是匹配点.本身
regex = "\\|"; //由于|本身代表或的意思，因此需要转义
regex = "\\d";//跟[0-9]意思一样
regex = "\\w";//跟[a-zA-Z_0-9]意思一样
regex = "[a-z]+"; // +可以出现一个或多个
regex = "a?"; //一次或一次也没有 比如 "" 空串 就是没有
regex = "[a-z]*";//零次或多次 （大于等于1次 都算多次）
regex = "[a-z]{6}";//a-z正好6个
regex = "[0-9]{6,}";//0-9的数至少6个
regex = "[0-9]{6,16}";//0-9的数大于等于6个小于等于16个
boolean flag = "123499988766454343".matches(regex);
System.out.println(flag);
}
}
（三）正则表达式的判断功能
public boolean matches(String regex)判断此字符串是否匹配给定的正则表达式
案例演示
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
String regex="[1][3|5|6|7|8|9][0-9]{9}";
Scanner sc = new Scanner(System.in);
System.out.println("请输入手机号码：");
String s = sc.nextLine();
boolean matches = s.matches(regex);//判断此字符串是否匹配给定的正则表达式
if(matches){
System.out.println("输入的手机号码符合规则");
}else{
System.out.println("输入的手机号码不符合规则");
}
}
}
（四）正则表达式的分割功能
String类的功能：public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
案例演示1
有一个由个人信息组成的字符串，需要提取其中的有效信息。
public class MyTest {
public static void main(String[] args) {
String s="张三==23==男";
String regex="==";
String[] a = s.split(regex);
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
}
}
案例演示2
需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
分析:
- a: 定义目标字符串"91 27 46 38 50"
- b: 对这个字符串进行切割,得到的就是一个字符串数组
- c: 把b中的字符串数组转换成int类型的数组
(1): 定义一个int类型的数组,数组的长度就是字符串数组长度
(2): 遍历字符串数组,获取每一个元素.将其转换成int类型的数据
(3): 把int类型的数据添加到int类型的数组的指定位置 - d: 排序
- e: 创建一个StringBuilder对象,用来记录拼接的结果
- f: 遍历int类型的数组, 将其每一个元素添加到StringBuilder对象中
- g: 就是把StringBuilder转换成String
- h: 输出
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
String s="91 27 46 38 50";
String regex=" ";
String[] a = s.split(regex);
int[] b=new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i]=Integer.parseInt(a[i]);
}
Arrays.sort(b);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < b.length; i++) {
sb.append(b[i]).append(" ");
}
String s1 = sb.toString();
String s2 = s1.trim();//去掉右边的空格
System.out.println(s2);
}
}
案例演示3
去除数组中的重复元素
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
int[] arr = {10, 50, 60, 70, 80, 90, 100, 10, 50, 60, 70, 80, 90, 100, 10, 50, 60, 70, 80, 90, 100};
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
if(sb.indexOf(String.valueOf(arr[i]))==-1){//查询sb中是否有，没有添加
sb.append(arr[i]).append(" ");
}
}
String regex=" ";
String s = sb.toString();
String[] split = s.split(regex);
int[] a=new int[split.length];
for (int i = 0; i < split.length; i++) {
a[i]=Integer.parseInt(split[i]);
}
System.out.println(Arrays.toString(a));
}
}
案例演示4
给数组中添加一个元素
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
int[] arr={1,3,5,6,7,8};
int num=9;
int[] a = new int[arr.length + 1];
for (int i = 0; i < arr.length; i++) {
a[i]=arr[i];
}
a[arr.length]=num;
arr=a;//让原数组的引用指向新的数组
System.out.println(Arrays.toString(arr));
}
}
案例演示5
删除索引是2的元素
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
int[] arr = {10, 50, 60, 70, 80, 90, 100};
int index=2;
int[] a = new int[arr.length - 1];
for (int i = 0; i < a.length; i++) {
if(i<index){
a[i]=arr[i];
}else{
a[i]=arr[i+1];
}
}
arr=a;
System.out.println(Arrays.toString(arr));
}
}
（五）正则表达式的替换功能
String类的功能：public String replaceAll(String regex,String replacement)将和正则表达式匹配的字符串替换为给定的字符串
案例演示
public class MyTest {
public static void main(String[] args) {
String s1="I love you";
String s2 = s1.replace("you", "her");//replace方法
System.out.println(s2);
//需要将s3的所有数字替换为空格，这时replace方法无法做到
String s3="I21154love54547478you";
String regex="[0-9]+";
String s4 = s3.replaceAll(regex, " ");//replaceAll方法
System.out.println(s4);
}
}
（六）Pattern类和Matcher类的概述
1.Pattern类（模式器）
成员方法
static Pattern compile(String regex)将给定的正则表达式编译到模式器中。
Matcher matcher(CharSequence input)创建匹配给定输入与此模式器的匹配器
static boolean matches(String regex, CharSequence input)返回给定正则表达式与给定输入匹配的结果
指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
因此，典型的调用顺序是
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
在仅使用一次正则表达式时，可以方便地通过Pattern类定义的 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句 boolean b = Pattern.matches("a*b", "aaaaab");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。 或者是通过String类定义的matches方法:boolean b="aaaaab".matches("a*b");
2.Matcher类（匹配器）
它是通过解释 Pattern 对输入序列执行匹配操作的引擎。
成员方法
boolean matches() 尝试将整个输入序列与模式匹配
boolean find () 尝试查找输入序列与该模式匹配的下一个子序列
String group () 返回由以前匹配操作所匹配的输入子序列
案例演示
需求：获取下面这个字符串中由三个字符组成的单词
da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class MyTest {
public static void main(String[] args) {
String str="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";
// \\b是单词边界（非单词字符部分），如果两边不加上边界，则会把ting的tin也看作是三个字符组成的单词拿出来
String regex="\\b[a-zA-Z]{3}\\b";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(str);
while(m.find()){//如果能找到str序列中与模式器匹配的子序列就输出
String s = m.group();
System.out.println(s);
}
}
}
二、Math类
（一）概述
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
（二）成员变量
public static final double E : 自然底数
public static final double PI: 圆周率
（三）成员方法
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)获取最大值
public static int min(int a, int b)获取最小值
public static double pow(double a,double b)获取a的b次幂
public static double random()获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
public static int round(float a)四舍五入
public static long round(double a)四舍五入
public static double sqrt(double a)获取正平方根
案例演示
public class MyTest10{
public static void main(String[] args) {
System.out.println(Math.E);
System.out.println(Math.PI);
int abs = Math.abs(-1);
double ceil = Math.ceil(3.15);
double floor = Math.floor(3.57);
int max = Math.max(3, 5);
int min = Math.min(3, 5);
double pow = Math.pow(2, 3);
double random = Math.random();
long round = Math.round(3.88);
double sqrt = Math.sqrt(4);//四的平方根
double pow1 = Math.pow(4, 1.0 / 3.0);//四的立方根
System.out.println(abs);
System.out.println(ceil);
System.out.println(floor);
System.out.println(max);
System.out.println(min);
System.out.println(pow);
System.out.println(random);
System.out.println(round);
System.out.println(sqrt);
System.out.println(pow1);
}
}
三、Random类
（一）概述
在JDK的java.util包中有一个Random类，此类用于产生随机数。
（二）构造方法
public Random()没有给定种子,使用的是默认的种子(当前系统的毫秒值)
public Random(long seed)给定一个long类型的种子,给定以后每一次生成的随机数是相同的
（三）成员方法
public int nextInt()没有参数 产生的随机数范围 是int类型的范围
public int nextInt(int n)可以指定一个从0（包括）到给定数字n（不包括）的随机数范围
void nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的 byte 数组中。
案例演示1
import java.util.Random;
public class MyTest {
public static void main(String[] args) {
Random random = new Random();
Random random1 = new Random(1L);
for (int i = 0; i < 10; i++) {
System.out.println(random.nextInt(100));
}
System.out.println("-------------------------");
for (int i = 0; i < 10; i++) {//给定一个long类型的种子,给定以后每一次生成的随机数是相同的
System.out.println(random1.nextInt(100));
}
}
}
运行第一次
运行第二次
可以看到有种子的随机数生成器两次运行生成的随机数一样
案例演示2
import java.util.Arrays;
import java.util.Random;
public class MyTest {
public static void main(String[] args) {
// 创建一个新的随机数生成器。
Random random = new Random();
//int nextInt ()
//返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
for (int i = 0; i < 10; i++) {
int num = random.nextInt();//生成随机整数，不给范围，他用的是int的范围
//double num = random.nextDouble();
//boolean b = random.nextBoolean();
System.out.print(num+" ");
}
System.out.println();
//int nextInt ( int n)
//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
for (int i = 0; i < 10; i++) {
int num = random.nextInt(100); //0----99
System.out.print(num+" ");
}
System.out.println();
// void nextBytes ( byte[] bytes)
// 生成随机字节并将其置于用户提供的 byte 数组中。
byte[] bytes = new byte[10];
random.nextBytes(bytes);
System.out.println(Arrays.toString(bytes));
}
}
四、System类
（一）概述
System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造方法是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
（二）成员变量
public static final InputStream in“标准”输入流。 此流已打开并准备提供输入数据。通常，此流对应于键盘输入。
public static final PrintStream out“标准”输出流。 此流已打开并准备接受输出数据。通常，此流对应于显示器。
public static final PrintStream err “标准”错误输出流。
案例演示
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
InputStream in = System.in;//“标准”输入流。 此流已打开并准备提供输入数据。通常，此流对应于键盘输入。
Scanner sc = new Scanner(in);
//Scanner sc = new Scanner(System.in);
PrintStream out = System.out;//“标准”输出流。 此流已打开并准备接受输出数据。通常，此流对应于显示器。
out.println("hello world");
//System.out.println("hello world");
PrintStream err = System.err;
err.println("这是一行错误的输出");
//System.err.println("这是一行错误的输出");
}
}
（三）成员方法
public static void gc()调用垃圾回收器
public static void exit(int status)退出java虚拟机 0 为正常退出 非0为 异常退出
public static long currentTimeMillis()获取当前时间的毫秒值（从计算机元年1970 01-01 00:00:00开始到现在间隔的毫秒值）
案例演示1
public class MyTest15 {
public static void main(String[] args) {
Object obj = new Object();
obj = null;
//运行垃圾回收器。
//调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，
// 以便能够快速地重用这些对象当前占用的内存。当控制权从方法调用中返回时，
// 虚拟机已经尽最大努力从所有丢弃的对象中回收了空间。
System.gc();//催促垃圾回收器，去回收垃圾
//调用 System.gc() 实际上等效于调用：
// Runtime.getRuntime().gc()
}
}
案例演示2
public class MyTest {
public static void main(String[] args) {
System.out.println("1");
System.out.println("2");
System.exit(0);//0 正常退出虚拟机 非0 强制退出虚拟机
System.out.println("3");
System.out.println("4");
}
}
案例演示3
public class MyTest {
public static void main(String[] args) {
// 1 s = 1000 ms
//计算机元年 1970 01-01 00:00:00----------到现在间隔的毫秒值
long start = System.currentTimeMillis(); //获取当前系统时间的毫秒值
System.out.println(start);
for (int i = 0; i < 100000; i++) {
System.out.print("a");
}
System.out.println();
long end = System.currentTimeMillis(); //获取当前系统时间的毫秒值
System.out.println("耗时 "+(end-start)+" 毫秒");
}
}
五、BigDecimal类
（一）概述
由于在运算的时候，float类型和double类型很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal类
它是不可变的、任意精度的有符号十进制数。BigDecimal 由任意精度的整数非标度值 和 32 位（-231 ~ 231 - 1）的整数标度 (scale) 组成。如果为零或正数，则标度是小数点后的位数。如果为负数，则将该数的非标度值乘以 10 的负 scale 次幂。
（二）构造方法
public BigDecimal(String val)
（三）成员方法
public BigDecimal add(BigDecimal augend)加
public BigDecimal subtract(BigDecimal subtrahend)减
public BigDecimal multiply(BigDecimal multiplicand)乘
public BigDecimal divide(BigDecimal divisor)除法（能整除）
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)除法（不能整除）scale：小数点后面保留几位 ；roundingMode：取舍模式 比如四舍五入
取舍模式：
BigDecimal.ROUND_UP 最后一位如果大于0，则向前进一位，正负数都如此。
BigDecimal.ROUND_DOWN 最后一位不管是什么都会被舍弃。
BigDecimal.ROUND_CEILING 如果是正数，按ROUND_UP处理，如果是负数，按照ROUND_DOWN处理。例如7.1->8; -7.1->-7;所以这种近似的结果都会>=实际值。
BigDecimal.ROUND_FLOOR 跟BigDecimal_ROUND_CEILING相反。例如7.1->7;-7.1->-8。这种处理的结果<=实际值。
BigDecimal.ROUND_HALF_DOWN 如果最后一位<=5则舍弃，如果>5， 向前进一位。如7.5->7;7.6->8;-7.5->-7
BigDecimal.ROUND_HALF_UP 如果最后一位<5则舍弃，如果>=5， 向前进一位。反之舍弃。如7.5->8;7.4->7;-7.5->-8
BigDecimal.ROUND_HALF_EVEN 如果倒数第二位是奇数，按照BigDecimal.ROUND_HALF_UP处理，如果是偶数，按照BigDecimal.ROUND_HALF_DOWN来处理。如7.5->8;8.5->8;7.4->7;-7.5->-8
案例演示1
import java.math.BigDecimal;
public class MyTest {
public static void main(String[] args) {
double x=10;
double y=3;
System.out.println(x/y);//精度只有十几位，但我想要精确到更多位怎么办？
//如果你对精度要求特别高，那么Java提供了一个类BigDecimal
//构造方法
//public BigDecimal(String val)
BigDecimal a = new BigDecimal(5.545518987332454645648712);
BigDecimal b = new BigDecimal(10.23115471115545662888888888888888888888888888);
//public BigDecimal add (BigDecimal augend)//加
BigDecimal add = a.add(b);
System.out.println(add);
//public BigDecimal subtract (BigDecimal subtrahend)//减
BigDecimal subtract = a.subtract(b);
System.out.println(subtract);
//public BigDecimal multiply (BigDecimal multiplicand)//乘
BigDecimal multiply = a.multiply(b);
System.out.println(multiply);
}
}
案例演示2
import java.math.BigDecimal;
public class MyTest {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(10);
BigDecimal b = new BigDecimal(2);
//public BigDecimal divide(BigDecimal divisor)除法（能整除）
BigDecimal divide1 = a.divide(b); //能整除用一个参数的divide方法
System.out.println(divide1);
//不能整除
BigDecimal c = new BigDecimal(3);
//public BigDecimal divide (BigDecimal divisor,int scale, int roundingMode)除法（不能整除）
// scale 小数点后面保留几位 roundingMode 取舍模式 比如四舍五入
BigDecimal divide2 = a.divide(c, 34, BigDecimal.ROUND_CEILING);
System.out.println(divide2);
//当一个数无限接近于一个数，就等于这个数
System.out.println(1 == 0.9999999999999999999999999999999999999999999999999999999999999999999999);
}
}
12345678910111213141516171819202122
六、Date类
（一）概述
java.util 包提供了 Date 类来封装当前的日期和时间，精确到毫秒。
（二）构造方法
public Date()表示当前的日期和时间。
public Date(long date) 表示标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）加上long类型的毫秒值后的日期对象。
（三）成员方法
public long getTime()`: 获取一个日期对象毫秒值
`public void setTime(long time)`: 给一个日期对象设置上指定的毫秒值 例：`date.setTime(1000 * 60 * 60);
案例演示1
构造方法
import java.util.Date;
public class MyTest {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);//等价于System.out.println(date.toString());Date重写过toString方法
Date date1 = new Date(1000 * 60 * 60 * 24);//给计算机元年增加一天
System.out.println(date1);//由于我们位于东八区 因此是08:00:00
}
}
案例演示2
成员方法
import java.util.Date;
public class MyTest {
public static void main(String[] args) {
Date date = new Date();
//获取日期对象毫秒值
long time = date.getTime();//等价于System.currentTimeMillis();
System.out.println(time);
//给计算机元年加上指定的毫秒值
date.setTime(1000*60*60*24);//等价于Date date=new Date(1000*60*60*24);
System.out.println(date);
}
}
案例演示3
Date类和long类型的互相转换
import java.util.Date;
public class MyTest18 {
public static void main(String[] args) {
//Date————>long（getTime方法）
Date date = new Date();
long time = date.getTime();
//long————>Date（1.构造方法 2.setTime方法）
long a=1000*60*60*24;
Date date1 = new Date(a);
date.setTime(a);
}
}
12345678910111213
七、SimpleDateFormat类
Date类的toString()方法的输出有时候我们不满意，我们需要以我们喜欢的格式输出日期和时间，这时就需要用到SimpleDateFormat类。
（一）概述
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。
（二）构造方法
public SimpleDateFormat():使用默认的模式来创建一个SimpleDateFormat对象
public SimpleDateFormat(String pattern):使用指定的模式（规则比如yyyy:MM:dd HH:mm:ss）来创建一个SimpleDateFormat对象
| 字母 | 描述 | 示例 |
|---|---|---|
| G | 纪元标记 | AD |
| y | 四位年份 | 2001 |
| M | 月份 | July or 07 |
| d | 一个月中的日子 | 10 |
| h | A.M./P.M. (1~12)格式小时 | 12 |
| H | 一天中的小时 (0~23) | 22 |
| m | 分钟数 | 30 |
| s | 秒数 | 55 |
| S | 毫秒数 | 234 |
| E | 星期几 | Tuesday |
| D | 一年中的日子 | 360 |
| F | 一个月中第几周的周几 | 2 (second Wed. in July) |
| w | 一年中第几周 | 40 |
| W | 一个月中第几周 | 1 |
| a | A.M./P.M. 标记 | PM |
| k | 一天中的小时(1~24) | 24 |
| K | A.M./P.M. (0~11)格式小时 | 10 |
| z | 时区 | Eastern Standard Time |
| ’ | 文字定界符 | Delimiter |
| " | 单引号 | ` |
（三）成员方法
public String format(Date date): 把一个日期对象格式化成一个字符串
public Date parse(String dateStr): 把一个日期字符串解析成一个日期对象（注意要以指定格式解析）
案例演示1
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyTest {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.toString());//直接输出的格式我们不满意
//使用空参创建SimpleDateFormat创建对象，那么使用的是默认的格式来格式化日期
SimpleDateFormat f = new SimpleDateFormat();
//格式化日期，返回的是格式化后的日期字符串
String s = f.format(date);
System.out.println(s);
//我们也可以指定格式来格式化日期
SimpleDateFormat f2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s1 = f2.format(date);
System.out.println(s1);
}
}
案例演示2
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyTest {
public static void main(String[] args) throws ParseException {
String s="2020-10-01 09:00:50";
//注意解析时：日期字符串和SimpleDateFormat("yyyy-MM-dd HH:mm:ss");它里面的格式要对应，否则解析失败
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(s);//此方法要抛出异常
System.out.println(date);
}
}
案例演示3
Date类和String类的相互转换
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyTest {
public static void main(String[] args) throws ParseException {
//String————>Date（parse方法）
String s="2008-08-08 08:00:00";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(s);
System.out.println(date);
//Date————>String（format方法）
Date date1 = new Date();
String s1 = sdf.format(date1);
System.out.println(s1);
}
}
思考题
计算一下你来到这个世界多少天
- 方法1
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入出生年月日：（格式如1998-01-01）");
String s = sc.nextLine();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date birthday = sdf.parse(s);
Date dateNow = new Date();
long time1 = dateNow.getTime();//获取当前时间的毫秒值
long time2 = birthday.getTime();//获取生日当天的毫秒值
long day=(time1-time2)/1000/60/60/24;//将两个毫秒值相减换算成天
System.out.println(day);
}
}
- 方法2
LocalDate类和Period类
import java.time.LocalDate;
import java.time.Period;
public class MyTest13 {
public static void main(String[] args) {
//JDK1.8 之后，提供了一套全新的时间日期API 也推荐你使用JDK1.8所提供的
LocalDate start = LocalDate.of(1998, 5, 13);//设置日期
LocalDate now = LocalDate.now();//获取当前的日期和时间
//算出两个日期的间隔
Period between = Period.between(start, now);
int years = between.getYears();
int months = between.getMonths();
int days = between.getDays();
System.out.println("你现在"+years+"岁 零"+months+"月 零"+days+"天");
}
}
八、Calendar类
（一）概述
Calendar 类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象。它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
（二）字段
static int YEAR`
`static int MONTH`
`static int DAY_OF_MONTH`
`static int HOUR_OF_DAY`
`static int MINUTE`
`static int SECOND
（三）成员方法
public static Calendar getInstance()使用默认时区和语言环境获得一个Calendar对象
public int get(int field)返回给定日历字段的值
public void add(int field,int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量
public final void set(int year,int month,int date)设置日历时间 年月日
案例演示1
import java.util.Calendar;
public class MyTest {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();
int year = instance.get(Calendar.YEAR);
int month = instance.get(Calendar.MONTH);//月份是0-11
int day = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(year);
System.out.println(month);
System.out.println(day);
System.out.println(instance.get(Calendar.HOUR_OF_DAY));
System.out.println(instance.get(Calendar.MINUTE));
System.out.println(instance.get(Calendar.SECOND));
}
}
案例演示2
import java.util.Calendar;
public class MyTest {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();
//给相应的日期字段，加上或减去相应的时间量
instance.add(Calendar.YEAR,1);
instance.add(Calendar.MONTH, 1);
instance.add(Calendar.DAY_OF_MONTH,-1);//减去一天
int i = instance.get(Calendar.YEAR);
int i1 = instance.get(Calendar.MONTH);
int i2 = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(i);
System.out.println(i1);
System.out.println(i2);
}
}
案例演示3
import java.util.Calendar;
public class MyTest {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();
//可以设置年月日，时分秒 给某个日历字段设置值
instance.set(Calendar.YEAR,2010);
instance.set(Calendar.MONTH,10);
instance.set(Calendar.DAY_OF_MONTH,1);
//等价于instance.set(2010,10,01);
System.out.println(instance.get(Calendar.YEAR));
System.out.println(instance.get(Calendar.MONTH));
System.out.println(instance.get(Calendar.DAY_OF_MONTH));
}
}
思考题
输入一个年份，判断是否为闰年
- 方法1
（1）若某个年份能被4整除但不能被100整除，则是闰年。
（2）若某个年份能被400整除，则也是闰年。
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份");
int i = sc.nextInt();
if(i<0||i>3000){
System.out.println("年份有误！");
}else if(i%4==0&&i%100!=0||i%400==0){
System.out.println("这一年是闰年");
}else{
System.out.println("这一年不是闰年");
}
}
}
- 方法2
import java.util.Calendar;
import java.util.Scanner;
public class MyTest18 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份");
int i = sc.nextInt();
if(i<0||i>3000){
System.out.println("输入年份有误");
}else{
Calendar instance = Calendar.getInstance();
instance.set(i,2,1);//将日历对象设置为该年的三月一号
instance.add(Calendar.DAY_OF_MONTH,-1);//减去一天，看看二月份共有几天
int i1 = instance.get(Calendar.DAY_OF_MONTH);
if(i1==29){
System.out.println("这一年是闰年");
}else{
System.out.println("这一年不是闰年");
}
}
}
}
- 方法3
LocalDate类
import java.time.LocalDate;
import java.util.Scanner;
public class MyTest18 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份：");
int i = sc.nextInt();
if(i<0||i>3000){
System.out.println("输入年份有误");
}else{
boolean b = LocalDate.of(i, 01, 01).isLeapYear();//判断是否为闰年
if(b==true){
System.out.println("这一年是闰年");
}else{
System.out.println("这一年不是闰年");
}
}
}
}
九、BigInteger类
（一）概述
Java中可以使用BigInteger操作大整数，也可以转换进制。如果在操作的时候一个整型数据已经超过了整数的最大类型长度long的话，则此数据就无法装入，所以，此时要使用BigInteger类进行操作。这些大数都会以字符串的形式传入。
（二）构造方法
public BigInteger(String val)
（三）成员方法
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)返回一个除法运算后包含的商和余数组成的数组
案例演示
import java.math.BigInteger;
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
int a=Integer.MAX_VALUE;
int b=Integer.MAX_VALUE;
//long l= a * b;//long类型装不下
BigInteger num1 = new BigInteger(String.valueOf(a));//构造方法的参数需要String类型
BigInteger num2 = new BigInteger(String.valueOf(b));
BigInteger result = num1.multiply(num2);//乘
System.out.println(result);
BigInteger num3 = new BigInteger(String.valueOf(10));
BigInteger num4 = new BigInteger(String.valueOf(3));
BigInteger result1 = num3.divide(num4);//除
System.out.println(result1);
BigInteger[] result2 = num3.divideAndRemainder(num4);//获得除法运算后的商和余数
System.out.println(Arrays.toString(result2));
}
}
BigInteger和BigDecimal的区别
一般来说，BigInteger用的不是很多，BigDecimal用的稍微多一点，就比如说JDBC中，如果一个字段的数据库类型是Number, 那么getObject().getClass()的结果是java.math.BigDecimal。BigDecimal的实现利用到了BigInteger, 所不同的是BigDecimal加入了小数位的概念。
1623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
