Java编程中的枚举、字符串操作与日期时间API详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_40154786/article/details/120707745

实用类介绍

技能目标

能够定义并使用枚举类型
掌握包装类及装箱、拆箱概念
会使用Math类进行数学运算
会使用Random类获取随机数
会使用String操作字符串

1. 使用java.lang包中的常用类

1.1 Java API介绍

Java应用程序编程接口(Java Application Programming Interface，Java API) 是运行库的集合，定义了一些接口和类来开发具体的应用，节约了程序员大量的时间和精力。API除了有“应用程序编程接口”的意思外，还特质API的说明文档，也成帮助文档。

Java API 提供了如下常用的包：

java.lang：编写Java程序时最广泛使用的包，自动导入到所有的程序中，包含了Java程序的基础类和接口。包装类、Math类、String类等常用的类都包含在此包中，java.lang包还提供了用于管理类的动态加载、外部进程创建、主机环境和安全策略实施等“系统工作”类
java.util：包含了系统辅助类，特别是Collection、List和Map等集合类
java.io：包含了与输入和输出有关的类，如文件操作等
java.net：包含了与网络有关的类，如Socket、ServerSocket等类
java.sql：包含了与数据库相关的类，如Connection、Statement等类

1.2 认识枚举

1. 枚举概述

枚举类型是Java 5中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性

枚举是由一组固定常量组成的类型。使用Enum定义。

定义枚举语法格式如下：

[Modifier] enum enumName{
    enumContantName1
    [,enumConstantName2...[;]]
    //[field，method] 
}

Modifier：是访问修饰符，如public等
enum：是关键字
enumContantName1[,enumConstantName2…[;]]：表示枚举的常量列表，枚举常量之间以逗号隔开。
[field，method] ：表示其他的成员，包括构造方法，置于枚举常量的后面
在枚举中，如果除了定义常量，还定义了其他成员，则枚举常量列表必须以分号（;）结尾

示例1

定义表示性别的枚举，两个枚举常量分别代表“男”和“女”。

关键代码如下：

public enum Gender {
	MALE,FEMALE
}

2. 使用枚举实现输出每周日程信息

通常使用枚举表示一组个数有限的值，用于实现对输入的值进行约束检查。

示例2

定义一个枚举，其中包括7个枚举常量，代表一周中的7天，编程实现一周中的每天的日程安排。

关键代码如下：

//枚举类型，使用关键字enum
enum Week{
	MONDAY,TUESDAY,WEDNESDAY,
	THURSDAY,FRIDAY,SATURDAY,SUNDAY
}

在定义枚举类型时我们使用的关键字是enum，与class关键字类似，只不过前者是定义枚举类型，后者是定义类类型。

枚举类型Week中分别定义了从周一到周日的值，这里要注意，值一般是大写的字母，多个值之间以逗号分隔。同时我们应该知道的是枚举类型可以像类(class)类型一样，定义为一个单独的文件，当然也可以定义在其他类内部，更重要的是枚举常量在类型安全性和便捷性都很有保证，如果出现类型问题编译器也会提示我们改进，但务必记住枚举表示的类型其取值是必须有限的，也就是说每个值都是可以枚举出来的，比如上述描述的一周共有七天。那么该如何使用呢？如下：

/**
 * 枚举常量的定义和使用
 * */
public class WeekDemo {
	/**
	 * 做什么事情
	 * */
	public void doWhat(Week day){
		//使用枚举
		switch(day){
			case MONDAY:
			case TUESDAY:
			case WEDNESDAY:
			case THURSDAY:
			case FRIDAY:
				System.out.println("工作日，努力写代码！");
				break;
			case SATURDAY:
				System.out.println("星期六，休息！看电影！");
				break;
			case SUNDAY:
				System.out.println("星期日，休息！看电影！");
				break;
			default:
				System.out.println("地球上的一个星期就7天");
		}
	}
	
	public static void main(String[] args){
		WeekDemo wd=new WeekDemo();
		wd.doWhat(Week.FRIDAY);
	}
}

就像上述代码那样，直接引用枚举的值即可，这便是枚举类型的最简单模型。

3. 枚举实现的原理

我们大概了解了枚举类型的定义与简单使用后，现在有必要来了解一下枚举类型的基本实现原理。实际上在使用关键字enum创建枚举类型并编译后，编译器会为我们生成一个相关的类，这个类继承了Java API中的java.lang.Enum类，也就是说通过关键字enum创建枚举类型在编译后事实上也是一个类类型而且该类继承自java.lang.Enum类。

下面我们编译前面定义的Week.java并查看生成的class文件来验证这个结论：

反编译Week.class，生成如下代码：

