Java SE第7章 Java基础类库

Java SE第7章 Java基础类库

• 1. Java 程序的参数
• 2. 程序运行过程中接收用户输入
• 3. System类相关用法
• 4. Runtime，ProcessHandle类的相关用法
• 5. Object与Objects类
• 6. 使用String，StringBuffer，StringBuilder类
• 7. 使用Math类进行数字计算
• 8. 使用BigDecimal保存精确浮点数
• 9. 使用Random类生成各种伪随机数
• 10. Date，Calendear 的用法及之间的联系
• 11. Java 8 新增的日期，时间的API的功能和用法
• 12. 创建正则表达式
• 13. 通过Pattern和Matcher使用正则表达式
• 14. 程序国际化的思路
• 15. 程序国际化

1. Java 程序的参数

先来分析一下java的**main()**方法~~~

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

首先，我们知道该方法是由 JVM 调用，为了让 JVM 自由调用此方法，所以应使用 public 修饰

JVM调用该方法时，不是先创建这个类的对象再调用main()方法，而是直接通过该类来调用该方法，所以应该用static修饰

因为方法的返回值会返回给调用此方法的对象，所以返回值将返回给 JVM ，没有什么意义，所以使用 void

对于形参列表String[] args ，则应由 JVM 负责赋值

赋值方法是

java ArgsTest Java Spring

ArgsTest 为类名，后面的两个参数 java,Spring 会以字符串形式加入到 args ，参数以空格为间隔，其中 args[0] = “java” ，args[1] = “Spring”

如果想加上空格，应

java ArgsTest "Java Spring"

2. 程序运行过程中接收用户输入

Scanner可以快速获取用户的键盘输入，它可以从文件，输入流，字符串中解析除基本类型值和字符串值

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

• hasNextXxx() : 用于判断是否有下一个输入项，Xxx可以是基本数据类型，如果判断下一个输入项是不是字符串，可以直接使用 hasNext()
• nextXxx(): 获取下一个输入项

Scanner 默认使用空白（空格，tab，回车）为分隔符，同时可以使用 **useDelimiter(String pattern)**设置分隔符，该方法参数应该是一个正则表达式（之后再谈）

使用方法如下，将回车设置为分隔符

Scanner sc = new Scanner(System.in); //Systerm.in 表示标准输入，即键盘输入
sc.useDelimiter("\n");

再介绍两个逐行读取的方法，这与集合使用迭代器进行遍历形式十分相似

• boolean hasNextLine(): 判断输入源是否有下一行
• String nextLine(): 返回输入源下一行的字符串

while(sc.hasNextLine()){	//如果输入源有下一行
    System.out.println(sc.nextLine());	//输出下一行
}

前面创建Scanner对象时形参为System.in ，表示接收键盘输入，如果想读取文件，就应该传入一个文件对象

Scanner scFile = new Scanner(new File("ScannerFile.java"));//读取创建的文件对象

之后使用时就和前面一样，只是因为涉及文件，可能会有异常，则可以将异常抛出或抓取处理

3. System类相关用法

System类代表当前Java程序的运行平台，程序不能创建System类的对象，允许调用类变量和类方法

System类提供了代表标准输入(通常键盘)，标准输出(通常显示器)，错误输出的类变量(流形式)，以可以通过对应set方法改变标准，并且提供了一些访问环境变量，系统属性的静态方法，还提供 加载文件和动态链接库的方法(主要对native方法有用，因为一些的底层的 功能需要使用c语言来实现)，实现步骤如下

1. native修饰的方法类似抽象方法，没有实现当使用带 -h 选项（Java 10 用-h 替换了 javah）的 javac 命令编译Java程序，会生成一个**.class文件和.h**文件
2. 用c语言实现该native方法，要引入上一步生成的**.h**头文件
3. 将第二步的文件编译成动态链接库文件
4. 在Java中用System类的loadLibrary…()或Runtime类的loadLibrary()加载第三步的动态链接库文件，就可以调用这个native方法

/*访问环境变量和系统属性*/
        Map<String, String> env = System.getenv();
        for(String name: env.keySet()){
            System.out.println(name + env.get(name));
        }
        //获取所有系统属性
        Properties properties = System.getProperties();
        //输出特定系统属性
        System.out.println(System.getProperty("os.name"));

System类还提供获取时间的方法

