Java讲课笔记20：Java中的常用类

零、本讲学习目标

1、掌握String类和StringBuffer类的使用

2、了解System类和Runtime类的使用

3、熟悉Math类和Random类的使用

4、掌握Java包装类的使用

5、掌握日期类与时间类的使用

6、掌握格式化类的使用

Java提供了丰富的基础类库，通过这些类库可以提高开发效率，降低开发难度。因此，对于一个Java初学者来说，掌握Java基础类库中的一些常用类就显得十分重要。在基础类库中，提供了处理字符串、数学运算、以及日期和时间等功能的类，这些类是开发时常用的，我们有必要详细讲解这些类的使用方法。

其实，最重要的是要学会查看JDK API文档，学习与掌握常见类的属性与方法。
JDK1.8 API下载链接：https://pan.baidu.com/s/1p4a2WPjDLAikOp5oCjW2PQ 提取码：w3re

一、String类与StringBuffer类

（一）Java字符串概述

• 在实际开发中经常会使用字符串，所谓字符串，由许多单个字符连接而成。
• 字符串中可以包含任意字符，这些字符必须包含在一对英文双引号之内，比如"love"、"泸州@泸职院·信息工程学院 2020"
• Java中定义了String和StringBuffer两个类来封装字符串，并提供了一系列操作字符串的方法
• String与StringBuffer两个类都位于java.lang包中，因此不需要导包就可以直接使用

（二）String类的初始化

1、使用字符串常量直接初始化一个String对象

（1）语法格式

String 变量名 = 字符串;

（2）简要说明

在初始化字符串对象时，既可以将字符串对象的初始化值设为空，也可以初始化为一个具体的字符串。

（3）案例演示

• 创建Example2001
  

package net.hw.lesson20;

/**
 * 功能：利用字符串常量初始化对象
 * 作者：华卫
 * 日期：2020年05月17日
 */
public class Example2001 {
    public static void main(String[] args) {
        String str1 = null; // 初始化为空
        String str2 = "";   // 初始化为空字符串
        String str3 = "泸州职业技术学院2020"; // 初始化为字符串常量

        System.out.println("str1 = " + str1);
        System.out.println("str2 = " + str2);
        System.out.println("str3 = " + str3);
    }
}

• 运行程序，查看结果
  

2、使用String的构造方法初始化字符串对象

（1）语法格式

String 变量名 = new String(字符串);

（2）简要说明

上述语法中，字符串同样可以为空或是一个具体的字符串。当为具体字符串时，会使用String类的不同参数类型的构造方法来初始化字符串对象。

（3）String类构造方法

其中，String类常用构造方法如下：

方法声明	功能描述
String()	创建一个内容为空的字符串
String(String value)	根据指定的字符串内容创建对象
String(char[] value)	根据指定的字符数组创建对象

（4）案例演示

• 创建Example2002
  

package net.hw.lesson20;

/**
 * 功能：利用构造方法初始化字符串对象
 * 作者：华卫
 * 日期：2020年05月17日
 */
public class Example2002 {
    public static void main(String[] args) {
        // 创建一个空字符串对象
        String str1 = new String(); // 相当于 str1 = "";
        // 基于一个字符串常量创建字符串对象
        String str2 = new String("泸州职业技术学院2020"); // // 相当于 str2 = "泸州职业技术学院2020";
        // 基于字符数组创建字符串对象
        String str3 = new String(new char[]{'我', '爱', 'J', 'a', 'v', 'a', '！'});
        // 基于字符数组的一部分创建字符串对象
        String str4 = new String(new char[]{'我', '爱', 'J', 'a', 'v', 'a', '！'}, 2, 4);

        System.out.println("str1 = " + str1);
        System.out.println("str2 = " + str2);
        System.out.println("str3 = " + str3);
        System.out.println("str4 = " + str4);
    }
}

• 运行程序，查看结果
  
  当然还可以基于String其它构造方法来初始化字符串对象，有兴趣的同学可以查看JDK API文档，了解各种构造方法初始化字符串对象的用法。

（三）String类常见操作

• String类常用方法

方法声明	功能描述
int indexOf(int ch)	返回指定字符在此字符串中第一次出现处的索引
int lastIndexOf(int ch)	返回指定字符在此字符串中最后一次出现处的索引
int indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引
int lastIndexOf(String str)	返回指定子字符串在此字符串中最后一次出现处的索引
char charAt(int index)	返回字符串中index位置上的字符，其中index的取值范围是：0~（字符串长度-1）
boolean endsWith(String suffix)	判断此字符串是否以指定的字符串结尾
int length()	返回此字符串的长度
boolean equals(Object anObject)	将此字符串与指定的字符串比较
boolean isEmpty()	当且仅当字符串长度为0时返回true
boolean startsWith(String prefix)	判断此字符串是否以指定的字符串开始
boolean contains(CharSequence cs)	判断此字符串中是否包含指定的字符序列
String toLowerCase()	使用默认语言环境的规则将String中的所有字符都转换为小写
String toUpperCase()	使用默认语言环境的规则将String中的所有字符都转换为大写
static String valueOf(int i)	返回 int 参数的字符串表示形式
char[] toCharArray()	将此字符串转换为一个字符数组
String replace(CharSequence oldstr, CharSequence newstr)	返回一个新的字符串，它是通过用newstr替换此字符串中出现的所有oldstr得到的
String[] split(String regex)	根据参数regex（regex是一个正则表达式，用来限定分隔规则）将字符串分割为若干个子字符串
String substring(int beginIndex)	返回一个新字符串，它包含从指定的beginIndex起始角标处开始，直到此字符串末尾的所有字符
String substring(int beginIndex, int endIndex)	返回一个新字符串，它包含从指定的beginIndex起始角标处开始，直到索引endIndex-1角标处的所有字符
String trim()	返回一个新字符串，它去除了原字符串首尾的空格

• String类常见操作
  

1、字符串基本操作

（1）思维导图

（2）案例演示

• 创建Example2003
  

package net.hw.lesson20;

/**
 * 功能：演示字符串基本操作
 * 作者：华卫
 * 日期：2020年05月17日
 */
public class Example2003 {
    public static void main(String[] args) {
        String msg = "I love Java I love Python I love Internet";
        System.out.println("字符串的内容：" + msg);
        System.out.println("字符串的长度：" + msg.length());
        System.out.println("字符串第一个字符：" + msg.charAt(0));
        System.out.println("字符串最后一个字符：" + msg.charAt(msg.length() - 1));
        System.out.println("字符[o]第一次出现的位置：" + msg.indexOf('o'));
        System.out.println("字符[o]最后一次出现的位置：" + msg.lastIndexOf('o'));
        System.out.println("字符串[love]第一次出现的位置：" + msg.indexOf("love"));
        System.out.println("字符串[love]最后一次出现的位置：" + msg.lastIndexOf("love"));
    }
}

• 运行程序，查看结果
  
• 说明：对于charAt()方法，如果传入的索引不存在，那么就会抛出字符串下标越界异常。
  
• 说明：对于indexOf()和lastIndexOf()方法，如果返回值是-1，那么表明没有找到。
  

课堂练习：找出字符串msg里所有的love及其出现位置与出现次数。

2、字符串转换操作

（1）思维导图

（2）案例演示

• 创建Example2004
  

package net.hw.lesson20;

/**
 * 功能：演示字符串转换操作
 * 作者：华卫
 * 日期：2020年05月17日
 */
public class Example2004 {
    public static void main(String[] args) {
        String str = "I love Java";
        System.out.println("字符串内容：" + str);
        char[] arr = str.toCharArray();
        System.out.print("转换成字符数组：");
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 1) {
                // 不是数组最后一个元素，加逗号
                System.out.print(arr[i] + ",");
            } else {
                // 数组最后一个元素，不加逗号
                System.out.println(arr[i]);
            }
        }

        // 其它类型数据转换成字符串
        System.out.println("String.valueOf(12) = " + String.valueOf(12));
        System.out.println("String.valueOf(34.56) = " + String.valueOf(34.56));
        System.out.println("String.valueOf(true) = " + String.valueOf(true));

        // 字符串解析成数值型数据
        int n = Integer.parseInt("250") + 100;
        System.out.println("n = " + n);
        double x = Double.parseDouble("-345.567") + 100;
        System.out.println("x = " + x);

        System.out.println("转成大写字符串：" + str.toUpperCase());
        System.out.println("转成小写字符串：" + str.toLowerCase());
    }
}

• 运行程序，查看结果
  

课堂练习：字符串大小写对换。

将一个字符串的大写字母转换成小写字母，小写字母转换成大写字母，其它字符保持不变。

3、字符串替换与去空操作

（1）思维导图

（2）案例演示

• 创建Example2005
  

package net.hw.lesson20;

/**
 * 功能：演示替换与去空操作
 * 作者：华卫
 * 日期：2020年05月17日
 */
public class Example2005 {
    public static void main(String[] args) {
        String url = "   ht%tp:%%%//w%%w%w.%%%%bai%du.com   ";

        System.out.println("url: " + url);
        System.out.println("去掉两端空格：" + url.trim());
        System.out.println("去掉全部[%]：" + url.replace("%", ""));
    }
}

• 运行程序，查看结果
  

（3）课堂练习

网址不仅两端有空格，中间也有空格，并且网址中间包含几种垃圾字符：%、#与$。

String url = "   ht%$tp:%$$%##%/  /   w%##%w%w.%%$$%##%16%$$3.c##om   ";

编程输出清洗过后的网址，结果如下图所示：

关于清洗网址垃圾字符有多种解决方法，大家可以参看《Java案例：清洗网址垃圾字符》。

（4）思考题

如何清洗掉一个英文字符串包含的所有标点符号？比如Howard: I love 'Java', and I love 'Python'. Do you love them? How useful they are!

4、字符串判断操作

（1）思维导图

（2）案例演示

• 创建Example2006
  

package net.hw.lesson20;

/**
 * 功能：演示字符串判断操作
 * 作者：华卫
 * 日期：2020年05月17日
 */
