Java数字和日期处理：Java数字处理和日期类

最新推荐文章于 2023-06-20 18:22:55 发布

小熊coder

最新推荐文章于 2023-06-20 18:22:55 发布

阅读量1.9k

点赞数 4

分类专栏： java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_41854911/article/details/122118824

版权

java 专栏收录该内容

40 篇文章 21 订阅

订阅专栏

转载于：http://c.biancheng.net/java/40/

在解决实际问题时，对数字和日期的处理是非常普遍的，如数学问题、随机数问题和日期问题等。为了解决这些问题，Java 提供了处理相关问题的类，包括 Math 类、Random 类、BigInteger 类、Date 类等。本章将会详细介绍这些与数学和日期处理相关的类。

本章学习要点

掌握 Math 类中的各种数学运算方法
掌握生成任意范围随机数的方法
掌握对数字进行格式化的方法
熟悉大数字的各种运算
掌握日期的处理和格式化方式

Java Math类的常用方法

Java 中的 +、-、*、/ 和 % 等基本算术运算符不能进行更复杂的数学运算，例如，三角函数、对数运算、指数运算等。于是 Java 提供了 Math 工具类来完成这些复杂的运算。

在 Java 中 Math 类封装了常用的数学运算，提供了基本的数学操作，如指数、对数、平方根和三角函数等。Math 类位于 java.lang 包，它的构造方法是 private 的，因此无法创建 Math 类的对象，并且 Math 类中的所有方法都是类方法，可以直接通过类名来调用它们。

下面详细介绍该类的常量及数学处理方法。

静态常量

Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）。

例 1

调用 Math 类的 E 和 PI 两个常量，并将结果输出。代码如下：

System.out.println("E 常量的值：" + Math.E);
System.out.println("PI 常量的值：" + Math.PI);

执行上述代码，输出结果如下：

E 常量的值：2.718281828459045
PI 常量的值：3.141592653589793

求最大值、最小值和绝对值

在程序中常见的就是求最大值、最小值和绝对值问题，如果使用 Math 类提供的方法可以很容易实现。这些方法的说明如表 1 所示。

方法	说明
static int abs(int a)	返回 a 的绝对值
static long abs(long a)	返回 a 的绝对值
static float abs(float a)	返回 a 的绝对值
static double abs(double a)	返回 a 的绝对值
static int max(int x,int y)	返回 x 和 y 中的最大值
static double max(double x,double y)	返回 x 和 y 中的最大值
static long max(long x,long y)	返回 x 和 y 中的最大值
static float max(float x,float y)	返回 x 和 y 中的最大值
static int min(int x,int y)	返回 x 和 y 中的最小值
static long min(long x,long y)	返回 x 和 y 中的最小值
static double min(double x,double y)	返回 x 和 y 中的最小值
static float min(float x,float y)	返回 x 和 y 中的最小值

例 2

求 10 和 20 的较大值、15.6 和 15 的较小值、-12 的绝对值，代码如下：

public class Test02 {
    public static void main(String[] args) {
        System.out.println("10 和 20 的较大值：" + Math.max(10, 20));
        System.out.println("15.6 和 15 的较小值：" + Math.min(15.6, 15));
        System.out.println("-12 的绝对值：" + Math.abs(-12));
    }
}

该程序的运行结果如下：

10和20的较大值：20
15.6和15的较小值：15.0
-12的绝对值：12

求整运算

Math 类的求整方法有很多，详细说明如表 2 所示。

方法	说明
static double ceil(double a)	返回大于或等于 a 的最小整数
static double floor(double a)	返回小于或等于 a 的最大整数
static double rint(double a)	返回最接近 a 的整数值，如果有两个同样接近的整数，则结果取偶数
static int round(float a)	将参数加上 1/2 后返回与参数最近的整数
static long round(double a)	将参数加上 1/2 后返回与参数最近的整数，然后强制转换为长整型

例 3

下面的实例演示了 Math 类中取整函数方法的应用：

import java.util.Scanner;
public class Test03 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.outprintln("请输入一个数字：");
        double num = input.nextDouble();
        System.out.println("大于或等于 "+ num +" 的最小整数：" + Math.ceil(num));
        System.out.println("小于或等于 "+ num +" 的最大整数：" + Math.floor(num));
        System.out.println("将 "+ num +" 加上 0.5 之后最接近的整数：" + Math.round(num));
        System.out.println("最接近 "+num+" 的整数：" + Math.rint(num));
    }
}

执行结果如下：

请输入一个数字：
99.01
大于或等于 99.01 的最小整数：100.0
小于或等于 99.01 的最大整数：99.0
将 99.01 加上 0.5 之后最接近的整数：100
最接近 99.01 的整数：99.0

三角函数运算

Math 类中包含的三角函数方法及其说明如表 3 所示。

方法	说明
static double sin(double a)	返回角的三角正弦值，参数以孤度为单位
static double cos(double a)	返回角的三角余弦值，参数以孤度为单位
static double asin(double a)	返回一个值的反正弦值，参数域在 [-1,1]，值域在 [-PI/2,PI/2]
static double acos(double a)	返回一个值的反余弦值，参数域在 [-1,1]，值域在 [0.0,PI]
static double tan(double a)	返回角的三角正切值，参数以弧度为单位
static double atan(double a)	返回一个值的反正切值，值域在 [-PI/2,PI/2]
static double toDegrees(double angrad)	将用孤度表示的角转换为近似相等的用角度表示的角
staticdouble toRadians(double angdeg)	将用角度表示的角转换为近似相等的用弧度表示的角

在表 3 中，每个方法的参数和返回值都是 double 类型，参数以弧度代替角度来实现，其中 1 度等于 π/180 弧度，因此平角就是 π 弧度。

例 4

计算 90 度的正弦值、0 度的余弦值、1 的反正切值、120 度的弧度值，代码如下：

public class Test04 {
    public static void main(String[] args) {
        System.out.println{"90 度的正弦值：" + Math.sin(Math.PI/2));
        System.out.println("0 度的余弦值：" + Math.cos(0));
        System.out.println("1 的反正切值：" + Math.atan(l));
        System.out.println("120 度的弧度值：" + Math.toRadians(120.0));
    }
}

在上述代码中，因为 Math.sin() 中的参数的单位是弧度，而 90 度表示的是角度，因此需要将 90 度转换为弧度，即 Math.PI/180*90，故转换后的弧度为 Math.PI/2，然后调用 Math 类中的 sin() 方法计算其正弦值。

该程序的运行结果如下：

90 度的正弦值：1.0
0 的余弦值：1.0
1 的反正切值：0.7853981633974483
120 度的弧度值：2.0943951023931953

