Java常用类——Java教案（六）

文章目录

1. 与用户互动
- Java程序入口
- 键盘录入
- - 字符串录入
  - long类型录入
  - 读取文件
  - next和nextline的区别
- nextline使用时，自动跳过的问题。
2. 系统相关
- System类
- - 获取系统信息
  - 获取当前时间
  - 获取对象真实的hashcode
- Runtime类
- - 调用主机程序
3. 常用类
- Object类
- Objects类
- String、StringBuffer、StringBuilder类
- - 介绍
  - 1. 字符串两种创建方式的存储位置和比较
  - 2. 字符串是常量，不可改变
  - 3. conect()和+""区别。
  - 4.+""的产生的结果
- Math类
- Random类
- BigDecimal类
- - BigDecimal(double)和BigDecimal(String)
  - 封装BigDecimal的工具类
4. 扩展学习
- 日期和时间类
- 正则表达式

1. 与用户互动

Java程序入口

main方法

public static void main(String[] args){}

public修饰符：Java类由JVM调用,为了让JVM可以自由调用这个main()方法,所以使用public修饰符把这个方法暴露出来。
static修饰符：JVM调用这个主方法时，不会先创建该主类的对象，然后通过对象来调用该主方法。JVM直接通过该类来调用主方法，因此使用static修饰该主方法。
void返回值：因为主方法被JVM调用，该方法的返回值将返回给JVM，这没有任何意义，因此main(）方法没有返回值。

字符串数组：main方法由JVM调用，形参args形参由JVM负责赋值。

赋值过程：

public class ArgsTest
{public static void main(String[] args){// 输出args数组的长度System.out.println(args.length);//0// 遍历args数组的每个元素for (String arg : args){System.out.println(arg);}}
}

测试：使用命令：java ArgsTest Java Spring javase
1. 控制台打印：

键盘录入

boolean hasNextLine(); 返回输入源是否还有下一行。
String nextLine(); 返回输入源下一行的字符串。

字符串录入

public class TestLongScanner
{public static void main(String[] args){// System.in代表标准输入，就是键盘输入Scanner sc = new Scanner(System.in);// 判断是否还有下一个long型整数while(sc.hasNextLong()){// 输出输入项System.out.println("键盘输入的内容是："+ sc.nextLong());}}
}

long类型录入

boolean hasLong(); 返回输入源是否还有下一行。
String nextLong(); 返回输入源下一行的数字。

public class TestLongScanner
{public static void main(String[] args){// System.in代表标准输入，就是键盘输入Scanner sc = new Scanner(System.in);// 判断是否还有下一个long型整数while(sc.hasNextLong()){// 输出输入项System.out.println("键盘输入的内容是："+ sc.nextLong());}}
}

读取文件

public class TestFile {public static void main(String[] args) {try {Scanner sc = new Scanner(new File("G:\\ComputerStudy\\JavaLession\\hsdlession\\lessionshow\\handele\\JavaLession\\src\\commonclass\\TestLongScanner.java"));while(sc.hasNextLine()) {System.out.println(sc.nextLine());}} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

next和nextline的区别

next：发现空格时，进行输出（空格包含普通空格和一些特殊字符）

nextline：发现空行时，进行输出

public class TestFile {public static void main(String[] args) {System.out.println("-------------NextLine------------------");int a = 1;try {Scanner sc = new Scanner(new File("G:\\ComputerStudy\\JavaLession\\hsdlession\\lessionshow\\handele\\JavaLession\\src\\commonclass\\TestLongScanner.java"));while(sc.hasNextLine()) {System.out.println("第"+a+"行"+sc.nextLine());a++;}} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("-------------Next------------------");int b = 1;try {Scanner sc = new Scanner(new File("G:\\ComputerStudy\\JavaLession\\hsdlession\\lessionshow\\handele\\JavaLession\\src\\commonclass\\TestLongScanner.java"));while(sc.hasNext()) {System.out.println("第"+b+"个"+sc.next());b++;}} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

nextline使用时，自动跳过的问题。

https://blog.csdn.net/qq_51954341/article/details/119941954

2. 系统相关

Java程序在不同操作系统上运行时，可能需要取得平台相关的属性，或者调用平台命令来完成特定功能。Java提供了System类和 Runtime类来与程序的运行平台进行交互。

System类

System类代表当前Java程序的运行平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接通过System类来调用这些类变量和类方法。

System类提供了代表标准输入、标准输出和错误输出的类变量，并提供了一些静态方法用于访问环境变量、系统属性的方法，还提供了加载文件和动态链接库的方法。

获取系统信息

通过System类来访问操作的环境变量和系统属性。

public class SystemTest
{public static void main(String[] args) throws Exception{// 获取系统所有的环境变量Map<String,String> env = System.getenv();for (String name : env.keySet()){System.out.println(name + " ---> " + env.get(name));}// 获取指定环境变量的值System.out.println(System.getenv("JAVA_HOME"));// 获取所有的系统属性Properties props = System.getProperties();// 将所有系统属性保存到props.txt文件中props.store(new FileOutputStream("props.txt"), "System Properties");// 输出特定的系统属性System.out.println(System.getProperty("os.name"));}
}

运行结果

结果：
USERDOMAIN_ROAMINGPROFILE ---> DESKTOP-DQT89ON
PROCESSOR_LEVEL ---> 6
SESSIONNAME ---> Console
ALLUSERSPROFILE ---> C:\ProgramData
PROCESSOR_ARCHITECTURE ---> AMD64
PSModulePath ---> C:\Program Files\WindowsPowerShell\Modules;C:\WINDOWS\system32\WindowsPowerShell\v1.0\Modules;C:\Program Files (x86)\Microsoft SQL Server\150\Tools\PowerShell\Modules\
SystemDrive ---> C:
MAVEN_HOME ---> E:\maven\apache-maven-3.3.9
USERNAME ---> DELL
ProgramFiles(x86) ---> C:\Program Files (x86)
QQ ---> C:\Users\DELL\Desktop
FPS_BROWSER_USER_PROFILE_STRING ---> Default
PATHEXT ---> .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
DriverData ---> C:\Windows\System32\Drivers\DriverData
OneDriveConsumer ---> C:\Users\DELL\OneDrive
ProgramData ---> C:\ProgramData
ProgramW6432 ---> C:\Program Files
RABBITMQ_SERVER ---> E:\rabbitmq\rabbitmq_server-3.8.22
HOMEPATH ---> \Users\DELL
MYSQL_HOME ---> E:\MySQL\mysql-5.7.29-winx64
PROCESSOR_IDENTIFIER ---> Intel64 Family 6 Model 158 Stepping 10, GenuineIntel
ProgramFiles ---> C:\Program Files
PUBLIC ---> C:\Users\Public
windir ---> C:\WINDOWS
=:: ---> ::\
ZES_ENABLE_SYSMAN ---> 1
LOCALAPPDATA ---> C:\Users\DELL\AppData\Local
ChocolateyLastPathUpdate ---> 132239825297988451
IntelliJ IDEA ---> E:\idea\IntelliJ IDEA 2019.3.2\bin;
USERDOMAIN ---> DESKTOP-DQT89ON
FPS_BROWSER_APP_PROFILE_STRING ---> Internet Explorer
LOGONSERVER ---> \\DESKTOP-DQT89ON
JAVA_HOME ---> C:\Program Files\Java\jdk1.8.0_131
ERLANG_HOME ---> E:\erl-24.0
OneDrive ---> C:\Users\DELL\OneDrive
APPDATA ---> C:\Users\DELL\AppData\Roaming
ChocolateyInstall ---> C:\ProgramData\chocolatey
NODE_PATH ---> E:\node\node_global\node_modules
CommonProgramFiles ---> C:\Program Files\Common Files
Path ---> C:/Program Files/Java/jre1.8.0_221/bin/server;C:/Program Files/Java/jre1.8.0_221/bin;C:/Program Files/Java/jre1.8.0_221/lib/amd64;C:\Python27\;C:\Python27\Scripts;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\ProgramData\Oracle\Java\javapath;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Program Files\Java\jdk1.8.0_131\bin;"C:\Program Files\Java\jdk1.8.0_131\jre\bin;";C:\Program Files;E:\node;C:\ProgramData\chocolatey\bin;E:\MySQL\mysql-5.7.29-winx64\bin;C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\170\Tools\Binn\;C:\Program Files (x86)\Microsoft SQL Server\150\Tools\Binn\;C:\Program Files\Microsoft SQL Server\150\Tools\Binn\;C:\Program Files\Microsoft SQL Server\150\DTS\Binn\;C:\Program Files (x86)\Microsoft SQL Server\150\DTS\Binn\;C:\WINDOWS\System32\OpenSSH\;E:\Git\cmd;E:\TortoiseGit\bin;E:\maven\apache-maven-3.3.9\bin;E:\LinuxConnection\Putty\;E:\redis\redis3.0;C:\Users\DELL\AppData\Local\Microsoft\WindowsApps;E:\Microsoft VS Code\bin;E:\node\node_global;E:\idea\IntelliJ IDEA 2019.3.2\bin;;E:\erl-24.0\bin;E:\rabbitmq\rabbitmq_server-3.8.22\sbin;E:\eclipse\eclipse;
OS ---> Windows_NT
COMPUTERNAME ---> DESKTOP-DQT89ON
CATALINA_HOME ---> E:\Tomcat\apache-tomcat-8.5.57
PROCESSOR_REVISION ---> 9e0a
CLASSPATH ---> .;C:\Program Files\Java\jdk1.8.0_131\lib;C:\Program Files\Java\jdk1.8.0_131\lib\tools.jar
CommonProgramW6432 ---> C:\Program Files\Common Files
ComSpec ---> C:\WINDOWS\system32\cmd.exe
SystemRoot ---> C:\WINDOWS
TEMP ---> C:\Users\DELL\AppData\Local\Temp
HOMEDRIVE ---> C:
USERPROFILE ---> C:\Users\DELL
TMP ---> C:\Users\DELL\AppData\Local\Temp
CommonProgramFiles(x86) ---> C:\Program Files (x86)\Common Files
NUMBER_OF_PROCESSORS ---> 8
C:\Program Files\Java\jdk1.8.0_131
Windows 10

生成的文件：

获取当前时间

获取1970-1-1 到现在的时间差（以时间戳的形式）

public class TestSytem {public static void main(String[] args) {long a =System.currentTimeMillis(); //毫秒为单位long b = System.nanoTime();//纳秒为单位  不用，大部分操作系统不支持System.out.println(a);System.out.println(b);}
}

获取对象真实的hashcode

identityHashCode(Object x)方法返回指定对象的精确hashCode值，是根据该对象的地址计算得到的 hashCode值。

当某个类的 hashCode()方法被重写后，该类实例的hashCode()方法就不能唯一地标识该对象;但通过identityHashCode()方法返回的 hashCode值，依然是根据该对象的地址计算得到的 hashCode值。所以，如果两个对象的identityHashCode值相同，则两个对象绝对是同一个对象。如下程序所示。

public class IdentityHashCodeTest
{public static void main(String[] args){// 下面程序中s1和s2是两个不同对象String s1 = new String("Hello");String s2 = new String("Hello");// String重写了hashCode()方法——改为根据字符序列计算hashCode值，// 因为s1和s2的字符序列相同，所以它们的hashCode方法返回值相同System.out.println(s1.hashCode()+ "----" + s2.hashCode());// s1和s2是不同的字符串对象，所以它们的identityHashCode值不同System.out.println(System.identityHashCode(s1)+ "----" + System.identityHashCode(s2));String s3 = "Java";String s4 = "Java";// s3和s4是相同的字符串对象，所以它们的identityHashCode值相同System.out.println(System.identityHashCode(s3)+ "----" + System.identityHashCode(s4));}
}

Runtime类

Runtime类代表Java程序的运行时环境，每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。

应用程序不能创建自己的Runtime实例,但可以通过getRuntime()方法获取与之关联的Runtime对象。

与System类似的是，Runtime类也提供了gc()方法和runFinalization()方法来通知系统进行垃圾回收、清理系统资源，并提供了load(String filename)和 loadLibrary(String libname)方法来加载文件和动态链接库。

Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，如处理器数量、内存信息等。如下程序所示。

public class RuntimeTest
{public static void main(String[] args){// 获取Java程序关联的运行时对象Runtime rt = Runtime.getRuntime();System.out.println("处理器数量："+ rt.availableProcessors());System.out.println("空闲内存数："+ rt.freeMemory());System.out.println("总内存数："+ rt.totalMemory());System.out.println("可用最大内存数："+ rt.maxMemory());}
}
结果：
处理器数量：8
空闲内存数：252664840
总内存数：255328256
可用最大内存数：3786407936

调用主机程序

             Runtime rt = Runtime.getRuntime();// 运行腾讯会议try {//执行文件所在路径rt.exec("E:\\腾讯会议\\wemeetapp.exe");} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}

详情查看API文档。

3. 常用类

Object类

equals()
finalize():当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法来清理该对象的资源。
getClass()：返回该对象的运行时类
hashCode()：返回对象的hashcode值，是经过对象的地址计算得到，默认与System.identityHashCode()的值相同。但是很多类重写了该方法
toString()：返回对象字符串
控制线程：wait()；notify()；notifyAll();
clone();实现对象自我clone，由protected修饰，只能被子类重写或调用。

实现clone步骤

实现Cloneable接口
自定义类实现自己的clone()方法
实现clone()方法时，通过super.clone()；调用Object实现的clone()方法来得到该对象的副本，并返回该副本.

class Address
{String detail;public Address(String detail){this.detail = detail;}
}
// 实现Cloneable接口
class User implements Cloneable
{int age;Address address;public User(int age){this.age = age;address = new Address("广州天河");}// 通过调用super.clone()来实现clone()方法public User clone()throws CloneNotSupportedException{return (User)super.clone();}
}
public class CloneTest
{public static void main(String[] args)throws CloneNotSupportedException{User u1 = new User(29);// clone得到u1对象的副本。User u2 = u1.clone();// 判断u1、u2是否相同System.out.println(u1 == u2);      //①// 判断u1、u2的address是否相同System.out.println(u1.address == u2.address);     //②System.out.println(u1.age==u2.age);}
}

注意：

克隆对象只是原对象的副本，二者只是属性相同，本质并不是同一个对象。
浅克隆，只克隆了所有成员变量值，不会对引用类型的成员变量值所引用的对象进行克隆。引用类型只克隆了地址值，本质还是指向同一个对象。

Objects类

操作对象的工具类。

String、StringBuffer、StringBuilder类

介绍

String

https://www.w3cschool.cn/java/java-string.html

Java StringBuffer 和 StringBuilder 类

https://www.w3cschool.cn/java/java-stringbuffer.html

String和StringBuffer和StringBuilder区别

https://www.runoob.com/java/java-stringbuffer.html

字符串就是一连串的字符序列，Java提供了String 和StringBuffer两个类来封装字符串，并提供了一系列方法来操作字符串对象。
String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。
StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的 append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer 生成了最终想要的字符串，就可以调用它的 toString()方法将其转换为一个String 对象。

StringBuilder类，它也代表字符串对象。StringBuilder和 StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是，StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用StringBuilder类。

String、StringBuilder、StringBuffer 都实现了CharSequence接口，因此CharSequence可认为是一个字符串的协议接口。

**常用方法：**详细查看API文档

1. 字符串两种创建方式的存储位置和比较

1. 存储位置的区别

直接创建的字符串存到String的公共池中，如果直接创建两个相等的字符串，那么他们引用常量池里的同一个字符串
new出来的字符串会创建两个字符串对象，一个保存在常量池，一个保存在堆里面

String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

        String s1="a"+"b"+"c";String s2="abc";7.System.out.println(s1==s2);  // true8.System.out.println(s1.equals(s2));java 中常量优化机制，编译时 s1 已经成为 abc 在常量池中查找创建，s2 不需要再创建。所以s1=s2

2.进行比较时的区别

        String a1 ="123";String b1= "123";1.System.out.println(a1==b1);  //true2.System.out.println(a1.equals(b1)); //trueString a2 = new String("123");String b2 = new String("123");3.System.out.println(a2==b2);  //false4.System.out.println(a2.equals(b2)); //true5.System.out.println(a1==a2);  //false6.System.out.println(a1.equals(a2)); //true

直接创建的字符串，值相等时，二者指向常量池同一个对象，所以二者相等。
对于引用类型来说，==比较的是二者的引用，所以常量池内的字符串！=对象创建的字符串
Java重写了String的equals方法，所以当两个值相等的字符串进行比较时，二者相等。

Java重写的equals方法

    public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;}

2. 字符串是常量，不可改变

字符串的存储是以final类型的char[]存储的（底层是byte[]），因此操作字符串时，字符串的值是不会发生改变的，但是字符变量指向的地址值是可以改变的。
1. 注意：1.8之前，String底层是char[]，1.9之后，底层是byte。
因为字符串的值是常量，所以所有提供的对字符串长度改变的操作，返回的都是一个新的字符串对象。（如下方的connect()方法）

//字符串源码中的成员
public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence {/** The value is used for character storage. */private final char value[];}
String s = "Google";
System.out.println("s = " + s);//Google
s = "Runoob";
System.out.println("s = " + s);//Runoob

String a = "123";
a=a+"456";
System.out.println(a);//123456

既然字符串是常量，为什么我修改后还是123456？

原因：

String a = “123”;此时会在常量池中创建一个字符串"123",当我再a=a+"456"时，原来的"123"仍在常量池中存在。其值并没有改变，但是a的指向发生了变化。
a=a+“456”,相当于先创建了一个StringBuilder(或StringBuffer)对象，通过append链接得到123456，再调用toString()转换得到的地址指向a,所以此时a是123456。注意：StringBuilder的toString()方法是新创建了一个StringBuffer()对象

3. conect()和+""区别。

+"456"相当于先创建了一个StringBuilder(或StringBuffer)对象，通过append链接得到123456，再调用toString()转换得到的地址指向b,所以此时b是123456。注意：StringBuilder的toString()方法是新创建了一个String()对象
a是变量，编译的时候确定不了值，再内存中会创建值，b再堆内存中，c在常量池。
connect（）是新建立了一个字符串对象，所有指向堆中新建的字符串对象。

        String a = "123";String b = a + "456";  //创建新的字符串对象String c = "123456";System.out.println(b == c);//falseString a = "123"+"456";String b = "123".concat("456");System.out.println(b==a);//faslse

    public String concat(String str) {int otherLen = str.length();if (otherLen == 0) {return this;}int len = value.length;char buf[] = Arrays.copyOf(value, len + other0Len);str.getChars(buf, len);      //将str的内容复制到buf中，复制的到数组的起始位置为lenreturn new String(buf, true);}

4.+""的产生的结果

        String a = "123";a  = a+"456";a  = a+"789"

以上3个操作，除了直接生成3个常量外，还会创建两个额外的变量"123456"和"123456789"。a依次指向3个不同的字符串对象。

每次+一下，都生成一个String对象，并且再在常量池中存放一份。

Math类

Java提供了Math 工具类来完成这些复杂的运算，Math类是一个工具类，它的构造器被定义成private 的，因此无法创建Math类的对象。

Math类中的所有方法都是类方法，可以直接通过类名来调用它们。

Math类提供了两个类变量:PI和E，分别等于π和e。

public class MathTest
{public static void main(String[] args){/*---------下面是三角运算---------*/// 将弧度转换角度System.out.println("Math.toDegrees(1.57)："+ Math.toDegrees(1.57));// 将角度转换为弧度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));/*---------下面是取整运算---------*/// 取整，返回小于目标数的最大整数。System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2 ));// 取整，返回大于目标数的最小整数。System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));// 四舍五入取整System.out.println("Math.round(2.3 )：" + Math.round(2.3 ));/*---------下面是乘方、开方、指数运算---------*/// 计算平方根。System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3 ));// 计算立方根。System.out.println("Math.cbrt(9)：" + Math.cbrt(9));// 返回欧拉数 e 的n次幂。System.out.println("Math.exp(2)：" + Math.exp(2));// 返回 sqrt(x2 +y2)System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4 , 4));// 按照 IEEE 754 标准的规定，对两个参数进行余数运算。System.out.println("Math.IEEEremainder(5 , 2)："+ Math.IEEEremainder(5 , 2));// 计算乘方System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));// 计算自然对数System.out.println("Math.log(12)：" + Math.log(12));// 计算底数为 10 的对数。System.out.println("Math.log10(9)：" + Math.log10(9));// 返回参数与 1 之和的自然对数。System.out.println("Math.log1p(9)：" + Math.log1p(9));/*---------下面是符号相关的运算---------*/// 计算绝对值。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));// 符号函数；如果参数为 0，则返回 0；如果参数大于 0，// 则返回 1.0；如果参数小于 0，则返回 -1.0。System.out.println("Math.signum(2.3)：" + Math.signum(2.3));/*---------下面是大小相关的运算---------*/// 找出最大值System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3 , 4.5));// 计算最小值System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2 , 3.4));// 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。System.out.println("Math.nextAfter(1.2, 1.0)："+ Math.nextAfter(1.2, 1.0));// 返回比目标数略大的浮点数System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2 ));// 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。System.out.println("Math.random()：" + Math.random());}
}

Random类

Random类专门用于生成一个伪随机数，它有两个构造器:一个构造器使用默认的种子（以当前时间作为种子)，另一个构造器需要程序员显式传入一个 long 型整数的种子。
ThreadLocalRandom类它是Random的增强版。在并发访问的环境下，使用ThreadLocalRandom来代替Random可以减少多线程资源竞争,最终保证系统具有更好的线程安全性。

ThreadLocalRandom类的用法与Random类的用法基本相似，它提供了一个静态的current()方法来获取ThreadLocalRandom对象，获取该对象之后即可调用各种nextXxx()方法来获取伪随机数了。

ThreadLocalRandom与Random都比Math 的 random()方法提供了更多的方式来生成各种伪随机数，可以生成浮点类型的伪随机数，也可以生成整数类型的伪随机数，还可以指定生成随机数的范围。

public class RandomTest
{public static void main(String[] args){Random rand = new Random();System.out.println("rand.nextBoolean()："+ rand.nextBoolean());byte[] buffer = new byte[16];rand.nextBytes(buffer);//随机生成16个字符System.out.println(Arrays.toString(buffer));// 生成0.0~1.0之间的伪随机double数System.out.println("rand.nextDouble()："+ rand.nextDouble());// 生成0.0~1.0之间的伪随机float数System.out.println("rand.nextFloat()："+ rand.nextFloat());// 生成平均值是 0.0，标准差是 1.0的伪高斯数System.out.println("rand.nextGaussian()："+ rand.nextGaussian());// 生成一个处于int整数取值范围的伪随机整数System.out.println("rand.nextInt()：" + rand.nextInt());// 生成0~26之间的伪随机整数System.out.println("rand.nextInt(26)：" + rand.nextInt(26));// 生成一个处于long整数取值范围的伪随机整数System.out.println("rand.nextLong()：" +  rand.nextLong());}
}

Random 使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，对它们以同样的顺序调用方法，则它们会产生相同的数字序列。

public class SeedTest
{public static void main(String[] args){Random r1 = new Random(50);System.out.println("第一个种子为50的Random对象");System.out.println("r1.nextBoolean():\t" + r1.nextBoolean());System.out.println("r1.nextInt():\t\t" + r1.nextInt());System.out.println("r1.nextDouble():\t" + r1.nextDouble());System.out.println("r1.nextGaussian():\t" + r1.nextGaussian());System.out.println("---------------------------");Random r2 = new Random(50);System.out.println("第二个种子为50的Random对象");System.out.println("r2.nextBoolean():\t" + r2.nextBoolean());System.out.println("r2.nextInt():\t\t" + r2.nextInt());System.out.println("r2.nextDouble():\t" + r2.nextDouble());System.out.println("r2.nextGaussian():\t" + r2.nextGaussian());System.out.println("---------------------------");Random r3 = new Random(100);System.out.println("种子为100的Random对象");System.out.println("r3.nextBoolean():\t" + r3.nextBoolean());System.out.println("r3.nextInt():\t\t" + r3.nextInt());System.out.println("r3.nextDouble():\t" + r3.nextDouble());System.out.println("r3.nextGaussian():\t" + r3.nextGaussian());}
}

结果：

结果可以看出，Random产生的数字并不是真正随机的，而是一种伪随机。
为了避免两个Random对象产生相同的数字序列,通常推荐使用当前时间作为Random对象的种子。

问题：如何解决伪随机(下面的方式无效)

     //附：Random rand = new Random(System.currentTimeMillis());Random rands = new Random(System.currentTimeMillis());System.out.println(rand.nextInt());System.out.println(rands.nextInt());

使用ThreadLocalRandom

     ThreadLocalRandom threadRandom = ThreadLocalRandom.current();System.out.println(threadRandom.nextInt());System.out.println(threadRandom.nextDouble(1.0,5.0));

BigDecimal类

问题：使用float和double会产生精度的丢失

public class DoubleTest
{public static void main(String args[]){System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));System.out.println("1.0 - 0.42 = " + (1.0 - 0.42));System.out.println("4.015 * 100 = " + (4.015 * 100));System.out.println("123.3 / 100 = " + (123.3 / 100));}
}
结果：
0.05 + 0.01 = 0.060000000000000005
1.0 - 0.42 = 0.5800000000000001
4.015 * 100 = 401.49999999999994
123.3 / 100 = 1.2329999999999999

发生精度丢失，其他语言也存在这样的问题。

BigDecimal(double)和BigDecimal(String)

BigDecimal(double)：

不推荐使用，有不可预见性。
使用new BigDecimal(0.1)来创建一个BigDecimal对象时，它的值并不是0.1，它实际上等于一个近似0.1的数。这是因为0.1无法准确地表示为double浮点数，所以传入 BigDecimal构造器的值不会正好等于0.1(虽然表面上等于该值)。
如果必须使用double浮点数作为 BigDecimal构造器的参数时，不要直接将该double
浮点数作为构造器参数创建BigDecimal对象，而是应该通过BigDecimal.valueOf(double value)静态方法来创建BigDecimal对象。

BigDecimal(String val)

使用BigDecimal(String val)构造器的结果是可预知的—写入new BigDecimal(“0.1”)将创建一个BigDecimal，它正好等于预期的0.1。
通常建议优先使用基于String 的构造器。

BigDecimal类提供了add()、subtract()、multiply()、divide()、pow()等方法对精确浮点数进行常规算术运算。

public class BigDecimalTest
{public static void main(String[] args){BigDecimal f1 = new BigDecimal("0.05");BigDecimal f2 = BigDecimal.valueOf(0.01);BigDecimal f3 = new BigDecimal(0.05);System.out.println("使用String作为BigDecimal构造器参数：");System.out.println("0.05 + 0.01 = " + f1.add(f2));System.out.println("0.05 - 0.01 = " + f1.subtract(f2));System.out.println("0.05 * 0.01 = " + f1.multiply(f2));System.out.println("0.05 / 0.01 = " + f1.divide(f2));System.out.println("使用double作为BigDecimal构造器参数：");System.out.println("0.05 + 0.01 = " + f3.add(f2));System.out.println("0.05 - 0.01 = " + f3.subtract(f2));System.out.println("0.05 * 0.01 = " + f3.multiply(f2));System.out.println("0.05 / 0.01 = " + f3.divide(f2));}
}运行结果：
使用String作为BigDecimal构造器参数：
0.05 + 0.01 = 0.06
0.05 - 0.01 = 0.04
0.05 * 0.01 = 0.0005
0.05 / 0.01 = 5
使用double作为BigDecimal构造器参数：
0.05 + 0.01 = 0.06000000000000000277555756156289135105907917022705078125
0.05 - 0.01 = 0.04000000000000000277555756156289135105907917022705078125
0.05 * 0.01 = 0.0005000000000000000277555756156289135105907917022705078125
0.05 / 0.01 = 5.000000000000000277555756156289135105907917022705078125

注意：

创建 BigDecimal 对象时，不要直接使用double浮点数作为构造器参数来调用BigDecimal构造器，否则同样会发生精度丢失的问题。

当使用BigDecimal.valueOf()时，Java讲double的数据转成字符串后，又创建了BigDecimal（String）对象。

使用BigDecimal（String）会讲输入的数值作为字符串进行处理。

    public static BigDecimal valueOf(double val) {// Reminder: a zero double returns '0.0', so we cannot fastpath// to use the constant ZERO.  This might be important enough to// justify a factory approach, a cache, or a few private// constants, later.return new BigDecimal(Double.toString(val));}

封装BigDecimal的工具类

public class Arith
{// 默认除法运算精度private static final int DEF_DIV_SCALE = 10;// 构造器私有，让这个类不能实例化private Arith()   {}// 提供精确的加法运算。public static double add(double v1,double v2){BigDecimal b1 = BigDecimal.valueOf(v1);BigDecimal b2 = BigDecimal.valueOf(v2);return b1.add(b2).doubleValue();}// 提供精确的减法运算。public static double sub(double v1,double v2){BigDecimal b1 = BigDecimal.valueOf(v1);BigDecimal b2 = BigDecimal.valueOf(v2);return b1.subtract(b2).doubleValue();}// 提供精确的乘法运算。public static double mul(double v1,double v2){BigDecimal b1 = BigDecimal.valueOf(v1);BigDecimal b2 = BigDecimal.valueOf(v2);return b1.multiply(b2).doubleValue();}// 提供（相对）精确的除法运算，当发生除不尽的情况时.// 精确到小数点以后10位的数字四舍五入。public static double div(double v1,double v2){BigDecimal b1 = BigDecimal.valueOf(v1);BigDecimal b2 = BigDecimal.valueOf(v2);return b1.divide(b2 , DEF_DIV_SCALE, RoundingMode.HALF_UP).doubleValue();}public static void main(String[] args){System.out.println("0.05 + 0.01 = "+ Arith.add(0.05 , 0.01));System.out.println("1.0 - 0.42 = "+ Arith.sub(1.0 , 0.42));System.out.println("4.015 * 100 = "+ Arith.mul(4.015 , 100));System.out.println("123.3 / 100 = "+ Arith.div(123.3 , 100));}
}

4. 扩展学习

日期和时间类

Date
Calendar
LocalDate
LocalDateTime
时间戳与时间类之间的互相转化
时间的格式化等等。

正则表达式

创建
使用
常用正则表达式汇总