与用户互动

运行Java程序的参数

//Java程序入口：main()方法
public static void main(String[] args){...}

• public修饰符：Java类由JVM调用，为了让JVM可以自由调用这个main()方法，所以使用public修饰符把这个方法暴露出来

• static修饰符：JVM调用这个主方法时，不会先创建该主类的对象，然后通过对象来调用该主方法。JVM直接通过该类来调用主方法，因此使用static修饰该主方法。

• void返回值：因为主方法被JVM调用，该方法的返回值将返回给JVM，因此main()方法没有返回值。

使用Scanner获取键盘输入

使用Scanner类可以很方便地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，可以从文件、输入流、字符串中解析出基本类型值和字符串值。

Scanner主要提供了两个方法来扫描输入

• hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果只是判断是否包含下一个字符串，则直接使用hasNext()

• nextXxx()：获取下一个输入项。

默认情况下，Scanner使用空白（空格、Tab空白、回车）作为多个输入项之间的分隔符。

import java.util.Scanner;public class ScannerKeyBoardTest
{public static void main(String[] args) {//System.in代表标准输入，就是键盘输入Scanner sc = new Scanner(System.in);//增加下面一行将只把回车作为分隔符//sc.useDelimiter("\n");//判断是否还有下一个输入项while (sc.hasNext()) {//输出输入项System.out.println("键盘输入的内容是："+ sc.next());}}
}

Scanner提供了两个简单的方法来逐行读取

• boolean hasNextLine()：返回输入源中是否还有下一行

• String nextLine()：返回输入源中下一行的字符串

创建Scanner对象，传入一个File对象作为参数，程序将读取ScannerFileTest.java文件中的内容

import java.io.File;
import java.util.Scanner;public class ScannerFileTest
{public static void main(String[] args) throws Exception{//将一个File对象作为Scanner的构造器参数，Scanner读取文件内容Scanner sc = new Scanner(new File("ScannerFileTest.java"));System.out.println("ScannerFileTest.java文件内容如下：");//判断是否还有下一行while (sc.hasNextLine()) {//输出文件中的下一行System.out.println(sc.nextLine());}}
}  

系统相关

System类

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

加载文件和动态链接库主要对naive方法有用，对于一些特殊的功能（如访问操作系统底层硬件设备等）Java程序无法实现必须借助C语音来完成，此时需要使用C语音为Java方法提供实现

1. Java程序中声明native修饰的方法，类似于abstract方法，只有方法签名，没有实现。编译该Java程序，生成一个class文件

2. 用javah编译第1步生成的class文件，将生成一个.h文件

3. 写一个.cpp文件实现native，这一步需要包含第2步生成的.h文件（.h文件中包含JDK带的jni.h文件）

4. 将第3步的.cpp文件编译成动态链接库文件

5. 在Java中用System类的loadLibrary..()方法或Runtime类的loadLibrary()方法加载第4步产生的动态链接库文件，Java程序中就可以调用这个native方法了。

import java.io.FileOutputStream;
import java.util.Map;
import java.util.Properties;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 properties = System.getProperties();//将所有的系统属性保存到properties.txt文件中properties.store(new FileOutputStream("properties.txt"), "System Properties");//输出特定的系统属性System.out.println(System.getProperty("os.name"));}
}

System类的in、out和err分别代表系统的标准输入（通常是键盘）、标准输出（通常是显示器）和错误输出流，并提供了setIn()、setOut()和setErr()方法

identityHashCode(Object x)方法，该方法返回指定对象的精确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程序的运行时环境，可以访问JVM的相关信息，如处理器数量、内存信息等。每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象。

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

public class ExecTest
{public static void main(String[] args) throws Exception{//获取Java程序关联的运行时对象Runtime runtime = Runtime.getRuntime();System.out.println("处理器数量：" + runtime.availableProcessors());System.out.println("空闲内存数：" + runtime.freeMemory());System.out.println("总内存数：" + runtime.totalMemory());System.out.println("可用最大内存数" + runtime.maxMemory());//运行记事本程序runtime.exec("notepad.exe");}
}

常用类

Object类

Object类是所有类、数组、枚举类的父类，Java允许把任何类型的对象赋给Object类型的变量。

• boolean equals(Object obj)：判断指定对象与该对象是否相等

• protected void finalize()：当系统中没有引用变量引用到该对象时，垃圾回收器调用该方法来清理该对象的资源

• Class<?>getClass()：返回该对象的运行时类

• int hashCode()：返回该对象的hashCode()值

• String toString()：返回该对象的字符串表示，当程序使用System.out.println()方法输出一个对象，或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的toString()方法返回该对象的字符串表示。

Java提供protected修饰的clone()方法，用于帮助其他对象来实现“自我克隆”，需要被子类重写或调用。

自定义类实现“克隆”的步骤

1. 自定义类实现Cloneable接口

2. 自定义实现自己的clone()方法

3. 实现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(27);//clone得到u1对象的副本User u2 = u1.clone();//判断u1、u2是否相同System.out.println(u1 == u2);//判断u1、u2的address是否相同System.out.println(u1.address == u2.address);}
}

Java7新增的Object类

如果不能确定一个引用变量是否为null，如果贸然地调用该变量的toString()方法，则可能引发NullPointerException异常；如果使用Object类提供的toString(Object o)方法，就不会引发空指针异常，当o为null时，程序将返回一个"null"字符串。

Java为工具类的命名习惯是添加一个字母s，比如操作数组的工具类Arrays，操作集合的工具类Collections。

import java.util.Objects;
public class ObjectsTest
{//定义一个objectsTest变量，它的默认值是nullstatic ObjectsTest objectsTest;public static void main(String[] args) {//输出一个null对象的hashCode值，输出0System.out.println(Objects.hashCode(objectsTest));//输出一个null对象的toString，输出nullSystem.out.println(Objects.toString(objectsTest));//要求objectsTest不能为null，如果objectsTest为nullSystem.out.println(Objects.requireNonNull(objectsTest,"objectsTest参数不能是null!"));}
}

requireNonNull()方法，当传入的参数不为null时，该方法返回参数本身；否则将会引发NullPointerException异常。

Math类

构造器被定义成private的，因此无法参加Math类的对象，所有方法都是类方法，可以直接通过类名来调用它们，还提供了两个类变量：PI和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());}
}

