Prism代码语法高亮

第6章 Java API

学习目标

掌握字符串类的使用,能够熟练使用String类和StringBuffer类定义字符串变量并对字符串进行操作
熟悉System类与Runtime类的使用,能够说出System类与Runtime类的常用方法及其作用
掌握Math类和Random类的使用,能够熟练使用Math类和Random类解决程序中的运算问题
掌握BigInteger类和BigDecimal类的使用,能够熟练使用BigInteger类和BigDecimal类解决程序中的大数运算问题
掌握日期与时间类的使用,能够使用日期与时间类操作日期与时间
掌握日期与时间格式化类的使用,能够使用日期与时间格式化类对日期与时间字符串进行格式化
熟悉NumberFormat类的使用,能够正确使用NumberFormat类对数字进行格式化
熟悉包装类的使用,能够说出Java中的基本数据类型对应的包装类
掌握正则表达式的使用,能够编写正则表达式解决程序中的字符串校验问题

1. 字符串类

1.1 String类

String类对象进行初始化的方式

(1) 使用字符串常量直接初始化一个String对象

String 变量名 = 字符串;

package cn.ls.ch06;
public class Ex00_ls {
    public static void main(String[] args) throws Exception{
        System.out.println("【例00】使用字符串常量直接初始化一个String对象 (柳帅)");
        String str1 = null;   //将字符串str1设置为空
        String str2 = "";     //将字符串str2设置为空字符串
        String str3 = "abc"; //将字符串str3设置为abc
        String str4 = "中华人民共和国"; //将字符串str4设置为 中华人民共和国
        System.out.println(str1);
        System.out.println("cc" + str2 + "dd");
        System.out.println(str3);
        System.out.println(str4);
        System.out.println("Hello World".length());
        System.out.println("中华人民共和国".length());
    }
}

字符串(常量)一旦被创建，其内容就不能再改变。

字符串变量(String)创建后，其内容可以改变，但是变量中保存的是地址，不是内容。

        String s = "hello";    //定义了一个类型为String的字符串s，并将其初始化为hello。
        s = "helloworld";      //为字符串s重新赋值为"helloworld"。

(2) 调用String类的构造方法初始化字符串对象

String 变量名 = new String([字符串]);

package cn.ls.ch06;
public class Ex01_ls {
    public static void main(String[] args) throws Exception{
        System.out.println("【例01】String类的常见构造方法 new String(...) (柳帅)");
        // 创建一个空字符串 ""
        String str1 = new String();
        // String str1 = "";  //创建一个空字符串
        // 创建一个内容为abcd的字符串
        String str2 = new String("abcd");
        // String str2 = "abcd";  //替换为实参
        // 创建一个字符数组
        char[] charArray = new char[] { '中', '国', '人', '民' };
        String str3 = new String(charArray);
        // 创建一个字节数组
        byte[] arr = {97,98,99};
        String str4 = new String(arr);
        System.out.println("aa" + str1 + "bb");
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }
}

1.2 String类的常用方法

(1) 获取字符串长度以及访问字符串中的字符

方法声明	功能描述
int length()	返回当前字符串的长度，即字符串中字符的个数。
int indexOf(int ch)	返回指定字符ch在字符串中第一次出现位置的索引。
int lastIndexOf(int ch)	返回指定字符ch在字符串中最后一次出现位置的索引。
int indexOf(String str)	返回指定子字符串str在字符串第一次出现位置的索引。
int lastIndexOf(String str)	返回指定子字符串str在此字符串中最后一次出现位置的索引。
char charAt(int index)	返回字符串中index位置上的字符，其中index的取值范围是0~(字符串长度-1)。
boolean endsWith(String suffix)	判断此字符串是否以指定的字符串结尾。

package cn.ls.ch06;
public class Ex02_ls {
    public static void main(String[] args) {
        System.out.println("【例02】获取字符串长度以及访问字符串中的字符(柳帅)");
        String s = "ababcdedcba"; // 定义字符串s
        // 获取字符串长度，即字符个数
        System.out.println("字符串的长度为：" + s.length());
        System.out.println("字符串中第一个字符:" + s.charAt(0));
        System.out.println("字符c第一次出现的位置:" + s.indexOf('c'));
        System.out.println("字符c最后一次出现的位置:" + s.lastIndexOf('c'));
        System.out.println("子字符串ba第一次出现的位置：" + s.indexOf("ba"));
        System.out.println("子字符串ab字符串最后一次出现的位置：" +
                s.lastIndexOf("ab"));
    }
}

(2) 字符串的转换操作

方法声明	功能描述
boolean contains(CharSequence cs)	判断此字符串中是否包含指定的字符序列cs。
String toLowerCase()	使用默认语言环境的规则将String中的所有字符都转换为小写。
String toUpperCase()	使用默认语言环境的规则将String中的所有字符都转换为大写。
static String valueOf(int i)	将int变量i转换成字符串。
char[] toCharArray()	将此字符串转换为一个字符数组。
String replace(CharSequence oldstr, CharSequence newstr)	使用newstr替换原字符串中的oldstr，返回一个新的字符串。
String concat(String str)	将str连接到当前字符串对象之后。

package cn.ls.ch06;
public class Ex03_ls {
    public static void main(String[] args) {
        System.out.println("【例03】字符串的转换操作(柳帅)");
        String str = "abcd";
        System.out.print("将字符串转为字符数组后的结果:");
        char[] charArray = str.toCharArray();     // 字符串转换为字符数组
        for (int i = 0; i < charArray.length; i++) {
            if (i != charArray.length - 1) {
                // 如果不是数组的最后一个元素,在元素后面加逗号
                System.out.print(charArray[i] + ",");
            } else {
                //如果不是数组的最后一个元素,则在元素后不加逗号
                System.out.println(charArray[i]);
            }
        }
        System.out.println("将int值转换为String类型之后的结果:" +
                String.valueOf(12));
        System.out.println("将字符串转换成大写之后的结果:" +
                str.toUpperCase());
        System.out.println("将字符串转换成小写之后的结果:" +
                str.toLowerCase());
    }
}

(3) 字符串的替换和去除空格操作

package cn.ls.ch06;
public class Ex04_ls {
    public static void main(String[] args) {
        System.out.println("【例04】字符串的替换和去除空格操作(柳帅)");
        String s = "itcast";
        // 字符串替换操作
        System.out.println("将it替换成cn.it的结果:" + s.replace("it",
                "cn.it"));
        // 字符串去除空格操作
        String s1 = "     i t c a s t     ";
        System.out.println("去除字符串两端空格后的结果:" + s1.trim());
        System.out.println("去除字符串中所有空格后的结果:" + s1.replace(" ",
                ""));
    }
}

(4) 字符串判断

方法声明	功能描述
boolean equals(Object obj)	比较obj与当前字符串对象的内容是否相同。
boolean equalsIgnoreCase(String str)	以忽略大小写的方式比较str与当前字符串对象的内容是否相同。
int compareTo(String str)	按对应字符的Unicode编码比较str与当前字符串对象的大小。若当前字符串对象比str大，返回正整数；若比str小，返回负整数；若相等则返回0。
int compareToIgnoreCase(String str)	按对应字符的Unicode编码以忽略大小写的方式比较str与当前字符串对象的大小。若当前字符串对象比str大，返回正整数；若比str小，返回负整数；若相等则返回0。
boolean isEmpty()	判断字符串长度是否为0，如果为0则返回true，反之则返回flase。
boolean startsWith(String prefix)	判断此字符串是否以指定的字符串prefix开始。

package cn.ls.ch06;
public class Ex05_ls {
    public static void main(String[] args) {
        System.out.println("【例05】字符串判断(柳帅)");
        String s1 = "String"; // 定义一个字符串
        String s2 = "string";
        String s3 = s1;
        String s4 = "String"; // 定义一个字符串
        System.out.println("判断s1字符串对象是否以Str开头:" +
                s1.startsWith("Str"));
        System.out.println("判断s1是否以字符串ng结尾:" + s1.endsWith("ng"));
        System.out.println("判断s1是否包含字符串tri:" + s1.contains("tri"));
        System.out.println("判断s1字符串是否为空:" + s1.isEmpty());
        System.out.println("判断s1和s2是否相同 ==:" + (s1 == s2));
        System.out.println("判断s1和s3是否相同 ==:" + (s1 == s3));
        System.out.println("判断s1和s4是否相同 ==:" + (s1 == s4));
        System.out.println("判断s1和s2内容是否相同:" + s1.equals(s2));
        System.out.println("判断s1和s4内容是否相同:" + s1.equals(s4));
        System.out.println("忽略大小写的情况下判断s1和s2内容是否相同:" +
                s1.equalsIgnoreCase(s2));
        System.out.println("按对应字符的Unicode比较s1和s2的大小:" +
                s1.compareTo(s2));
    }
}