• Long currentTimeMillis()：返回当前时间到UTC 1970年1月1日午夜到现在的毫秒数
• Long nanoTime(): 返回当前时间到UTC 1970年1月1日午夜到现在的纳秒数

System还提供 **identityHashCode(Object x)方法，返回指定对象精确的hashCode值，因为可能会重写hashCode()方法，所以该对象的hashCode()**不能唯一标识该对象，但使用 **identityHashCode(Object x)**方法比较，可以保证两个对象一定是同一个对象,即 任何两个对象的 identityHashCode值都不同

4. Runtime，ProcessHandle类的相关用法

Runtime 类代表Java程序当前运行环境，每个Java程序都有一个与之对应的 Runtime 实例，但程序不能创建该实例，但可以通过 **getRuntime()**方法获取与之关联的 Runtime对象

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

Runtime能访问Jvm的相关信息

//获取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还可以直接单独启用一个进程来运行操作系统的命令

//Process 代表进程
Process p = runtime.exec("notepad.exe");//单独启用笔记本线程

Java 使用 Process代表进程，Java 9 还新增一个 ProcessHandle接口，通过该接口可获取进程的各项信息，通过该接口的 onExit() 方法可以在进程结束时完成某些行为

ProcessHandle还提供一个 ProcessHandle.Info类，用于获取进程的命令，参数，启动时间，累计运行时间，用户等信息

Runtime runtime = Runtime.getRuntime();
Process p = runtime.exec("notepad.exe");
ProcessHandle ph = p.toHandle();
//ProcessHandle.Info 
ProcessHandle.Info info = ph.info();
System.out.println("进程相关参数"+ info.command() + info.arguments() + info.startInstant + info.totalCpuDuration);
//通过CompletableFuture在进程结束时运行某个任务
CompletableFuture<ProcessHandle> cf = ph.onExit();
cf.thenRunAsync(() -> {
     System.out.println("程序退出");
});

注意上述类的不同分工，主要就是通过 ProcessHandle对象来获取进程信息

5. Object与Objects类

Object类是所有类，数组，枚举类的父类，任何对象都可以赋值给 Object类型的变量，因为所有对象默认继承 Object类，所以它们都可以使用 Object类的方法

• boolean equals(Object obj): 判断指定对象与该对象是否相等，只判断是不是一个对象，所以一般会重写此方法
• protected void finalize(): 当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法清理该对象的资源
• Class<?> getClass(): 返回该对象的运行类型
• **int hashCode(): **返回该对象的 hashCode值，默认情况是根据对象的地址计算的
• String toString(): 返回该对象的字符串表示，默认格式为 运行时类名@十六进制hashCode值 ，当直接输出一个对象时，其实是调用该对象的 toString()方法

Java克隆方法，自我克隆：得到一个该对象的副本，二者之间完全隔离

但克隆机制只是对对象各实例变量进行复制值，但如果有引用变量，克隆之后依旧指向原来实例

实现 User类的克隆

class User implements Cloneable{	//需要先实现 Cloneable 接口，接口里没有定义方法
    public User clone() throws CloneNotSupportedException{	//实现克隆方法
        return (User) super.clone();
    }
}

Java 7 新增一个 Object工具类，它里面提供了一些工具方法来操作对象，这些方法大多是空指针安全的，不会引发空指针异常

public class Objects_ {
    //定义一个 obj 变量，默认null
    static Objects_ obj;
    public static void main(String[] args) {
        System.out.println(Objects.hashCode(obj));//输出 0
        System.out.println(Objects.toString(obj));//输出 null
        System.out.println(Objects.requireNonNull(obj));//要求 obj 不能为空，否则会引发异常,一般用于检验参数是否为空
    }
}

6. 使用String，StringBuffer，StringBuilder类

String类是不可变类，一旦创建一个 String 对象，这个对象的字符序列就不可变，直到这个对象销毁

StringBuffer 对象代表一个字符序列可变的字符串，通过其方法可以改变字符序列，再通过 toString方法转成String对象

StringBuilder是JDK 1.5新增的类，也代表字符序列可变的字符串，它与 StringBuffer基本相似，只是StringBuffer是线程安全的，所以 StringBuilder效率更高，应优先考虑

三个类都实现了 CharSequence接口，可认为是一个字符串的协议接口

java 9 改进了字符串的实现，java 9之前，字符串采用 **char[]**保存字符，所以每个字符占2字节，之后 字符串采用 **byte[]**外加一个 encoding-flag字段来保存字符，因此每个字符只占一个字节