指数运算

指数的运算包括求方根、取对数及其求 n 次方的运算。在 Math 类中定义的指数运算方法及其说明如表 4 所示。

方法	说明
static double exp(double a)	返回 e 的 a 次幂
static double pow(double a,double b)	返回以 a 为底数，以 b 为指数的幂值
static double sqrt(double a)	返回 a 的平方根
static double cbrt(double a)	返回 a 的立方根
static double log(double a)	返回 a 的自然对数，即 lna 的值
static double log10(double a)	返回以 10 为底 a 的对数

例 5

使用 Math 类中的方法实现指数的运算，main() 方法中的代码如下：

public class Test05 {
    public static void main(String[] args) {
        System.out.println("4 的立方值：" + Math.pow(4, 3));
        System.out.println("16 的平方根：" + Math.sqrt(16));
        System.out.println("10 为底 2 的对数：" + Math.log1O(2));
    }
}

该程序的运行结果如下：

4 的立方值：64.0
16 的平方根：4.0
10 为底 2 的对数：0.3010299956639812

Java生成随机数（random()和Random类）

在 Java 中要生成一个指定范围之内的随机数字有两种方法：一种是调用 Math 类的 random() 方法，一种是使用 Random 类。

Random 类提供了丰富的随机数生成方法，可以产生 boolean、int、long、float、byte 数组以及 double 类型的随机数，这是它与 random() 方法最大的不同之处。random() 方法只能产生 double 类型的 0~1 的随机数。

Random 类位于 java.util 包中，该类常用的有如下两个构造方法。

Random()：该构造方法使用一个和当前系统时间对应的数字作为种子数，然后使用这个种子数构造 Random 对象。
Random(long seed)：使用单个 long 类型的参数创建一个新的随机数生成器。

Random 类提供的所有方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的概率是均等的，在表 1 中列出了 Random 类中常用的方法。

方法	说明
boolean nextBoolean()	生成一个随机的 boolean 值，生成 true 和 false 的值概率相等
double nextDouble()	生成一个随机的 double 值，数值介于 [0,1.0)，含 0 而不包含 1.0
int nextlnt()	生成一个随机的 int 值，该值介于 int 的区间，也就是 -231~231-1。如果需要生成指定区间的 int 值，则需要进行一定的数学变换
int nextlnt(int n)	生成一个随机的 int 值，该值介于 [0,n)，包含 0 而不包含 n。如果想生成指定区间的 int 值，也需要进行一定的数学变换
void setSeed(long seed)	重新设置 Random 对象中的种子数。设置完种子数以后的 Random 对象和相同种子数使用 new 关键字创建出的 Random 对象相同
long nextLong()	返回一个随机长整型数字
boolean nextBoolean()	返回一个随机布尔型值
float nextFloat()	返回一个随机浮点型数字
double nextDouble()	返回一个随机双精度值

例 1

下面编写一个 Java 程序，演示如何使用 Random 类提供的方法来生成随机数。具体代码如下:

import java.util.Random;
public class Test06 {
    public static void main(String[] args) {
        Random r = new Random();
        double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
        double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数
        int i1 = r.nextInt(10); // 生成[0,10]区间的整数
        int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
        long l1 = r.nextLong(); // 生成一个随机长整型值
        boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
        float f1 = r.nextFloat(); // 生成一个随机浮点型值
        System.out.println("生成的[0,1.0]区间的小数是：" + d1);
        System.out.println("生成的[0,7.0]区间的小数是：" + d2);
        System.out.println("生成的[0,10]区间的整数是：" + i1);
        System.out.println("生成的[-3,15]区间的整数是：" + i2);
        System.out.println("生成一个随机长整型值：" + l1);
        System.out.println("生成一个随机布尔型值：" + b1);
        System.out.println("生成一个随机浮点型值：" + f1);
        System.out.print("下期七星彩开奖号码预测：");
        for (int i = 1; i < 8; i++) {
            int num = r.nextInt(9); // 生成[0,9]区间的整数
            System.out.print(num);
        }
    }
}

本实例每次运行时结果都不相同，这就实现了随机产生数据的功能。该程序的运行结果如下：

生成的[0,1.0]区间的小数是：0.8773165855918825
生成的[0,7.0]区间的小数是：6.407083074782282
生成的[0,10]区间的整数是：5
生成的[-3,15]区间的整数是：4
生成一个随机长整型值：-8462847591661221914
生成一个随机布尔型值：false
生成一个随机浮点型值：0.6397003
下期七星彩开奖号码预测：0227168

例 2

Math 类的 random() 方法没有参数，它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数，即 0<=随机数<1.0。对 random() 方法返回的数字稍加处理，即可实现产生任意范围随机数的功能。

下面使用 random() 方法实现随机生成一个 2~100 偶数的功能。具体代码如下：

public class Test07 {
    public static void main(String[] args) {
        int min = 2; // 定义随机数的最小值
        int max = 102; // 定义随机数的最大值
        // 产生一个2~100的数
        int s = (int) min + (int) (Math.random() * (max - min));
        if (s % 2 == 0) {
            // 如果是偶数就输出
            System.out.println("随机数是：" + s);
        } else {
            // 如果是奇数就加1后输出
            System.out.println("随机数是：" + (s + 1));
        }
    }
}

由于 m+(int)(Math.random()n) 语句可以获取 m~m+n 的随机数，所以 2+(int)(Math. random()(102-2)) 表达式可以求出 2~100 的随机数。在产生这个区间的随机数后还需要判断是否为偶数，这里使用了对 2 取余数，如果余数不是零，说明随机数是奇数，此时将随机数加 1 后再输出。

该程序的运行结果如下：

随机数是：20

Java数字格式化

数字的格式在解决实际问题时使用非常普遍，这时可以使用 DedmalFormat 类对结果进行格式化处理。例如，将小数位统一成 2 位，不足 2 位的以 0 补齐。

DecimalFormat 是 NumberFormat 的一个子类，用于格式化十进制数字。DecimalFormat 类包含一个模式和一组符号，常用符号的说明如表 1 所示。

符号	说明
0	显示数字，如果位数不够则补 0
#	显示数字，如果位数不够不发生变化
.	小数分隔符
-	减号
,	组分隔符
E	分隔科学记数法中的尾数和小数
%	前缀或后缀，乘以 100 后作为百分比显示
?	乘以 1000 后作为千进制货币符显示。用货币符号代替。如果双写，用国际货币符号代替；如果出现在一个模式中，用货币十进制分隔符代替十进制分隔符

例 1