public class Example2006 {
    public static void main(String[] args) {
        String s = "Internet";

        System.out.println("s = " + s);
        System.out.println("字符串s是否以I开头：" + s.startsWith("I"));
        System.out.println("字符串s是否以te结尾：" + s.endsWith("te"));
        System.out.println("字符串s是否包含了net：" + s.contains("net"));
        System.out.println("字符串s是否是空字符串：" + s.isEmpty());

        String s1 = "I love Java";
        String s2 = "I LOVE JAVA";
        System.out.println("s1 = " + s1);
        System.out.println("s2 = " + s2);
        System.out.println("s1.equals(s2) = " + s1.equals(s2));
        System.out.println("s1.equalsIgnoreCase(s2) = " + s1.equalsIgnoreCase(s2));
    }
}

• 运行程序，查看结果
  
  startsWith()、endsWith()与contains()方法经常用在过滤或清洗的场合。
• 有一组网址，既有http://打头的，也有https://打头的，我们就可以使用url.startsWith("https://")将加密的网址给过滤出来。
• 有一组文件名，我们可以使用filename.endsWith(".exe")将所有可执行文件名给过滤出来。
• 有若干行字符串，我们可以用str.contains("java")将所有包含java的行给过滤出来。
• 输入验证码一般不考虑大小写的，用的是equalsIgnoreCase来比较两个字符串的内容是否相等

（3）简要说明

• s1 == s2 判断两个字符串内容与地址是否相同
• s1.equals(s2) 只判断两个字符串内容是否相同

（4）课堂练习

模拟QQ登录程序，输入QQ号与密码。

• 正确的QQ号与密码分别是“375912390”与“hwyl”
• 如果输入的QQ号与密码都对，那么提示“QQ登录成功~”
• 如果输入的QQ号或密码有误，那是提示“QQ登录失败~”

引申：如果QQ登录失败，能够准确提示用户是QQ号错误还是密码错误。

5、字符串截取与分割操作

（1）思维导图

（2）案例演示：字符串截取

• 创建Example2007
  

package net.hw.lesson20;