注意：==和equals()方法的区别

equals()方法用于比较两个字符串内容是否相等，==方法用于比较两个字符串对象的地址是否相同。

package cn.ls.ch06;
public class Ex05_ls_ {
    public static void main(String[] args) {
        System.out.println("【例05】== 和 .equals() (柳帅)");
        String str1 = new String("abc");
        String str2 = new String("abc");
        /*使用==判断的结果为false，因为
         *str1和str2是两个对象，地址不同*/
        System.out.println(str1 == str2);
        /*使用equals判断的结果为true，
         *因为str1和str2字符内容相同*/
        System.out.println(str1.equals(str2));
    }
}

(5) 字符串的截取和分割操作

方法声明	功能描述
String[] split(String regex)	根据参数regex将原来的字符串分割为若干个子字符串。
String substring(int beginIndex)	返回一个新字符串，它包含从指定的beginIndex处开始，直到此字符串末尾的所有字符。
String substring(int beginIndex, int endIndex)	返回一个新字符串，它包含从指定的beginIndex处开始，直到索引endIndex-1处的所有字符。
String trim()	去除了原字符串首尾的空格。

package cn.ls.ch06;
public class Ex06_ls {
    public static void main(String[] args) {
        System.out.println("【例06】字符串的截取substring和分割split操作(柳帅)");
        String str = "石家庄-武汉-哈尔滨";
        // 下面是字符串截取操作
        System.out.println("从第5个字符截取到末尾的结果：" +
                str.substring(4));
        System.out.println("从第5个字符截取到第6个字符的结果：" +
                str.substring(4, 6));
        // 下面是字符串分割操作
        System.out.print("分割后的字符串数组中的元素依次为:");
        String[] strArray = str.split("-"); // 将字符串转换为字符串数组
        for (int i = 0; i < strArray.length; i++) {
            if (i != strArray.length - 1) {
                // 如果不是数组的最后一个元素,在元素后面加逗号
                System.out.print(strArray[i] + ",");
            } else {
                // 数组的最后一个元素后面不加逗号
                System.out.println(strArray[i]);
            }
        }
    }
}

字符串索引越界异常

package cn.ls.ch06;
public class Ex07_ls {
    public static void main(String[] args) {
        System.out.println("【例07】 字符串索引越界异常(柳帅)");
        String s = "itcast";
        //String s = "黑马程序员";
        System.out.println(s.charAt(8));
    }
}

1.3 StringBuffer类

在Java中，因为String类是final类型的，所以使用String定义的字符串是一个常量，也就是说使用String定义的字符串一旦创建，其内容和长度是不可改变的。

为了便于对字符串进行修改，Java提供了StringBuffer类（也称字符串缓冲区）来操作字符串。StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或删除字符时，所操作的都是这个字符容器，因此并不会产生新的StringBuffer对象。

StringBuffer类的常用方法

方法声明	功能描述
StringBuffer()	创建初始容量为16，不含任何内容的字符串缓冲区
StringBuffer(int capacity)	创建初始容量为capacity，不含任何内容的字符串缓冲区
StringBuffer(String s)	创建初始容量为s.length()+16，内容为s的字符串缓冲区
int length()	获取缓冲区中字符串内容的长度
int capacity()	获取字符串缓冲区的当前容量
StringBuffer append(char c)	添加参数到StringBuffer对象中
StringBuffer insert(int offset,String str)	在字符串的offset位置插入字符串str
StringBuffer deleteCharAt(int index)	移除此序列指定位置的字符

方法声明	功能描述
StringBuffer delete(int start,int end)	删除StringBuffer对象中指定范围的字符或字符串序列
StringBuffer replace(int start,int end,String s)	在StringBuffer对象中替换指定的字符或字符串序列
void setCharAt(int index, char ch)	修改指定位置index处的字符序列
String toString()	返回StringBuffer缓冲区中的字符串
StringBuffer reverse()	反转字符串
String substring(int start)	获取缓冲区中字符串从索引start（含）至末尾的子串
String substring(int start,int end)	获取缓冲区中字符串从索引start（含）至索引end（不含）的子串
String toString()	获取缓冲区中的字符串

package cn.ls.ch06;
public class Ex08_ls {
    public static void main(String[] args) {
        System.out.println("【例08】 StringBuffer常用操作(柳帅)");
        System.out.println("1.添加------------------------");
        add();
        System.out.println("2.删除------------------------");
        remove();
        System.out.println("3.修改------------------------");
        alter();
        System.out.println("4.截取------------------------");
        sub();
    }
    public static void add() {
        StringBuffer sb = new StringBuffer();           // 定义一个字符串缓冲区
        sb.append("abcdefg");                             // 在末尾添加字符串
        sb.append("hij").append("klmn");                 // 连续调用append()方法添加字符串
        System.out.println("append添加结果：" + sb);
        sb.insert(2, "123");                 // 在指定位置插入字符串
        System.out.println("insert添加结果：" + sb);
    }
    public static void remove() {
        StringBuffer sb = new StringBuffer("abcdefg");
        sb.delete(1, 5);                         // 指定范围删除
        System.out.println("删除指定位置结果：" + sb);
        sb.deleteCharAt(2);                     // 指定位置删除
        System.out.println("删除指定位置结果：" + sb);
        sb.delete(0, sb.length());                 // 清空字符串缓冲区
        System.out.println("清空缓冲区结果：" + sb);
    }
    public static void alter() {
        StringBuffer sb = new StringBuffer("abcdef");
        sb.setCharAt(1, 'p');                    // 修改指定位置字符
        System.out.println("修改指定位置字符结果：" + sb);
        sb.replace(1, 3, "qq");             // 替换指定位置字符串或字符
        System.out.println("替换指定位置字符（串）结果：" + sb);
        System.out.println("字符串翻转结果：" + sb.reverse());
    }
    public static void sub() {
        StringBuffer sb = new StringBuffer();   // 定义一个字符串缓冲区
        System.out.println("获取sb的初始容量：" + sb.capacity());
        sb.append("itcast123");                 // 在末尾添加字符串
        System.out.println("append添加结果：" + sb);
        System.out.println("截取第7~9个字符：" + sb.substring(6,9));
    }
}

StringBuffer类和StringBuilder类：
- 相同：两者可以被多次修改，且不产生新的对象。
- 不同：StringBuffer的方法是线程安全的，而StringBuilder没有实现线程安全功能，所以性能略高。通常情况下，如果创建一个内容可变的字符串对象，应该优先考虑使用StringBuilder类。
(1) String类、StringBuffer类和StringBuilder类：
- String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。
- StringBuilder和StringBuffer表示字符容器，其内容和长度可以随时修改。
- StringBuffer的方法是线程安全的，而StringBuilder没有实现线程安全功能。
- 如果该字符串仅用于表示数据类型，则使用String类即可；
- 如果需要对字符串中的字符进行增删操作，则使用StringBuffer与StringBuilder类。
- 如果有大量字符串拼接操作，并且不要求线程安全的情况下，采用StringBuilder类更高效。
- 如果需要线程安全则需要使用StringBuffer类。
(2) 对于euals()方法：String类重写Object类的equals()方法，但是StringBuffer类与StringBuilder类中并没有重写Object类的equals()方法。
(3) String类对象可以用操作符“+”进行连接，而StringBuffer类和StringBuild类的对象之间不能。

package cn.ls.ch06;
public class Ex08_ls_ {
    public static void main(String[] args) {
        System.out.println("【例08】String、StringBuffer、StringBuilder比较(柳帅)");
        String s1 = new String("abc");
        String s2 = new String("abc");
        StringBuffer sb1 = new StringBuffer("abc");
        StringBuffer sb2 = new StringBuffer("abc");
        StringBuilder sbr1=new StringBuilder("abc");
        StringBuilder sbr2=new StringBuilder("abc");
        // equals方法
        System.out.println(s1.equals(s2));      // 打印结果为true
        System.out.println(sb1.equals(sb2));   // 打印结果为false, StringBuffer对象上存在可疑的equals()调用
        System.out.println(sbr1.equals(sbr2));    //打印结果为false, StringBuilder对象上存在可疑的equals()调用
        // + 运算
        System.out.println(s1+s2);                    // 打印输出 合法
        //StringBuffer sb3 = sb1 + sb2;                 // 编译出错
        //StringBuilder sb让 = sbr1 + sbr2;               // 编译出错
    }
}

2. System类与Runtime类

2.1 System类

