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
-
控制台打印：
-
-
-
键盘录入
- 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 block
e.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 block
e.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 block
e.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 block
e.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); // true
8.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); //true
2.System.out.println(a1.equals(b1)); //true
String a2 = new String("123");
String b2 = new String("123");
3.System.out.println(a2==b2); //false
4.System.out.println(a2.equals(b2)); //true
5.System.out.println(a1==a2); //false
6.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.8之前，String底层是char[]，1.9之后，底层是byte。
-
因为字符串的值是常量，所以所有提供的对字符串长度改变的操作，返回的都是一个新的字符串对象。（如下方的connect()方法）
//字符串源码中的成员
public final class String
implements 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);//false
String 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中，复制的到数组的起始位置为len
return 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
- 时间戳与时间类之间的互相转化
- 时间的格式化等等。
正则表达式
- 创建
- 使用
- 常用正则表达式汇总
636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