/**
 * 功能：演示字符串截取
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2007 {
    public static void main(String[] args) {
        String str1 = "international";

        System.out.println("截取字符串[" + str1 + "]第3个字符到最后：" + str1.substring(2));
        System.out.println("截取字符串[" + str1 + "]前3个字符：" + str1.substring(0, 3));
        System.out.println("截取字符串[" + str1 + "]第5个字符到第10个字符：" + str1.substring(4, 10));
        System.out.println("截取字符串[" + str1 + "]末尾3个字符：" + str1.substring(str1.length() - 3, str1.length()));
    }
}

• 运行程序，查看结果
  
• 拓展练习：做一个音乐播放器，扫描磁盘上所有MP3文件，可以用filname.endsWith(".mp3")来实现，但是获取的文件名包含了路径与扩展名，真正要显示在列表里的只是文件名，不要前面的路径和后面的扩展名，此时就可以使用filename.substring(filename.lastIndexOf("/") + 1, filename.lastIndexOf("."))来完成任务。
  

（3）案例演示：字符串分隔

• 创建Example2008
  

package net.hw.lesson20;

/**
 * 功能：演示字符串分隔
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2008 {
    public static void main(String[] args) {
        String line = "001 李晓红 20 15893932340 [email protected] 软件技术";
        System.out.println(line);

        String[] fields = line.split(" ");
        System.out.println("学号：" + fields[0]);
        System.out.println("姓名：" + fields[1]);
        System.out.println("年龄：" + fields[2]);
        System.out.println("电话：" + fields[3]);
        System.out.println("邮箱：" + fields[4]);
        System.out.println("专业：" + fields[5]);
    }
}

• 运行程序，查看结果
  
  拆分字符串的可以是空格，也可以是其它字符，比如将日期2020-5-18拆分成年月日，那么就要使用split("-")来完成日期字符串的拆分工作。

（4）课堂练习：统计英文字符串中的单词个数

• 英文字符串没有标点符号："I love Java programming because it is very useful and interesting"
  
• 英文字符串里有标点符号："Howard: I love 'Java', and I love 'Python'. Do you love them? How useful they are!"
  

（四）StringBuffer类

1、为什么要引入StringBuffer类

• 存在问题：在Java中，由于String类是final类型的，所以使用String定义的字符串是一个常量，因此它一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串。
  
• 解决方法：可以使用StringBuffer类（也称字符串缓冲区）来操作字符串。
• 简要说明：StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或删除字符时，所操作的都是这个字符容器，因此并不会产生新的StringBuffer对象。

2、StringBuffer类常用方法

方法声明	功能描述
StringBuffer append(char c)	添加字符到StringBuffer对象中末尾
StringBuffer insert(int offset,String str)	在StringBuffer对象中的offset位置插入字符串str
StringBuffer deleteCharAt(int index)	移除StringBuffer对象中指定位置的字符
StringBuffer delete(int start,int end)	删除StringBuffer对象中指定范围的字符或字符串
StringBuffer replace(int start,int end,String s)	将StringBuffer对象中指定范围的字符或字符串用新的字符串s进行替换
void setCharAt(int index, char ch)	修改指定位置index处的字符
String toString()	返回StringBuffer缓冲区中的字符串对象
StringBuffer reverse()	将此StringBuffer对象用其反转形式取代

3、案例演示StringBuffer类用法

• 创建Example2009
  

package net.hw.lesson20;

/**
 * 功能：演示StringBuffer用法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2009 {
    public static void main(String[] args) {
        System.out.println("1. 演示字符串添加功能");
        add();
        System.out.println("2. 演示字符串修改功能");
        update();
        System.out.println("3. 演示字符串删除功能");
        delete();
    }

    private static void add() {
        StringBuffer sb = new StringBuffer();
        sb.append("Java");
        System.out.println("添加Java后的结果：" + sb.toString());
        sb.insert(2, "%%");
        System.out.println("在指定位置插入%%的结果：" + sb.toString());
    }

    private static void update() {
        StringBuffer sb = new StringBuffer("international");
        System.out.println("字符串原始内容：" + sb.toString());
        sb.setCharAt(5, 'N');
        System.out.println("修改指定位置的字符：" + sb.toString());
        sb.replace(2, 4, "TE");
        System.out.println("替换指定位置的字符（串）：" + sb.toString());
        sb.reverse();
        System.out.println("字符串翻转结果：" + sb.toString());
    }

    private static void delete() {
        StringBuffer sb = new StringBuffer("I love Java");
        System.out.println("字符串原始内容：" + sb.toString());
        sb.deleteCharAt(1);
        System.out.println("删除指定位置的字符：" + sb.toString());
        sb.delete(1, 5);
        System.out.println("删除指定范围的字符：" + sb.toString());
        sb.delete(0, sb.length());
        System.out.println("清空缓冲区后的结果：" + sb.toString());
    }
}

• 运行程序，查看结果
  

课堂练习1、按奇偶位置提取字符串

• 将一个字符串拆分成两个子串，第一个子串是由字符串里奇数位置的字符构成，第二个子串是由字符串里偶数位置的字符构成。
  

课堂练习2、奇偶交叉拼接字符串

• 已知两个字符串，按照奇偶交叉拼接成一个新字符串。两个字符串长度相等与不相等两种情况都应该考虑到，按照短板理论，以较短字符串为准来进行奇偶交叉拼接。
  

4、StringBuffer与String对比分析

• String类定义的字符串是常量，一旦创建后，内容和长度都是无法改变的。StringBuffer表示字符容器，其内容和长度可以随时修改
  
• String类重写了Object类的equals()方法，而StringBuffer类没有重写Object类的equals()方法
  
• String对象可以用操作符+进行连接，但是StringBuffer对象不允许这样操作
  

（五）StringBuilder类

1、StringBuilder概述

• 除了使用StringBuffer外，JDK 1.5之后提供了一个StringBuilder类同样可以操作字符串。StringBuilder与StringBuffer的功能相似，且两个类中所提供的方法也基本相同。
• 主要区别：二者所不同的是StringBuffer是线程安全的，而StringBuilder没有实现线程安全功能，所以性能略高。通常情况下，如果创建一个内容可变的字符串对象，应该优先考虑StringBuilder类。

2、案例演示StringBuilder用法

• 创建Example2013
  

package net.hw.lesson20;

/**
 * 功能：演示StringBuilder用法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2013 {
    public static void main(String[] args) {
        System.out.println("1. 演示字符串添加功能");
        add();
        System.out.println("2. 演示字符串修改功能");
        update();
        System.out.println("3. 演示字符串删除功能");
        delete();
    }

    private static void add() {
        StringBuilder sb = new StringBuilder();
        sb.append("Java");
        System.out.println("添加Java后的结果：" + sb.toString());
        sb.insert(2, "%%");
        System.out.println("在指定位置插入%%的结果：" + sb.toString());
    }

    private static void update() {
        StringBuilder sb = new StringBuilder("international");
        System.out.println("字符串原始内容：" + sb.toString());
        sb.setCharAt(5, 'N');
        System.out.println("修改指定位置的字符：" + sb.toString());
        sb.replace(2, 4, "TE");
        System.out.println("替换指定位置的字符（串）：" + sb.toString());
        sb.reverse();
        System.out.println("字符串翻转结果：" + sb.toString());
    }

    private static void delete() {
        StringBuilder sb = new StringBuilder("I love Java");
        System.out.println("字符串原始内容：" + sb.toString());
        sb.deleteCharAt(1);
        System.out.println("删除指定位置的字符：" + sb.toString());
        sb.delete(1, 5);
        System.out.println("删除指定范围的字符：" + sb.toString());
        sb.delete(0, sb.length());
        System.out.println("清空缓冲区后的结果：" + sb.toString());
    }
}

• 运行程序，查看结果
  

二、System类与Runtime类

（一）System类

1、System类概述

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，因此，想要引用这些属性和方法，直接使用System类调用即可。

2、System类常用方法

方法声明	功能描述
static void exit(int status)	该方法用于终止当前正在运行的Java虚拟机，其中参数status表示状态码，若状态码非0 ，则表示异常终止
static void gc()	运行垃圾回收器，并对垃圾进行回收
static native long currentTimeMillis()	返回以毫秒为单位的当前时间
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)	从src引用的指定源数组复制到dest引用的数组，复制从指定的位置开始，到目标数组的指定位置结束
static Properties getProperties()	取得当前的系统属性
static String getProperty(String key)	获取指定键描述的系统属性

3、案例演示

（1）演示getProperties()方法

该方法用于获取当前系统的全部属性该方法会返一个Properties对象，其中封装了系统的所有属性，这些属性是以键值对形式存在的。

• 创建Example2014
  

package net.hw.lesson20;

import java.util.Properties;
import java.util.Set;

/**
 * 功能：演示getProperties()方法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2014 {
    public static void main(String[] args) {
        // 获取当前系统属性
        Properties properties = System.getProperties();
        // 获取所有系统属性的属性名（key），返回Set对象
        Set<String> keys = properties.stringPropertyNames();
        // 遍历全部属性名
        for (String key : keys) {
            // 通过属性名获取属性值
            String value = System.getProperty(key);
            // 输出属性名与属性值构成的键值对
            System.out.println(key + " : " + value);
        }
    }
}

• 运行程序，查看结果
  

java.runtime.name : Java(TM) SE Runtime Environment
sun.boot.library.path : D:\Program Files\Java\jdk1.8.0_231\jre\bin
java.vm.version : 25.231-b11
java.vm.vendor : Oracle Corporation
java.vendor.url : http://java.oracle.com/
path.separator : ;
java.vm.name : Java HotSpot(TM) 64-Bit Server VM
file.encoding.pkg : sun.io
user.script : 
user.country : CN
sun.java.launcher : SUN_STANDARD
sun.os.patch.level : 
java.vm.specification.name : Java Virtual Machine Specification
user.dir : D:\IdeaProjects\JavaDemo2020
java.runtime.version : 1.8.0_231-b11
java.awt.graphicsenv : sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs : D:\Program Files\Java\jdk1.8.0_231\jre\lib\endorsed
os.arch : amd64
java.io.tmpdir : C:\Users\howard\AppData\Local\Temp\
line.separator : 

java.vm.specification.vendor : Oracle Corporation
user.variant : 
os.name : Windows 10
sun.jnu.encoding : GBK
java.library.path : D:\Program Files\Java\jdk1.8.0_231\bin;C:\WINDOWS\Sun\Java\bin;C:\WINDOWS\system32;C:\WINDOWS;D:\Program Files\Java\jdk1.8.0_231\bin;D:\apache-tomcat-8.5.45\bin;D:\hadoop\hadoop-2.7.1\bin;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;D:\Program Files\apache-maven-3.3.9\bin;D:\Program Files\nodejs;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Program Files (x86)\MySQL\MySQL Server 5.5\bin;D:\Program Files\TortoiseSVN\bin;D:\Program Files\VisualSVN Server\bin;D:\Python37;D:\Python37\Scripts;C:\WINDOWS\System32\OpenSSH\;D:\Program Files\nodejs\;C:\ProgramData\chocolatey\bin;D:\Program Files (x86)\scala\bin;D:\Program Files\Python\Python36\Scripts\;D:\Program Files\Python\Python36\;C:\Users\howard\AppData\Local\Microsoft\WindowsApps;C:\Program Files (x86)\SSH Communications Security\SSH Secure Shell;C:\Users\howard\AppData\Roaming\npm;.
java.specification.name : Java Platform API Specification
java.class.version : 52.0
sun.management.compiler : HotSpot 64-Bit Tiered Compilers
os.version : 10.0
user.home : C:\Users\howard
user.timezone : 
java.awt.printerjob : sun.awt.windows.WPrinterJob
file.encoding : UTF-8
java.specification.version : 1.8
user.name : howard
java.class.path : D:\Program Files\Java\jdk1.8.0_231\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\deploy.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\access-bridge-64.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\cldrdata.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\dnsns.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\jaccess.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\jfxrt.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\localedata.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\nashorn.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunec.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunjce_provider.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunmscapi.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunpkcs11.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\zipfs.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\javaws.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jce.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jfxswt.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\management-agent.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\plugin.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\resources.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\rt.jar;D:\IdeaProjects\JavaDemo2020\out\production\JavaDemo2020;D:\Program Files\JetBrains\IntelliJ IDEA 2019.3.1\lib\idea_rt.jar
java.vm.specification.version : 1.8
sun.arch.data.model : 64
java.home : D:\Program Files\Java\jdk1.8.0_231\jre
sun.java.command : net.hw.lesson20.Example2014
java.specification.vendor : Oracle Corporation
user.language : zh
awt.toolkit : sun.awt.windows.WToolkit
java.vm.info : mixed mode
java.version : 1.8.0_231
java.ext.dirs : D:\Program Files\Java\jdk1.8.0_231\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
sun.boot.class.path : D:\Program Files\Java\jdk1.8.0_231\jre\lib\resources.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\rt.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\sunrsasign.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jce.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.8.0_231\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.8.0_231\jre\classes
java.vendor : Oracle Corporation
file.separator : \
java.vendor.url.bug : http://bugreport.sun.com/bugreport/
sun.cpu.endian : little
sun.io.unicode.encoding : UnicodeLittle
sun.desktop : windows
sun.cpu.isalist : amd64

（2）演示currentTimeMillis()方法

该方法返回一个long类型的值，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间戳。

• 创建Example2015
  

package net.hw.lesson20;

/**
 * 功能：演示currentTimeMillis()方法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2015 {
    public static void main(String[] args) {
        // 开始时间
        long startTime = System.currentTimeMillis();

        // 耗时工作
        long sum = 0;
        for (int i = 1; i <= 1000000000; i++) {
            sum += i;
        }
        System.out.println("sum = " + sum);

        // 结束时间
        long endTime = System.currentTimeMillis();

        System.out.println("程序运行耗时：" + (endTime - startTime) + "毫秒");
    }
}

• 运行程序，查看结果
  

（3）演示arraycopy()方法

该方法用于将一个数组中的元素快速拷贝到另一个数组。

• src：表示源数组（source array）

• dest：表示目标数组（destination array）

• srcPos：表示源数组中拷贝元素的起始位置

• destPos：表示拷贝到目标数组的起始位置

• length：表示拷贝元素的个数

• 创建Example2016
  

package net.hw.lesson20;

/**
 * 功能：演示arraycopy()方法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2016 {
    public static void main(String[] args) {
        // 源数组
        int[] arr1 = {34, 56, 78, 12, 89, 46, 20, 60};
        System.out.println("源数组：");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        System.out.println();
        
        // 目标数组
        int[] arr2 = {100, 200, 300, 400, 500, 600};
        System.out.println("目标数组：");
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
        System.out.println();

        // 数组拷贝
        System.out.println("将源数组从第3个元素开始拷贝到目标数组第2个位置，拷贝4个元素");
        System.arraycopy(arr1, 2, arr2, 1, 4);
        System.out.println("新目标数组：");
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
    }
}

• 如果采用Lambda表达式来输出数组，那么代码修改如下：

public class Example2016 {
    public static void main(String[] args) {
        // 定义源数组
        Integer[] arr1 = {34, 56, 78, 12, 89, 46, 20, 60};
        // 输出源数组
        System.out.print("源数组：");
        Arrays.asList(arr1).forEach(x -> System.out.print(x + " "));
        System.out.println();

        // 定义目标数组
        Integer[] arr2 = {100, 200, 300, 400, 500, 600};
        // 输出目标数组
        System.out.print("目标数组：");
        Arrays.asList(arr2).forEach(x -> System.out.print(x + " "));
        System.out.println();

        // 进行数组拷贝
        System.out.println("将源数组从第3个位置开始拷贝到目标数组第2个位置，拷贝4个元素");
        System.arraycopy(arr1, 2, arr2, 1, 4);
        System.out.print("新目标数组：");
        Arrays.asList(arr2).forEach(x -> System.out.print(x + " "));
        System.out.println();
    }
}

• 思考题：如何将一个数组的全部元素完整地拷贝到另一个数组。
• 建议同学们采用Lambda表达式来输出数组，但是数组类型应改为Integer
  
  

（二）Runtime类

1、Runtime类定义

Runtime类用于表示Java虚拟机运行时的状态，它用于封装Java虚拟机进程。

2、Runtime类说明

每次使用“java”命令启动Java虚拟机时都会对应一个Runtime实例，并且只有一个实例，应用程序会通过该实例与其运行时的环境相连。

3、获取Runtime实例的方式

Runtime rt = Runtime.getRuntime();

4、案例演示Runtime类用法

（1）获取虚拟机信息

• 创建Example2017
  

package net.hw.lesson20;

/**
 * 功能：获取虚拟机信息
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2017 {
    public static void main(String[] args) {
        // 获取Java程序关联的运行时对象
        Runtime rt = Runtime.getRuntime();
        // 获取虚拟机的信息
        System.out.println("处理器的个数：" + rt.availableProcessors() + "个");
        System.out.println("最大可用内存：" + rt.maxMemory() / 1024 / 1024 + "M");
        System.out.println("虚拟机总内存：" + rt.totalMemory() / 1024 / 1024 + "M");
        System.out.println("空闲内存大小：" + rt.freeMemory() / 1024 / 1024 + "M");
    }
}

• 运行程序，查看结果
  
  同学们，可以在网上搜索，了解一下这几个内存概念之间的区别和联系。

（2）启动Windows自带计算器

Runtime类中提供了一个exec()方法，该方法用于执行一个DOS命令，从而实现和在命令行窗口中输入DOS命令同样的效果。

• 创建Example2018
  

package net.hw.lesson20;

import java.io.IOException;

/**
 * 功能：启动Windows自带计算器
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2018 {
    public static void main(String[] args) {
        // 获取Java程序关联的运行时对象
        Runtime rt = Runtime.getRuntime();
        // 调用exec()方法启动计算器
        try {
            rt.exec("calc.exe");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• 运行程序，查看结果
  
  在任务管理器里，可以看到启动的计算器进程：
  

（3）自动关闭启动的Windows记事本

Runtime类的exec()方法会返回一个Process对象，该对象表示操作系统的一个进程，通过Process对象可以对产生的新进程进行管理，比如调用Process对象的destroy()方法就可以关闭此进程。

• 创建Example2019
  

package net.hw.lesson20;

/**
 * 功能：启动与关闭Windows记事本
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2019 {
    public static void main(String[] args) throws Exception {
        // 获取Java程序关联的运行时对象
        Runtime rt = Runtime.getRuntime();
        // 调用exec()方法启动记事本，返回进程对象
        Process process = rt.exec("notepad.exe");
        // 让程序休眠3秒
        Thread.sleep(3000);
        // 关闭进程对象
        process.destroy();
    }
}

• 启动程序，查看结果
  
  大家可以看到，记事本程序启动之后3秒就自动关闭了。

课堂练习：在Java程序里启动Windows的画图程序。

三、Math类与Random类

（一）Math类

1、Math类概述

• Math类是一个工具类，主要用于完成复杂的数学运算，如求绝对值、三角函数、指数运算等。
• 由于Math类的构造方法被定义成private，因此无法创建Math类的对象。
• Math类中的所有方法都是静态方法，可以直接通过类名来调用它们。
• 除静态方法外，Math类中还有两个静态常量PI和E，分别代表数学中的π和e。

2、案例演示Math类

• 创建Example2020
  

package net.hw.lesson20;

/**
 * 功能：演示Math类用法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2020 {
    public static void main(String[] args) {
        System.out.println("Math.abs(-1.5) = " + Math.abs(-1.5)); // 绝对值
        System.out.println("Math.sin(30 * Math.PI / 180) = " + String.format("%.1f", Math.sin(30 * Math.PI / 180))); // 正弦函数
        System.out.println("Math.cos(60 * Math.PI / 180) = " + String.format("%.1f", Math.cos(60 * Math.PI / 180))); // 余弦函数
        System.out.println("Math.tan(45 * Math.PI / 180) = " + String.format("%.1f", Math.tan(45 * Math.PI / 180))); // 正切函数
        System.out.println("Math.sqrt(100) = " + Math.sqrt(100)); // 平方根（square root）
        System.out.println("Math.cbrt(100) = " + Math.cbrt(64));  // 立方根（cube root）
        System.out.println("Math.pow(2, 4) = " + Math.pow(2, 4)); // 幂运算（2的4次幂）
        System.out.println("Math.ceil(4.56) = " + Math.ceil(4.56)); // 大于参数的最小整数
        System.out.println("Math.floor(-4.56) = " + Math.floor(-4.56)); // 小于参数的最大整数
        System.out.println("Math.round(-4.46) = " + Math.round(-4.46)); // 四舍五入取整
        System.out.println("Math.max(125, 320) = " + Math.max(125, 320)); // 求两个整数的最大值
        System.out.println("Math.min(125, 320) = " + Math.min(125, 320)); // 求两个整数的最小值
        System.out.println("Math.random() = " + Math.random()); // 产生[0, 1)之内的随机数
    }
}

• 运行程序，查看结果
  

3、简要说明

• 三角函数接收的参数是弧度，不是角度，因此需要进行转换。
  例如：$sin30^o=sin\frac{30\pi }{180}=sin\frac{\pi }{6}=\frac{1}{2}=0.5$
• 可以利用Math.random()生成指定范围[a, b]的随机整数。（伸缩变换 + 取整操作 + 平移变换）

 int num = (int)(Math.random() * (b - a + 1)) + a;

• round()方法用于对某个小数进行四舍五入，此方法会将小数点后面的数字全部忽略，返回一个int类型的数，而ceil()方法和floor()方法返回的都是double类型的数。

课堂练习：猜数游戏里需要产生10到100之间的随机整数。

（二）Random类

1、Random类概述

• 在JDK的java.util包中，有一个Random类，它可以在指定的取值范围内随机产生数字。
• Random类的两个构造方法

方法声明	功能描述
Random()	构造方法，用于创建一个随机数生成器，每次实例化Random对象会生成不同的随机数
Random(long seed)	构造方法，使用一个long型的seed（种子）创建伪随机数生成器，当seed相同时，每次实例化Random对象会生成相同的随机数

• Random类常用方法

方法声明	功能描述
boolean nextBoolean()	随机生成boolean类型的随机数
double nextDouble()	随机生成double类型的随机数
float nextFloat()	随机生成float类型的随机数
int nextInt()	随机生成int类型的随机数
int nextInt(int n)	随机生成[0,n)之间int类型的随机数
long nextLong()	随机生成long类型的随机数

2、案例演示Random类

• 创建Example2021
  

package net.hw.lesson20;

import java.util.Random;

/**
 * 功能：演示Random类用法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2021 {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println("生成布尔型随机数：" + r.nextBoolean());
        System.out.println("生成浮点型随机数：" + r.nextFloat());
        System.out.println("生成双精度随机数：" + r.nextDouble());
        System.out.println("生成整型随机数：" + r.nextInt());
        System.out.println("生成[0, 100]范围的整型随机数：" + r.nextInt(100));
        System.out.println("生成长整型随机数：" + r.nextLong());
    }
}

• 运行程序，查看结果
  

3、简要说明

可以利用Random类生成[a, b]之间的随机整数：

Random r = new Random();
int num = r.nextInt(b - a + 1) + a;

四、包装类（Wrapper Class）

（一）为什么需要包装类？

虽然Java是面向对象的编程语言，但它所包含的8种基本数据类型却不支持面向对象的编程机制（没有属性和方法）。在Java中，很多类的方法都需要接收引用类型的对象，此时就无法将一个基本数据类型的值传入。为了解决这样的问题，JDK中提供了一系列的包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。

（二）基本类型——包装类对照表

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

（三）基本类型与包装类相互转换

1、自动装箱（Autoboxing）

自动装箱是指将基本数据类型的变量赋给对应的包装类变量。

2、自动拆箱（AutoUnboxing）

自动拆箱是指将包装类对象类型直接赋给一个对应的基本数据类型变量。

3、案例演示

• 创建Example2022
  

package net.hw.lesson20;

/**
 * 功能：演示自动装箱与自动拆箱
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2022 {
    public static void main(String[] args) {
        // 定义整型变量aInt
        int aInt = 100;
        // 输出整型变量aInt
        System.out.println("整型变量 aInt = " + aInt);

        // 自动装箱：将变量aInt的值赋给整数对象aInteger
        Integer aInteger = aInt;
        // 输出整数对象aInteger
        System.out.println("整数对象 aInteger = " + aInteger);

        // 自动拆箱：将整数对象aInteger赋给整型变量bInt
        int bInt = aInteger;
        // 输出整型变量bInt
        System.out.println("整型变量 bInt = " + bInt);
    }
}

• 运行程序，查看结果
  

（四）基本数据类型、包装类以及字符串之间的相互转换

1、基本数据类型转换成字符串

（1）转换方法

通过引用数据类型字符串String类的valueOf()方法可以将8种基本数据类型转换为对应的字符串类型。

（2）案例演示

• 创建Example2023
  

package net.hw.lesson20;

/**
 * 功能：演示将基本类型转换成字符串
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2023 {
    public static void main(String[] args) {
        System.out.println("String.valueOf(100) = " + String.valueOf(100));
        System.out.println("String.valueOf(45.87) = " + String.valueOf(45.87));
        System.out.println("String.valueOf('K') = " + String.valueOf('K'));
        boolean aBoolean = false;
        System.out.println("String.valueOf(aBoolean) = " + String.valueOf(aBoolean));
    }
}

• 运行程序，查看结果
  

2、基本数据类型转换成包装类

（1）转换方法

• 通过8种包装类的静态方法valueOf()既可以将对应的基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类（Character包装类除外）
• 通过8种包装类的有参构造方法同样既可以将对应的基本数据类型转换为包装类，也可以将变量内容匹配的字符串转换为对应的包装类（Character包装类除外）

（2）案例演示

• 创建Example2024
  

package net.hw.lesson20;

/**
 * 功能：将基本数据类型转换成包装类
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2024 {
    public static void main(String[] args) {
        // 方法一、利用包装类的valueOf()方法
        Integer aInteger = Integer.valueOf(100);
        System.out.println("aInteger = " + aInteger);
        aInteger = Integer.valueOf("100");
        System.out.println("aInteger = " + aInteger);
        Double aDouble = Double.valueOf(23.45);
        System.out.println("aDouble = " + aDouble);
        aDouble = Double.valueOf("23.45");
        System.out.println("aDouble = " + aDouble);
        Character aCharacter = Character.valueOf('$');
        System.out.println("aCharacter = " + aCharacter);        

        // 方法二、利用包装的构造方法
        Integer bInteger = new Integer(50);
        System.out.println("bInteger = " + bInteger);
        bInteger = new Integer("50");
        System.out.println("bInteger = " + bInteger);
        Double bDouble = new Double(23.85);
        System.out.println("bDouble = " + bDouble);
        bDouble = new Double("23.85");
        System.out.println("bDouble = " + bDouble);
        Character bCharacter = Character.valueOf('#');
        System.out.println("bCharacter = " + bCharacter);
    }
}

• 运行程序，查看结果
  

（3）注意事项

• Character.valueOf()方法只接受字符数据，不接受字符串数据
  
• Character类构造方法只接受字符参数，不接受字符串参数
  
• 除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。

Integer i = Integer.valueOf("123");       // 合法
Integer i = Integer.valueOf("12a3");      // 不合法

3、将字符串数据转换成基本数据类型

（1）转换方法

通过8种包装类的静态方法parseXxx()可以将变量内容匹配的字符串转换为对应的基本数据类型。

（2）案例演示

（3）注意事项

除了Character外，包装类都有parseXxx(String s)的静态方法，将字符串转换为对应的基本类型的数据。参数s不能为null，而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。

int m = Integer.parseInt("1000");        // 合法    
Integer n = Integer.parseInt("lzy2020");  // 不合法 

4、将包装类对象转换成字符串

（1）转换方法

包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。

（2）案例演示

• 创建Example2025
  

package net.hw.lesson20;

/**
 * 功能：包装类对象转换成字符串
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2025 {
    public static void main(String[] args) {
        // 创建整数对象
        Integer aInteger = new Integer(1000);
        // 输出整数对象
        System.out.println("aInteger = " + aInteger);
        // 将整数对象转换成字符串
        String aString = aInteger.toString();
        // 输出转换后的字符串
        System.out.println("aString = " + aString);
    }
}

• 运行程序，查看结果
  

五、日期类与时间类

（一）Date类

1、Date类概述

在JDK的java.util包中，提供了一个Date类用于表示日期和时间。随着JDK版本的不断升级和发展，Date类中大部分的构造方法和普通方法都已经不再推荐使用。目前JDK 8中，Date类只有两个构造方法是可以使用的。

2、Date类构造方法

• Date()：用来创建当前日期时间的Date对象。
• Date(long date)：用于创建指定时间的Date对象，其中date参数表示1970年1月1日0时0分0（称为历元）以来的毫秒数，即时间戳。

3、案例演示

• 创建Example2026
  

package net.hw.lesson20;

import java.util.Date;

/**
 * 功能：演示Date类用法
 * 作者：华卫
 * 日期：2020年05月18日
 */