熟悉System类，能够说出System类的作用，并使用System类的方法将源数组中的元素复制到目标数组、获取当前系统的时间、获取当前系统的全部属性、进行垃圾回收

System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，

System类的常用方法

方法名称	功能描述
static void exit(int status)	该方法用于终止当前正在运行的Java虚拟机，其中参数status表示状态码，若状态码非0 ，则表示异常终止
static void gc()	运行垃圾回收器，并对内存中的垃圾进行回收
static void currentTimeMillis()	返回以毫秒为单位的当前时间
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)	从src引用的指定源数组的srcPos位置，复制length个元素，到dest引用的数组的destPos位置
static Properties getProperties()	获取当前系统全部属性
static String getProperty(String key)	获取指定键描述的系统属性

(1) arraycopy()方法

static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)

srcPos：表示源数组中复制元素的起始位置，即从哪个位置开始复制元素。
destPos：表示复制到目标数组的起始位置，即复制到目标数组的哪个位置。

package cn.ls.ch06;
public class Ex09_ls {
    public static void main(String[] args) {
        System.out.println("【例09】System.arraycopy()数组复制方法(柳帅)");
        int[] fromArray = { 10, 11, 12, 13, 14, 15 };    // 源数组
        int[] toArray = { 20, 21, 22, 23, 24, 25, 26 }; // 目标数组
        System.arraycopy(fromArray, 2, toArray, 3, 4);  // 复制数组元素
        // 打印复制后数组的元素
        System.out.println("复制后的数组元素为：");
        for (int i = 0; i < toArray.length; i++) {
            System.out.print(toArray[i]+" ");
        }
    }
}

(2) currentTimeMillis()方法

currentTimeMillis()方法用于获取当前系统的时间，返回值类型是long，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间戳（系统当前时间）。

package cn.ls.ch06;
public class Ex10_ls {
    public static void main(String[] args) {
        System.out.println("【例10】System.currentTimeMillis()方法--时间戳(柳帅)");
        long startTime = System.currentTimeMillis();// 循环开始时的当前时间
        int sum = 0;
        for (int i = 0; i < 1000000000; i++) {
            sum += i;
        }
        long endTime = System.currentTimeMillis();// 循环结束后的当前时间
        System.out.println("程序运行的时间为："+(endTime - startTime)+
                "ms");
    }
}

(3) getProperties()和getProperty()方法

System类的getProperties()方法用于获取当前系统的全部属性，该方法会返回一个Properties对象，Properties对象封装了系统的所有属性，这些属性以键值对形式存在。
System类的getProperty()方法可以根据系统的属性名获取对应的属性值。

package cn.ls.ch06;
import java.util.Enumeration;
import java.util.Properties;
public class Ex11_ls {
    public static void main(String[] args) {
        System.out.println("【例11】System.getProperties()和getProperty()方法(柳帅)");
        // 获取当前系统属性
        Properties properties = System.getProperties();
        // 获取所有系统属性的key，返回Enumeration对象
        Enumeration propertyNames = properties.propertyNames();
        while (propertyNames.hasMoreElements()) {
            // 获取系统属性的键key
            String key = (String) propertyNames.nextElement();
            // 获取当前键key对应的值value
            String value = System.getProperty(key);
            System.out.println(key + "--->" + value);
        }
    }
}

图13 System.getProperties()和getProperty()

(4) gc()方法

在Java中，一个对象如果不再被任何栈内存所引用，该对象就称为垃圾对象。垃圾对象会占用内存空间，时间一长，垃圾对象越来越多，就会导致内存空间不足。针对这种情况，Java引入了垃圾回收机制。除了等待Java虚拟机进行自动垃圾回收外，还可以通过调用System.gc()方法通知Java虚拟机立即进行垃圾回收。

package cn.ls.ch06;
class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    //    System.out.println("对象被创建-->"+this);
    }
    @Override
    public String toString() {
        return "姓名:"+this.name+"，年龄:"+this.age;
    }
    // 下面定义的finalize()方法会在垃圾回收前被调用
    public void finalize() throws Throwable {
        System.out.println("对象被释放-->"+this);
    }
}

public class Ex12_ls{
    public static void main(String[] args){
        System.out.println("【例12】System.gc()方法--立即进行垃圾回收(柳帅)");
        // 下面是创建Person对象
       Person p = new Person("张三",20);
        // 下面将变量置为null，让对象p成为垃圾
        p = null;
        // 调用方法进行垃圾回收
        System.gc();
        for (int i = 0; i < 10000000; i++) {
            // 为了延长程序运行的时间，执行空循环
        }
    }
}

2.2 Runtime类

熟悉Runtime类的使用，能够说出Runtime类的常用方法及其作用，并使用Runtime类的方法获取当前虚拟机信息、操作系统进程

Runtime类用于封装JVM虚拟机进程，通过Runtime类，可以获取虚拟机运行时状态。每一个JVM都对应着一个Runtime类的实例。在JDK文档中读者不会发现任何有关Runtime类构造方法的定义，这是因为Runtime类本身的构造方法是私有化的(单例设计模式)，若想在程序中获取一个Runtime类实例，只能通过调用getRuntime()方法获取，getRuntime()方法是Runtime类提供的一个静态方法，用于获取Runtime类实例。

Runtime rt = Runtime.getRuntime();

Runtime类的常用方法

方法名称	功能描述
getRuntime()	用于获取Runtime类的实例
exec(String command)	用于根据指定的路径执行对应的可执行文件
freeMemory()	用于返回Java虚拟机中的空闲内存量，以字节为单位
maxMemory()	用于返回Java虚拟机的最大可用内存量
availableProcessors()	用于返回当前虚拟机的处理器个数
totalMemory()	用于返回Java虚拟机中的内存总量

(1) 获取当前JVM虚拟机信息

package cn.ls.ch06;
public class Ex13_ls {
    public static void main(String[] args) {
        System.out.println("【例13】Runtime类: 获取当前JVM的信息(柳帅)");
        Runtime rt = Runtime.getRuntime(); // 创建Runtime对象
        System.out.println("处理器的个数: " + rt.availableProcessors()+"个");
        System.out.println("空闲内存数量: " + rt.freeMemory() / 1024 / 1024
                + "MB");
        System.out.println("最大可用内存数量: " + rt.maxMemory() / 1024 /
                1024 + "MB");
        System.out.println("内存总容量: " + rt.totalMemory() / 1024 /
                1024 + "MB");
    }
}

(2) 操作系统进程

Runtime类中提供了一个exec()方法，该方法用于执行一个DOS命令，exec()方法的执行效果与DOS命令的效果相同。

package cn.ls.ch06;
import java.io.IOException;
public class Ex14_ls {
    public static void main(String[] args) throws IOException {
        System.out.println("【例14】Runtime 打开外部可执行程序(柳帅)");
        Runtime rt = Runtime.getRuntime();              // 创建Runtime实例对象
        rt.exec("notepad.exe c:\\新建文本文件.txt");               // 调用exec()方法
    }
}

package cn.ls.ch06;
import java.io.IOException;
public class Ex14_ls_ {
    public static void main(String[] args) throws IOException, InterruptedException {
        System.out.println("【例14_】Runtime 打开外部可执行程序,30秒后自动关闭进程(柳帅)");
        Runtime rt = Runtime.getRuntime();  // 创建一个Runtime实例对象
        Process process = rt.exec("notepad.exe");//得到表示进程的Process对象
        Thread.sleep(30000); // 程序休眠30秒
        process.destroy();  //关闭进程
    }
}

3. Math类、Random类和BigInteger类

3.1 Math类

Math类是一个工具类，类中包含许多用于进行科学计算的方法，如计算一个数的平方根、绝对值或获取一个随机数等。因为Math类构造方法的访问权限是private，所以无法创建Math类的对象。Math类中所有方法都是静态方法，可以直接通过类名调用Math类中的方法。除静态方法外，Math类中还定义了两个静态常量PI和E，分别代表数学中的π和e。

Math类的常用方法

方法声明	功能描述
abs(double a)	用于计算a的绝对值
sqrt(double a)	用于计算a的方根
ceil(double a)	用于计算大于a的最小整数，并将该整数转化为double型数据。例如Math.ceil(15.2)的值是16.0
floor(double a)	用于计算小于a的最大整数，并将该整数转化为double型数据。例如Math.ceil(-15.2)的值是-16.0
round(double a)	用于计算小数a进行四舍五入后的值
max(double a,double b)	用于返回a和b的较大值
min(double a,double b)	用于返回a和b的较小值
random()	用于生成一个大于0.0小于1.0的随机值（包括0不包括1）
sin(double a)	返回a的正弦值
asin(double a)	返回a的反正弦值
pow(double a,double b)	用于计算a的b次幂，即ab的值