下面编写一个 Java 程序，演示如何使用 DecimalFormat 类将数字转换成各种格式，实现代码如下。

import java.text.DecimalFormat;
import java.util.Scanner;
public class Test08 {
    public static void main(String[] args) {
        // 实例化DecimalFormat类的对象，并指定格式
        DecimalFormat df1 = new DecimalFormat("0.0");
        DecimalFormat df2 = new DecimalFormat("#.#");
        DecimalFormat df3 = new DecimalFormat("000.000");
        DecimalFormat df4 = new DecimalFormat("###.###");
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入一个float类型的数字：");
        float f = scan.nextFloat();
        // 对输入的数字应用格式，并输出结果
        System.out.println("0.0 格式：" + df1.format(f));
        System.out.println("#.# 格式：" + df2.format(f));
        System.out.println("000.000 格式：" + df3.format(f));
        System.out.println("###.### 格式：" + df4.format(f));
    }
}

执行上述代码，输出结果如下所示：

请输入一个float类型的数字：5487.45697
0.0 格式：5487.5
#.# 格式：5487.5
000.000 格式：5487.457
###.### 格式：5487.457
请输入一个float类型的数字：5.0
0.0 格式：5.0
#.# 格式：5
000.000 格式：005.000
###.### 格式：5

Java大数字运算（BigInteger类和BigDecimal类）

在 Java 中提供了用于大数字运算的类，即 java.math.BigInteger 类和 java.math.BigDecimal 类。这两个类用于高精度计算，其中 BigInteger 类是针对整型大数字的处理类，而 BigDecimal 类是针对大小数的处理类。

BigInteger 类

如果要存储比 Integer 更大的数字，Integer 数据类型就无能为力了。因此，Java 中提供 BigInteger 类来处理更大的数字。

BigInteger 类型的数字范围较 Integer 类型的数字范围要大得多。BigInteger 支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值。

除了基本的加、减、乘、除操作之外，BigInteger 类还封装了很多操作，像求绝对值、相反数、最大公约数以及判断是否为质数等。

要使用 BigInteger 类，首先要创建一个 BigInteger 对象。BigInteger 类提供了很多种构造方法，其中最直接的一种是参数以字符串形式代表要处理的数字。这个方法语法格式如下：

BigInteger(String val)

这里的 val 是数字十进制的字符串。例如，要将数字 5 转换为 BigInteger 对象，语句如下：

BigInteger bi = new BigInteger("5")

注意：这里数字 5 的双引号是必需的，因为 BigInteger 类构造方法要求参数是字符串类型。

创建 BigInteger 对象之后，便可以调用 BigInteger 类提供的方法进行各种数学运算操作，表 1 列出了 BigInteger 类的常用运算方法。

方法名称	说明
add(BigInteger val)	做加法运算
subtract(BigInteger val)	做减法运算
multiply(BigInteger val)	做乘法运算
divide(BigInteger val)	做除法运算
remainder(BigInteger val)	做取余数运算
divideAndRemainder(BigInteger val)	做除法运算，返回数组的第一个值为商，第二个值为余数
pow(int exponent)	做参数的 exponent 次方运算
negate()	取相反数
shiftLeft(int n)	将数字左移 n 位，如果 n 为负数，则做右移操作
shiftRight(int n)	将数字右移 n 位，如果 n 为负数，则做左移操作
and(BigInteger val)	做与运算
or(BigInteger val)	做或运算
compareTo(BigInteger val)	做数字的比较运算
equals(Object obj)	当参数 obj 是 Biglnteger 类型的数字并且数值相等时返回 true, 其他返回 false
min(BigInteger val)	返回较小的数值
max(BigInteger val)	返回较大的数值

例 1

编写一个 Java 程序，将用户输入的数字作为 BigInteger 对象，然后调用该对象的各种方法实现加、减、乘、除和其他运算，并输出结果。具体实现代码如下：

import java.math.BigInteger;
import java.util.Scanner;
public class Test09 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个整型数字：");
        // 保存用户输入的数字
        int num = input.nextInt();
        // 使用输入的数字创建BigInteger对象
        BigInteger bi = new BigInteger(num + "");
        // 计算大数字加上99的结果
        System.out.println("加法操作结果：" + bi.add(new BigInteger("99")));
        // 计算大数字减去25的结果
        System.out.println("减法操作结果：" + bi.subtract(new BigInteger("25")));
        // 计算大数字乘以3的结果
        System.out.println("乘法橾作结果：" + bi.multiply(new BigInteger("3")));
        // 计算大数字除以2的结果
        System.out.println("除法操作结果：" + bi.divide(new BigInteger("2")));
        // 计算大数字除以3的商
        System.out.println("取商操作结果：" + bi.divideAndRemainder(new BigInteger("3"))[0]);
        // 计算大数字除以3的余数
        System.out.println("取余操作结果：" + bi.divideAndRemainder(new BigInteger("3"))[1]);
        // 计算大数字的2次方
        System.out.println("取 2 次方操作结果：" + bi.pow(2));
        // 计算大数字的相反数
        System.out.println("取相反数操作结果：" + bi.negate());
    }
}

上述代码将用户输入的整型数字保存到 num 变量中，由于 BigInteger 类的构造方法只接收字符串类型的参数，所以使用“new BigInteger(num+"")”代码来创建 BigInteger 对象。接下来的代码演示了如何调用 BigInteger 类提供的运算方法，运行效果下所示。

请输入一个整型数字：
125
加法操作结果：224
减法操作结果：100
乘法橾作结果：375
除法操作结果：62
取商操作结果：41
取余操作结果：2
取 2 次方操作结果：15625
取相反数操作结果：-125

BigDecimal 类

BigInteger 和 BigDecimal 都能实现大数字的运算，不同的是 BigDecimal 加入了小数的概念。一般的 float 和 double 类型数据只能用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal 类。BigDecimal 类支持任何精度的浮点数，可以用来精确计算货币值。

BigDecimal 常用的构造方法如下。

BigDecimal(double val)：实例化时将双精度型转换为 BigDecimal 类型。
BigDecimal(String val)：实例化时将字符串形式转换为 BigDecimal 类型。

BigDecimal 类的方法可以用来做超大浮点数的运算，像加、减、乘和除等。在所有运算中，除法运算是最复杂的，因为在除不尽的情况下，末位小数的处理方式是需要考虑的。

下面列出了 BigDecimal 类用于实现加、减、乘和除运算的方法。

BigDecimal add(BigDecimal augend)    // 加法操作
BigDecimal subtract(BigDecimal subtrahend)    // 减法操作
BigDecimal multiply(BigDecimal multiplieand)    // 乘法操作
BigDecimal divide(BigDecimal divisor,int scale,int roundingMode )    // 除法操作