public class Example2026 {
    public static void main(String[] args) {
        // 创建日期对象，获取当前时间
        Date date1 = new Date();
        // 输出日期对象date1
        System.out.println("date1: " + date1);

        // 创建日期对象，获取当前时间之后3秒的时间
        Date date2 = new Date(System.currentTimeMillis() + 3000);
        // 输出日期对象date2
        System.out.println("date2: " + date2);
    }
}

• 运行程序，查看结果
  

4、 补充说明

对于Date类，只需要了解如何通过创建对象封装时间值即可。由于Date类在设计之初，没有考虑到国际化的问题，因此从JDK1.1开始，Date类相应的功能也被Calendar类中的方法取代。

（二）Calendar类

1、Calendar类概述

• Calendar类用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分和秒等。
• Calendar类是一个抽象类，不可以被实例化。
• 在程序中需要调用其静态方法getInstance()来得到一个Calendar对象，然后才能调用其相应的方法。Calendar calendar = Calendar.getInstance();

2、Calendar类常用方法

方法声明	功能描述
int get(int field)	返回指定日历字段的值
void add(int field,int amount)	根据日历规则，为指定的日历字段增加或减去指定的时间量
void set(int field,int value)	为指定日历字段设置指定值
void set(int year,int month,int date)	设置Calendar对象的年、月、日三个字段的值
void set(int year.int month,int date,int hourOfDay,int minute,int second)	设置Calendar对象的年、月、日、时、分、秒六个字段的值

