第七章.Java基础类库

运行Java程序的参数：

　　//Java程序入口：

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

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

　　　　static修饰符：JVM调用这个方法时，JVM直接通过该类来调用主方法，因此使用static修饰该主方法

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

　　　　args参数：运行的Java命令参数。

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

使用Scanner获取键盘输入：

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

　　Scanner提供两个方法来扫描输入：

　　　　1.hasNextXxx()：是否还有下一个输入项。若只是判断是否包含下一个字符串，则直接使用hasNext()

　　　　2.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提供两个方法逐行读取：

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

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

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.hasNextLine()){
            //输出输入项
            System.out.println("键盘输入的内容是：" + sc.nextLine());
        }
    }
}

　　Scanner读入文件：

import java.util.Scanner;
import java.io.File;

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类来调用这些类变量和类方法。

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

　　　　下面程序通过System类来访问操作的环境变量和系统属性：

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

结果太多，没办法截图，自己运行一遍。

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

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对象。

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());
    }
}

　　　　Runtime类还可以单独启动一个进程来运行操作系统命令：

public class ExecTest{
    public static void main(String[] args) throws Exception{
        Runtime rt = Runtime.getRuntime();
        //运行记事本程序
        rt.exec("notepad.exe");
    }
}

常用类：

　　Object类：

　　　　Object类时所有类、数组、枚举类的父类，默认继承Object父类

　　　　Object类常用方法：

　　　　　　1.boolean equals(Object obj)：判断指定对象和该对象是否相等。此处相等标准是，两个对象是同一个对象。

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

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

　　　　　　4.int hashCode()：返回该对象的hashCode()值。默认情况下，Object类的hashCode()方法根据该对象的地址来计算。

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

　　　　　　　对象的toString()方法返回该对象的字符串表示。Object类的toString()方法返回“运行时类名@十六进制hashCode值”格式的字符串。

　　　　　　6.Object clone()：帮助其他对象实现“自我克隆”，得到当前对象的一个副本，而且两者之间完全隔离。由于Object类的clone()方法使用了protected修饰，所以只能被

　　　　　　　子类重写或调用

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

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

　　　　　　　　上面程序User类实现了Cloneable接口，而且实现了clone()方法。克隆出来的对象只是原有对象的副本，所以u1 == u2为false

　　　　　　　　Object类提供的Clone机制只对对象里各实例进行“简单复制”，若实例变量类型是引用类型，Object的Clone机制也只是简单的复制这个引用变量，这样原有对象的

　　　　　　　　引用类型的实例变量与克隆对象的引用类型的实例变量依然指向内存中的同一个实例。所以u1.address == u2.address为true

Java7新增的Objects类：

　　Objects工具类，提供一些工具方法来操作对象，这些工具大多是“空指针”安全的。如：若不能确定一个引用变量是否为null，贸然调用该变量的toString()方法，则可能引

　　发NullPointerException异常。但若使用Objects类的toString(Object o)方法就不会引发空指针异常，当o为null时，程序将返回一个“null”字符串。

import java.util.Objects;

public class ObjectsTest{
    //定义了一个obj变量，它的默认值是null
    static ObjectsTest obj;
    public static void main(String[] args){
        //输出一个null对象的hashCode值，输出0
        System.out.println(Objects.hashCode(obj));
        //输出一个null对象的toString，输出null
        System.out.println(Objects.toString(obj));
        //要求obj不能为null，若obj为null则引发异常
        System.out.println(Objects.requireNonNull(obj, "obj参数不能为null！"));
    }
}

　　String、StringBuffer和StringBuilder类：

　　　　String类是不可变类，即一旦一个String对象被创建，包含在这个对象的字符序列是不可以被改变的，直至这个对象被销毁。

　　　　StringBuffer对象则代表一个字符序列可变得字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等

　　　　方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。

　　　　JDK1.5新增了StringBuilder类，也代表字符串对象，实际上，StringBuilder和StringBuffer基本相似，StringBuffer是线程安全的，StringBuilder没有实现线程安全。一般优先