其中，divide() 方法的 3 个参数分别表示除数、商的小数点后的位数和近似值处理模式。

表 2 列出了 roundingMode 参数支持的处理模式。

模式名称	说明
BigDecimal.ROUND_UP	商的最后一位如果大于 0，则向前进位，正负数都如此
BigDecimal.ROUND_DOWN	商的最后一位无论是什么数字都省略
BigDecimal.ROUND_CEILING	商如果是正数，按照 ROUND_UP 模式处理；如果是负数，按照 ROUND_DOWN 模式处理
BigDecimal.ROUND_FLOOR	与 ROUND_CELING 模式相反，商如果是正数，按照 ROUND_DOWN 模式处理；如果是负数，按照 ROUND_UP 模式处理
BigDecimal.ROUND_HALF_ DOWN	对商进行五舍六入操作。如果商最后一位小于等于 5，则做舍弃操作，否则对最后一位进行进位操作
BigDecimal.ROUND_HALF_UP	对商进行四舍五入操作。如果商最后一位小于 5，则做舍弃操作，否则对最后一位进行进位操作
BigDecimal.ROUND_HALF_EVEN	如果商的倒数第二位是奇数，则按照 ROUND_HALF_UP 处理；如果是偶数，则按照 ROUND_HALF_DOWN 处理

例 2

编写一个 Java 程序，演示如何使用 BigDecimal 类提供的方法对数字执行运算，并输出结果。具体实现代码如下：

import java.math.BigDecimal;
import java.util.Scanner;
public class Test10 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        // 保存用户输入的数字
        double num = input.nextDouble();
        // 使用输入的数字创建BigDecimal对象
        BigDecimal bd = new BigDecimal(num);
        // 计算大数字加上99.154的结果
        System.out.println("加法操作结果：" + bd.add(new BigDecimal(99.154)));
        // 计算大数字减去-25.157904的结果
        System.out.println("减法操作结果：" + bd.subtract(new BigDecimal(-25.157904)));
        // 计算大数字乘以3.5的结果
        System.out.println("乘法操作结果：" + bd.multiply(new BigDecimal(3.5)));
        // 计算大数字除以3.14的结果，并保留小数后2位
        System.out.println("除法操作结果(保留 2 位小数)：" + bd.divide(new BigDecimal(3.14), 2, BigDecimal.ROUND_CEILING));
        // 计算大数字除以3.14的结果，并保留小数后5位
        System.out.println("除法操作结果(保留 5 位小数)：" + bd.divide(new BigDecimal(3.14), 5, BigDecimal.ROUND_CEILING));
    }
}

上述代码将用户输入的数字保存到 num 变量中，然后调用“newBigDecimal(num)”方法来创建 BigDecimal 对象。接下来的代码演示了如何调用 BigDecimal 类提供的运算方法，运行效果如下所示。

请输入一个数字：
100
加法操作结果：199.15399999999999636202119290828704833984375
减法操作结果：125.157903999999998490011421381495893001556396484375
乘法操作结果：350.0
除法操作结果(保留 2 位小数)：31.85
除法操作结果(保留 5 位小数)：31.84714

Java时间日期的处理：Java Date类、Calendar类详解

在 Java 中获取当前时间，可以使用 java.util.Date 类和 java.util.Calendar 类完成。其中，Date 类主要封装了系统的日期和时间的信息，Calendar 类则会根据系统的日历来解释 Date 对象。下面详细介绍这两个类的具体使用。

Date 类

Date 类表示系统特定的时间戳，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

1. 构造方法

Date 类有如下两个构造方法。

Date()：此种形式表示分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒），使用该构造方法创建的对象可以获取本地的当前时间。
Date(long date)：此种形式表示从 GMT 时间（格林尼治时间）1970 年 1 月 1 日 0 时 0 分 0 秒开始经过参数 date 指定的毫秒数。

这两个构造方法的使用示例如下：

Date date1 = new Date();    // 调用无参数构造函数System.out.println(date1.toString());    // 输出：Wed May 18 21:24:40 CST 2016Date date2 = new Date(60000);    // 调用含有一个long类型参数的构造函数System.out.println(date2);    // 输出：Thu Jan 0108:01:00 CST 1970

Date 类的无参数构造方法获取的是系统当前的时间，显示的顺序为星期、月、日、小时、分、秒、年。

Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟的时间为 1970 年 1 月 1 日 00:01:00 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:00 CST 1970。

2. 常用方法

Date 类提供了许多与日期和事件相关的方法，其中常见的方法如表 1 所示。

方法	描述
boolean after(Date when)	判断此日期是否在指定日期之后
boolean before(Date when)	判断此日期是否在指定日期之前
int compareTo(Date anotherDate)	比较两个日期的顺序
boolean equals(Object obj)	比较两个日期的相等性
long getTime()	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来，此 Date 对象表示的毫秒数
String toString()	把此 Date 对象转换为以下形式的 String: dow mon dd hh:mm:ss zzz yyyy。其中 dow 是一周中的某一天(Sun、Mon、Tue、Wed、Thu、Fri 及 Sat)

例 1

下面使用一个实例来具体演示 Date 类的使用。假设，某一天特定时间要去做一件事，而且那个时间已经过去一分钟之后才想起来这件事还没有办，这时系统将会提示已经过去了多长时间。具体的代码如下：

import java.util.Date;
import java.util.Scanner;
public class Test11 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要做的事情：");
        String title = input.next();
        Date date1 = new Date(); // 获取当前日期
        System.out.println("[" + title + "] 这件事发生时间为：" + date1);
        try {
            Thread.sleep(60000);// 暂停 1 分钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Date date2 = new Date();
        System.out.println("现在时间为：" + date2);
        if (date2.before(date1)) {
            System.out.println("你还有 " + (date2.getTime() - date1.getTime()) / 1000 + " 秒需要去完成【" + title + "】这件事！");
        } else {
            System.out.println("【" + title + "】事情已经过去了 " + (date2.getTime() - date1.getTime()) / 1000 + " 秒");
        }
    }
}

在该程序中，分别使用 Date 类的无参数构造方法创建了两个 Date 对象。在创建完第一个 Date 对象后，使用 Thread.sleep() 方法让程序休眠 60 秒，然后再创建第二个 Date 对象，这样第二个 Date 对象所表示的时间将会在第一个 Date 对象所表示时间之后，因此“date2.before(date1)”条件表达式不成立，从而执行 else 块中的代码，表示事情已经发生过。