3、案例演示Calendar类

任务1、获取当前日期与时间

• 创建Example2027
  

package net.hw.lesson20;

import java.util.Calendar;

/**
 * 功能：利用Calendar类获取当前日期与时间
 * 作者：华卫
 * 日期：2020年05月19日
 */
public class Example2027 {
    public static void main(String[] args) {
        // 获取日历对象（单例模式获取实例）
        Calendar calendar = Calendar.getInstance();

        // 获取年份
        int year = calendar.get(Calendar.YEAR);
        // 获取月份（注意要加1）
        int month = calendar.get(Calendar.MONTH) + 1;
        // 获取天日
        int day = calendar.get(Calendar.DATE);
        // 获取时
        int hour = calendar.get(Calendar.HOUR);
        // 获取分
        int minute = calendar.get(Calendar.MINUTE);
        // 获取秒
        int second = calendar.get(Calendar.SECOND);

        // 输出当前时间
        System.out.println("当前时间：" + year + "年" + month + "月"
                + day + "日 " + hour + ":" + minute + ":" + second);
    }
}

• 运行程序，查看结果
  
• 注意：calendar.get(Calendar.MONTH) + 1 才是当前日期的月份。

任务2、设置日期与时间

• 创建Example2028
  

package net.hw.lesson20;

import java.util.Calendar;

/**
 * 功能：利用Calendar类设置日期与时间
 * 作者：华卫
 * 日期：2020年05月19日
 */
public class Example2028 {
    public static void main(String[] args) {
        // 获取日历对象（单例模式获取实例）
        Calendar calendar = Calendar.getInstance();

        // 设置年份
        calendar.set(Calendar.YEAR, 1997);
        // 设置月份
        calendar.set(Calendar.MONTH, 7);
        // 设置天日
        calendar.set(Calendar.DATE, 1);
        // 设置时
        calendar.set(Calendar.HOUR, 8);
        // 设置分
        calendar.set(Calendar.MINUTE, 10);
        // 设置秒
        calendar.set(Calendar.SECOND,30);

        // 输出设置后的日历对象
        System.out.println(calendar);
    }
}

• 运行程序，查看结果
  
• 设置日期的另一种方式

calendar.set(1997, 7, 1, 8, 10, 30);

• 补充说明：按照Calendar类的设计，calendar.get(Calendar.MONTH) + 1 才是当前日期的月份，那么在设置月份时，就应该减1才符合要求。1997年7月1日，应该设置为calendar.set(1997, 6, 1);

课堂练习：给出年月日，确定它是该年的第几天

我们在《Java讲课笔记06：选择结构与条件循环》补充案例Example616里利用选择结构搞定这个问题：

不过现在要求大家采用Calendar来完成同样的任务。

任务3、日期往前或往后推

利用方法abstract public void add(int field, int amount);即可完成日期前推与后推。第一个参数是前推或后推的单位，比如Calendar.YEAR，Calendar.MONTH，Calendar.DATE，Calendar.HOUR，Calendar.MINUTE，Calendar.SECOND；第二参数是前推或后推的数量，如果是正数，那么就是日期后推，如果是负数，那么就是日期前推。

• 创建Example2029
  

package net.hw.lesson20;

import java.util.Calendar;

/**
 * 功能：日期往前或往后推
 * 作者：华卫
 * 日期：2020年05月19日
 */
public class Example2029 {
    public static void main(String[] args) {
        int year, month, day;
        // 获取日历对象（单例模式获取实例）
        Calendar calendar = Calendar.getInstance();

        // 设置新日期（2020-1-1）
        calendar.set(2020, 0, 1); // 月份要减1

        // 获取年份
        year = calendar.get(Calendar.YEAR);
        // 获取月份（注意要加1）
        month = calendar.get(Calendar.MONTH) + 1;
        // 获取天日
        day = calendar.get(Calendar.DATE);

        // 输出设定的日期
        System.out.println("设定的日期：" + year + "年" + month + "月" + day + "日");

        // 日期往后推100天
        calendar.add(Calendar.DATE, 100);

        // 获取年份
        year = calendar.get(Calendar.YEAR);
        // 获取月份（注意要加1）
        month = calendar.get(Calendar.MONTH) + 1;
        // 获取天日
        day = calendar.get(Calendar.DATE);

        // 输出后推100天的日期
        System.out.println("后推100天：" + year + "年" + month + "月" + day + "日");

        // 日期往前推150天
        calendar.add(Calendar.DATE, -150);

        // 获取年份
        year = calendar.get(Calendar.YEAR);
        // 获取月份（注意要加1）
        month = calendar.get(Calendar.MONTH) + 1;
        // 获取天日
        day = calendar.get(Calendar.DATE);

        // 输出前推50天的日期
        System.out.println("前推150天：" + year + "年" + month + "月" + day + "日");
    }
}

• 运行程序，查看结果
  

课堂练习：计算香港回归中国多少天。

（三）JDK8新增日期与时间类

1、新增日期与时间类

为了满足更多的需求，JDK 8中新增了一个java.time包，在该包下包含了更多的日期和时间操作类。

类名	功能描述
Clock	用于获取指定时区的当前日期、时间。
DayOfWeek	枚举类，定义了一周七天周一到周日的枚举值
Duration	表示持续时间。该类提供的ofXxx()方法用于获取指定的时间的小时、分钟、秒数等。
Instant	表示一个具体时刻，可以精确到纳秒。该类提供了静态的now()方法来获取当前时刻，提供了静态的now(Clock clock)方法来获取clock对应的时刻。同时还提供了一系列的plusXxx()方法来获取当前时刻基础上加上一段时间，以及一系列的minusXxx()方法在当前时刻基础上减去一段时间。
LocalDate	表示不带时区的日期，如2018-01-27。该类提供了静态的now()方法来获取当前日期，提供了静态的now(Clock clock)方法来获取clock对应的日期。同时还提供了一系列的plusXxx()方法在当前年份基础上加上几年、几月、几日等，以及一系列的minusXxx()方法在当前年份基础上减去几年、几月、几日等。
LocalTime	表示不带时区的时间，如14:49:20。该类提供了静态的now()方法来获取当前时间，提供了静态的now(Clock clock)方法来获取clock对应的时间。同时还提供了一系列的plusXxx()方法在当前年份基础上加上几小时、几分、几秒等，以及一系列的minusXxx()方法在当前年份基础上减去几小时、几分、几秒等。
LocalDateTime	表示不带时区的日期、时间。该类提供了静态的now()方法来获取当前日期、时间，提供了静态的now(Clock clock)方法来获取clock对应的日期、时间。同时还提供了一系列的plusXxx()方法在当前年份基础上加上几年、几月、几日、几小时、几分、几秒等，以及一系列的minusXxx()方法在当前年份基础上减去几年、几月、几日、几小时、几分、几秒等。
Month	枚举类，定义了一月到十二月的枚举值
MonthDay	表示月日，如–01-27。该类提供了静态的now()方法来获取当前月日，提供了静态的now(Clock clock)方法来获取clock对应的月日。
Year	表示年，如2018。该类提供了静态的now()方法来获取当前年份，提供了静态的now(Clock clock)方法来获取clock对应的年份。同时还提供了plusYears()方法在当前年份基础上增加几年，以及minusYears()方法在当前年份基础上减去几年。
YearMonth	表示年月，如2018-01。该类提供了静态的now()方法来获取当前年月，提供了静态的now(Clock clock)方法来获取clock对应的年月。同时还提供了plusXxx()方法在当前年月基础上增加几年、几月，以及minusXxx()方法在当前年月基础上减去几年、几月。
ZoneId	表示一个时区
ZonedDateTime	表示一个时区化的日期、时间