Java 7的ThreadLocalRandom与Random

Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（当前时间作为种子），另一个构造器需要程序员显式传入一个long型整数的种子

ThreadLocalRandom类是Java7新增的一个类，在并发访问环境下，可以减少多线程资源竞争，最终保证系统具有更好的线程安全性。提供静态的current()方法来获取ThreadLocalRandom对象，获取该对象之后调用各种nextXxx()方法来获取伪随机数

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

Random使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，对它们以同样的顺序调用方法，则它们会产生相同的数字序列。为避免两个Random对象产生相同的数字序列，推荐使用当前时间作为Random对象的种子

Random rt = new Random(System.currentTimeMillis());

ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
//生成一个4~20之间的伪随机整数
int vall = threadLocalRandom.nextInt(4, 20);
//生成一个2.0~10.0之间的伪随机浮点数
int vall2 = threadLocalRandom.nextDouble(2.0, 10.0);

BigDecimal类

BigDecimal能精确表示、计算浮点数。该类提供了大量的构造器用于创建BigDecimal对象，包括把所有基本数值型变量转换成一个BigDecimal对象，也包括利用数字字符串、数字字符数组来创建BigDecimal对象。

BigDecimal(String val)构造器的结果是可预知的——写入new BigDecimal("0.1")将创建一个BigDecimal对象，优先建议使用基于String的构造器

如果必须使用double浮点数作为BigDecimal构造器的参数时， 不要直接将该double浮点数作为构造器参数创建BigDecimal对象，而是通过BigDecimal.valueOf(double calue)静态方法来创建BigDecimal对象

Java8的日期、时间类

Date类

Date()：生成一个代表当前日期的Date对象
Date(long date)：根据指定的long型整数来生成一个Date对象
boolean after(Date when)：测试该日期是否在指定日期when之后
boolean before(Date when)：测试该日期是否在指定日期when之前
long getTime()：返回该时间对应的long型整数，即从GMT 1970-01-01 00:00:00到该Date对象之间的时间差，以毫秒为计时单位
void setTime()：设置该Date对象的时间

Calendar类

Calendar类是一个抽象类，所以不能使用构造器来创建Calendar对象。但它提供了几个静态getInstance()方法来获取Calendar对象，这些方法根据TimeZone，Locale类来获取特定的Calendar

Calendar类提供了大量访问、修改日期时间的方法