运行该程序，执行结果如下所示。

请输入要做的事情：
收快递
【收快递】这件事发生时间为：Fri Oct 12 11:11:07 CST 2018
现在时间为：Fri Oct 12 11:12:07 CST 2018
【收快递】事情已经过去了 60 秒

Calendar 类

Calendar 类是一个抽象类，它为特定瞬间与 YEAR、MONTH、DAY_OF—MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（如获得下星期的日期）提供了一些方法。

创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

Calendar c = Calendar.getInstance();

当创建了一个 Calendar 对象后，就可以通过 Calendar 对象中的一些方法来处理日期、时间。Calendar 类的常用方法如表 2 所示。

方法	描述
void add(int field, int amount)	根据日历的规则，为给定的日历字段 field 添加或减去指定的时间量 amount
boolean after(Object when)	判断此 Calendar 表示的时间是否在指定时间 when 之后，并返回判断结果
boolean before(Object when)	判断此 Calendar 表示的时间是否在指定时间 when 之前，并返回判断结果
void clear()	清空 Calendar 中的日期时间值
int compareTo(Calendar anotherCalendar)	比较两个 Calendar 对象表示的时间值（从格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒至现在的毫秒偏移量），大则返回 1，小则返回 -1，相等返回 0
int get(int field)	返回指定日历字段的值
int getActualMaximum(int field)	返回指定日历字段可能拥有的最大值
int getActualMinimum(int field)	返回指定日历字段可能拥有的最小值
int getFirstDayOfWeek()	获取一星期的第一天。根据不同的国家地区，返回不同的值
static Calendar getInstance()	使用默认时区和语言坏境获得一个日历
static Calendar getInstance(TimeZone zone)	使用指定时区和默认语言环境获得一个日历
static Calendar getInstance(TimeZone zone, Locale aLocale)	使用指定时区和语言环境获得一个日历
Date getTime()	返回一个表示此 Calendar 时间值（从格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒至现在的毫秒偏移量）的 Date 对象
long getTimeInMillis()	返回此 Calendar 的时间值，以毫秒为单位
void set(int field, int value)	为指定的日历字段设置给定值
void set(int year, int month, int date)	设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
void set(int year, int month, int date, int hourOfDay, int minute, int second)	设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、 MINUTE 和 SECOND 的值
void setFirstDayOfWeek(int value)	设置一星期的第一天是哪一天
void setTimeInMillis(long millis)	用给定的 long 值设置此 Calendar 的当前时间值

Calendar 对象可以调用 set() 方法将日历翻到任何一个时间，当参数 year 取负数时表示公元前。Calendar 对象调用 get() 方法可以获取有关年、月、日等时间信息，参数 field 的有效值由 Calendar 静态常量指定。

Calendar 类中定义了许多常量，分别表示不同的意义。

Calendar.YEAR：年份。
Calendar.MONTH：月份。
Calendar.DATE：日期。
Calendar.DAY_OF_MONTH：日期，和上面的字段意义完全相同。
Calendar.HOUR：12小时制的小时。
Calendar.HOUR_OF_DAY：24 小时制的小时。
Calendar.MINUTE：分钟。
Calendar.SECOND：秒。
Calendar.DAY_OF_WEEK：星期几。

例如，要获取当前月份可用如下代码：

int month = Calendar.getInstance().get(Calendar.MONTH);

如果整型变量 month 的值是 0，表示当前日历是在 1 月份；如果值是 11，则表示当前日历在 12 月份。

使用 Calendar 类处理日期时间的实例如下：

Calendar calendar = Calendar.getInstance(); // 如果不设置时间，则默认为当前时间
calendar.setTime(new Date()); // 将系统当前时间赋值给 Calendar 对象
System.out.println("现在时刻：" + calendar.getTime()); // 获取当前时间
int year = calendar.get(Calendar.YEAR); // 获取当前年份
System.out.println("现在是" + year + "年");
int month = calendar.get(Calendar.MONTH) + 1; // 获取当前月份（月份从 0 开始，所以加 1）
System.out.print(month + "月");
int day = calendar.get(Calendar.DATE); // 获取日
System.out.print(day + "日");
int week = calendar.get(Calendar.DAY_OF_WEEK) - 1; // 获取今天星期几（以星期日为第一天）
System.out.print("星期" + week);
int hour = calendar.get(Calendar.HOUR_OF_DAY); // 获取当前小时数（24 小时制）
System.out.print(hour + "时");
int minute = calendar.get(Calendar.MINUTE); // 获取当前分钟
System.out.print(minute + "分");
int second = calendar.get(Calendar.SECOND); // 获取当前秒数
System.out.print(second + "秒");
int millisecond = calendar.get(Calendar.MILLISECOND); // 获取毫秒数
System.out.print(millisecond + "毫秒");
int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH); // 获取今天是本月第几天
System.out.println("今天是本月的第 " + dayOfMonth + " 天");
int dayOfWeekInMonth = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH); // 获取今天是本月第几周
System.out.println("今天是本月第 " + dayOfWeekInMonth + " 周");
int many = calendar.get(Calendar.DAY_OF_YEAR); // 获取今天是今年第几天
System.out.println("今天是今年第 " + many + " 天");
Calendar c = Calendar.getInstance();
c.set(2012, 8, 8); // 设置年月日，时分秒将默认采用当前值
System.out.println("设置日期为 2012-8-8 后的时间：" + c.getTime()); // 输出时间

上面的示例代码演示了 Calendar 类中的方法与常量的结合使用，从而完成处理日期的操作。

例 2

下面使用 Calendar 类来实现日历的打印功能，代码实现如下：

import java.util.Calendar;
public class CalendarDemo {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2016, 5, 1); // 实际的calendar对象所表示的日期为2016年6月1日
        // 判断2016年6月1日为一周中的第几天
        int index = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        char[] title = { '日', '一', '二', '三', '四', '五', '六' }; // 存放曰历的头部
        int daysArray[][] = new int[6][7];// 存放日历的数据
        int daysInMonth = 31; // 该月的天数
        int day = 1; // 自动增长
        for (int i = index; i < 7; i++) {
            // 填充第一周的日期数据，即日历中的第一行
            daysArray[0][i] = day++;
        }
        for (int i = 1; i < 6; i++) {
            // 填充其他周的日历数据，控制行
            for (int j = 0; j < 7; j++) {
                // 如果当前day表示的是本月最后一天，则停止向数组中继续赋值
                if (day > daysInMonth) {
                    i = 6;
                    break;
                }
                daysArray[i][j] = day++;
            }
        }
        System.out.println("------------------2016 年 6 月--------------------\n");
        for (int i = 0; i < title.length; i++) {
            System.out.print(title[i] + "\t");
        }
        System.out.print("\n");
        // 输出二元数组daysArray中的元素
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 7; j++) {
                if (daysArray[i][j] == 0) {
                    if (i != 0) {
                        // 如果到月末，则完成显示日历的任务，停止该方法的执行
                        return;
                    }
                    System.out.print("\t");
                    continue;
                }
                System.out.print(daysArray[i][j] + "\t");
            }
            System.out.print("\n");
        }
    }
}