//反编译Day.class
final class Week extends Enum
{
    //编译器为我们添加的静态的values()方法
    public static Week[] values()
    {
        return (Week[])$VALUES.clone();
    }
    //编译器为我们添加的静态的valueOf()方法，注意间接调用了Enum也类的valueOf方法
    public static Week valueOf(String s)
    {
        return (Week)Enum.valueOf(cn/bdqn/enumdemo/Week, s);
    }
    //私有构造函数
    private Week(String s, int i)
    {
        super(s, i);
    }
     //前面定义的7种枚举实例
    public static final Week MONDAY;
    public static final Week TUESDAY;
    public static final Week WEDNESDAY;
    public static final Week THURSDAY;
    public static final Week FRIDAY;
    public static final Week SATURDAY;
    public static final Week SUNDAY;
    private static final Week $VALUES[];

    static 
    {    
        //实例化枚举实例
        MONDAY = new Week("MONDAY", 0);
        TUESDAY = new Week("TUESDAY", 1);
        WEDNESDAY = new Week("WEDNESDAY", 2);
        THURSDAY = new Week("THURSDAY", 3);
        FRIDAY = new Week("FRIDAY", 4);
        SATURDAY = new Week("SATURDAY", 5);
        SUNDAY = new Week("SUNDAY", 6);
        $VALUES = (new Week[] {
            MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
        });
    }
}

从反编译的代码可以看出编译器确实帮助我们生成了一个Week类(注意该类是final类型的，将无法被继承)而且该类继承自java.lang.Enum类，该类是一个抽象类(稍后我们会分析该类中的主要方法)，除此之外，编译器还帮助我们生成了7个Day类型的实例对象分别对应枚举中定义的7个日期，这也充分说明了我们前面使用关键字enum定义的Day类型中的每种日期枚举常量也是实实在在的Day实例对象，只不过代表的内容不一样而已。

注意

编译器还为我们生成了两个静态方法，分别是values()和 valueOf()，稍后会分析它们的用法，到此我们也就明白了，使用关键字enum定义的枚举类型，在编译期后，也将转换成为一个实实在在的类，而在该类中，会存在每个在枚举类型中定义好变量的对应实例对象，如上述的MONDAY枚举类型对应public static final Week MONDAY;，同时编译器会为该类创建两个方法，分别是values()和valueOf()。

ok~，到此相信我们对枚举的实现原理也比较清晰，至于Enum类的方法，此处不做深入讲解，以后用到时请自行查看API即可。

1.3 Math类

1. 概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不用创建对象，调用起来非常简单。

2. 基本运算的方法

public static double abs(double a) ：返回 double 值的绝对值。例如：Math.abs(-3.5);返回3.5
public static double max(double a,double b)：返回两个double值中的较大的一个。例如：Math.max(2.5,90.5);f返回90.5
public static double random()：返回一个随机的double值，该值大于等0.0且小于1.0。更多方法请查看API手册

下面通过示例3演示Math类的常用方法

示例3

商场抽奖规则如下：会员号的百位数字等于产生的随机数字即为幸运会员。

编码实现：

/*
 * 幸运抽奖：会员号的百位数与系统随机数相同，即为中奖
 * */
public class GoodLuck {
	
	public static void main(String[] args) {
		//随机产生一个0-9之间的任意整数
		int random=(int)(Math.random()*10);
//		System.out.println(random);
		//从控制台接收一个任意的四位数
		System.out.print("请输入4位会员号：");
		Scanner input=new Scanner(System.in);
		int custNo=input.nextInt();
		//获得会员号的百位数
		int baiwei=custNo/100%10;
		if(baiwei==random){
			System.out.println(custNo+"是幸运客户，获得精美MP3一个。");
		}else{
			System.out.println(custNo+" 谢谢您的支持！");
		}
		
	}
}

2. 操作字符串

关键步骤如下：

判断字符串长度
比较字符串
字符串大小写转换
连接字符串
获取子字符串
获取字符位置索引
StringBuffer 类及 StringBuilder 类的用法

2.1 String类

1. String 类概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

特点：

字符串不变：字符串的值在创建后不能被更改

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

因为String对象是不可变的，所以它们可以被共享。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

“abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。

//例如：
String str = "abc";
//相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的。

2. 使用步骤

查看类
- java.lang.String ：此类不需要导入。
查看构造方法
- public String() ：初始化新创建的 String对象，以使其表示空字符序列。
- public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
- public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
- 构造举例，代码如下：
```
// 无参构造
String str = new String（）；
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
```

3. 常用方法

(1) 求字符串长度length()

public int length ()：返回此字符串的长度。

示例4

注册新用户，要求密码长度不少于6位

public class Register {

	/**
	 * 注册密码长度不少于6位
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String uname,pwd;
		
		System.out.print("请输入用户名： ");
		uname=input.next();
		System.out.print("请输入密码： ");
		pwd=input.next();
		
		if(pwd.length() >= 6){
			System.out.print("注册成功！ ");
		}else{
			System.out.print("密码长度不能小于6位！");
		}
		
	}
}

(2) 字符串比较

public boolean equals (Object anObject)：将此字符串与指定对象进行比较。

public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

示例5

注册成功后，实现登录验证。用户名为“Tom”，且不区分大小写，密码为“1234567”

代码如下：

public class Login {

	/**
	 * 登录
	 * 
	 */
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String uname,pwd;
		