（1）Clock类

（2）Duration类

（3）Instant类

（4）LocalDate类

（5）LocalTime类

（6）LocalDateTime类

（7）Year类、YearMonth类、MonthDay类

（8）ZoneId类

2、案例演示

• 创建Example2030
  

package net.hw.lesson20;

import java.time.*;

/**
 * 功能：演示JDK8新增日期类
 * 作者：华卫
 * 日期：2020年05月19日
 */
public class Example2030 {
    public static void main(String[] args) {
        // 1. 演示Clock类的使用
        Clock clock = Clock.systemDefaultZone(); // 获取默认时区的时钟
        System.out.println("获取默认时区转换的当前时间：" + clock.instant());
        System.out.println("获取默认时区转换的毫秒数：" + clock.millis());
        /* 协调世界时（Universal Time Coordinated），简称UTC*/
        clock = Clock.systemUTC(); // 获取UTC时区的时钟
        System.out.println("获取UTC时区转换的当前时间：" + clock.instant());
        System.out.println("获取UTC时区转换的毫秒数：" + clock.millis());
        System.out.println("System.currentTimeMillis() = " + System.currentTimeMillis());
        System.out.println();

        // 2. 演示Duration类的使用
        int days = 3;
        Duration duration = Duration.ofDays(days);
        System.out.println(days + "天 = " + duration.toHours() + "小时");
        System.out.println(days + "天 = " + duration.toMinutes() + "分钟");
        System.out.println(days + "天 = " + duration.toMillis() + "秒");
        System.out.println(days + "天 = " + duration.toNanos() + "纳秒");
        int hours = 5;
        duration = Duration.ofHours(hours);
        System.out.println(hours + "小时 = " + duration.toMinutes() + "分钟");
        System.out.println(hours + "小时 = " + duration.toMillis() + "秒");
        System.out.println(hours + "小时 = " + duration.toNanos() + "纳秒");
        System.out.println();

        // 3. 演示Instant的使用
        Instant instant = Instant.now();
        System.out.println("获取UTC时区转换的当前时间：" + instant);
        System.out.println("当前时间往前推1个小时后的时间：" + instant.minusSeconds(3600));
        System.out.println("当前时间往后推2个小时后的时间：" + instant.plusSeconds(7200));
        System.out.println();

        // 4. 演示LocalDate类的使用
        LocalDate localDate = LocalDate.now();
        System.out.println("从本地日期对象获取当前日期：" + localDate);
        System.out.println("从本地日期对象获取当前年份：" + localDate.getYear());
        System.out.println("从本地日期对象获取当前月份：" + localDate.getMonth());
        System.out.println("从本地日期对象获取当前天日：" + localDate.getDayOfMonth());
        System.out.println("一年的第几天：" + localDate.getDayOfYear());
        System.out.println("星期几：" + localDate.getDayOfWeek());
        System.out.println();

        // 5. 演示LocalTime类的使用
        LocalTime localTime = LocalTime.now();
        System.out.println("从本地时间对象获取当前时间：" + localTime);
        System.out.println("从本地时间对象获取当前小时：" + localTime.getHour());
        System.out.println("从本地时间对象获取当前分钟：" + localTime.getMinute());
        System.out.println("从本地时间对象获取当前秒钟：" + localTime.getSecond());
        System.out.println("从本地时间对象获取当前毫秒：" + localTime.getNano() / 1000000);
        System.out.println();

        // 6. 演示LocalDateTime类的使用
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("从本地日期时间对象获取当前时间：" + localDateTime);
        System.out.println("从本地日期时间对象获取当前年份：" + localDateTime.getYear());
        System.out.println("从本地日期时间对象获取当前月份：" + localDateTime.getMonth());
        System.out.println("从本地日期时间对象获取当前天日：" + localDateTime.getDayOfMonth());
        System.out.println("从本地日期时间对象获取当前小时：" + localDateTime.getHour());
        System.out.println("从本地日期时间对象获取当前分钟：" + localDateTime.getMinute());
        System.out.println("从本地日期时间对象获取当前秒钟：" + localDateTime.getSecond());
        System.out.println("从本地日期时间对象获取当前毫秒：" + localDateTime.getNano() / 1000000);
        System.out.println();

        // 7. 演示Year、YearMonth、MonthDay类的使用
        Year year = Year.now();
        System.out.println("当前年份：" + year);
        YearMonth yearMonth = YearMonth.now();
        System.out.println("当前年月：" + yearMonth);
        MonthDay monthDay = MonthDay.now();
        System.out.println("当前月日：" + monthDay);

        // 8. 演示ZoneId类的使用
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println("当前系统默认时区：" + zoneId);
        System.out.println("系统可用时区：" + ZoneId.getAvailableZoneIds());
    }
}

• 运行程序，查看结果
  
• 完整的运行结果

获取默认时区转换的当前时间：2020-05-20T23:38:38.932Z
获取默认时区转换的毫秒数：1590017918961
获取UTC时区转换的当前时间：2020-05-20T23:38:38.961Z
获取UTC时区转换的毫秒数：1590017918961
System.currentTimeMillis() = 1590017918961

3天 = 72小时
3天 = 4320分钟
3天 = 259200000秒
3天 = 259200000000000纳秒
5小时 = 300分钟
5小时 = 18000000秒
5小时 = 18000000000000纳秒

获取UTC时区转换的当前时间：2020-05-20T23:38:38.962Z
当前时间往前推1个小时后的时间：2020-05-20T22:38:38.962Z
当前时间往后推2个小时后的时间：2020-05-21T01:38:38.962Z

从本地日期对象获取当前日期：2020-05-21
从本地日期对象获取当前年份：2020
从本地日期对象获取当前月份：MAY
从本地日期对象获取当前天日：21
一年的第几天：142
星期几：THURSDAY

从本地时间对象获取当前时间：07:38:38.964
从本地时间对象获取当前小时：7
从本地时间对象获取当前分钟：38
从本地时间对象获取当前秒钟：38
从本地时间对象获取当前毫秒：964

从本地日期时间对象获取当前时间：2020-05-21T07:38:38.965
从本地日期时间对象获取当前年份：2020
从本地日期时间对象获取当前月份：MAY
从本地日期时间对象获取当前天日：21
从本地日期时间对象获取当前小时：7
从本地日期时间对象获取当前分钟：38
从本地日期时间对象获取当前秒钟：38
从本地日期时间对象获取当前毫秒：965