通过 String构造器可以将 **byte[] 或 char[]**转成字符串

• int compareTo(String anotherString): 比较两个字符串的大小，相等返回0，否则返回长度差
• String concat(String str): 将两个字符串连接起来，和’+'相同
• boolean contentEquals(StirngBuffer sb): 将 String对象和StringBuffer对象比较，字符序列相同时返回true
• static String copyValueOf(char[] data): 将字符数组转为字符串，和构造器转换相同
• **boolean endsWith(String suffix)😗*返回该String 对象是否以 suffix结尾,对应还有 startWith方法
• boolean equalsIgnoreCase(String str): 和equals() 相同，只是忽略大小写
• **byte[] getBytes()😗*将String对象转为 byte[]
• **char[] toCharArray()😗*将String对象转为 char[]
• **void getChars(int srcBegin,int srcEnd,char[] dst, int dstBegin)😗*将字符串从 srcBegin开始到srcEnd结束的字符复制到 dst字符数组中,dstBegin为起始复制位置
• **String replace(char oldChar ,char newChar)😗*将字符串里的第一个 oldChar替换成 newChar
• **String toLowerCase()😗*将字符串转换为小写
• **String toUpperCase()😗*将字符串转换为大写
• **static String valueOf(X x)😗*将一切基本类型值转为String对象

StringBuilder使用

public class StringBuilder_ {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("asd");//追加
        sb.insert(0, "sda");//插入
        sb.replace(5,6,",");//替换
        sb.delete(5,6);//删除
        sb.reverse();//翻转
        sb.setLength(10);//改变长度，保留
    }
}

StringBuffer和StringBuilder有两个属性，length,capacity，容量通常比length大

7. 使用Math类进行数字计算

Math类是一个工具类，构造器私有，所以无法创建对象，都是类方法，还有两个类变量:PI E

可以查看对应 API熟悉这些类方法

8. 使用BigDecimal保存精确浮点数

float和double容易造成精度丢失，BigDecimal提供大量构造器创建对象,其中 **BigDecimal(double val)**构造器不建议使用，因为有一定的不可预知性，实际值并不会是val，而是一个近似值，应该使用 **BigDecinmal(String val)**构造器，这样结果可预知

如果必须使用double作为构造器参数时，应该通过 **BigDecimal.valueOf(double value)**静态方法创建对象

BigDecimal提供 **add(), subtract(), multiply(), divide(), pow()**等方法对浮点数进行常规运算

9. 使用Random类生成各种伪随机数

Random类用于生成一个伪随机数，一个构造器使用默认时间作为种子，另一个传入一个long型整数的种子

ThreadLocalRandom类是 java 7 新增的一个类，是 Random的加强版,在并发访问下，可以减少多线程资源竞争，保证系统具有良好的线程安全性,提供了一个静态的 **current()**方法获取其对象，之后调用 **nextXxx()**方法就可以获得伪随机数

public class Random_ {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextBoolean());
        byte[] bytes = new byte[16];
        random.nextBytes(bytes);
        System.out.println(Arrays.toString(bytes));
        //种子相同时，生成的随机数也相同，所以是伪随机
        Random r1 = new Random(50);
        System.out.println(r1.nextInt());//-1160871061
        Random r2 = new Random(50);
        System.out.println(r2.nextInt());//-1160871061
    }
}

BigDecimal提供 **add(), subtract(), multiply(), divide(), pow()**等方法对浮点数进行常规运算

10. Date，Calendear 的用法及之间的联系

Date类用于处理时间，历史悠久，所以有很多过时的方法和构造器
剩下两个构造器

• Date(): 生成一个代表当前日期时间的 Date对象，底层调用 **System.currentTimeMills()**获得 long整数作为日期参数
• Date(long date): 参数创建的对象和 GMT 1970年1月1日 00:00:00之间的时间差，以毫秒为计时单位

现在一般使用 Calendar工具类
Calendar是一个抽象类，用于表示日历,java 本身提供了一个 GregorianCalendar类代表公历

创建Calendar对象

Calendar cal = Calendar.getInstance();

同时 Calendar对象和 Date对象可以相互转化

主要注意月份是以0为起始点，同时注意 add()和 roll()

Calendar call = Calendar.getInstance();
call.set(2003, 7 ,23, 0, 0 ,0);//2003-8-23
//call.add(MONTH, 6);//2004-2-23
//call.roll(MONTH, 6);//2003-2-23	不会进位