• void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量

• int get(int field)：返回给定日历字段的值

• int getActualMaximum(int field)：返回指定日历字段可能拥有的最大值

• int getActualMinimum(int field)：返回指定日历字段可能拥有的最小值

• void roll(int field, int amount)：向指定日历字段添加指定（有符号的）时间量，不更改更大的字段

• void set(int field, int value)：将给定的日历字段设置为给定值

• void set(int year, int month, int date)：设置日历字段年、月、日的值

• void set(int year, int month, int date, int hourOfDay, int minute)：设置日历字段年、月、日、时、分、秒的值。

public class CalendarTest
{public static void main(String[] args){Calendar c = Calendar.getInstance();// 取出年System.out.println(c.get(YEAR));// 取出月份System.out.println(c.get(MONTH));// 取出日System.out.println(c.get(DATE));// 分别设置年、月、日、小时、分钟、秒c.set(2003 , 10 , 23 , 12, 32, 23); //2003-11-23 12:32:23System.out.println(c.getTime());// 将Calendar的年前推1年c.add(YEAR , -1); //2002-11-23 12:32:23System.out.println(c.getTime());// 将Calendar的月前推8个月c.roll(MONTH , -8); //2002-03-23 12:32:23System.out.println(c.getTime());Calendar cal1 = Calendar.getInstance();cal1.set(2003, 7, 23, 0, 0 , 0); // 2003-8-23cal1.add(MONTH, 6); //2003-8-23 => 2004-2-23System.out.println(cal1.getTime());Calendar cal2 = Calendar.getInstance();cal2.set(2003, 7, 31, 0, 0 , 0); // 2003-8-31// 因为进位到后月份改为2月，2月没有31日，自动变成29日cal2.add(MONTH, 6); // 2003-8-31 => 2004-2-29System.out.println(cal2.getTime());Calendar cal3 = Calendar.getInstance();cal3.set(2003, 7, 23, 0, 0 , 0); //2003-8-23// MONTH字段“进位”，但YEAR字段并不增加cal3.roll(MONTH, 6); //2003-8-23 => 2003-2-23System.out.println(cal3.getTime());Calendar cal4 = Calendar.getInstance();cal4.set(2003, 7, 31, 0, 0 , 0); //2003-8-31// MONTH字段“进位”后变成2，2月没有31日，// YEAR字段不会改变，2003年2月只有28天cal4.roll(MONTH, 6); //2003-8-31 => 2003-2-28System.out.println(cal4.getTime());}
}

add与roll的区别

add(int field, int amount)

• 当被修改的字段超过它允许的范围时，会发生进位，即上一级字段会增大

• 如果下一级字段也需要改变，那么该字段会修正到变化最小的值

roll当被修改的字段超过它允许的范围时，上一级字段不会增大，下一级字段的处理规则与add相似

Calendar的容错性

public class LenientTest
{public static void main(String[] args){Calendar cal = Calendar.getInstance();// 结果是YEAR字段加1，MONTH字段为1（二月）cal.set(MONTH , 13);   //①System.out.println(cal.getTime());// 关闭容错性cal.setLenient(false);// 导致运行时异常cal.set(MONTH , 13);   //②System.out.println(cal.getTime());}
}

①代码可以正常运行，YEAR字段加1；②代码将会导致运行时异常，因为设置MONTH字段超出了MONTH字段允许的范围。Calendar提供了一个setLenient()用于设置它的容错性，Calendar默认支持较好的容错性，通过setLenient(false)可以关闭Calendar的容错性，让它严格的参数检查。

Java8新增的日期、时间包

• Clock：该类用于获取指定时间的当前的日期、时间。该类可取代System类的currentTimeMillis()方法，而且提供了更多方法来获取当前日期、时间。该类提供了大量静态方法来获取Clock对象

• Duration:该类代表持续的时间

• Instant：代表一个具体的时刻，可以精确到纳秒。提供了静态now()方法来获取当前时刻，也提供了静态的now(Clock clock)方法来获取clock对应的时刻。minusXxx()和plusXxx()方法在当前时刻的基础上减去/加上一段时间

• LocalDate：该类代表不带时区的日期。供了静态的now(Clock clock)方法来获取clock对应的日期。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几年、几月、几周或几日

• LocalTime：该类代表不带时区的时间。供了静态的now(Clock clock)方法来获取clock对应的时间。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几小时、几分、几秒等

• LocalDateTime：该类代表不带时区的日期、时间。供了静态的now(Clock clock)方法来获取clock对应的时间、日期。minusXxx()和plusXxx()方法在当前年份基础上减去/加上几年、几月、几周、几日、几小时、几分、几秒等

• MonthDay：该类仅表示月日。提供了静态的now(Clock clock)方法

• Year：该类仅表示年。提供了静态的now(Clock clock)方法。minusYears()和plusYears()方法
  -YearMonth：该类仅代表年月。提供了静态的now(Clock clock)方法，minusXxx()和plusXxx()方法

• ZonedDatetime：该类代表一个时区化的日期、时间

• ZoneId：该类代表一个时区

• DayofWeek：这是一个枚举类周一到周六的枚举

• Mouth：该类也是一个枚举类，定义一月到十二月的枚举值