		System.out.print("请输入用户名： ");
		uname=input.next();
		System.out.print("请输入密码： ");
		pwd=input.next();
		
		/*
		if(uname.equals("TOM")&&pwd.equals("1234567")){
			System.out.print("登录成功！ ");
		}else{
			System.out.print("用户名或密码不匹配，登录失败！");
		}*/
		if(uname.equalsIgnoreCase("TOM")&&pwd.equals("1234567")){
			System.out.print("登录成功！ ");
		}else{
			System.out.print("用户名或密码不匹配，登录失败！");
		}
	}
}

(3) 字符串连接

public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

示例6

字符串连接

public class PrintScore {
	/**
	 * 打印成绩单
	 * 
	 */
	public static void main(String[] args) {
		int sqlScore = 80;        	//SQL成绩
		int javaScore = 90;       	//Java成绩
		double htmlScore = 86.7;  	//HTML成绩

		//成绩单
		String scoreSheet = "SQL:" + sqlScore + "  Java:" + 
            javaScore  + "  HTML:" + htmlScore;  
		
		//打印成绩单
        System.out.println("*****成绩单*****");
        System.out.println(scoreSheet);   

        String bottom = "\n\t\t版权所有：".concat("课工场");
        System.out.println(bottom);
		
	}
}

(4) 字符串的提取和查询

方法名	说明
public int indexOf(int ch)	搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int indexOf(String value)
public int lastIndexOf(int ch)	搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int lastIndexOf(String value)
public String substring(int index)	提取从位置索引开始的字符串部分
public String substring(int beginindex, int endindex)	提取beginindex和endindex之间的字符串部分
public String trim()	返回一个前后不含任何空格的调用字符串的副本

示例7

判断.java文件名是否正确，判断邮箱格式是否正确

public class Verify{
	public static void main(String[] args) {
        // 声明变量
        boolean fileCorrect = false; 	//标识文件名是否正确
        boolean emailCorrect = false; 	//标识E-mail是否正确
        System.out.print("---欢迎进入作业提交系统---");
        Scanner input = new Scanner(System.in);
        System.out.println("请输入Java文件名: ");
        String fileName = input.next();
        System.out.print("请输入你的邮箱:");
        String email = input.next();
        
        //检查Java文件名
        int index = fileName.lastIndexOf(".");  //"."的位置
         /*if(index!=-1 && index!=0 && 
            fileName.substring(index+1, 
            fileName.length()).equals("java")){
            fileCorrect = true;   	//标识文件名正确
        }else{
            System.out.println("文件名无效。");
        } */   
        //判断某文件的后缀
        if(fileName.endsWith("java")) {
        	fileCorrect = true;   	//标识文件名正确
//        	System.out.println("文件名正确。");
        }else {
        	System.out.println("文件名无效。");
        }      
        //检查你的邮箱格式
        if(email.indexOf('@') != -1 &&
            email.indexOf('.') > email.indexOf('@')){  
            emailCorrect = true;   	//标识E-mail正确
        }else{
            System.out.println("E-mail无效。");
        }        
        //输出检测结果
        if(fileCorrect && emailCorrect){
            System.out.println("作业提交成功!");
        }else{
            System.out.println("作业提交失败!");
        }
    }
}

(5) 字符串拆分

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

示例8

现有一个字符串，它是一段歌词，每句都以空格“ ”结尾

示例代码如下：

public class Lyric {
	/**
	 * 拆分歌词
	 * 
	 */
	public static void main(String[] args) {
		String words="长亭外 古道边 芳草碧连天 晚风扶 柳笛声残 夕阳山外山";
		System.out.println("***原歌词格式***\n"+words);
		System.out.println("\n***拆分后歌词格式***");
		String[] printword=words.split(" ");//按照空格进行拆分
		for(int i=0;i<printword.length;i++){
			System.out.println(printword[i]);//打印输出
		}
    }    
}

字符练习

统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

示例代码如下：

public class StringTest{
    public static void main(String[] args) throws ParseException {
		// 键盘录入一个字符串数据
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串数据：");
		String s = sc.nextLine();
		// 定义四个统计变量，初始化值都是0
		int bigCount = 0;
		int smallCount = 0;
		int numberCount = 0;
		int otherCount = 0;
		// 遍历字符串，得到每一个字符
		for (int x = 0; x < s.length(); x++) {
			char ch = s.charAt(x);
			// 拿字符进行判断
			if (ch >= 'A' && ch <= 'Z') {
				bigCount++;
			} else if (ch >= 'a' && ch <= 'z') {
				smallCount++;
			} else if (ch >= '0' && ch <= '9') {
				numberCount++;
			} else {
				otherCount++;
			}
		}
		// 输出结果
		System.out.println("大写字符：" + bigCount + "个");
		System.out.println("小写字符：" + smallCount + "个");
		System.out.println("数字字符：" + numberCount + "个");
		System.out.println("其它字符：" + otherCount + "个");
	}

}