package cn.ls.ch06;
public class Ex15_ls {
    public static void main(String[] args) {
        System.out.println("【例15】Math类介绍(柳帅)");
        System.out.println("计算-10的绝对值: " + Math.abs(-10));
        System.out.println("求大于5.6的最小整数: " + Math.ceil(5.6));
        System.out.println("求小于-4.2的最大整数: " + Math.floor(-4.2));
        System.out.println("对-4.6进行四舍五入: " + Math.round(-4.6));
        System.out.println("求2.1和-2.1中的较大值: " + Math.max(2.1, -2.1));
        System.out.println("求2.1和-2.1中的较小值: " + Math.min(2.1, -2.1));
        System.out.println("生成一个大于等于0.0小于1.0随机值: " +
                Math.random());
        System.out.println("计算1.57的正弦结果: "+Math.sin(1.57));
        System.out.println("计算4的开平方的结果: "+Math.sqrt(4));
        System.out.println("计算指数函数2的3次方的值: "+Math.pow(2, 3));
    }
}

3.2 Random类

Random类可以产生指定取值范围的随机数字。Random类提供了两个构造方法

方法声明	功能描述
Random()	使用当前机器时间创建一个Random对象
Random(long seed)	使用参数seed指定的种子创建一个Random对象

(1) 无参构造方法来产生随机数 -- 每次运行都不一样

package cn.ls.ch06;
import java.util.Random;
public class Ex16_ls {
    public static void main(String[] args) {
        System.out.println("【例16】Random类1 产生10个[0,100)之间的整数(柳帅)");
        Random random = new Random(); // 不传入种子
        // 随机产生10个[0,100)之间的整数
        for (int x = 0; x < 10; x++) {
            System.out.print(random.nextInt(100)+"  ");
        }
    }
}

没有指定种子，系统会以当前时间戳作为种子，产生随机数。由于每一时刻的时间戳都不一样，所以每一次运行时，产生的随机数也不一样。

(2) 有参(种子)构造方法来产生随机数 -- 每次运行都一样

package cn.ls.ch06;
import java.util.Random;
public class Ex17_ls {
    public static void main(String[] args) {
        System.out.println("【例17】Random类2 产生10个[0,100)之间的整数--传入种子(柳帅)");
        Random r = new Random(13); // 创建对象时传入种子
        // 随机产生10个[0,100)之间的整数
        for (int x = 0; x < 10; x++) {
            System.out.print(r.nextInt(100)+"  ");
        }
    }
}

(3) 生成不同类型的随机数

Random类的常用方法

方法声明	功能描述
boolean nextBoolean()	随机生成boolean类型的随机数
double nextDouble()	随机生成double类型的随机数
float nextFloat()	随机生成float类型的随机数
long nextLong()	随机生成long类型的随机数
int nextInt()	随机生成int类型的随机数
int nextInt(int n)	随机生成[0~n)之间int类型的随机数

package cn.ls.ch06;
import java.util.Random;
public class Ex18_ls {
    public static void main(String[] args) {
        System.out.println("【例18】Random类3 生成不同类型的随机数(柳帅)");
        Random r = new Random(); // 创建Random实例对象
        System.out.println("生成boolean类型的随机数: " + r.nextBoolean());
        System.out.println("生成float类型的随机数: " + r.nextFloat());
        System.out.println("生成double类型的随机数:" + r.nextDouble());
        System.out.println("生成int类型的随机数:" + r.nextInt());
        System.out.println("生成0~100之间int类型的随机数:" +
                r.nextInt(100));
        System.out.println("生成long类型的随机数:" + r.nextLong());
    }
}

4. BigInteger类与BigDecimal类

4.1 BigInteger类

BigInteger类处理大整数。定义在java.math包。BigInteger类型可以表示任意长度的整数，但是它的计算速度相对较慢。

long类型的取值范围是从-9,223,372,036,854,775,808（-2⁶³）到9,223,372,036,854,775,807（2⁶³-1）。922亿亿，19位十进制。

BigInteger类中常用的基本运算方法

方法声明	功能描述
BigInteger(String val)	将字符串val变为BigInteger类型的数据
BigInteger add(BigInteger val)	返回当前对象与val的和
BigInteger subtract(BigInteger val)	返回当前对象与val的差
BigInteger multiply(BigInteger val)	返回当前对象与val的积
BigInteger divide(BigInteger val)	返回当前对象与val的商

BigInteger类中常用的基本运算方法

方法声明	功能描述
BigInteger max(BigInteger val)	返回当前对象与val之中的较大值
BigInteger min(BigInteger val)	返回当前对象与val之中的较小值
BigInteger[] divideAndRemainder(BigInteger val)	除法操作，计算当前对象/val的结果，返回一个数组，数组的第1个元素为商，第2个元素为余数

package cn.ls.ch06;
import java.math.BigInteger;
public class Ex19_ls {
    public static void main(String[] args) {
        System.out.println("【例19】BigInteger类介绍(柳帅)");
        BigInteger bi1 = new BigInteger("12345678901234567890");  // 创建BigInteger对象
        BigInteger bi2 = new BigInteger("98765432109876543210");  // 创建BigInteger对象
        System.out.println("bi2与bi1的和: " + bi2.add(bi1));
        System.out.println("bi2与bi1的差: " + bi2.subtract(bi1));
        System.out.println("bi2与bi1的积: " + bi2.multiply(bi1));
        System.out.println("bi2与bi1的商: " + bi2.divide(bi1));
        System.out.println("bi2与bi1之间的较大值: " + bi2.max(bi1));
        System.out.println("bi2与bi1之间的较小值: " + bi2.min(bi1));
        //创建BigInteger数组接收bi2除以bi1的商和余数
        BigInteger result[] = bi2.divideAndRemainder(bi1);
        System.out.println("bi2除以bi1的商: " + result[0]+
                ":bi2除以bi1的余数："+result[1]);
    }
}

4.2 BigDecimal类十进制精确计算

Java提供了BigDecimal类。BigDecimal类可以表示任意精度的小数，多用于数字精度要求高的场景，例如商业计算、货币值计算等。

BigDecimal类中常用的方法

方法声明	功能描述
BigDecimal BigDecimal(String val)	将字符串val转为BigDecimal类型的数据
static BigDecimal valueOf(double d)	将double类型的数据转为BigDecimal类型的数据
BigDecimal add(BigDecimal val)	返回当前对象与val的和
BigDecimal subtract(BigDecimal val)	返回当前对象与val的差
BigDecimal multiply(BigDecimal val)	返回当前对象与val的积
BigDecimal divide(BigDecimal val)	返回当前对象与val的商
BigDecimal max(BigDecimal val)	返回当前对象与val之中的较大值
BigDecimal min(BigDecimal val)	返回当前对象与val之中的较小值

package cn.ls.ch06;
import java.math.BigDecimal;
public class Ex20_ls {
    public static void main(String[] args) {
        System.out.println("【例20】BigDecimal类介绍--十进制精确计算(柳帅)");
        BigDecimal bd1 = new BigDecimal("1234567890.023451");  // 创建BigDecimal对象
        BigDecimal bd2 = BigDecimal.valueOf(4);// 创建BigDecimal对象
        System.out.println("bd1: " + bd1);
        System.out.println("bd2: " + bd2);
        System.out.println("bd2与bd1的和: " + bd2.add(bd1));
        System.out.println("bd2与bd1的差: " + bd2.subtract(bd1));
        System.out.println("bd2与bd1的积: " + bd2.multiply(bd1));
        System.out.println("bd1与bd2的商: " + bd1.divide(bd2));
        System.out.println("bd2与bd1之间的较大值: " + bd2.max(bd1));
        System.out.println("bd2与bd1之间的较小值: " + bd2.min(bd1));
    }
}

5. 日期和时间类

5.1 Date类

DK的java.util包提供了一个Date类用于表示日期和时间：

Date()：用于创建当前日期时间的Date对象。
Date(long date)：用于创建指定时间的Date对象，其中date参数表示1970年1月1日0时0分0（称为历元）以来的毫秒数，即时间戳。

java.util.Date并不表示日期，他表示时间的一个瞬间，并且精度为秒。

package cn.ls.ch06;
import java.util.Date;
public class Ex21_ls {
    public static void main(String[] args) {
        System.out.println("【例21】当前时间的Date对象(柳帅)");
        // 创建表示当前时间的Date对象
        Date date1 = new Date();
        // 获取当前时间后1秒的时间
        Date date2 = new Date(System.currentTimeMillis() + 1000);
        System.out.println("当前时间: "+date1);
        System.out.println("当前时间1秒后: "+date2);
    }
}