该程序看似复杂其实很简单。因为 Calendar 类所表示的时间月份是 set() 方法中表示月份的参数值 +1，因此 Calendar 类的实际时间为 2016 年 6 月 1 日。在下面的代码中分别获取 6 月 1 日为本周中的第几天，以便在相应的星期下开始输出 6 月份的日历。程序中的 daysArray 是一个二元数组，该二元数组控制了日历的格式输出，第一个子数组控制日历的行，第二个子数组控制曰历的列，即可输出二元数组中的每一个元素。

运行程序，执行结果如下所示。

------------------2016 年 6 月--------------------

日 一 二 三 四 五 六
   1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31

Java日期格式化（DateFormat类和SimpleDateFormat类）

格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。

在 Java 中，可以使用 DateFormat 类和 SimpleDateFormat 类来格式化日期，下面详细介绍这两个格式化日期类的使用。

DateFormat 类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期→文本）、解析（文本→日期）和标准化日期。

在创建 DateFormat 对象时不能使用 new 关键字，而应该使用 DateFormat 类中的静态方法 getDateInstance()，示例代码如下：

DateFormat df = DateFormat.getDatelnstance();

在创建了一个 DateFormat 对象后，可以调用该对象中的方法来对日期/时间进行格式化。DateFormat 类中常用方法如表 1 所示。

方法	描述
String format(Date date)	将 Date 格式化日期/时间字符串
Calendar getCalendar()	获取与此日期/时间格式相关联的日历
static DateFormat getDateInstance()	获取具有默认格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style)	获取具有指定格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style, Locale locale)	获取具有指定格式化风格和指定语言环境的日期格式
static DateFormat getDateTimeInstance()	获取具有默认格式化风格和默认语言环境的日期/时间格式
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle)	获取具有指定日期/时间格式化风格和默认语言环境的日期/时间格式
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle,Locale locale)	获取具有指定日期/时间格式化风格和指定语言环境的日期/时间格式
static DateFormat getTimeInstance()	获取具有默认格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style)	获取具有指定格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style, Locale locale)	获取具有指定格式化风格和指定语言环境的时间格式
void setCalendar(Calendar newCalendar)	为此格式设置日历
Date parse(String source)	将给定的字符串解析成日期/时间

格式化样式主要通过 DateFormat 常量设置。将不同的常量传入到表 1 所示的方法中，以控制结果的长度。DateFormat 类的常量如下。

SHORT：完全为数字，如 12.5.10 或 5:30pm。
MEDIUM：较长，如 May 10，2016。
LONG：更长，如 May 12，2016 或 11:15:32am。
FULL：是完全指定，如 Tuesday、May 10、2012 AD 或 11:l5:42am CST。

使用 DateFormat 类格式化曰期/时间的示例如下：

// 获取不同格式化风格和中国环境的日期
DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT, Locale.CHINA);
DateFormat df2 = DateFormat.getDateInstance(DateFormat.FULL, Locale.CHINA);
DateFormat df3 = DateFormat.getDateInstance(DateFormat.MEDIUM, Locale.CHINA);
DateFormat df4 = DateFormat.getDateInstance(DateFormat.LONG, Locale.CHINA);
// 获取不同格式化风格和中国环境的时间
DateFormat df5 = DateFormat.getTimeInstance(DateFormat.SHORT, Locale.CHINA);
DateFormat df6 = DateFormat.getTimeInstance(DateFormat.FULL, Locale.CHINA);
DateFormat df7 = DateFormat.getTimeInstance(DateFormat.MEDIUM, Locale.CHINA);
DateFormat df8 = DateFormat.getTimeInstance(DateFormat.LONG, Locale.CHINA);
// 将不同格式化风格的日期格式化为日期字符串
String date1 = df1.format(new Date());
String date2 = df2.format(new Date());
String date3 = df3.format(new Date());
String date4 = df4.format(new Date());
// 将不同格式化风格的时间格式化为时间字符串
String time1 = df5.format(new Date());
String time2 = df6.format(new Date());
String time3 = df7.format(new Date());
String time4 = df8.format(new Date());
// 输出日期
System.out.println("SHORT：" + date1 + " " + time1);
System.out.println("FULL：" + date2 + " " + time2);
System.out.println("MEDIUM：" + date3 + " " + time3);
System.out.println("LONG：" + date4 + " " + time4);

运行该段代码，输出的结果如下：

SHORT：18-10-15 上午9:30
FULL：2018年10月15日 星期一 上午09时30分43秒 CST
MEDIUM：2018-10-15 9:30:43
LONG：2018年10月15日 上午09时30分43秒

该示例主要介绍了 DateFormat 类中方法与常量的结合使用，通过使用 DateFomat 类可以对日期进行不同风格的格式化。

SimpleDateFormat 类

如果使用 DateFormat 类格式化日期/时间并不能满足要求，那么就需要使用 DateFormat 类的子类——SimpleDateFormat。

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类，它允许进行格式化（日期→文本）、解析（文本→日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期/时间格式的模式。

SimpleDateFormat 类主要有如下 3 种构造方法。

SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateF ormat。
SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateF ormat。

SimpleDateFormat 自定义格式中常用的字母及含义如表 2 所示。