　　　　考虑使用StringBuilder类。

　　　　三者都实现了CharSequence接口。

　　　　String类的方法：

　　　　　　1.char charAt(int index)：获取字符串中指定位置的字符。字符串序数从0到length() - 1；

　　　　　　2.int compateTo(String anotherString)：比较两个字符串的大小。若两个字符串字符序列相等，返回0；不相等，从两个字符串第0个字符开始比较，返回第一个不相

　　　　　　　等的字符差。另一种情况，较长字符串的前面部分恰巧是较短的字符串，则返回它们的长度差：

class StringCompareTest{
    public static void main(String[] args){
        String s1 = new String("abcdefghijklmn");
        String s2 = new String("abcdefghij");
        String s3 = new String("abcdefghijalmn");
        System.out.println("s1.compareT(s2)：" + s1.compareTo(s2));//返回长度差
        
        System.out.println("s1.compareTo(s3)：" + s1.compareTo(s3));//返回'k' - 'a'的差
    }
}

　　　　　　3.String concat(String str)：将该String对象与str连接在一起。

　　　　　　4.boolean contentEquals(StringBuffer sb)：将该String对象与StringBuffer对象sb进行比较，当它们包含的字符序列相同时返回true

　　　　　　5.static String copyValueOf(char[] data)：将字符数组连缀成字符串。

　　　　　　6.static String copyValueof(char[] data, int offset, int count)：将char数组的子类数组中的元素连缀成字符串。

　　　　　　7.boolean endsWith(String suffix)：返回该String对象是否以suffix结尾

　　　　　　8.boolean equals(Object anObject)：将该字符串与指定对象比较，若二者包含字符序列相等，则返回true，否则返回false

　　　　　　9.boolean equalsIgnoreCase(String str)：与前一个基本相似，只是忽略大小写。

　　　　　　10.byte[] getBytes()：将该String对象转换成byte数组

　　　　　　11.void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：该方法将字符串中从srcBegin开始，到srcEnd结束的字符复制到dst字符数组中，其中dstBegin

　　　　　　　为目标字符数组的起始复制位置。

　　　　　　12.int indexOf(int ch)：找出ch字符在该字符串中第一次出现的位置

　　　　　　13.int indexOf(int ch, int fromIndex)：找出ch字符在该字符串中从fromIndex开始后第一次出现的位置

　　　　　　14.int indexOf(String str)：找出str子字符在该字符串中第一次出现的位置

　　　　　　15.int indexOf(String str, int fromIndex)：找出str子字符串在该字符串中从fromIndex开始后第一次出现的位置　　　

　　　　　　16.int lastIndexOf(int ch)：找出ch字符在该字符串中最后一次出现的位置

　　　　　　17.int lastIndexOf(int ch, int fromIndex)：找出ch字符在该字符串中从fromIndex开始后最后一次出现的位置

　　　　　　18.int lastIndexOf(String str)：找出str子字符在该字符串中最后一次出现的位置

　　　　　　19.int lastIndexOf(String str, int fromIndex)：找出str子字符串在该字符串中从fromIndex开始后最后一次出现的位置

　　　　　　20.int length()：返回当前字符串长度

　　　　　　21.String replace(char oldChar, char newChar)：将字符串中的第一个oldChar替换成newChar

　　　　　　22.boolean startsWith(String prefix)：该String对象是否以prefix开始

　　　　　　23.boolean startsWith(String prefix, String toffset)：该String对象从toffset位置算起，是否以prefix开始

　　　　　　24.subString(int beginIndex)：获取从beginIndex位置开始到结束的子字符串

　　　　　　25.subString(int beginIndex, int endIndex)：获取从beginIndex位置开始到endIndex位置的子字符串

　　　　　　26.char[] toCharArray()：将该String对象转换成char数组

　　　　　　27.String toLowerCase()：将字符串转换成小写

　　　　　　28.String toUpperCase()：将字符串转换成大写