当前年份：2020
当前年月：2020-05
当前月日：--05-21
当前系统默认时区：Asia/Shanghai
系统可用时区：[Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/GMT+8, Africa/Nairobi, America/Marigot, Asia/Aqtau, Pacific/Kwajalein, America/El_Salvador, Asia/Pontianak, Africa/Cairo, Pacific/Pago_Pago, Africa/Mbabane, Asia/Kuching, Pacific/Honolulu, Pacific/Rarotonga, America/Guatemala, Australia/Hobart, Europe/London, America/Belize, America/Panama, Asia/Chungking, America/Managua, America/Indiana/Petersburg, Asia/Yerevan, Europe/Brussels, GMT, Europe/Warsaw, America/Chicago, Asia/Kashgar, Chile/Continental, Pacific/Yap, CET, Etc/GMT-1, Etc/GMT-0, Europe/Jersey, America/Tegucigalpa, Etc/GMT-5, Europe/Istanbul, America/Eirunepe, Etc/GMT-4, America/Miquelon, Etc/GMT-3, Europe/Luxembourg, Etc/GMT-2, Etc/GMT-9, America/Argentina/Catamarca, Etc/GMT-8, Etc/GMT-7, Etc/GMT-6, Europe/Zaporozhye, Canada/Yukon, Canada/Atlantic, Atlantic/St_Helena, Australia/Tasmania, Libya, Europe/Guernsey, America/Grand_Turk, US/Pacific-New, Asia/Samarkand, America/Argentina/Cordoba, Asia/Phnom_Penh, Africa/Kigali, Asia/Almaty, US/Alaska, Asia/Dubai, Europe/Isle_of_Man, America/Araguaina, Cuba, Asia/Novosibirsk, America/Argentina/Salta, Etc/GMT+3, Africa/Tunis, Etc/GMT+2, Etc/GMT+1, Pacific/Fakaofo, Africa/Tripoli, Etc/GMT+0, Israel, Africa/Banjul, Etc/GMT+7, Indian/Comoro, Etc/GMT+6, Etc/GMT+5, Etc/GMT+4, Pacific/Port_Moresby, US/Arizona, Antarctica/Syowa, Indian/Reunion, Pacific/Palau, Europe/Kaliningrad, America/Montevideo, Africa/Windhoek, Asia/Karachi, Africa/Mogadishu, Australia/Perth, Brazil/East, Etc/GMT, Asia/Chita, Pacific/Easter, Antarctica/Davis, Antarctica/McMurdo, Asia/Macao, America/Manaus, Africa/Freetown, Europe/Bucharest, Asia/Tomsk, America/Argentina/Mendoza, Asia/Macau, Europe/Malta, Mexico/BajaSur, Pacific/Tahiti, Africa/Asmera, Europe/Busingen, America/Argentina/Rio_Gallegos, Africa/Malabo, Europe/Skopje, America/Catamarca, America/Godthab, Europe/Sarajevo, Australia/ACT, GB-Eire, Africa/Lagos, America/Cordoba, Europe/Rome, Asia/Dacca, Indian/Mauritius, Pacific/Samoa, America/Regina, America/Fort_Wayne, America/Dawson_Creek, Africa/Algiers, Europe/Mariehamn, America/St_Johns, America/St_Thomas, Europe/Zurich, America/Anguilla, Asia/Dili, America/Denver, Africa/Bamako, Europe/Saratov, GB, Mexico/General, Pacific/Wallis, Europe/Gibraltar, Africa/Conakry, Africa/Lubumbashi, Asia/Istanbul, America/Havana, NZ-CHAT, Asia/Choibalsan, America/Porto_Acre, Asia/Omsk, Europe/Vaduz, US/Michigan, Asia/Dhaka, America/Barbados, Europe/Tiraspol, Atlantic/Cape_Verde, Asia/Yekaterinburg, America/Louisville, Pacific/Johnston, Pacific/Chatham, Europe/Ljubljana, America/Sao_Paulo, Asia/Jayapura, America/Curacao, Asia/Dushanbe, America/Guyana, America/Guayaquil, America/Martinique, Portugal, Europe/Berlin, Europe/Moscow, Europe/Chisinau, America/Puerto_Rico, America/Rankin_Inlet, Pacific/Ponape, Europe/Stockholm, Europe/Budapest, America/Argentina/Jujuy, Australia/Eucla, Asia/Shanghai, Universal, Europe/Zagreb, America/Port_of_Spain, Europe/Helsinki, Asia/Beirut, Asia/Tel_Aviv, Pacific/Bougainville, US/Central, Africa/Sao_Tome, Indian/Chagos, America/Cayenne, Asia/Yakutsk, Pacific/Galapagos, Australia/North, Europe/Paris, Africa/Ndjamena, Pacific/Fiji, America/Rainy_River, Indian/Maldives, Australia/Yancowinna, SystemV/AST4, Asia/Oral, America/Yellowknife, Pacific/Enderbury, America/Juneau, Australia/Victoria, America/Indiana/Vevay, Asia/Tashkent, Asia/Jakarta, Africa/Ceuta, Asia/Barnaul, America/Recife, America/Buenos_Aires, America/Noronha, America/Swift_Current, Australia/Adelaide, America/Metlakatla, Africa/Djibouti, America/Paramaribo, Asia/Qostanay, Europe/Simferopol, Europe/Sofia, Africa/Nouakchott, Europe/Prague, America/Indiana/Vincennes, Antarctica/Mawson, America/Kralendijk, Antarctica/Troll, Europe/Samara, Indian/Christmas, America/Antigua, Pacific/Gambier, America/Indianapolis, America/Inuvik, America/Iqaluit, Pacific/Funafuti, UTC, Antarctica/Macquarie, Canada/Pacific, America/Moncton, Africa/Gaborone, Pacific/Chuuk, Asia/Pyongyang, America/St_Vincent, Asia/Gaza, Etc/Universal, PST8PDT, Atlantic/Faeroe, Asia/Qyzylorda, Canada/Newfoundland, America/Kentucky/Louisville, America/Yakutat, Asia/Ho_Chi_Minh, Antarctica/Casey, Europe/Copenhagen, Africa/Asmara, Atlantic/Azores, Europe/Vienna, ROK, Pacific/Pitcairn, America/Mazatlan, Australia/Queensland, Pacific/Nauru, Europe/Tirane, Asia/Kolkata, SystemV/MST7, Australia/Canberra, MET, Australia/Broken_Hill, Europe/Riga, America/Dominica, Africa/Abidjan, America/Mendoza, America/Santarem, Kwajalein, America/Asuncion, Asia/Ulan_Bator, NZ, America/Boise, Australia/Currie, EST5EDT, Pacific/Guam, Pacific/Wake, Atlantic/Bermuda, America/Costa_Rica, America/Dawson, Asia/Chongqing, Eire, Europe/Amsterdam, America/Indiana/Knox, America/North_Dakota/Beulah, Africa/Accra, Atlantic/Faroe, Mexico/BajaNorte, America/Maceio, Etc/UCT, Pacific/Apia, GMT0, America/Atka, Pacific/Niue, Australia/Lord_Howe, Europe/Dublin, Pacific/Truk, MST7MDT, America/Monterrey, America/Nassau, America/Jamaica, Asia/Bishkek, America/Atikokan, Atlantic/Stanley, Australia/NSW, US/Hawaii, SystemV/CST6, Indian/Mahe, Asia/Aqtobe, America/Sitka, Asia/Vladivostok, Africa/Libreville, Africa/Maputo, Zulu, America/Kentucky/Monticello, Africa/El_Aaiun, Africa/Ouagadougou, America/Coral_Harbour, Pacific/Marquesas, Brazil/West, America/Aruba, America/North_Dakota/Center, America/Cayman, Asia/Ulaanbaatar, Asia/Baghdad, Europe/San_Marino, America/Indiana/Tell_City, America/Tijuana, Pacific/Saipan, SystemV/YST9, Africa/Douala, America/Chihuahua, America/Ojinaga, Asia/Hovd, America/Anchorage, Chile/EasterIsland, America/Halifax, Antarctica/Rothera, America/Indiana/Indianapolis, US/Mountain, Asia/Damascus, America/Argentina/San_Luis, America/Santiago, Asia/Baku, America/Argentina/Ushuaia, Atlantic/Reykjavik, Africa/Brazzaville, Africa/Porto-Novo, America/La_Paz, Antarctica/DumontDUrville, Asia/Taipei, Antarctica/South_Pole, Asia/Manila, Asia/Bangkok, Africa/Dar_es_Salaam, Poland, Atlantic/Madeira, Antarctica/Palmer, America/Thunder_Bay, Africa/Addis_Ababa, Asia/Yangon, Europe/Uzhgorod, Brazil/DeNoronha, Asia/Ashkhabad, Etc/Zulu, America/Indiana/Marengo, America/Creston, America/Punta_Arenas, America/Mexico_City, Antarctica/Vostok, Asia/Jerusalem, Europe/Andorra, US/Samoa, PRC, Asia/Vientiane, Pacific/Kiritimati, America/Matamoros, America/Blanc-Sablon, Asia/Riyadh, Iceland, Pacific/Pohnpei, Asia/Ujung_Pandang, Atlantic/South_Georgia, Europe/Lisbon, Asia/Harbin, Europe/Oslo, Asia/Novokuznetsk, CST6CDT, Atlantic/Canary, America/Knox_IN, Asia/Kuwait, SystemV/HST10, Pacific/Efate, Africa/Lome, America/Bogota, America/Menominee, America/Adak, Pacific/Norfolk, Europe/Kirov, America/Resolute, Pacific/Tarawa, Africa/Kampala, Asia/Krasnoyarsk, Greenwich, SystemV/EST5, America/Edmonton, Europe/Podgorica, Australia/South, Canada/Central, Africa/Bujumbura, America/Santo_Domingo, US/Eastern, Europe/Minsk, Pacific/Auckland, Africa/Casablanca, America/Glace_Bay, Canada/Eastern, Asia/Qatar, Europe/Kiev, Singapore, Asia/Magadan, SystemV/PST8, America/Port-au-Prince, Europe/Belfast, America/St_Barthelemy, Asia/Ashgabat, Africa/Luanda, America/Nipigon, Atlantic/Jan_Mayen, Brazil/Acre, Asia/Muscat, Asia/Bahrain, Europe/Vilnius, America/Fortaleza, Etc/GMT0, US/East-Indiana, America/Hermosillo, America/Cancun, Africa/Maseru, Pacific/Kosrae, Africa/Kinshasa, Asia/Kathmandu, Asia/Seoul, Australia/Sydney, America/Lima, Australia/LHI, America/St_Lucia, Europe/Madrid, America/Bahia_Banderas, America/Montserrat, Asia/Brunei, America/Santa_Isabel, Canada/Mountain, America/Cambridge_Bay, Asia/Colombo, Australia/West, Indian/Antananarivo, Australia/Brisbane, Indian/Mayotte, US/Indiana-Starke, Asia/Urumqi, US/Aleutian, Europe/Volgograd, America/Lower_Princes, America/Vancouver, Africa/Blantyre, America/Rio_Branco, America/Danmarkshavn, America/Detroit, America/Thule, Africa/Lusaka, Asia/Hong_Kong, Iran, America/Argentina/La_Rioja, Africa/Dakar, SystemV/CST6CDT, America/Tortola, America/Porto_Velho, Asia/Sakhalin, Etc/GMT+10, America/Scoresbysund, Asia/Kamchatka, Asia/Thimbu, Africa/Harare, Etc/GMT+12, Etc/GMT+11, Navajo, America/Nome, Europe/Tallinn, Turkey, Africa/Khartoum, Africa/Johannesburg, Africa/Bangui, Europe/Belgrade, Jamaica, Africa/Bissau, Asia/Tehran, WET, Europe/Astrakhan, Africa/Juba, America/Campo_Grande, America/Belem, Etc/Greenwich, Asia/Saigon, America/Ensenada, Pacific/Midway, America/Jujuy, Africa/Timbuktu, America/Bahia, America/Goose_Bay, America/Virgin, America/Pangnirtung, Asia/Katmandu, America/Phoenix, Africa/Niamey, America/Whitehorse, Pacific/Noumea, Asia/Tbilisi, America/Montreal, Asia/Makassar, America/Argentina/San_Juan, Hongkong, UCT, Asia/Nicosia, America/Indiana/Winamac, SystemV/MST7MDT, America/Argentina/ComodRivadavia, America/Boa_Vista, America/Grenada, Asia/Atyrau, Australia/Darwin, Asia/Khandyga, Asia/Kuala_Lumpur, Asia/Famagusta, Asia/Thimphu, Asia/Rangoon, Europe/Bratislava, Asia/Calcutta, America/Argentina/Tucuman, Asia/Kabul, Indian/Cocos, Japan, Pacific/Tongatapu, America/New_York, Etc/GMT-12, Etc/GMT-11, Etc/GMT-10, SystemV/YST9YDT, Europe/Ulyanovsk, Etc/GMT-14, Etc/GMT-13, W-SU, America/Merida, EET, America/Rosario, Canada/Saskatchewan, America/St_Kitts, Arctic/Longyearbyen, America/Fort_Nelson, America/Caracas, America/Guadeloupe, Asia/Hebron, Indian/Kerguelen, SystemV/PST8PDT, Africa/Monrovia, Asia/Ust-Nera, Egypt, Asia/Srednekolymsk, America/North_Dakota/New_Salem, Asia/Anadyr, Australia/Melbourne, Asia/Irkutsk, America/Shiprock, America/Winnipeg, Europe/Vatican, Asia/Amman, Etc/UTC, SystemV/AST4ADT, Asia/Tokyo, America/Toronto, Asia/Singapore, Australia/Lindeman, America/Los_Angeles, SystemV/EST5EDT, Pacific/Majuro, America/Argentina/Buenos_Aires, Europe/Nicosia, Pacific/Guadalcanal, Europe/Athens, US/Pacific, Europe/Monaco]