字母	含义	示例
y	年份。一般用 yy 表示两位年份，yyyy 表示 4 位年份	使用 yy 表示的年扮，如 11；使用 yyyy 表示的年份，如 2011
M	月份。一般用 MM 表示月份，如果使用 MMM，则会根据语言环境显示不同语言的月份	使用 MM 表示的月份，如 05；使用 MMM 表示月份，在 Locale.CHINA 语言环境下，如“十月”；在 Locale.US 语言环境下，如 Oct
d	月份中的天数。一般用 dd 表示天数	使用 dd 表示的天数，如 10
D	年份中的天数。表示当天是当年的第几天，用 D 表示	使用 D 表示的年份中的天数，如 295
E	星期几。用 E 表示，会根据语言环境的不同，显示不同语言的星期几	使用 E 表示星期几，在 Locale.CHINA 语言环境下，如“星期四”；在 Locale.US 语言环境下，如 Thu
H	一天中的小时数（0~23)。一般用 HH 表示小时数	使用 HH 表示的小时数，如 18
h	一天中的小时数（1~12)。一般使用 hh 表示小时数	使用 hh 表示的小时数，如 10 (注意 10 有可能是 10 点，也可能是 22 点）
m	分钟数。一般使用 mm 表示分钟数	使用 mm 表示的分钟数，如 29
s	秒数。一般使用 ss 表示秒数	使用 ss 表示的秒数，如 38
S	毫秒数。一般使用 SSS 表示毫秒数	使用 SSS 表示的毫秒数，如 156

例 1

编写 Java 程序，使用 SimpleDateFormat 类格式化当前日期并打印，日期格式为“xxxx 年 xx 月 xx 日星期 xxx 点 xx 分 xx 秒”，具体的实现代码如下：

import java.text.SimpleDateFormat;
import java.util.Date;
public class Test13 {
    public static void main(String[] args) {
        Date now = new Date(); // 创建一个Date对象，获取当前时间
        // 指定格式化格式
        SimpleDateFormat f = new SimpleDateFormat("今天是 " + "yyyy 年 MM 月 dd 日 E HH 点 mm 分 ss 秒");
        System.out.println(f.format(now)); // 将当前时间袼式化为指定的格式
    }
}

该程序的运行结果如下：

今天是 2018 年 10 月 15 日 星期一 09 点 26 分 23 秒

Java计算课程结束的日期

假设，每周曰到周六为整的一周，每周从周日开始算起。其中每周的周一、周二、周五需要去学校上课，总共再上9天本学期就结束了。编写 Java 程序，计算上完 9 次课后的日期及星期，以及从当天起到本学期结束总共需要度过的天数。具体的程序代码如下：

import java.util.Calendar;
public class Test14 {
    // 定义一周所要上课的天数。定义为周一、周二、周五共3天上课
    public static final int HAVEClass_OF_WEEK = 3;
    // 定义需要上的课次
    public static final int COURSENUM = 9;
    public static void main(String[] args) {
        int weekCount = -1; // 定义上完全部课程需要多少周，取整数
        int surplusDay = -1; // 取整后多余的天数
        int count = 0; // 获取上了多少次课
        int surplusClass = -1; // 取整后所剩的课程数
        int total = 0; // 上课所花的时间总数
        Calendar calendar = Calendar.getInstance();
        // 获取今天是周几
        int weekdays = (calendar.get(Calendar.DAY_OF_WEEK) - 1);
        /*
         * 定义一周中所要上课的天数，若上课一天则count+1 周一、周二、周五上课 今天是周三，这个星期只有周五上课
         */
        switch (weekdays) {
        case 0:
        case 1: // 上课
            count++;
        case 2: // 上课
            count++;
        case 3:
        case 4:
        case 5: // 上课
            count++;
        case 6:
            break;
        }
        /*
         * 计算今天是周几，如果不是周末，则计算到周六还有几天 （因为周日是一周的开始）
         */
        if (0 != weekdays)
            surplusDay = 6 - weekdays;
        // 获取上课所用多少周，取整
        weekCount = (COURSENUM - count) / HAVEClass_OF_WEEK;
        // 获取取整后剩下的课程数
        surplusClass = (COURSENUM - count) - (weekCount * HAVEClass_OF_WEEK);
        /*
         * 计算取整周后剩下的次数（从每周日开始算起） 若不剩课程，则日期-1（因为取整后的最后一天为周六，不上课） 则计算周五的日期
         * 若还剩1节课，肯定是周一上课，所以天数+2天 若还剩2节课，则周一、周二上课，所以天数+3天 若还剩3节课，则周一、周二、周五上课，所以天数+6天
         */
        switch (surplusClass) {
        case 0:
            surplusDay = surplusDay - 1;
            break;
        case 1:
            surplusDay += 2;
            break;
        case 2:
            surplusDay += 3;
            break;
        case 5:
            surplusDay += 6;
            break;
        }
        // 要上课所用的总天数
        total = surplusDay + (weekCount * 7);
        // 设置课程结束当天的日期
        calendar.set(Calendar.DAY_OF_MONTH, calendar.get(Calendar.DAY_OF_MONTH) + total);
        String strWeek = "";
        int week = (calendar.get(Calendar.DAY_OF_WEEK) - 1);
        switch (week) {
        case 1:
            strWeek = "一";
            break;
        case 2:
            strWeek = "二";
            break;
        case 3:
            strWeek = "三";
            break;
        case 4:
            strWeek = "四";
            break;
        case 5:
            strWeek = "五";
            break;
        case 6:
            strWeek = "六";
            break;
        case 7:
            strWeek = "日";
            break;
        }
        // 如果取整后剩下的课程数为零，直接取周五的日期
        System.out.println("距离本学期结束还有 " + total + " 天，日期为：" + calendar.get(Calendar.YEAR) + "-"
                + (calendar.get(Calendar.MONTH) + 1) + "-" + calendar.get(Calendar.DATE) + "，星期" + strWeek);
    }
}

上述代码首先使用 Calendar.getlnstance() 创建了一个 Calendar 实例，并通过 Calendar 类的 DAY_OF_WEEK 常量获取了今天的星期，若今天为星期一、星期二、星期五中的任意一天，则上课的次数加 1。获取上课所需要的周数以及剩下的次数和所需要的天数。最后设置课程结束后当前的日期，并获取当天的星期。

运行程序，该程序的输出结果如下：

距离本学期结束还有 19 天，日期为：2019-10-15，星期二

Java日期查询

本实例使用有关日期处理和日期格式化的类实现一个日期查询的功能，即查询指定日期所在周的周一日期、两个指定日期间相差的天数和指定日期为所在周的星期几的日期 3 个功能。

从功能上来看，本实例至少需要定义 3 个方法，分别完成：获取指定日期所在周的周一日期、获取两个指定日期的相差天数以及获取指定日期为所在周的星期几的日期这 3 个功能，同时需要定义 Date 类型的日期与 String 类型之间的转换方法。

(1) 新建 Exercise 类，在该类中导入需要的包。代码如下：

import java.text.Parse Exception;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Exercise {
    // 在该类中有5个方法，在下面的步骤中将会讲解，这里省略
}

(2) 在 Exercise 类中定义获取指定日期所在周的周一日期的方法——getMonday()，该方法是一个静态方法，返回值为 String 类型，并且需要传递一个 Date 类型的参数，然后将该日期参数作为 Calendar 对象的日期，并调用 Calendar 类的 set(int field,int value)方法改变 Calendar 对象中的日期，再将使用 SimpleDateFormat 类格式化后的日期返回。

getMonday() 方法的代码实现如下：

// 获取指定日期所在周的周一日期
public static String getMonday(Date date) {
    Calendar c = Calendar.getInstance();
    c.setTime(date);
    c.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY);
    return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
}