Calendar默认支持较好的容错性，可以传入超范围的参数，会取余，也可以关闭容错性，此时传入超范围参数时会报错

11. Java 8 新增的日期，时间的API的功能和用法

java 新增了 java.time包，包含很多常用类，可以查阅对应API熟悉使用方法

12. 创建正则表达式

正则表达式可以对字符串进行查找，提取，分割，替换等操作

**String **类的几个特殊方法

• **booelan matches(String regex)😗*用于判断该字符串是否匹配指定的正则表达式
• String replaceAll(String regex, String replacement): 将该字符串所有匹配正则表达式的子串替换为 replacement
• String replaceFirst(String regex, String replacement): 将该字符串第一个匹配正则表达式的子串替换为 replacement
• String[] split(String regex): 以 regex 为分隔符，分割字符串

特殊字符

$：匹配一行开头

^：匹配一行结尾

[]：匹配其中任意一个字符

{}：标记前面子表达式出现的频度,{n , m}表示前面出现次数 >= n 同时 <= m

*：前面子表达式可以出现任意次

+：前面子表达式出现 >= 1次

?：前面子表达式出现 0/1 次

. ：匹配除 \n外任何单字符

\：转义

“\u0041\\\\" //匹配 A\

两个反斜杠相当于一个

通配符

\d：0-9数字

\D：除\d

\s：所有空白字符

\S：除\s

\w：匹配所有单词字符，数字，英文字母，_

\W：除\w

-：表示范围

^：表示求否

正则表达式的数量标识符有三种模式，默认贪婪模式（一直匹配）勉强模式（以?结尾,匹配最少字符) 占有模式（以 + 结尾)

13. 通过Pattern和Matcher使用正则表达式

Pattern对象是正则表达式编译后在内存中的表示形式，因此，正则表达式字符串应该先被编译成Pattern对象，再利用 Pattern对象创建对应的 Matcher对象，多个 Matcher对象共享一个 Pattern对象

//将一个字符串编译成pattern对象
Pattern p = Pattern.compile("a*b");
//使用Pattern对象创建Matcher对象
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();//true

如果只使用一次 Pattern对象，可以

boolean b = Pattern.matches("a*b", "aaaaab");//true

**Pattern **是不可变类，可以供多个并发线程安全使用
Matcher类常用方法

• **find()😗*返回目标字符串是否包含于 Pattern 匹配的子串
• **matches()😗*返回整个目标字符串与 Pattern 是否匹配
• group(): 返回上一次与 Pattern匹配的子串
• **reset()😗*将现有的matcher对象应用于一个新的字符序列

public class FindGroup_ {
    public static void main(String[] args) {
        String str = "电话1：13500006666,电话2：18292900758，电话3：13611125565，电话4：15899903312";
        //创建一个Pattern对象，建立一个 Matcher对象
        //抓取 13X和15X的电话号
        Matcher matcher = Pattern.compile("((13\\d)|(15\\d))\\d{8}").matcher(str);
        //输出所有符合正则表达式的子串
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

String类也提供 **matches()**方法，用于返回该字符串是否匹配指定的正则表达式

"kongyeeku@163.com".matches("\\w{3,20}@\\w+\\.(com|org|cn|net|gov)");//返回true

14. 程序国际化的思路

获取java所支持的国家和语言

        Locale[] availableLocales = Locale.getAvailableLocales();
        for(int i = 0;i < availableLocales.length;i++){
            System.out.println(availableLocales[i].getDisplayCountry() + "=" + 											availableLocales[i].getCountry() + " "
                    			+ availableLocales[i].getDisplayLanguage() + "=" + 										availableLocales[i].getLanguage());
        }

15. 程序国际化

Java 9 开始，Java支持使用 UTF-8字符集保存属性文件，注意属性文件必须显式保存为 UTF-8字符集

ResourceBundle类有一个静态方法 getBundle(String baseName, Locale locale):，该方法将根据 Locale加载资源文件, Locale 封装了一个国家，语言，可以通过 **Locale.getDefault(Locale.Category.FORMAT）**获取系统默认的国家/语言环境，而文件的 baseName都相同，加载时环境取决于 Locale，加载了该文件之后，该资源文件对应的内容就是多个 key-value，程序根据 key获取 value信息，就可以达到转换语言的目的