Java的常用类—Date类和Calendar类

Java的常用类—Date类和Calendar类

开发工具与关键技术：工具：myeclipse  技术： Math、Random 
作者：吴东梅
撰写时间：2019-06-01

Math类
Java提供了Math工具类来完成复杂的运算，Math类是一个工具类，构造器被private的，无法创建Math类的对象；Math类中的所有方法都是静态方法（类方法），可以直接通过类名来调用它们。Math类还提供了两个类变量：PI（圆周率）和E（自然对数的底数）。
接下来我们就来了解一下Math类常用到的一些方法，如下所示：
（1） 两个类变量，一个是PI(圆周率)，另一个是E(自然对数的底数)。
如下图所示：把这两个类变量的值显示出来，值并不是完整的。

（2） 三角运算
代码：
System.out.println("-------三角运算------");
// toDegrees：将弧度转换为角度。
System.out.println(“Math.toDegrees(1.57)=”+Math.toDegrees(1.57));
// toRadians：将角度转换为弧度
System.out.println(“Math.toRadians(90)=”+Math.toRadians(90));
//计算反余弦,返回的角度范围在0.0到pi之间。
System.out.println(“Math.acos(1.2)=”+Math.acos(1.2));
// 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
System.out.println(“Math.asin(0.8)=”+Math.asin(0.8));
// 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
System.out.println(“Math.atan(2.3) = " + Math.atan(2.3));
//计算三角余弦
System.out.println(“Math.cos(1.57)=”+Math.cos(1.57));
//计算值的双曲余弦
System.out.println(“Math.cosh(1.2)=”+Math.cosh(1.2));
//计算正弦
System.out.println(“Math.sin(1.57)=”+Math.sin(1.57));
//计算双曲正弦
System.out.println(“Math.sinh(1.2)=”+Math.sinh(1.2));
//计算三角正切
System.out.println(“Math.tan(0.8)=”+Math.tan(0.8));
//计算双曲正切
System.out.println(“Math.tanh(2.1)=”+Math.tanh(2.1));
//将矩形坐标(x,y)转换成极坐标(r,thet);
System.out.println(“Math.atan2(0.1, 0.2)=”+Math.atan2(0.1, 0.2));
效果图：

（3） 取整运算
1）floor：取整，返回小于目标数的最大整数。
2）ceil：取整，返回大于目标数的最小整数。
3）round：四舍五入取整。
如下图所示，就是取整运算的应用和执行的效果图：

（4） 乘方、开方、指数运算
代码：
System.out.println(”-----------乘方、开方、指数运算-------");
// sqrt：计算平方根
System.out.println(“Math.sqrt(9)=”+Math.sqrt(9));
// cbrt：计算立方根
System.out.println(“Math.cbrt(27)=”+Math.cbrt(27));
// exp：返回欧拉数e的n次幂。
System.out.println(“Math.exp(2)=”+Math.exp(2));
//hypot：返回sqrt(x2 +y2)
System.out.println(“Math.hypot(4, 4)=”+Math.hypot(4, 4));
// IEEEremainder：按照IEEE 754标准的规定，对两个参数进行余数运算。
System.out.println(“Math.IEEEremainder(5, 2)=”+Math.IEEEremainder(5, 2));
// pow：计算乘方
System.out.println(“Math.pow(3, 2)=”+Math.pow(3, 2));
// log：计算自然对数
System.out.println(“Math.log(12)=”+Math.log(12));
// log10：计算底数为10的对数。
System.out.println(“Math.log10(9)=”+Math.log10(9));
// log1p：返回参数与1之和的自然对数
System.out.println(“Math.log1p(9)=”+Math.log1p(9));
效果图：

（5） 符号相关的方法
1）abs：计算绝对值。
2）copySign：符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
3）signum：符号函数：如果参数为0,则返回0;如果参数大于0,则返回1.0;如果参数小于0,则返回-1.0。
System.out.println("-----------符号相关的方法-------");
System.out.println(“Math.abs(-4.5)=”+Math.abs(-4.5));
System.out.println(“Math.copySign(1.2, -1.0)=”+Math.copySign(1.2, -1.0));
System.out.println(“Math.signum(2.3)=”+Math.signum(2.3));
效果图如下图所示：

（6） 大小比较相关的方法
代码：
System.out.println("-----------大小比较相关的方法--------");
// max：找出最大值
System.out.println(“Math.max(2.3, 4.5)=”+Math.max(2.3, 4.5));
// min：计算最小值
System.out.println(“Math.min(1.2, 3.4)=”+Math.min(1.2, 3.4));
// nextAfter：返回第一个参数和第二个参数之间与第一个参数相邻的浮点数
System.out.println(“Math.nextAfter(1.2, 1.0)=”+Math.nextAfter(1.2, 1.0));
// nextUp：返回比目标数略大的浮点数
System.out.println(“Math.nextUp(1.2)=”+Math.nextUp(1.2));
// random：返回一个伪随机数，该值大于等于0.0且小于1.0. [0,1)
System.out.println(“Math.random()=”+Math.random());
如下执行的效果图：

Random类
Random类专门用于生成一个伪随机数的类，其产生的随机数是根据种子和顺序决定的；ThreadLocalRandom类是Java 7新增的一个类，它是Random的增强版。在并发访问的环境下,保证系统具有更好的线程安全性。 Random类是一个随机数产生器，随机数是按照某种算法产生的，一旦用一个初值（俗称种子）创建Random对象，就可以得到一系列的随机数。但如果用相同的“种子”创建Random对象，得到的随机数序列是相同的，这样就起不到“随机”的作用。针对这个问题，Java设计者在Random类的Random()构造方法中，使用当前的时间来初始化Random对象，因为时间是单纬度地一直在流逝，多次运行含有Random对象的程序，在不考虑并发的情况下，程序中调用Random对象的时刻是不相同的，这样就可以最大程度上避免产生相同的随机数序列。

接下来了解一下Random类的常用构造器和常用的方法：
构造器：
1）Random() 创建一个新的随机数生成器。
2）Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。(long型：一般用currentTimeMillis)
应用方法如下图所示：
Random random = new Random();
Random random2 = new Random(System.currentTimeMillis());
ThreadLocalRandom random3 = ThreadLocalRandom.current();
常用方法：
1）nextBoolean() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean 值。
2）nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的 byte 数组中。
3）nextFloat() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0之间均匀分布的 float 值。
4）nextDouble() 返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0之间均匀分布的 double 值。
5）nextLong() 返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long值。
6）nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
7）nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
如下所示，是Random类常用的方法的应用和执行应用的效果图：
代码：
System.out.println(“random.nextBoolean()=”+random.nextBoolean());
System.out.print(“random.nextBytes(bytes) =”);
byte[] bytes = new byte[5];
random.nextBytes(bytes);
for (byte b : bytes) {
System.out.print(b+" , ");
}
System.out.println();
System.out.println(“random.nextFloat()=”+random.nextFloat());
System.out.println(“random.nextDouble()=”+random.nextDouble());
System.out.println(“random.nextLong()=”+random.nextLong());
System.out.println(“random.nextInt()=”+random.nextInt());
System.out.println(“random.nextInt(9)=”+random.nextInt(9));
执行的效果图如下：

演示说明：为什么说Random生成的随机数是伪随机数？
只要两个Random对象的种子相同，而且方法的调用顺序也相同，产生的随机数相同。
Random产生的数字并不是真正随机的，而是一种伪随机。
看第一个种子为16的Random对象：
代码：
Random r1 = new Random(16);
System.out.println(“第一个种子为16的Random对象”);
System.out.println("r1.nextBoolean() = " + r1.nextBoolean());
System.out.println("r1.nextInt() = " + r1.nextInt());
System.out.println("r1.nextDouble() = " + r1.nextDouble());
System.out.println("r1.nextGaussian() = " + r1.nextGaussian());
效果图：

看第二个种子为16的Random对象，如下图所示：
Random r2 = new Random(16);
System.out.println(“第二个种子为16的Random对象”);
System.out.println("r2.nextBoolean() = " + r2.nextBoolean());
System.out.println("r2.nextInt() = " + r2.nextInt());
System.out.println("r2.nextDouble() = " + r2.nextDouble());
System.out.println("r2.nextGaussian() = " + r2.nextGaussian());
效果图如下：

看第三个种子为16的Random对象，如下图所示：
代码：
Random r3 = new Random(16);
System.out.println(“第三个种子为16的Random对象”);
System.out.println("r3.nextBoolean() = " + r3.nextBoolean());
System.out.println("r3.nextInt() = " + r3.nextInt());
System.out.println("r3.nextDouble() = " + r3.nextDouble());
System.out.println(“r3.nextGaussian() = " + r3.nextGaussian());
效果图如下：

下面我们利用Random类来模拟掷骰子：
如果说，我们要模拟掷骰子，就需要随机产生1—6的随机整数，代码如下：
Random random = new Random();
int simuDie = 1+random.nextInt(6);
注意，方法nextInt(6)产生的随机整数范围是0—5，所以对于产生1—6的随机整数，所以要+1操作。
接下来写掷骰子的代码：
代码：
class RandomDie{
private int sides;
private Random random;
public RandomDie(int s) {
sides = s;
random = new Random();
}
public int cast(){
return 1+random.nextInt(sides);
}
}
public class RandomDieSimulator {
public static void main(String[] args) {
int Num;
RandomDie die = new RandomDie(6);
final int TRIES = 15;
for (int i = 1; i <= TRIES; i++) {
Num = die.cast();
System.out.print(Num+” ");
}
System.out.println();
}
}
效果图如下：每次运行的结果是不一样的。

利用Random随机产生一组数列，这种方式得到的结果事先都是未知的。每次运行的结果和上一次都不同。