(3) 继续在 Exercise 类中定义获取两个日期间相差天数的方法——getTwoDay()，该方法需要传递两个 String 类型的参数。

在该方法的主体中，首先需要创建一个 SimpleDateFormat 类对象，并指定日期的格式，然后需要调用 SimpleDateFormat 对象的 parse() 方法，将传递过来的两个 String 类型的日期转换为 Date 类型，并将这两个 Date 类型的日期进行运算，得出相差的天数，返回一个 int 类型的变量。

getTwoDay() 方法的代码实现如下：

// 获取两个日期间相差的天数
public static int getTwoDay(String sj1, String sj2) {
    SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
    int day = 0;
    try {
        Date date = myFormatter.parse(sj1);
        Date mydate = myFormatter.parse(sj2);
        // 计算两个日期间相差的天数
        day = (int)((date.getTime()-mydate.getTime())/(24*60*60*1000));
    } catch(Exception e) {
        return 0;
    }
    return day;
}

(4) 在 Exercise 类中继续创建两个静态方法，分别完成 String 类型的日期与 Date 类型日期的互换功能。代码如下：

// 将String类型的日期转换为Date类型
public static Date strToDate(String strDate) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = null;
    try {
        date = sdf.parse(strDate);
    } catch(ParseException e) {
        e.printStackTrace();
    }
    return date;
}
// 将Date类型的日期转换为String类型
public static String DateToStr(Date date) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    String strDate = sdf.format(date);
    return strDate;
}

(5) 在 Exercise 类中定义获取指定日期所在周的指定星期的日期方法——getWeek()，该方法需要传递两个 String 类型的参数，其中第一个参数表示指定的日期，第二个参数表示星期几。

在该方法的主体中，首先调用了 strToDate() 方法，将 String 类型的日期转换为 Date 类型的日期，并将该日期作为 Calendar 类对象日期，然后判断传递过来的第二个参数的值，使用 Calendar 类中的 set(int field，int value) 方法改变日期，从而将格式化后的日期返回。

getWeek() 方法的代码实现如下：

// 获得一个日期所在周的星期几的日期，如要找出2011年5月1日所在周的星期一是几号
// @param sdate所确定的日期形式2011-05-01
// @param num要确定的是周几（1表示周一，2表示周二）
// @return
public static String getWeek(String sdate, String num) {
    // 再转换为时间
    Date dd = strToDate(sdate);
    Calendar c = Calendar.getInstance();
    c.setTime(dd);
    int weekNo = Integer.parseInt(num);
    switch (weekNo) {
        case 1:
            c.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY);    //返回星期一所在的日期
            break;
        case 2:
            c.set(Calendar.DAY_OF_WEEK,Calendar.TUESDAY);    //返回星期二所在的日期
            break;
        case 3:
            c.set(Calendar.DAY_OF_WEEK,Calendar.WEDNESDAY);    //返回星期三所在的日期
            break;
        case 4:
            c.set(Calendar.DAY_OF_WEEK,Calendar.THURSDAY);    //返回星期四所在的日期
            break;
        case 5:
            c.set(Calendar.DAY_OF_WEEK,Calendar.FRIDAY);    //返回星期五所在的日期
            break;
        case 6:
            c.set(Calendar.DAY_OF_WEEK,Calendar.SATURDAY);    //返回星期六所在的曰期
            break;
        case 7:
            c.set(Calendar.DAY_OF_WEEK,Calendar.SUNDAY);    //返回星期曰所在的日期
            break;
    }
    return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());
}

(6) 创建测试类 Test15，调用 Exercise 类的方法，完成查询当前日期所在周的周一日期，并获取本周的周一曰期与当前曰期相差的天数，同时还可以查询本周中任意星期几的曰期。代码实现如下：

package com.common.mxl;
import java.util.Date;
import java.util.Scanner;
import com.common.mxl.Exercise;
public class Test15 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Date date = new Date();
        String monday = Exercise.getMonday(date);
        System.out.print("这周一的日期为【"+monday+"】，");
        String nowStr = Exercise.DateToStr(date);       // 将 Date 类型的日期转换为 String 类型
        int num = Exercise.getTwoDay(nowStr,monday);
        System.out.print("与今天相差【"+num+"】天");
        SyStem.out.println("\n请输入您要查询本周星期几的日期（1表示星期一，2表示星期二…)：");
        String weekNo = input.next();       //获取用户输入的星期
        int no = Integer.parseInt(weekNo);
        //将用户输入的星期转换为int类型，以便使用switch语句
        String strWeekNo = "";
        switch(no) {
            case 1:
                strWeekNo = "星期一";
                break;
            case 2:
                strWeekNo = "星期二";
                break;
            case 3:
                strWeekNo = "星期三";
                break;
            case 4:
                strWeekNo = "星期四";
                break;
            case 5:
                strWeekNo = "星期五";
                break;
            case 6:
                strWeekNo = "星期六";
                break;
            case 7:
                strWeekNo = "星期日";
                break;
        }
        System.out.println("本周【"+strWeekNo+"】的日期为："+Exercise.getWeek(nowStr,weekNo));
    }
}

在本程序中，综合使用了 Date 类、Calendar 类和 SimpleDateFormat 类完成了时间处理功能。在源码中，多次使用 Calendar 类的 set(int field,int value) 方法来改变日期，从而获取用户查询的日期。该方法在日期操作方面比较常用，大家需要熟练掌握该方法。

该程序的运行结果如下所示：

这周一的日期为【2018-10-15】，与今天相差【0】天
请输入您要查询本周星期几的日期（1表示星期一，2表示星期二…)：
1
本周【星期一】的日期为：2018-10-15

小熊coder

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java数字和日期处理：Java数字处理和日期类

文章目录本章学习要点Java Math类的常用方法静态常量例 1求最大值、最小值和绝对值例 2求整运算例 3三角函数运算例 4指数运算例 5Java生成随机数（random()和Random类）例 1例 2Java数字格式化例 1Java大数字运算（BigInteger类和BigDecimal类）BigInteger 类例 1BigDecimal 类例 2Java时间日期的处理：Java Date类、Calendar类详解Date 类1. 构造方法2. 常用方法例 1Calendar 类例 2Java日期格
复制链接

扫一扫