2.2 StringBuffer 类和 StringBuilder 类

1. 字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

2. StringBuilder概述

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。

3. 构造方法

根据StringBuilder的API文档，常用构造方法有2个：

public StringBuilder()：构造一个空的StringBuilder容器。

public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用带参构造
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println(sb2); // hello
    }
}

4. 常用方法

StringBuilder常用的方法有3个：

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。
public StringBuilder insert(位置,参数)：将参数插入到字符串指定位置后并返回。

示例代码如下所示：

public class StringBuilderDemo {
	public static void main(String[] args) {
		// 创建对象
		StringBuilder sb = new StringBuilder("青春无悔");
		int num = 100;
		//追加字符串
		sb.append("我心永恒");
		//追加数值
		sb.append(num);
		System.out.println(sb);
		StringBuilder nums = new StringBuilder("12345678");
		for (int i = nums.length() - 3; i > 0; i-=3) {
			//指定位置插入字符串
			nums.insert(i,",");
		}
		System.out.println(nums);
	}
}

5. StringBuffer

由于StringBuffer和StringBuilder在使用上几乎一样，所以只写一个，详细说明请查询API

2.3 String、StringBuilder和StringBuffer的区别

区别：String为字符串常量，一旦被创建的话，就不能在改变了。

StringBuilder和StringBuffer为字符串变量，创建后是可以被更改的

速度：StringBuilder>StringBuffer>String

String str = "abc";
String str1 = str+"cd";

我们通过反编译工具可以看到

String str = "abc";
String str1 = (new StringBuilder("str").append("cd"));

所以说Java中+对字符串的拼接，其实现原理是使用StringBuilder.append

String str="abc";
System.out.println(str);
str=str+"de";
System.out.println(str);

看上面的代码，貌似只有一个对象，只是其中的值变化看而已，但是我们可以从Java的Jvm中看到，JVM又创建了一个新的对象也名为str，然后再把原来的str的值和“de”加起来再赋值给新的str，而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了，所以，str实际上并没有被更改，也就是前面说的String对象一旦创建之后就不可更改了。所以，Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。

而StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，而不进行创建和回收的操作，所以速度要比String快很多。

什么情况下使用StringBuilder,什么情况下使用StringBuffer

区别:StringBuilder是线程不安全,StringBuffer是线程安全的

如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。

总结下:

String：适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

3. 使用java.util包中的常用类

关键步骤如下：

使用Date类与Calendar类操作日期时间
使用SimpleDateFormat类格式化时间
使用Random类生成随机函数

3.1 日期操作类

1. Date类

概述

java.util.Date类表示特定的瞬间，精确到毫秒。

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

标注: 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。例如：

import java.util.Date;