六、格式化类

（一）DateFormat类

1、概述

DateFormat类专门用于将日期格式化为字符串或者将用特定格式显示的日期字符串转换成一个Date对象。DateFormat是一个抽象类，不能被直接实例化，但它提供了一系列的静态方法来获取DateFormat类的实例对象，并能调用其他相应的方法进行操作。

2、常用方法

方法声明	功能描述
static DateFormat getDateInstance()	用于创建默认语言环境和格式化风格的日期格式器
static DateFormat getDateInstance(int style)	用于创建默认语言环境和指定格式化风格的日期格式器
static DateFormat getDateTimeInstance()	用于创建默认语言环境和格式化风格的日期/时间格式器
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle)	用于创建默认语言环境和指定格式化风格的日期/时间格式器
String format(Date date)	将一个 Date 格式化为日期/时间字符串。
Date parse(String source)	将给定字符串解析成一个日期

3、常用常量

序号	常量	用途
1	FULL	用于表示完整格式
2	LONG	用于表示长格式
3	MEDIUM	用于表示普通格式
4	SHORT	用于表示短格式

4、案例演示

任务1、输出各种格式的当前日期（时间）

• 创建Example2031
  

package net.hw.lesson20;

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

/**
 * 功能：演示DateFormat类
 * 作者：华卫
 * 日期：2020年05月21日
 */
public class Example2031 {
    public static void main(String[] args) {
        // 创建日期对象
        Date date = new Date();

        // 声明日期格式对象
        DateFormat df;

        // 创建完整日期格式对象
        df = DateFormat.getDateInstance(DateFormat.FULL);
        // 输出当前日期的完整格式
        System.out.println("当前日期的完整格式：" + df.format(date));

        // 创建长日期格式对象
        df = DateFormat.getDateInstance(DateFormat.LONG);
        // 输出当前日期的长格式
        System.out.println("当前日期的长格式：" + df.format(date));

        // 创建普通日期时间格式对象
        df = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
        // 输出当前日期时间的普通格式
        System.out.println("当前日期时间的普通格式：" + df.format(date));

        // 创建短日期时间格式对象
        df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
        // 输出当前日期时间的短格式
        System.out.println("当前日期时间的短格式：" + df.format(date));
    }
}

• 运行程序，查看结果
  

任务2、解析字符串日期

• 创建Example2032
  

package net.hw.lesson20;

import java.text.DateFormat;
import java.text.ParseException;

/**
 * 功能：解析字符串日期
 * 作者：华卫
 * 日期：2020年05月21日
 */
public class Example2032 {
    public static void main(String[] args) throws ParseException {
        // 声明日期格式对象
        DateFormat df;
        // 声明日期字符串
        String strDate;

        // 创建完整日期格式对象
        df = DateFormat.getDateInstance(DateFormat.FULL);
        // 定义字符串日期
        strDate = "2020年5月20日 星期三";
        // 解析并输出
        System.out.println(strDate + "\t" + df.parse(strDate));

        // 创建长日期格式对象
        df = DateFormat.getDateInstance(DateFormat.LONG);
        // 定义字符串日期
        strDate = "2020年1月23日";
        // 解析并输出
        System.out.println(strDate + "\t" + df.parse(strDate));

        // 创建普通日期时间格式对象
        df = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
        // 定义字符串日期时间
        strDate = "2020-4-1 9:43:05";
        // 解析并输出
        System.out.println(strDate + "\t" + df.parse(strDate));

        // 创建短日期时间格式对象
        df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
        // 定义字符串日期时间
        strDate = "20-5-1 下午3:20:15";
        // 解析并输出
        System.out.println(strDate + "\t" + df.parse(strDate));
    }
}

• 运行程序，查看结果
  

（二）SimpleDateFormat类

1、概述

• 在使用DateFormat对象的parse()方法将字符串解析为日期时，需要输入固定格式的字符串，这显然不够灵活。为了能够更好地格式化日期、解析字符串，Java中提供了一个SimpleDateFormat类。
• SimpleDateFormat类是DateFormat类的子类，它可以使用new关键字创建实例对象。在创建实例对象时，它的构造方法需要接收一个表示日期格式模板的字符串参数。

2、案例演示

任务1、按照指定格式输出当前日期

• 创建Example2033
  

package net.hw.lesson20;

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

/**
 * 功能：演示SimpleDateFormat类
 * 作者：华卫
 * 日期：2020年05月21日
 */
public class Example2033 {
    public static void main(String[] args) throws ParseException {
        // 声明简单日期格式变量
        SimpleDateFormat sdf;

        // 1. 将当前日期按指定格式输出
        sdf = new SimpleDateFormat("Gyyyy年MM月dd日 今天是yyyy年的第D天 E");
        System.out.println("按指定格式输出当前日期：" + sdf.format(new Date()));

        // 2. 将指定格式的日期字符串解析成日期对象
        sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String strDateTime = "2020-01-01 10:10:30";
        System.out.println("日期字符串[" + strDateTime + "]解析结果：" + sdf.parse(strDateTime));
    }
}

• 运行程序，查看结果
  
• 如果日期字符串不符合简单日期格式对象里指定的格式，那么会抛出异常。
  

（三）DateTimeFomatter类

1、概述

JDK 8在java.time.format包下还提供了一个DateTimeFormatter类，该类也是一个格式化类，其功能相当于DateFormat和SimpleDateFormat的合体，它不仅可以将日期、时间对象格式化成字符串，还能将特定格式的字符串解析成日期、时间对象。

2、获取实例的方式

• 使用静态常量创建DateTimeFormatter格式器。
  在DateTimeFormatter类中包含大量的静态常量，如BASIC_ISO_DATE、ISO_LOCAL_DATE、ISO_LOCAL_TIME等，通过这些静态常量都可以获取DateTimeFormatter实例。
• 使用不同风格的枚举值来创建DateTimeFormatter格式器。
  在FormatStyle类中定义了FULL、LONG、MEDIUM和SHORT四个枚举值，它们表示日期和时间的不同风格。通过调用DateTimeFormatter类的ofLocalizedDateTime()方法创建。
• 根据模式字符串创建DateTimeFormatter格式器。通过调用DateTimeFormatter类的ofPattern()方法创建。

3、案例演示

任务1、格式化输出日期与时间

• 创建Example2034
  

package net.hw.lesson20;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;

/**
 * 功能：采用DateTimeFormatter格式化输出日期时间
 * 作者：华卫
 * 日期：2020年05月21日
 */
public class Example2034 {
    public static void main(String[] args) {
        // 声明日期时间格式化器变量
        DateTimeFormatter dtf;
        // 获取本地日期时间
        LocalDateTime dt = LocalDateTime.now();

        // 1. 使用静态常量创建DateTimeFormatter格式器
        System.out.print("使用静态常量创建DateTimeFormatter格式器：");
        dtf = DateTimeFormatter.ISO_DATE_TIME;
        System.out.println(dtf.format(dt));

        // 2. 使用LONG类型风格创建DateTimeFormatter格式器
        System.out.print("使用LONG类型风格创建DateTimeFormatter格式器：");
        dtf = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        System.out.println(dtf.format(dt));

        // 3. 根据模式字符串创建DateTimeFormatter格式器
        System.out.print("根据模式字符串创建DateTimeFormatter格式器：");
        dtf = DateTimeFormatter.ofPattern("yyyy.MM.dd hh:mm:ss");
        System.out.println(dtf.format(dt));
    }
}

• 运行程序，查看结果
  

任务2、解析日期（时间）字符串

• 创建Example2035
  

package net.hw.lesson20;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 功能：采用DateTimeFormatter解析日期字符串
 * 作者：华卫
 * 日期：2020年05月21日
 */
public class Example2035 {
    public static void main(String[] args) {
        // 声明日期字符串变量
        String strDate;
        // 声明日期时间格式化器
        DateTimeFormatter dtf;

        // 定义日期字符串
        strDate = "2020.05.21 10:42:20";
        // 创建日期时间格式化器
        dtf = DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss"); // 注意要HH，不能hh
        // 解析日期并输出
        System.out.println("日期字符串[" + strDate + "]解析结果：" + LocalDateTime.parse(strDate, dtf));

        // 定义日期字符串
        strDate = "2020年05月21日 10时42分20秒";
        // 创建日期时间格式化器
        dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒"); // 注意要HH，不能hh
        // 解析日期并输出
        System.out.println("日期字符串[" + strDate + "]解析结果：" + LocalDateTime.parse(strDate, dtf));
    }
}

• 运行程序，查看结果
  
• 说明：模式字符串yyyy.MM.dd HH:mm:ss里的HH如果写成hh，运行就会报错。
  

七、本讲小结

主要讲解了Java中常用的一些类的使用，首先讲解了处理字符串的String类和StringBuffer 类的使用，然后讲解了系统相关的System类和Runtime类的使用，以及Math类Randorm类和Java中包装类的相关知识，接下来讲解了Java中的日期、时间类以及格式化器类的使用。由于篇幅有限，在Java中还有很多类是这里没有介绍到的，初学者也没有必要把所有的类全部学习，只需要在使用这些类时，通过上一些技术论坛或者查看API文档就能掌握这些类的用法。

八、课后作业

任务1、编程实现字符串大小写转换并倒序输出

• 使用for循环将字符串“Hello World"从最后一个字符开始遍历。
• 避历的当前字符如果是大写字符，就使用toLowerCase()方法将其转换为小写字母，反之则使用toUppercase()方法将其转换为大写字符。
• 定义一个StringBuffer对象，调用append()方法依次添加反向遍历的字符，最后调用StringBuffer对象的toString()方法，并将得到的结果输出。

任务2、利用Random类来产生5个20~30之间的随机整数

提示：[n, m]（n, m均为整数，n < m）之间的随机数的公式为(new Random().nextlnt(m - n + 1) + n

任务3、模拟微信拼手气红包程序产生指定个数的随机红包

• 输入红包总金额
• 输入红包个数
• 输出所有红包