　　　　　　29.static String valueOf(X x)：一系列用于将基本类型转换为String对象的方法

public class StringBuilderTest{
    public static void main(String[] args){
        StringBuilder sb = new StringBuilder();
        //追加字符串
        sb.append("java");//sb = "java"
        //插入
        sb.insert(0, "hello ");//sb = "hello java"
        //替换
        sb.replace(5, 6, ",");//sb = "hello,java"
        //删除
        sb.delete(5, 6);//sb = "hellojava"
        //反转
        sb.reverse();//sb = "avajolleh"
        System.out.println(sb);
        System.out.println(sb.length());//输出9
        System.out.println(sb.capacity());//输出16
        //改变StringBuilder的长度，将只保留前面部分
        sb.setLength(5);//sb = "avajo";
        System.out.println(sb);
    }
}

　　Math类：

　　　　Math类构造器被定义成private的，因此无法创建Math类的对象；Math类的所有方法都是类方法，可以通过类名调用。

　　　　Math类提供了两个类变量：PI和E，值分别是圆周率和log底数e

　　　　自行查阅API。

　　Java7的ThreadLocalRandom和Random

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

　　　　ThreadLocalRandom类是Java7新增的类，是Random类的增强版。在并发访问的环境下，使用TreadLocalRandom来代替Random可以减少多线程资源竞争，最终保证

　　　　　系统具有更好的线程安全

import java.util.Random;
import java.util.Arrays;

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);
        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对象产生相同的数字序列，通常推荐使用当前时间作为Random对象的种子：

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

　　　　ThreadLocalRandom的用法：

　　　　ThreadLocalRandom rand = ThreadLocalRandom.current();//获取一个ThreadLocalRandom对象

　　　　//生成一个4~20之间的为随机数

　　　　int val1 = rand.nextInt(4, 20);

　　　　//生成一个2.0~10.0之间的伪随机浮点数

　　　　int val2 = rand.nextDouble(2.0, 10.0);

　　BigDecimal类：

　　　　为了精确表示、计算浮点数，Java提供了BigDecimal类

import java.math.BigDecimal;

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的构造器，若必须使用double浮点数作为BigDecimal构造器参数时，通过BigDecimal.valueOf(double value)静态方法来创建BigDecimal对象。

　　　　若程序中要求对double浮点数进行加、减、乘、除基本运算，则需要先将double类型包装成BigDecimal对象，调用BigDecimal的方法执行运算后再将结果转换成double型

　　　　　变量。这是比较繁琐的过程，可以考虑以BigDecimal为基础定义一个Arithmetic工具类：

import java.math.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, BigDecimal.ROUND_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));
    }
}

　　Java8的日期、时间类：

　　　　Date类：一般不用了，只举一个例子：

import java.util.Date;

public class DateTest{
    public static void main(String[] args){
        Date d1 = new Date();
        //获取当前时间之后100ms的时间
        Date d2 = new Date(System.currentTimeMillis() + 100);
        System.out.println(d2);
        System.out.println(d1.compareTo(d2));
        System.out.println(d1.before(d2));
    }
}

　　　　Calendar类：

　　　　　　Calendar类本身是一个抽象类，它是所有日历类的模板，并提供了一些所有日历通用的方法；但它本身不能直接实例化，程序只能创建Calendar子烈的实例。

//创建一个默认的Calendar对象
Calendar calendar = Calendar.getInstance();
//从Calendar对象中取出Date对象
Date date = calendar.getTime();
//通过Date对象获得对应的Calendar对象
//因为Calendar/GregorianCalendar没有构造器函数可以接收Date对象
//所以必须先获得一个Calendar实例，然后调用其setTime()方法
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(date);

　　　　　　Calendar类中的方法：

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

　　　　　　　　2.int get(int field)：返回指定日历字段的值

　　　　　　　　3.int getActualMaximum(int field)：返回指定日历字段可能拥有的最大值。如：月，最大值为11

　　　　　　　　4.int getActualMinimum(int field)：返回指定日历字段可能拥有的最小值。如：月，最小值为0