public class DateDemo{
    public static void main(String[] args) {
        // 创建日期对象，把当前的时间
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
        // 创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

备注：在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

常用方法

Date类中的多数方法已经过时，常用的方法有：

public long getTime() 把日期对象转换成对应的时间毫秒值。

2. DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

格式化：按照指定的格式，从Date对象转换为String对象。
解析：按照指定的格式，从String对象转换为Date对象。

构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

参数pattern是一个字符串，代表日期时间的自定义格式。

格式规则

常用的格式规则为：

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档0。

创建SimpleDateFormat对象的代码如：

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        // 对应的日期格式如：2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

常用方法

DateFormat类的常用方法有：

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

format方法

使用format方法的代码为：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class DateFormatMethodDemo {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

parse方法

使用parse方法的代码为：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把String转换成Date对象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

练习

请使用日期时间相关的API，计算出一个人已经出生了多少天。

思路：

1.获取当前时间对应的毫秒值

2.获取自己出生日期对应的毫秒值

3.两个时间相减（当前时间– 出生日期）

代码实现：

public static void main(String[] args) throws Exception {
	System.out.println("请输入出生日期 格式 YYYY-MM-dd");
	// 获取出生日期,键盘输入
	String birthdayString = new Scanner(System.in).next();
	// 将字符串日期,转成Date对象
	// 创建SimpleDateFormat对象,写日期模式
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	// 调用方法parse,字符串转成日期对象
	Date birthdayDate = sdf.parse(birthdayString);	
	// 获取今天的日期对象
	Date todayDate = new Date();	
	// 将两个日期转成毫秒值,Date类的方法getTime
	long birthdaySecond = birthdayDate.getTime();
    //今天的时间毫秒数
	long todaySecond = todayDate.getTime();
	long second = todaySecond-birthdaySecond;	
	int day = (int) (second/1000/60/60/24);
	System.out.println("活了"+day+"天");
	
}

3. Calendar类

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

获取方式

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：

Calendar静态方法

public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

例如：

import java.util.Calendar;

public class CalendarInitDemo {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }    
}

常用方法

根据Calendar类的API文档，常用方法有：

public int get(int field)：返回给定日历字段的值。
public void set(int field, int value)：将给定的日历字段设置为给定值。
public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

Calendar类中提供很多成员常量，代表给定的日历字段：

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

get/set方法

get方法用来获取指定字段的值，set方法用来设置指定字段的值，代码使用演示：

import java.util.Calendar;

public class CalendarUtil {
    public static void main(String[] args) {
         // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        // 获取年 
        int year = cal.get(Calendar.YEAR);
        // 获取月 （从0开始）
        int month = cal.get(Calendar.MONTH) + 1;
        // 获取日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "年" + month + "月" + dayOfMonth + "日");
        //设置年
        cal.set(Calendar.YEAR, 1992);
        int brithday = cal.get(Calendar.YEAR);
        System.out.println(year-brithday);//计算活了多少年
    }    
}

add方法

add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。代码如：

import java.text.ParseException;
import java.util.Calendar;
public class EnumDemo {
	public static void main(String[] args) throws ParseException {
		Calendar cal = Calendar.getInstance();
		 // 获取年 
        int year = cal.get(Calendar.YEAR);
        // 获取月 （从0开始）
        int month = cal.get(Calendar.MONTH) + 1;
        // 获取日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
		System.out.println(year + "年" + month + "月" + dayOfMonth + "日"); // 2019年1月17日
		// 使用add方法
		cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
		cal.add(Calendar.YEAR, -3); // 减3年
		 // 获取年 
        year = cal.get(Calendar.YEAR);
        // 获取月 （从0开始）
        month = cal.get(Calendar.MONTH) + 1;
        // 获取日
        dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
		System.out.println(year + "年" + month + "月" + dayOfMonth + "日"); // 2016年1月18日;
	}
}

getTime方法

Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。

import java.util.Calendar;
import java.util.Date;

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}

温馨提示：

西方星期的开始为周日，中国为周一。

在Calendar类中，月份的表示是以0-11代表1-12月。

日期是有大小关系的，时间靠后，时间越大。

> 备注

从Java 8开始，java.time包提供了新的日期和时间API，主要涉及的类型有：

本地日期和时间：LocalDateTime，LocalDate，LocalTime；
带时区的日期和时间：ZonedDateTime；
时刻：Instant；
时区：ZoneId，ZoneOffset；
时间间隔：Duration。

以及一套新的用于取代SimpleDateFormat的格式化类型DateTimeFormatter。

和旧的API相比，新API严格区分了时刻、本地日期、本地时间和带时区的日期时间，并且，对日期和时间进行运算更加方便。

此外，新API修正了旧API不合理的常量设计：

Month的范围用1~12表示1月到12月；
Week的范围用1~7表示周一到周日。

最后，新API的类型几乎全部是不变类型（和String类似），可以放心使用不必担心被修改。

4. LocalDateTime类

我们首先来看最常用的LocalDateTime，它表示一个本地日期和时间：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDate d = LocalDate.now(); // 当前日期
        LocalTime t = LocalTime.now(); // 当前时间
        LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
        System.out.println(d); // 严格按照ISO 8601格式打印
        System.out.println(t); // 严格按照ISO 8601格式打印
        System.out.println(dt); // 严格按照ISO 8601格式打印
    }
}

本地日期和时间通过now()获取到的总是以当前默认时区返回的，和旧API不同，LocalDateTime、LocalDate和LocalTime默认严格按照ISO 8601规定的日期和时间格式进行打印。

上述代码其实有一个小问题，在获取3个类型的时候，由于执行一行代码总会消耗一点时间，因此，3个类型的日期和时间很可能对不上（时间的毫秒数基本上不同）。为了保证获取到同一时刻的日期和时间，可以改写如下：

LocalDateTime dt = LocalDateTime.now(); // 当前日期和时间
LocalDate d = dt.toLocalDate(); // 转换到当前日期
LocalTime t = dt.toLocalTime(); // 转换到当前时间

反过来，通过指定的日期和时间创建LocalDateTime可以通过of()方法：

// 指定日期和时间:
LocalDate d2 = LocalDate.of(2019, 11, 30); // 2019-11-30, 注意11=11月
LocalTime t2 = LocalTime.of(15, 16, 17); // 15:16:17
LocalDateTime dt2 = LocalDateTime.of(2019, 11, 30, 15, 16, 17);
LocalDateTime dt3 = LocalDateTime.of(d2, t2);

因为严格按照ISO 8601的格式，因此，将字符串转换为LocalDateTime就可以传入标准格式：

LocalDateTime dt = LocalDateTime.parse("2019-11-19T15:16:17");
LocalDate d = LocalDate.parse("2019-11-19");
LocalTime t = LocalTime.parse("15:16:17");

注意ISO 8601规定的日期和时间分隔符是T。标准格式如下：