5.2 Calendar类

calendar 英 [ˈkælɪndə(r)] 日历

Calendar类也用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分、秒等。

Calendar类是一个抽象类，不可以被实例化，如果想在程序中获取一个Calendar实例，则需要调用Calendar类的静态方法getInstance()。

Calendar calendar = Calendar.getInstance();

instance 英 [ˈɪnstəns] 例子，实例;

Calendar类的常用方法

方法声明	功能描述
int get(int field)	返回指定日历字段field的值
void add(int field,int amount)	根据日历规则，为指定的日历字段增加或减去指定的时间量
void set(int field,int value)	将指定日历字段field的值设置为value
void set(int year,int month,int date)	设置Calendar对象的年、月、日三个字段的值
void set(int year.int month,int date,int hourOfDay,int minute,int second)	设置Calendar对象的年、月、日、时、分、秒六个字段的值

package cn.ls.ch06;
import java.util.Calendar;
public class Ex22_ls {
    public static void main(String[] args) {
        System.out.println("【例22】当前时间的Calendar对象(柳帅)");
        // 获取表示当前时间的Calendar对象
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);       // 获取当前年份
        int month = calendar.get(Calendar.MONTH) + 1; // 获取当前月份
        int date = calendar.get(Calendar.DATE);       // 获取当前日
        int hour = calendar.get(Calendar.HOUR);       // 获取时
        int minute = calendar.get(Calendar.MINUTE);   // 获取分
        int second = calendar.get(Calendar.SECOND);   // 获取秒
        System.out.println("当前时间为:" + year + "年 " + month + "月 "
                + date + "日 "+ hour + "时 " + minute + "分 " + second + "秒");
    }
}

package cn.ls.ch06;
import java.util.Calendar;
public class Ex23_ls {
    public static void main(String[] args) {
        System.out.println("【例23】当前时间的Calendar对象的set|add方法(柳帅)");
        // 获取表示当前时间的Calendar对象
        Calendar calendar = Calendar.getInstance();
        // 设置指定日期
        calendar.set(2021, 1, 1);
        // 为指定日期增加时间
        calendar.add(Calendar.DATE, 100);
        // 返回指定日期的年
        int year = calendar.get(Calendar.YEAR);
        // 返回指定日期的月
        int month = calendar.get(Calendar.MONTH) + 1;
        // 返回指定日期的日
        int date = calendar.get(Calendar.DATE);
        System.out.println("计划竣工日期为:" + year + "年"
                + month + "月" + date + "日");
    }
}

5.3 Instant类

Instant 类代表的是某个瞬间的时间。其内部由两个部分组成，第一部分保存的是标准Java计算时代（就是1970年1月1日开始）到现在的秒数，第二部分保存的是纳秒数。

instant 英 [ˈɪnstənt] 瞬息; (某一)时刻

Instant类常用的方法

方法声明	功能描述
Instant.now()	从系统时钟获取当前瞬间的时间。
Instant.now(Clock clock)	从指定时钟获取当前时刻。
Instant.ofEpochSecond(long epochSecond)	使用从自标准Java计算时代开始的秒数获取一个Instant的实例。
Instant.ofEpochMilli(long epochMilli)	从1970-01-01T00:00:00Z的纪元中使用毫秒获取Instant的实例。
Instant.getEpochSecond()	从1970-01-01T00:00:00Z的Java时代获取秒数。
Instant.getNano()	用于从第二秒开始在此瞬间表示的时间轴中返回纳秒数。
Instant.parse(CharSequence text)	从一个时间文本字符串（如2007-12-03T10:15:30.00Z）获取一个Instant的实例。
fInstant.rom(TemporalAccessor tenporal)	从时间对象获取一个Instant的实例。

epoch 英 [ˈiːpɒk] 时代，纪元;

package cn.ls.ch06;
import java.time.Instant;
public class Ex24_ls {
    public static void main(String[] args) {
        System.out.println("【例24】Instant类的静态方法(柳帅)");
        //  Instant 类的时间戳类从1970-01-01 00:00:00 截止到当前时间的毫秒值
        Instant now = Instant.now();
        System.out.println("从系统获取的当前时刻为："+now);
        Instant instant = Instant.ofEpochMilli(1000 * 60 * 60 * 24);
        System.out.println("计算机元年增加1000 * 60 * 60 * 24毫秒数后为："
                +instant);
        Instant instant1 = Instant.ofEpochSecond(60 * 60 * 24);
        System.out.println("计算机元年增加60 * 60 * 24秒数后为："
                +instant1);
        System.out.println("2007-12-03T10:15:30.44Z 获取的秒值为："
                +Instant.parse("2007-12-03T10:15:30.44Z").getEpochSecond());
        System.out.println("2007-12-03T10:15:30.44Z 获取的纳秒值为："
                +Instant.parse("2007-12-03T10:15:30.44Z").getNano());
        System.out.println("从时间对象获取的Instant实例为："+
                Instant.from(now));
    }
}

5.4 LocalDate类

local 英 [ˈləʊkl] 本地的

LocalDate类表示不带时区的日期，它所表示的日期包括年份和月份两部分。LocalDate类不能代表时间线上的即时信息，只是描述日期。

LocalDate类获取日期对象的方法

// 按指定日期创建LocalDate对象
 LocalDate date = LocalDate.of(2020, 12, 12);
// 从默认时区的系统时钟获取当前日期
LocalDate now1 = LocalDate.now();

LocalDate类的常用方法(对象方法)：日期格式化、增减年月日等

方法声明	功能描述
getYear()	获取年份字段
getMonth()	使用Month枚举获取月份字段
getMonthValue()	获取当前日期的月份
getDayOfMonth()	获取当月第几天字段
format(DateTimeFormatter formatter)	使用指定的格式化程序格式化此日期
isBefore(ChronoLocalDate other)	检查此日期是否在指定日期之前
isAfter(ChronoLocalDate other)	检查此日期是否在指定日期之后
isEqual(ChronoLocalDate other)	检查此日期是否等于指定的日期
isLeapYear()	根据ISO培训日历系统规则，检查年份是否是闰年
parse(CharSequence text)	从一个文本字获取一个 LocalDate的实例
parse(CharSequence text, DateTimeFormatter formatter)	使用特定格式格式化 LocalDate从文本字符串获取的 LocalDate实例
plusYears(long yearsToAdd)	增加指定年份
plusMonths(long monthsToAdd)	增加指定月份
plusDays(long daysToAdd)	增加指定日数
minusYears(long yearsToSubtract)	减少指定年份
minusMonths(long monthsToSubtract)	减少指定月份
minusDays(long daysToSubtract)	减少指定日数
withYear(int year)	指定年
withMonth(int month)	指定月
withDayOfYear(int dayOfYear)	指定日

package cn.ls.ch06;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class Ex25_ls {
    public static void main(String[] args) {
        System.out.println("【例25】LocalDate类(不带时区的日期)：日期格式化和增减年月日(柳帅)");
        //获取日期时分秒
        LocalDate now = LocalDate.now();
        LocalDate of = LocalDate.of(2015, 12, 12);
        System.out.println("1. LocalDate的获取及格式化的相关方法--------");
        System.out.println("从LocalDate实例获取当前的年份是："+now.getYear());
        System.out.println("从LocalDate实例获取当前的月份是："
                +now.getMonthValue());
        System.out.println("从LocalDate实例获取当天为本月的第几天："
                +now.getDayOfMonth());
        System.out.println("将获取到的Loacaldate实例格式化后是："
                +now.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));
        System.out.println("2. LocalDate判断的相关方法----------------");
        System.out.println("判断日期of是否在now之前："+of.isBefore(now));
        System.out.println("判断日期of是否在now之后："+of.isAfter(now));
        System.out.println("判断日期of和now是否相等："+now.equals(of));
        System.out.println("判断日期of是否是闰年："+ of.isLeapYear());
        //给出一个符合默认格式要求的日期字符串
        System.out.println("3. LocalDate解析以及加减操作的相关方法---------");
        String dateStr="2020-02-01";
        System.out.println("把日期字符串解析成日期对象的结果是："
                +LocalDate.parse(dateStr));
        System.out.println("将LocalDate实例年份加1后的结果是："
                +now.plusYears(1));
        System.out.println("将LocalDate实例天数减10后的结果是："
                +now.minusDays(10));
        System.out.println("将LocalDate实例的年份设置为2014后的结果是："
                +now.withYear(2014));
    }
}

5.5 LocalTime类与LocalDateTime类

小目标：