　　　　　　　　5.void roll(int field, int amout)：与add()方法类似，区别在于加上amount后超过了该字段所能表示的最大范围时，也不会向上一个字段进位。

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

　　　　　　　　7.void set(int year, int month, int date)：设置Calendar对象的年、月、日三个字段的值

　　　　　　　　8.void set(int year, int month, int date, int hourOfDay, int minute, int second)：设置年、月、日、时、分、秒6个字段的值

　　　　　　　　Calendar.YEAR、Calendar.MONTH等分别代表年、月、日、小时、分钟、秒等。Calender.MONTH：月份的起始值是0，所以设置8月时，用7

import java.util.Calendar;

public class CalendarTest{
    public static void main(String[] args){
        Calendar c = Calendar.getInstance();
        //取出年
        System.out.println(c.get(Calendar.YEAR));
        //取出月份
        System.out.println(c.get(Calendar.MONTH));
        //取出日
        System.out.println(c.get(Calendar.DATE));
        //分别设置年月日时分秒
        c.set(2003, 10, 23, 12, 32, 23);//2003-11-23 12:32:23
        System.out.println(c.getTime());
        //将Calendar的年前推1年
        c.add(Calendar.YEAR, -1);//2002-11-23 12:32:23
        System.out.println(c.getTime());
        //将Calendar的月前推12个月
        c.roll(Calendar.MONTH, -13);//2002-10-23 12:32:23
        System.out.println(c.getTime());
    }
}

　　　　　　　　Calendar类的容错性：

　　　　　　　　　　调用Calendar对象的set()方法改变指定时间字段的值时，有可能传入一个不合法的参数，如：为MONTH字段设置13：

import java.util.Calendar;

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

　　　　　　　　set()方法延迟修改：

import java.util.Calendar;

public class LazyTest{
    public static void main(String[] args){
        Calendar cal = Calendar.getInstance();
        cal.set(2003, 7, 31);// 2003-08-31
        //将月份设为9，但9月31日不存在
        //若立即修改，系统将会把查了自动调整到10月1日
        cal.set(Calendar.MONTH, 8);
        //下面代码输出10月1日
        //System.out.println(cal.getTime());
        //设置DATE字段为5
        cal.set(Calendar.DATE, 5);
        System.out.println(cal.getTime());
    }
}

　　　　　　　　　　set(f, value)方法将日历字段f更改为value，尽管f立即更改，但该Calendar所代表的时间不会立即修改，知道下次调用get()、getTime()、getTimeInMillis()、

　　　　　　　　　　　add()或roll()时才会重新计算日历时间

　　Java8新增的日期、时间包：

　　　　Java8专门新增了一个java.time包，该包下有如下类：

　　　　　　1.Clock：该类用于获取指定时区的当前日期、时间。该类可取代System类的currentTimeMillis()方法，且提供了更多方法来获取当前日期、时间。

　　　　　　2.Duration：该类代表持续时间。很方便获取一段时间

　　　　　　3.Instant：代表一个具体的时刻，可以精确到纳秒。该类提供了静态的now()方法来获取当前时刻，也提供了静态的now(Clock clock)方法获取clock对应的日期。除此

　　　　　　　之外，提供了minusXxx()方法在当前时刻基础上减去一段时间，plusXxx()方法在当前时刻基础上加上一段时间。

　　　　　　4.LocalDate：该类代表不带时区的日期，如：2017-08-08.

　　　　　　5.LocalTime：该类代表不带时区的时间，如：10:15:30.

　　　　　　6.LocalDateTime：该类代表不带时区的日期、时间，如：2017-08-08 10:15:30.

　　　　　　7.MonthDay：该类仅代表月日，如：--08-08.

　　　　　　8.Year：该类仅代表年，如：2017.

　　　　　　9.YearMonth：该类仅代表年月，如：2017-08

　　　　　　10.ZonedDateTime：该类代表一个时区化的日期、时间。