日期：yyyy-MM-dd
时间：HH:mm:ss
带毫秒的时间：HH:mm:ss.SSS
日期和时间：yyyy-MM-dd’T’HH:mm:ss
带毫秒的日期和时间：yyyy-MM-dd’T’HH:mm:ss.SSS

如果要自定义输出的格式，或者要把一个非ISO 8601格式的字符串解析成LocalDateTime，可以使用新的DateTimeFormatter：

import java.time.*;
import java.time.format.*;
public class Main {
    public static void main(String[] args) {
        // 自定义格式化:
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
        System.out.println(dtf.format(LocalDateTime.now()));

        // 用自定义格式解析:
        LocalDateTime dt2 = LocalDateTime.parse("2019/11/30 15:16:17", dtf);
        System.out.println(dt2);
    }
}

LocalDateTime提供了对日期和时间进行加减的非常简单的链式调用：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);
        System.out.println(dt);
        // 加5天减3小时:
        LocalDateTime dt2 = dt.plusDays(5).minusHours(3);
        System.out.println(dt2); // 2019-10-31T17:30:59
        // 减1月:
        LocalDateTime dt3 = dt2.minusMonths(1);
        System.out.println(dt3); // 2019-09-30T17:30:59
    }
}

注意到月份加减会自动调整日期，例如从2019-10-31减去1个月得到的结果是2019-09-30，因为9月没有31日。

对日期和时间进行调整则使用withXxx()方法，例如：withHour(15)会把10:11:12变为15:11:12：

调整年：withYear()
调整月：withMonth()
调整日：withDayOfMonth()
调整时：withHour()
调整分：withMinute()
调整秒：withSecond()

示例代码如下：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDateTime dt = LocalDateTime.of(2019, 10, 26, 20, 30, 59);
        System.out.println(dt);
        // 日期变为31日:
        LocalDateTime dt2 = dt.withDayOfMonth(31);
        System.out.println(dt2); // 2019-10-31T20:30:59
        // 月份变为9:
        LocalDateTime dt3 = dt2.withMonth(9);
        System.out.println(dt3); // 2019-09-30T20:30:59
    }
}

同样注意到调整月份时，会相应地调整日期，即把2019-10-31的月份调整为9时，日期也自动变为30。

实际上，LocalDateTime还有一个通用的with()方法允许我们做更复杂的运算。例如：

import java.time.*;
import java.time.temporal.*;
public class Main {
    public static void main(String[] args) {
        // 本月第一天0:00时刻:
        LocalDateTime firstDay = LocalDate.now().withDayOfMonth(1).atStartOfDay();
        System.out.println(firstDay);

        // 本月最后1天:
        LocalDate lastDay = LocalDate.now().with(TemporalAdjusters.lastDayOfMonth());
        System.out.println(lastDay);

        // 下月第1天:
        LocalDate nextMonthFirstDay = LocalDate.now().with(TemporalAdjusters.firstDayOfNextMonth());
        System.out.println(nextMonthFirstDay);

        // 本月第1个周一:
        LocalDate firstWeekday = LocalDate.now().with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
        System.out.println(firstWeekday);
    }
}

对于计算某个月第1个周日这样的问题，新的API可以轻松完成。

要判断两个LocalDateTime的先后，可以使用isBefore()、isAfter()方法，对于LocalDate和LocalTime类似：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime target = LocalDateTime.of(2019, 11, 19, 8, 15, 0);
        System.out.println(now.isBefore(target));
        System.out.println(LocalDate.now().isBefore(LocalDate.of(2019, 11, 19)));
        System.out.println(LocalTime.now().isAfter(LocalTime.parse("08:15:00")));
    }
}

注意到LocalDateTime无法与时间戳进行转换，因为LocalDateTime没有时区，无法确定某一时刻。后面我们要介绍的ZonedDateTime相当于LocalDateTime加时区的组合，它具有时区，可以与long表示的时间戳进行转换。

6. Duration和Period

Duration表示两个时刻之间的时间间隔。另一个类似的Period表示两个日期之间的天数：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2019, 11, 19, 8, 15, 0);
        LocalDateTime end = LocalDateTime.of(2020, 1, 9, 19, 25, 30);
        Duration d = Duration.between(start, end);
        System.out.println(d); // PT1235H10M30S

        Period p = LocalDate.of(2019, 11, 19).until(LocalDate.of(2020, 1, 9));
        System.out.println(p); // P1M21D
    }
}

注意到两个LocalDateTime之间的差值使用Duration表示，类似PT1235H10M30S，表示1235小时10分钟30秒。而两个LocalDate之间的差值用Period表示，类似P1M21D，表示1个月21天。

Duration和Period的表示方法也符合ISO 8601的格式，它以P...T...的形式表示，P...T之间表示日期间隔，T后面表示时间间隔。如果是PT...的格式表示仅有时间间隔。利用ofXxx()或者parse()方法也可以直接创建Duration：