掌握LocalTime类与LocalDateTime类，能够使用这两个类获取时间对象、时间格式化、增减时分秒，以及日期时间转换

(1) LocalTime类 (类同LocalDate)

LocalTime类用来表示时间，通常表示的是小时分钟秒，没有时区概念只是时间的描述。

LocalTime类中提供了获取时间对象的方法，也提供了时间格式化、增减时分秒等常用方法。

package cn.ls.ch06;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
public class Ex26_ls {
    public static void main(String[] args) {
        System.out.println("【例26】LocalTime类(不带时区的时间)：时间格式化(柳帅)");
        // 获取当前时间，包含毫秒数
        LocalTime time = LocalTime.now();
        LocalTime of = LocalTime.of(9,23,23);
        System.out.println("从LocalTime获取的小时为："+time.getHour());
        System.out.println("将获取到的LoacalTime实例格式化为："+
                time.format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        System.out.println("判断时间of是否在now之前："+of.isBefore(time));
        System.out.println("将时间字符串解析为时间对象后为："+
                LocalTime.parse("12:15:30"));
        System.out.println("从LocalTime获取当前时间，不包含毫秒数："+
                time.withNano(0));
    }
}

(2) LocalDateTime类

LocalDateTime类是LocalDate类与LocalTime类的综合，它既包含日期也包含时间(描述性日期和时间)。不含时区，描述性日期和时间。

package cn.ls.ch06;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Ex27_ls {
    public static void main(String[] args) {
        System.out.println("【例27】当地日期时间LocalDateTime的获取、转换和格式化(柳帅)");
        //获取系统当前年月日时分秒
        LocalDateTime now = LocalDateTime.now();
        System.out.println("获取的当前日期时间为:"+now);
        System.out.println("将目标LocalDateTime转换为相应的LocalDate实例:"+
                now.toLocalDate());
        System.out.println("将目标LocalDateTime转换为相应的LocalTime实例:"+
                now.toLocalTime());
        //指定格式
        DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern
                ("yyyy年MM月dd日 HH时mm分ss秒");
        System.out.println("格式化后的日期时间为:"+now.format(ofPattern));
    }
}

5.6 lsration类与Period类

(1) lsration类

lsration 英 [djuˈreɪʃn] 持续时间; 期间

lsration类表示两个时间之间的间隔，间隔时间的单位可以是天、时、分、秒、毫秒和纳秒

lsration类的常用方法

方法声明	功能描述
between(Temporal startInclusive, Temporal endExclusive)	获取一个lsration实例，表示两个时间对象之间的持续时间
toDays()	将间隔时间转换为以天为单位
toHours()	将间隔时间转换为以时为单位
toMinutes()	将间隔时间转换为以分钟为单位
toMillis()	将间隔时间转换为以毫秒为单位
toNanos()	将间隔时间转换为以纳秒为单位

package cn.ls.ch06;
import java.time.lsration;
import java.time.LocalTime;
public class Ex28_ls {
    public static void main(String[] args) {
        System.out.println("【例28】lsration类(间隔)的常用方法 (柳帅)");
        LocalTime start = LocalTime.now();
        LocalTime end = LocalTime.of(20,13,23);
        lsration lsration = lsration.between(start, end);
        //间隔的时间
        System.out.println("时间间隔为："+lsration.toNanos()+"纳秒");
        System.out.println("时间间隔为："+lsration.toMillis()+"毫秒");
        System.out.println("时间间隔为："+lsration.toHours()+"小时");
    }
}

(2) Period类

period 英 [ˈpɪəriəd] 一段时间; 阶段; 时期;

Period类主要用于计算两个日期的间隔，与lsration类相同，Period类也是通过between()方法计算日期间隔，并提供了获取年月日的三个常用方法，分别是 getYears()、getMonths()和getDays()。

package cn.ls.ch06;
import java.time.LocalDate;
import java.time.Period;
public class Ex29_ls {
    public static void main(String[] args) {
        System.out.println("【例29】Period类(间隔)的常用方法(柳帅)");
        LocalDate birthday = LocalDate.of(2018, 12, 12);
        LocalDate now = LocalDate.now();
        //计算两个日期的间隔
        Period between = Period.between(birthday, now);
        System.out.println("时间间隔为"+between.getYears()+"年");
        System.out.println("时间间隔为"+between.getMonths()+"月");
        System.out.println("时间间隔为"+between.getDays()+"天");
    }
}

6. 日期与时间格式化类

6.1 DateFormat类

小目标

掌握DateFormat类，使用DateFormat类对日期和时间进行格式化

尽管使用java.util.Date类能够获取日期和时间，但是因为其显示格式与日常使用的日期格式不同，因此，Java提供了DateFormat类，DateFormat类可以将日期时间进行格式化，使日期时间的格式符合人们的阅读习惯。DateFormat是一个抽象类，不能被直接实例化，但它提供了一系列用于获取DateFormat类实例的静态方法，并能调用其他相应的方法进行操作。

DateFormat类的常用方法

方法声明	功能描述
static DateFormat getDateInstance()	用于创建默认语言环境和格式化风格的日期格式器
static DateFormat getDateInstance(int style)	用于创建默认语言环境和指定格式化风格的日期格式器
static DateFormat getDateTimeInstance()	用于创建默认语言环境和格式化风格的日期/时间格式器
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle)	用于创建默认语言环境和指定格式化风格的日期/时间格式器
String format(Date date)	将一个 Date 格式化为日期/时间字符串
Date parse(String source)	将给定字符串解析成一个日期

DateFormat类的4个常量值

FULL：用于表示完整格式的日期时间。
LONG：用于表示长格式的日期时间。
MEDIUM：用于表示普通格式的日期时间。
SHORT：用于表示短格式的日期时间。

package cn.ls.ch06;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
public class Ex30_ls {
    public static void main(String[] args) throws ParseException {
        System.out.println("【例30】 DateFormat类的常用方法(柳帅)");
        // 创建Date对象
        Date date = new Date();
        // Full格式的日期格式器对象
        DateFormat fullFormat =
                DateFormat.getDateInstance(DateFormat.FULL);
        // LONG格式的日期格式器对象
        DateFormat longFormat =
                DateFormat.getDateInstance(DateFormat.LONG);
        // MEDIUM格式的日期/时间 格式器对象
        DateFormat mediumFormat = DateFormat.getDateTimeInstance(
                DateFormat.MEDIUM, DateFormat.MEDIUM);
        // SHORT格式的日期/时间格式器对象
        DateFormat shortFormat = DateFormat.getDateTimeInstance(
                DateFormat.SHORT, DateFormat.SHORT);
        // 打印格式化后的日期或者日期/时间
        System.out.println("当前日期的完整格式为："
                + fullFormat.format(date));
        System.out.println("当前日期的长格式为："
                + longFormat.format(date));
        System.out.println("当前日期的普通格式为："
                + mediumFormat.format(date));
        System.out.println("当前日期的短格式为："
                + shortFormat.format(date));
    }
}

DateFormat类还提供了一个parse()方法，该方法能将一个字符串解析成Date对象

package cn.ls.ch06;
import java.text.DateFormat;
import java.text.ParseException;
public class Ex31_ls {
    public static void main(String[] args) throws ParseException {
        System.out.println("【例31】DateFormat类的parse()方法--解析字符串为Date(柳帅)");
        // 创建LONG格式的DateFormat对象
        DateFormat dt = DateFormat.getDateInstance(DateFormat.LONG);
        // 定义日期格式的字符串
        String str = "2021年05月20日";
        // 输出对应格式的字符串解析成Date对象后的结果
        System.out.println(dt.parse(str));
    }
}

6.2 SimpleDateFormat类

simple 英 [ˈsɪmpl] 简单的;

小目标

掌握SimpleDateFormat类，能够使用SimpleDateFormat类根据日期模板格式化日期

SimpleDateFormat类是DateFormat类的子类，它可以使用new关键字创建实例对象。在创建实例对象时，SimpleDateFormat类的构造方法需要接收一个表示日期格式模板的字符串参数，日期格式模板通过特定的日期标记可以将一个日期格式的日期数字提取出来。

日期格式化模板标记

标记	功能描述
y	年，年份是4位数字，使用yyyy表示
M	月份，月份是两位数字，使用MM表示
d	天，天数是两位数字，使用dd表示
H	小时（24小时），小时是两位数字，使用HH表示
m	分钟，分钟是两位数字，使用mm表示
s	秒，秒是两位数字，使用ss表示
S	毫秒，毫秒是3位数字，使用SSS表示

SimpleDateFormat类常用的方法