  public class NewDatePackageTest
  {

  public static void main(String[] args)
  {// -----下面是关于Clock的用法-----// 获取当前ClockClock clock = Clock.systemUTC();// 通过Clock获取当前时刻System.out.println("当前时刻为：" + clock.instant());// 获取clock对应的毫秒数，与System.currentTimeMillis()输出相同System.out.println(clock.millis());System.out.println(System.currentTimeMillis());// -----下面是关于Duration的用法-----Duration d = Duration.ofSeconds(6000);System.out.println("6000秒相当于" + d.toMinutes() + "分");System.out.println("6000秒相当于" + d.toHours() + "小时");System.out.println("6000秒相当于" + d.toDays() + "天");// 在clock基础上增加6000秒，返回新的ClockClock clock2 = Clock.offset(clock, d);// 可看到clock2与clock1相差1小时40分System.out.println("当前时刻加6000秒为：" +clock2.instant());// -----下面是关于Instant的用法-----// 获取当前时间Instant instant = Instant.now();System.out.println(instant);// instant添加6000秒（即100分钟），返回新的InstantInstant instant2 = instant.plusSeconds(6000);System.out.println(instant2);// 根据字符串中解析Instant对象Instant instant3 = Instant.parse("2014-02-23T10:12:35.342Z");System.out.println(instant3);// 在instant3的基础上添加5小时4分钟Instant instant4 = instant3.plus(Duration.ofHours(5).plusMinutes(4));System.out.println(instant4);// 获取instant4的5天以前的时刻Instant instant5 = instant4.minus(Duration.ofDays(5));System.out.println(instant5);// -----下面是关于LocalDate的用法-----LocalDate localDate = LocalDate.now();System.out.println(localDate);// 获得2014年的第146天localDate = LocalDate.ofYearDay(2014, 146);System.out.println(localDate); // 2014-05-26// 设置为2014年5月21日localDate = LocalDate.of(2014, Month.MAY, 21);System.out.println(localDate); // 2014-05-21// -----下面是关于LocalTime的用法-----// 获取当前时间LocalTime localTime = LocalTime.now();// 设置为22点33分localTime = LocalTime.of(22, 33);System.out.println(localTime); // 22:33// 返回一天中的第5503秒localTime = LocalTime.ofSecondOfDay(5503);System.out.println(localTime); // 01:31:43// -----下面是关于localDateTime的用法-----// 获取当前日期、时间LocalDateTime localDateTime = LocalDateTime.now();// 当前日期、时间加上25小时３分钟LocalDateTime future = localDateTime.plusHours(25).plusMinutes(3);System.out.println("当前日期、时间的25小时3分之后：" + future);// 下面是关于Year、YearMonth、MonthDay的用法示例-----Year year = Year.now(); // 获取当前的年份System.out.println("当前年份：" + year); // 输出当前年份year = year.plusYears(5); // 当前年份再加5年System.out.println("当前年份再过5年：" + year);// 根据指定月份获取YearMonthYearMonth ym = year.atMonth(10);System.out.println("year年10月：" + ym); // 输出XXXX-10，XXXX代表当前年份// 当前年月再加5年，减3个月ym = ym.plusYears(5).minusMonths(3);System.out.println("year年10月再加5年、减3个月：" + ym);MonthDay md = MonthDay.now();System.out.println("当前月日：" + md); // 输出--XX-XX，代表几月几日// 设置为5月23日MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);System.out.println("5月23日为：" + md2); // 输出--05-23
  }

  }