Duration d1 = Duration.ofHours(10); // 10 hours
Duration d2 = Duration.parse("P1DT2H3M"); // 1 day, 2 hours, 3 minutes

7. 小结

Java 8引入了新的日期和时间API，它们是不变类，默认按ISO 8601标准格式化和解析；

使用LocalDateTime可以非常方便地对日期和时间进行加减，或者调整日期和时间，它总是返回新对象；

使用isBefore()和isAfter()可以判断日期和时间的先后；

使用Duration和Period可以表示两个日期和时间的“区间间隔”。

8. ZonedDateTime类

LocalDateTime总是表示本地日期和时间，要表示一个带时区的日期和时间，我们就需要ZonedDateTime。

可以简单地把ZonedDateTime理解成LocalDateTime加ZoneId。ZoneId是java.time引入的新的时区类，注意和旧的java.util.TimeZone区别。

要创建一个ZonedDateTime对象，有以下几种方法，一种是通过now()方法返回当前时间：

public class Main {
    public static void main(String[] args) {
        ZonedDateTime zbj = ZonedDateTime.now(); // 默认时区
        //ZonedDateTime zny = ZonedDateTime.now(ZoneId.of(ZoneId.SHORT_IDS.get("EST")));
        ZonedDateTime zny = ZonedDateTime.now(ZoneId.of("America/New_York")); // 用指定时区获取当前时间
        System.out.println(zbj);
        System.out.println(zny);
    }
}

观察打印的两个ZonedDateTime，发现它们时区不同，但表示的时间都是同一时刻（毫秒数不同是执行语句时的时间差）：

2019-09-15T20:58:18.786182+08:00[Asia/Shanghai]
2019-09-15T08:58:18.788860-04:00[America/New_York]

另一种方式是通过给一个LocalDateTime附加一个ZoneId，就可以变成ZonedDateTime：

import java.time.*;
public class Main {
    public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.of(2019, 9, 15, 15, 16, 17);
        ZonedDateTime zbj = ldt.atZone(ZoneId.systemDefault());
        ZonedDateTime zny = ldt.atZone(ZoneId.of("America/New_York"));
        System.out.println(zbj);
        System.out.println(zny);
    }
}

以这种方式创建的ZonedDateTime，它的日期和时间与LocalDateTime相同，但附加的时区不同，因此是两个不同的时刻：

2019-09-15T15:16:17+08:00[Asia/Shanghai]
2019-09-15T15:16:17-04:00[America/New_York]

时区转换

要转换时区，首先我们需要有一个ZonedDateTime对象，然后，通过withZoneSameInstant()将关联时区转换到另一个时区，转换后日期和时间都会相应调整。

下面的代码演示了如何将北京时间转换为纽约时间：

public class Main {
    public static void main(String[] args) {
        // 以中国时区获取当前时间:
        ZonedDateTime zbj = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
        // 转换为纽约时间:
        ZonedDateTime zny = zbj.withZoneSameInstant(ZoneId.of("America/New_York"));
        System.out.println(zbj);
        System.out.println(zny);
    }
}

要特别注意，时区转换的时候，由于夏令时的存在，不同的日期转换的结果很可能是不同的。这是北京时间9月15日的转换结果：

2019-09-15T21:05:50.187697+08:00[Asia/Shanghai]
2019-09-15T09:05:50.187697-04:00[America/New_York]

这是北京时间11月15日的转换结果：

2019-11-15T21:05:50.187697+08:00[Asia/Shanghai]
2019-11-15T08:05:50.187697-05:00[America/New_York]

两次转换后的纽约时间有1小时的夏令时时差。

涉及到时区时，千万不要自己计算时差，否则难以正确处理夏令时。

有了ZonedDateTime，将其转换为本地时间就非常简单：

ZonedDateTime zdt = ...
LocalDateTime ldt = zdt.toLocalDateTime();

转换为LocalDateTime时，直接丢弃了时区信息。

9. DateTimeFormatter类

使用旧的Date对象时，我们用SimpleDateFormat进行格式化显示。使用新的LocalDateTime或ZonedLocalDateTime时，我们要进行格式化显示，就要使用DateTimeFormatter。

和SimpleDateFormat不同的是，DateTimeFormatter不但是不变对象，它还是线程安全的。线程的概念我们会在后面涉及到。现在我们只需要记住：因为SimpleDateFormat不是线程安全的，使用的时候，只能在方法内部创建新的局部变量。而DateTimeFormatter可以只创建一个实例，到处引用。

创建DateTimeFormatter时，我们仍然通过传入格式化字符串实现：

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");

格式化字符串的使用方式与SimpleDateFormat完全一致。

另一种创建DateTimeFormatter的方法是，传入格式化字符串时，同时指定Locale：

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("E, yyyy-MMMM-dd HH:mm", Locale.US);

这种方式可以按照Locale默认习惯格式化。我们来看实际效果：