标记	功能描述
SimpleDateFormat(String pattern)	通过一个指定的模板构造对象
Date parse(String source) throws ParseException	将一个包含日期的字符串变为Date类型
String format(Date date)	将一个Date类型对象按照指定格式变为String类型

package cn.ls.ch06;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Ex32_ls {
    public static void main(String[] args) {
        System.out.println("【例32】使用SimpleDateFormat类将日期对象转为特定格式的字符串(柳帅)");
        // 创建一个SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        // 按SimpleDateFormat对象的日期模板格式化Date对象
        System.out.println(sdf.format(new Date()));
    }
}

图34 使用SimpleDateFormat类将日期对象转为特定格式的字符串/figcaption>

package cn.ls.ch06;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Ex33_ls {
    public static void main(String[] args) throws ParseException {
        System.out.println("【例33】使用SimpleDateFormat类将特定格式的字符串转为Date日期对象(柳帅)");
        String strDate = "2021-03-02 17:26:11.234";     //定义日期时间的字符串
        String pat = "yyyy-MM-dd HH:mm:ss.SSS";         //定义日期时间的模板
        // 创建一个SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat(pat);
        // 将一个包含日期/时间的字符串格式化为Date对象
        Date d = sdf.parse(strDate);
        System.out.println(d);
    }
}

图35 使用SimpleDateFormat类将特定格式的字符串转为Date日期对象/figcaption>

7. 数字格式化类

NumberFormat类可以格式化和解析任何区域设置的货币、财务数字格式，使数字的格式符合人们的阅读习惯。NumberFormat类是一个抽象类，不能被直接实例化，但是它提供了一系列用于获取NumberFormat类实例的静态方法，并能调用其他相应的方法进行操作。

umberFormat类的常用方

方法声明	功能描述
static NumberFormatgetCurrencyInstance()	返回当前默认FORMAT语言环境的货币格式
static NumberFormatgetCurrencyInstance(Locale i)	返回指定语言环境的货币格式
static NumberFormat getInstance()	返回当前默认FORMAT语言环境的通用数字格式
static NumberFormatgetInstance(Locale i)	返回指定语言环境的通用数字格式
String format(double number)	将给定的double类型的数值格式化为数值字符串
String format(long number)	将给定的long类型的数值格式化为数值字符串
Number parse(String source)	将给定的字符串解析，生成对应的数值

package cn.ls.ch06;
import java.text.NumberFormat;
import java.util.Locale;
public class Ex34_ls {
    public static void main(String[] args) {
        System.out.println("【例34】NumberFormat类可以格式化和解析任何区域设置的货币、财务数字格式(柳帅)");
        double price = 18.01;   //定义货币
        int number = 1000010000;//定义数字
        //按照当前默认语言环境的货币格式显示
        NumberFormat nf = NumberFormat.getCurrencyInstance();
        System.out.println("按照当前默认语言环境的货币格式显示："
                + nf.format(price));
        //按照指定的语言环境的货币格式显示
        nf = NumberFormat.getCurrencyInstance(Locale.US);
        System.out.println("按照指定的语言环境(Locale.US)的货币格式显示："
                + nf.format(price));
        //按照当前默认语言环境的数字格式显示
        NumberFormat nf2 = NumberFormat.getInstance();
        System.out.println("按照当前默认语言环境的数字格式显示："
                + nf2.format(number));
        //按照指定的语言环境的数字格式显示
        nf2 = NumberFormat.getInstance(Locale.US);
        System.out.println("按照指定的语言环境(Locale.US)的数字格式显示："
                + nf.format(number));
    }
}

图36 NumberFormat类可以格式化和解析任何区域设置的货币、财务数字格式

8. 包装类

Java中的基本数据类型对应的包装类

基本数据类型	对应的包装类
byte	Byte
char	Character
int	Integer
short	Short
long	Long
float	Float
double	Double
boolean	Boolean

Number类

除了Character和Boolean是Object的直接子类外，Integer、Byte、Float、Double、Short、Long都属于Number类的子类。Number类是一个抽象类，其本身提供了一系列的返回以上6种基本数据类型的方法，Number类的方法主要是将数字包装类中的内容变为基本数据类型。

包装类对象转基本类的方法--拆箱

方法	方法描述
byte byteValue()	以byte形式返回指定的数值
abstract double doubleValue()	以double形式返回指定的数值
abstract float floatValue()	以float形式返回指定的数值
abstract int intValue()	以int形式返回指定的数值
abstract long longValue()	以long形式返回指定的数值
short shortValue()	以short形式返回指定的数值

将一个基本数据类型转变为包装类的过程，称为装箱操作，
反之，将一个包装类转变为基本数据类型的过程称为拆箱操作。

package cn.ls.ch06;
public class Ex35_ls {
    public static void main(String[] args) {
        System.out.println("【例35】基本数据类型和包装类：装箱和拆箱(柳帅)");
        int a = 20;                      //声明一个基本数据类型
        Integer in = new Integer(a);     //装箱：将基本数据类型变为包装类
        System.out.println(in);
        int temp = in.intValue();        //拆箱：将一个包装类变为基本数据类型
        System.out.println(temp);
    }
}

返回Xxx实例对象、解析为基本类型(以Integer类为例)

方法		功能描述
Integer Integer.valueOf(int i)	类方法	返回一个表示指定的int值的 Integer 实例
Integer Integer.valueOf(String s)	类方法	返回保存指定的String的值的 Integer 对象
int Integer.parseInt(String s)	类方法	将字符串参数作为有符号的十进制整数进行解析
int intValue()	成员方法	将 Integer 类型的值以int类型返回

package cn.ls.ch06;

public class Ex36_ls {
    public static void main(String[] args) {
        System.out.println("【例36】包装类：valueOf(...),parseXxx(String s),xxxValue()方法 (柳帅)");
        Integer num = new Integer(20);     //手动装箱  -- 构造方法
        int sum = num.intValue() + 10;           //手动拆箱
        System.out.println("将Integer类值转化为int类型后与10求和为："+ sum);
        System.out.println("返回表示10的Integer实例为：" +
                Integer.valueOf(10));
        int w = Integer.parseInt("20")+32;
        System.out.println("将字符串转化为整数位：" + w);
    }
}

图38 包装类：valueOf(...),parseXxx(String s),xxxValue()方法

使用包装类时的注意事项

（1）包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。
（2）除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数创建包装类对象，但参数字符串s不能为null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。
```
Integer i = Integer.valueOf("123");  // 合法
Integer i = Integer.valueOf("12a");   // 不合法，12a不能被正确解析为基本类型数据
```
（3）除了Character外，包装类都有parseXxx(String s)的静态方法，该方法的作用是将字符串转换为对应的基本类型的数据。参数s不能为null，而且同样字符串必须可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会报错。
```
int i = Integer.parseInt("123");    // 合法    
int i = Integer.parseInt("itcast"); // 不合法
```

9. 正则表达式

Java提供了正则表达式，通过正则表达式可以快速校验信息格式。

9.1 正则表达式语法

正则表达式

正则表达式是由普通字符（如字符a~z）和特殊字符（元字符）组成的文本模式，例如，正则表达式“[a-z]*”描述了所有仅包含小写字母的字符串，其中a、z为普通字符，短横线、左右中括号及星号则为元字符。


1	.	点号	匹配除“\n”之外的任何单个字符。
2	[]	中括号	匹配中括号内所有字符中的任意一个。含-指定的范围
3	(\	)	选择	匹配其左侧或右侧的符号。①
4	^	开始	“^”符号可以匹配一行的开始。
5	$	结尾	”$”符号可以匹配一行的结束。
6	\	转义	”\”符号表示其后的字符是普通字符而非元字符。②
7	*+?	次数	匹配次数元字符
8			其他常用符号

①t(a|e|i|io)n匹配tan，ten，tin和tion

②\$用来匹配$字符而非结束

匹配次数元字符

元字符	含义
X*	匹配X出现零次或多次，如Y，YXXXY
X+	匹配X出现一次或多次，如YXY，YXX
X?	匹配X出现零次或一次，如Y，YXY
X{n}	匹配X出现恰好n次
X{n,}	匹配X出现至少出现n次
X{n,m}	n<=m，匹配X出现至少n次，最多m次

其他常用符号

元字符	含义
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾

9.2 Pattern类和Matcher类

熟悉Pattern类与Matcher类，能够使用Pattern类创建一个正则表达式，并通过Matcher类验证字符串是否和 Pattern类定义的正则表达式匹配

pattern 英 [ˈpætn] 模式;