　　　　　　11.ZoneId：该类代表一个时区。

　　　　　　12.DayOfWeek：这是一个枚举类，定义了周一到周日的枚举值

　　　　　　13.Month：这也是一个枚举类，定义了一月到十二月的枚举值。

import java.time.*;

public class NewDatePackageTest{
    public static void main(String[] args){
        //------下面是关于Clock的用法------
        //获取当前Clock
        Clock 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秒，返回新的Clock
        Clock 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分钟），返回新的Instant
        Instant 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 = instant.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小时3分钟
        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);
        //根据指定月份获取YearMonth
        YearMonth 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-X，代表几月几日
        //设置为5月23日
        MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);
        System.out.println("5月23日为：" + md2);//输出--05-23
    }
}

　　正则表达式：

　　　　正则表达式是一个强大的字符串处理工具，可以对字符串进行查找、提取、分割、替换等操作。

　　　　String类中也提供了以下几个特殊方法：

　　　　　　1.boolean matches(String regex)：判断该字符串是否匹配指定的正则表达式

　　　　　　2.String replaceAll(String regex, String replacement)：将该字符串中所有匹配regex的子串替换成replacement。

　　　　　　3.String replaceFirst(String regex, String replacement)：将该字符串中第一个匹配regex的子串替换成replacement

　　　　　　4.String[] split(String regex)：以regex作为分隔符，把该字符串分割成多个子串

　　　　java还提供了Pattern类和Matcher类专门用于提供正则表达式支持

d是digit的意思，代表数字；s是space的意思，代表空白；w是Word的意思，代表单词。

　　　　使用正则表达式：

　　　　　　可以导入Pattern类和Matcher类，使用正则表达式

　　　　　　Pattern对象是正则表达式编译后在内存中的表示形式，因此，正则表达式字符串必须先被编译为Pattern对象，然后再利用该Pattern对象创建对应的Matcher对象。执

　　　　　　　行匹配所涉及的状态保留在Matcher对象中，多个Match而对象可共享同一个Pattern对象

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

　　　　　　Pattern是不可变类，可供多个并发线程安全使用

　　　　　　Matcher类提供了几个常用方法：

　　　　　　　　1.find()：返回目标字符串中是否包含与Pattern匹配的子串

　　　　　　　　2.group()：返回上一次与Pattern匹配的子串

　　　　　　　　3.start()：返回上一次与Pattern匹配的子串在目标字符串中开始的位置

　　　　　　　　4.end()：返回上一次与Pattern匹配的子串在目标字符串中的结束位置加1

　　　　　　　　5.lookingAt()：返回目标字符串前面部分与Pattern是否匹配

　　　　　　　　6.matches()：返回整个目标字符串与Pattern是否匹配

　　　　　　　　7.reset()：将现有的Matcher对象应用于一个新的字符序列

　　　　　　　　通过Matcher类的find()和group()方法可以从目标字符串中依次取出特定子串：

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class FindGroup{
    public static void main(String[] args){
        //使用字符串模拟从网络上得到的网页源码
        String str = "我想求购译本《疯狂Java讲义》，尽快联系我13500006666" + "交朋友，电话号码是13611125565" + "出售二手电脑，联系方式15899903312";
        //创建一个Pattern对象，并用它建立一个Matcher对象
        //该正则表达式只抓取13X和15X段的手机号
        //实际要抓取哪些电话号码，只要修改正则表达式即可
        Matcher m = Pattern.compile("((13\\d)|(15\\d))\\d{8}").matcher(str);
        //将所有符合正则表达式的传（电话号码）全部输出
        while(m.find()){
            System.out.println(m.group());
        }
    }
}

　　　　　　　　从运行结果看，find()方法依次查找字符串中与Pattern匹配的子串，一旦找到对应的子串，下次调用find()方法时将接着向下查找。

　　　　　　　　find()方法还可以传入一个int类型的参数，带int参数的find()方法将从该int索引处向下搜索。