import java.time.*;
import java.time.format.*;
import java.util.Locale;
public class Main {
    public static void main(String[] args) {
        ZonedDateTime zdt = ZonedDateTime.now();
        var formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm ZZZZ");
        System.out.println(formatter.format(zdt));

        var zhFormatter = DateTimeFormatter.ofPattern("yyyy MMM dd EE HH:mm", Locale.CHINA);
        System.out.println(zhFormatter.format(zdt));

        var usFormatter = DateTimeFormatter.ofPattern("E, MMMM/dd/yyyy HH:mm", Locale.US);
        System.out.println(usFormatter.format(zdt));
    }
}

在格式化字符串中，如果需要输出固定字符，可以用'xxx'表示。

运行上述代码，分别以默认方式、中国地区和美国地区对当前时间进行显示，结果如下：

2019-09-15T23:16 GMT+08:00
2019 9月 15 周日 23:16
Sun, September/15/2019 23:16

当我们直接调用System.out.println()对一个ZonedDateTime或者LocalDateTime实例进行打印的时候，实际上，调用的是它们的toString()方法，默认的toString()方法显示的字符串就是按照ISO 8601格式显示的，我们可以通过DateTimeFormatter预定义的几个静态变量来引用：

var ldt = LocalDateTime.now();
System.out.println(DateTimeFormatter.ISO_DATE.format(ldt));
System.out.println(DateTimeFormatter.ISO_DATE_TIME.format(ldt));

得到的输出和toString()类似：

2019-09-15
2019-09-15T23:16:51.56217

小结

对ZonedDateTime或LocalDateTime进行格式化，需要使用DateTimeFormatter类；

DateTimeFormatter可以通过格式化字符串和Locale对日期和时间进行定制输出。

> 在数据库中存储日期和时间

除了旧式的java.util.Date，我们还可以找到另一个java.sql.Date，它继承自java.util.Date，但会自动忽略所有时间相关信息。这个奇葩的设计原因要追溯到数据库的日期与时间类型。

在数据库中，也存在几种日期和时间类型：

DATETIME：表示日期和时间；
DATE：仅表示日期；
TIME：仅表示时间；
TIMESTAMP：和DATETIME类似，但是数据库会在创建或者更新记录的时候同时修改TIMESTAMP。

在使用Java程序操作数据库时，我们需要把数据库类型与Java类型映射起来。下表是数据库类型与Java新旧API的映射关系：

数据库	对应Java类（旧）	对应Java类（新）
DATETIME	java.util.Date	LocalDateTime
DATE	java.sql.Date	LocalDate
TIME	java.sql.Time	LocalTime
TIMESTAMP	java.sql.Timestamp	LocalDateTime

实际上，在数据库中，我们需要存储的最常用的是时刻（Instant），因为有了时刻信息，就可以根据用户自己选择的时区，显示出正确的本地时间。所以，最好的方法是直接用长整数long表示，在数据库中存储为BIGINT类型。

3.2 Random类

1. Random类概述

此类的实例用于生成伪随机数。例如，以下代码使用户能够得到一个随机数：

Random r = new Random();
int i = r.nextInt();

2. Random使用步骤

查看类

java.util.Random ：该类需要 import导入使后使用。法。使用Random类，完成生成3个10以内的随机整数的操作，代码如下：

查看构造方法

public Random() ：创建一个新的随机数生成器

查看成员方法

public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和指定值 n （不包括）之间的 int 值。

使用Random类，完成生成10个0-10以内的随机整数的操作，代码如下：

//1. 导包
import java.util.Random;
public class DemoRandom {
   	public static void main(String[] args) {
		// 2. 创建键盘录入数据的对象
		Random r = new Random();
		for (int i = 0; i < 10; i++) {
			// 3. 随机生成一个数据
			int number = r.nextInt(10);
			// 4. 输出数据
			System.out.println("number:" + number);
		}
	} 
}

备注：创建一个 Random 对象，每次调用 nextInt() 方法，都会生成一个随机数。

3. 猜数字小游戏

游戏开始时，会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ，会与 number 作比较，系统提示大了或者小了，直到玩家猜中，游戏结束。

提示：先运行程序代码，理解此题需求，经过分析后，再编写代码

编写代码如下：

import java.util.Random;
import java.util.Scanner;

public class TestGuessNumber {
	public static void main(String[] args) {
		// 系统产生一个随机数1‐100之间的。
		Random r = new Random();
		int number = r.nextInt(100) + 1;
		while (true) {
			// 键盘录入我们要猜的数据
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数字(1‐100)：");
			int guessNumber = sc.nextInt();
			// 比较这两个数据(用if语句)
			if (guessNumber > number) {
				System.out.println("你猜的数据" + guessNumber + "大了");
			} else if (guessNumber < number) {
				System.out.println("你猜的数据" + guessNumber + "小了");
			} else {
				System.out.println("恭喜你,猜中了");
				break;
			}
		}
	}
}