matcher 英 ['mætʃə] 匹配器

(1) Pattern类

Pattern类用于创建一个正则表达式，也可以说创建一个匹配模式。Pattern类的构造方法是私有的，不可以直接创建正则表达式，为此，Pattern类提供了一个静态的complie()方法，通过调用complie()方法可以创建一个正则表达式。

Pattern p = Pattern.compile("\\w+");

Pattern类常用方法

方法声明	功能描述
static Pattern compile(String re)	将正则表达式编译为模式
Matcher matcher(CharSequence input)	根据模式为字符串input创建匹配器。String类实现了CharSequence接口，CharSequence接口可视为String
Static boolean matches(String regex, CharSequence input)	判断字符串input是否匹配正则表达式regex。该方法适合于只进行一次匹配情况
String pattern()	返回模式使用的正则表达式
String[] split(CharSequence input)	根据模式将字符串input分割为字符串数组
String[] split(CharSequence input,int limit)	根据模式将字符串input分割为字符串数组，同时指定了子串的最大个数为limit

package cn.ls.ch06;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Ex37_ls {
    public static void main(String[] args) {
        System.out.println("【例37】Pattern类常用方法(柳帅)");
        Pattern p1 = Pattern.compile("a*b");        //根据参数指定的正则表达式创建模式
        Matcher m1 = p1.matcher("aaaaab");    //获取目标字符串的匹配器
        Matcher m2 = p1.matcher("aaabbb");    //获取目标字符串的匹配器
        System.out.println(m1.matches());           //执行匹配器
        System.out.println(m2.matches());           //执行匹配器
        Pattern p2 = Pattern.compile("[/]+");
        String[] str = p2.split("张三//李四/王五///赵六/钱七"); //按模式分割字符串
        for(String s : str){
            System.out.print(s+"\t");
        }
    }
}

(2) Matcher类

Matcher类用于验证Pattern定义的模式与字符串是否匹配，因此Matcher实例也称为匹配器。Matcher类的构造方法也是私有的，不能直接创建Macher实例，只能通过Pattern.matcher()方法获取该类的实例，多个Matcher对象可以使用同一Pattern对象。

Matcher类常用方法

方法声明	功能描述
Pattern pattern()	返回匹配器的模式
Matcher usePattern(Pattern p)	返回匹配器的模式为p
Matcher reset()	重设匹配器到初始状态
Matcher reset(CharSequence input)	重设匹配器到初始状态，并使用input为目标字符串
Boolean find()	在目标字符串中查找下一个匹配字符串，找到返回true
int start()	正则表达式所匹配的字符串在整个字符串中第一次出现的索引
int end()	正则表达式所匹配的字符串在整个字符串中最后一次出现的索引
String group()	返回匹配到的子字符串
String group(int i)	返回上一次匹配的子串中与第i个组相匹配的那个子串。正则表达式中以一对圆括号括起来的部分称为组
boolean matcher()	对整个字符串进行匹配，只有整个字符串都匹配了才返回true
boolean lookingAt()	从目标字符串的第一个字符开始匹配，有匹配成功的返回true，否则返回false
String replaceAll(String s)	将目标字符串中与模式相匹配的全部子串替换为s并返回替换后的字符串
String replaceFirst(String s)	将目标字符串中与模式相匹配的首个子串替换为s并返回替换后的字符串

package cn.ls.ch06;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Ex38_ls {
    public static void main(String[] args) {
        System.out.println("【例38】 Matcher类常用方法(柳帅)");
        Pattern p=Pattern.compile("\\d+");
        Matcher m=p.matcher("22bb23");
        System.out.println("字符串是否匹配:"+ m.matches());
        Matcher m2=p.matcher("2223");
        System.out.println("字符串2223与模式p是否匹配:"+ m2.matches());
        System.out.println("字符串22bb23与模式p的匹配结果:"+ m.lookingAt());
        Matcher m3=p.matcher("aa2223");
        System.out.println("字符串aa2223与模式p的匹配结果:"+m3.lookingAt());
        System.out.println("字符串22bb23与模式p是否存在下一个匹配结果:"+
                m.find());
        m3.find();//返回true
        System.out.println("字符串aa2223与模式p是否存在在下一个匹配结果："+
                m3.find());
        Matcher m4=p.matcher("aabb");
        System.out.println("字符串aabb与模式p是否存在下一个匹配结果："+
                m4.find());
        Matcher m1=p.matcher("aaa2223bb");
        m1.find();//匹配2223
        System.out.println("模式p与字符串aaa2223bb的匹配的起始索引:"+
                m1.start());
        System.out.println("模式p与字符串aaa2223bb的最后一个字符匹配后的偏移量"+
                m1.end());
        System.out.println("模式p与字符串aaa2223bb的匹配到的子字符串:"+
                m1.group());
        Pattern p2 = Pattern.compile("[/]+");
        Matcher m5 = p2.matcher("张三/李四//王五///赵六");
        System.out.println("将字符串张三/李四//王五///赵六中的/全部替换为|:"+
                m5.replaceAll("|"));
        System.out.println("将字符串张三/李四//王五///赵六中的首个/替换为|:"+
                m5.replaceFirst("|"));
    }
}

9.3 String类对正则表达式的支持

String类提供了3个支持正则表达式操作的方法

方法声明	功能描述
boolean matches(String regex)	匹配字符串regex
String replaceAll(String regex, String replacement)	使用字符串replacement替换regex
String[] split(String regex)	拆分字符串

package cn.ls.ch06;

public class Ex39_ls {
    public static void main(String[] args) {
        System.out.println("【例39】使用String类判断字符串与自定义的模式是否匹配、拆分字符串、替换字符串(柳帅)");
        String str = "A1B22DDS34DSJ9D".replaceAll("\\d+","_");
        System.out.println("字符串替换后为："+str);
        boolean te = "321123as1".matches("\\d+");
        System.out.println("字符串是否匹配："+te);
        String[] s="SDS45d4DD4dDS88D".split("\\d+");
        System.out.print("字符串拆分后为：");
        for(int i=0;i<s.length;i++){
            System.out.print(s[i]+"  ");
        }
    }
}

图41 使用String类判断字符串与自定义的模式是否匹配、拆分字符串、替换字符串

第6章 Java API

学习目标

1. 字符串类

1.1 String类

String类对象进行初始化的方式

(1) 使用字符串常量直接初始化一个String对象

(2) 调用String类的构造方法初始化字符串对象

1.2 String类的常用方法

(1) 获取字符串长度以及访问字符串中的字符

(2) 字符串的转换操作

(3) 字符串的替换和去除空格操作

(4) 字符串判断

注意：==和equals()方法的区别

(5) 字符串的截取和分割操作

字符串索引越界异常

1.3 StringBuffer类

StringBuffer类的常用方法

2. System类与Runtime类

2.1 System类

System类的常用方法

(1) arraycopy()方法

(2) currentTimeMillis()方法

(3) getProperties()和getProperty()方法

(4) gc()方法

2.2 Runtime类

Runtime类的常用方法

(1) 获取当前JVM虚拟机信息

(2) 操作系统进程

3. Math类、Random类和BigInteger类

3.1 Math类

3.2 Random类

(1) 无参构造方法来产生随机数 -- 每次运行都不一样

(2) 有参(种子)构造方法来产生随机数 -- 每次运行都一样

(3) 生成不同类型的随机数

Random类的常用方法

4. BigInteger类与BigDecimal类

4.1 BigInteger类

BigInteger类中常用的基本运算方法

BigInteger类中常用的基本运算方法

4.2 BigDecimal类 十进制精确计算

BigDecimal类中常用的方法

5. 日期和时间类

5.1 Date类

5.2 Calendar类

Calendar类的常用方法

5.3 Instant类

Instant类常用的方法

5.4 LocalDate类

LocalDate类获取日期对象的方法

LocalDate类的常用方法(对象方法)：日期格式化、增减年月日等

5.5 LocalTime类与LocalDateTime类

小目标：

(1) LocalTime类 (类同LocalDate)

(2) LocalDateTime类

5.6 lsration类与Period类

(1) lsration类

lsration类的常用方法

(2) Period类

6. 日期与时间格式化类

6.1 DateFormat类

小目标

DateFormat类的常用方法

DateFormat类的4个常量值

6.2 SimpleDateFormat类

小目标

日期格式化模板标记

SimpleDateFormat类常用的方法

7. 数字格式化类

umberFormat类的常用方

8. 包装类

Java中的基本数据类型对应的包装类

Number类

包装类对象转基本类的方法--拆箱

返回Xxx实例对象、解析为基本类型(以Integer类为例)

使用包装类时的注意事项

9. 正则表达式

9.1 正则表达式语法

正则表达式

匹配次数元字符

其他常用符号

4.2 BigDecimal类十进制精确计算