　　　　　　　　start()和end()方法主要用于确定子串在目标字符串中的位置：

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class StartEnd{
    public static void main(String[] args){
        //创建一个Pattern对象，并用它建立一个Matcher对象
        String regStr = "Java is very easy!";
        System.out.println("目标字符串是：" + regStr);
        Matcher m = Pattern.compile("\\w+").matcher(regStr);
        while(m.find()){
            System.out.println(m.group() + "子串的起始位置：" + m.start() + "，其结束位置：" + m.end());
        }
    }
}

　　　　　　　　matches()和lookingAt()方法相似，matches()方法要求整个字符串和Pattern完全匹配时才返回true，而lookingAt()只要字符串以Pattern开头就会返回true。

　　　　　　　　reset()方法可将现有的Matcher对象应用于新的字符序列。

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class MatchesTest{
    public static void main(String[] args){
        String[] mails = {
            "kongyeeku@163.com",
            "kongyeeku@gmail.com",
            "ligang@crazyit.org",
            "wawa@abc.xx"
        };
        String mailRegEx = "\\w{3,20}@\\w+\\.(com|org|cn|net|gov)";
        Pattern mailPattern = Pattern.compile(mailRegEx);
        Matcher matcher = null;
        for(String mail : mails){
            if(matcher == null){
                matcher = mailPattern.matcher(mail);
            }else{
                matcher.reset(mail);
            }
        String result = mail + (matcher.matches() ? "是" : "不是") + "一个有效的邮件地址！";
        System.out.println(result);
        }
    }
}

　　　　　　　　利用正则表达式对目标字符串进行分割、查找、替换等操作：

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class ReplaceTest{
    public static void main(String[] args){
        String[] msgs = {
            "Java has regular expressions in 1.4",
            "regular expressions now expressing in Java",
            "Java represses oracular expressions"
        };
        Pattern p = Pattern.compile("re\\w*");
        Matcher matcher = null;
        for(int i = 0; i < msgs.length; i++){
            if(matcher == null){
                matcher = p.matcher(msgs[i]);
            }else{
                matcher.reset(msgs[i]);
            }
            System.out.println(matcher.replaceAll("哈哈:)"));
        }
    }
}

　　　　　　　　String类也提供了replaceAll()、replaceFirst()、split()方法：

import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.Arrays;

public class StringReg{
    public static void main(String[] args){
        String[] msgs = {
            "Java has regular expressions in 1.4",
            "regular expressions now expressing in Java",
            "Java represses oracular expressions"
        };
        for(String msg : msgs){
            System.out.println(msg.replaceFirst("re\\w*", "哈哈:)"));
            System.out.println(Arrays.toString(msg.split(" ")));
        }
    }
}

 　　国际化与格式化：

　　　　Java国际化的思路：

　　　　　　Java程序的国际化主要通过如下三个类完成：

　　　　　　　　1.java.util.ResourceBundle：用于加载国家、语言资源包

　　　　　　　　2.java.util.Locale：用于封装特定的国家/区域、语言环境

　　　　　　　　3.java.text.MessageFormat：用于格式化带占位符的字符串

　　　　Java支持的国家和语言：

　　　　　　若需要获取Java所支持的国家和语言，则调用Locale类的getAvailableLocales()方法，该方法返回一个Locale数组，该数组中包含了Java所支持的国家和语言

import java.util.Locale;

public class LocaleList{
    public static void main(String[] args){
        //返回Java所支持的全部国家和语言的数组
        Locale[] localeList = Locale.getAvailableLocales();
        //遍历数组的每个元素，获取所支持的国家和语言
        for(int i = 0; i < localeList.length; i++){
            //输出所支持的国家和语言
            System.out.println(localeList[i].getDisplayCountry() + "=" + localeList[i].getCountry() + " " + localeList[i].getDisplayLanguage() + "=" + localeList[i].getLanguage());
        }
    }
}

书中的完成程序国际化不知道该怎样做，等我上网搜索之后，在修改。

　　　　使用MessageFormat处理包含占位符的字符串：