【Java基础系列教程】第十四章 Java 包装类、日期与日期格式化类、数值格式化等常用类详解

一、包装类

1.1 什么是包装类

        Java中的数据类型分为基本数据类型和引用数据类型，其中基本数据类型是不具有对象特征的，也就是说它们不能像对象一样拥有属性和方法，以及对象化交互。
    
        包装类的产生就是为了解决基本数据类型存在的这样一些问题，通过包装类可以让基本数据类型获取对象一样的特征，行使对象相关的权力。
    
        针对八种基本数据类型定义相应的引用类型—包装类（封装类）,有了类的特点，就可以调用类中的方法，Java才是真正的面向对象。

1.2 基本数据类型与包装类

        所在包: java.lang...

        类的定义:
                byte类型包装类: Byte:
                        public final class Byte 
                                extends Number 
                                implements Comparable
                boolean类型包装类: Boolean
                        public final class Boolean 
                                extends Object 
                                implements Serializable, Comparable
                其他请见文档API:
                ...

1.2.1 特点

        所有包装类都是使用 final 修饰的，不能被继承，其中数值型对应的包装类都是继承自 Number 类。

        包装类是不可变类，包装类的对象被创建后，它所包含的基本类型数据就不能改变。

        抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。Number 的子类必须提供将表示的数值转换为 byte、double、float、int、long 和 short 的方法。 

        byte byteValue()                    以 byte 形式返回指定的数值。 

        abstract double doubleValue()        以 double 形式返回指定的数值。 

        abstract float floatValue()            以 float 形式返回指定的数值。  

        abstract int intValue()                以 int 形式返回指定的数值。 

        abstract long longValue()            以 long 形式返回指定的数值。 

        short shortValue()                    以 short 形式返回指定的数值。 

1.2.2 作用

        作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

        提供每种基本数据类型的相关属性如最大值、最小值等以及相关的操作方法。

1.3 包装类的使用

1.3.1 与基本数据类型的转换

        装箱：基本数据类型包装成包装类的实例，分为自动装箱和手动装箱；
        拆箱：获得包装类对象中包装的基本类型变量，分为自动拆箱和手动拆箱；

        注：JDK1.5之后，支持自动装箱、自动拆箱，但类型必须匹配。

基本数据类型转换为包装类：

public class WrapperClass {
    public static void main(String[] args) {
        /*
         * 以Integer类型为例,来解释装箱和拆箱
         * 其他的都是类似的
         */
        /*
         * 一个数值10,就是基本数据类型int
         * int类型10,对应的包装类是Integer
         * 装箱: 基本数据类型包装成包装类的实例
         */
        int num = 10;
        // 基本数据类型无法调用方法
        // System.out.println(num1.toString());
        
        // 自动装箱
        Integer i1 = num;  // 把基本数据类型值赋值给包装类
        System.out.println(i1.toString());

        // 手动装箱
        Integer i2 = new Integer(num); // 调用构造函数,把基本数据类型转换为包装类
        System.out.println(i2.toString());
        Integer in2 = new Integer("123");
        System.out.println(in2.toString());

        //报异常
        Integer in3 = new Integer("123abc");
        System.out.println(in3.toString());

        Float f1 = new Float(12.3f);
        Float f2 = new Float("12.3");
        System.out.println(f1);
        System.out.println(f2);

        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("TrUe");
        System.out.println(b2);
        Boolean b3 = new Boolean("true123");
        System.out.println(b3);//false


        Order order = new Order();
        System.out.println(order.isMale);//false
        System.out.println(order.isFemale);//null

    }
}

class Order {
    boolean isMale;
    Boolean isFemale;
}

包装类转换为基本数据类型：

public class WrapperClass {
    public static void main(String[] args) {
        /*
         * 拆箱: 获得包装类对象中包装的基本类型变量
         */
        Integer i2 = new Integer(100);

        // 自动拆箱
        int i3 = i2;

        // 手动拆箱
        int i4 = i2.intValue();

        Float f1 = new Float(12.3);
        float f2 = f1.floatValue();
        System.out.println(f2 + 1);
    }
}

1.3.2 与字符串的转换

        基本数据类型转换为字符串:
                使用 String.valueOf(基本类型值)
                        String fstr = String.valueOf(2.34f);

                使用 包装类.toString(基本类型值)

                拼接字符串
                        String intStr = 5 + "";

        字符串转换为基本数据类型、包装类:
                将该字符串封装成了包装类对象 并调用对象的方法valueOf() / 或者直接赋值给基本数据类型变量;
                        int i = new Integer("124");

                使用包装类.parseXxx(numstring); 不用建立对象 直接类名调用

基本数据类型、包装类转换为String类型：

public class WrapperClass {
    public static void main(String[] args) {
        int num1 = 10;
        //方式1：连接运算
        String str1 = num1 + "";

        //方式2：调用String的valueOf(Xxx xxx)
        float f1 = 12.3f;
        String str2 = String.valueOf(f1);
        System.out.println(str2);//"12.3"

        Double d1 = new Double(12.4);
        String str3 = String.valueOf(d1);

        System.out.println(str3);//"12.4"

        //方式3：调用Integer的toString(Xxx xxx)
        int t1 = 2;
        String t2 = Integer.toString(t1);
    }
}

String类型转化为基本数据类型、包装类：

public class WrapperClass {
    public static void main(String[] args) {
        String str = "21";

        //字符串转换为基本数据类型
        //1、包装类的parseXXX()
        int t3 = Integer.parseInt(str);

        //2、包装类的valueOf() 先将字符串转换为包装类，再通过自动拆箱完成基本类型转换
        int t4 = Integer.valueOf(str);
    }
}

1.3.3 整数转成其他进制

        static String toBinaryString(int i)    以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。 

        static String toOctalString(int i)    以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 

        static String toHexString(int i)    以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 

        static Integer valueOf(String s, int radix)    返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。 

1.3.4 总结：基本类型、包装类与String类间的转换

1.4 注意事项

        在jdk1.5版本后，对基本数据类型对象包装类进行升级；在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样进行运算。
                Integer i = new Integer(4); //1.5版本之前的写法
                Integer i = 4; //自动装箱 1.5版本后的写法
                i = i + 5;

        i对象是不能直接和5相加的；其实底层先将i转成int类型，再和5相加，而转成int类型的操作是隐式的自动拆箱: 拆箱的原理就是i.intValue(); i+5运算完是一个int整数 如何赋值给引用类型i呢? 其实又对结果进行装箱；
                Integer c = 127;
                Integer d = 127;
                System.out.println(c == d); //true
                详情见面试题；

1.5 面试题

        如下两个题目输出结果相同吗？各是什么：

 Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);// 1.0

Object o2;
if (true){
    o2 = new Integer(1);
}else{
    o2 = new Double(2.0);
}
System.out.println(o2);// 1

        如下代码的运行结果：

public class WrapperClassTest {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j); // false

        //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);// true

        Integer x = 128;//相当于new了一个Integer对象
        Integer y = 128;
        System.out.println(x == y);// false
    }
}

二、System 系统类

2.1 System类概述

        所在包:java.lang.System

        类的定义：
                public final class System
                    extends Object

        System 类包含一些有用的类字段和方法。它不能被实例化。 

        在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。 

        属性和行为都是静态的。

2.2 字段摘要

        static PrintStream err    “标准”错误输出流。 

        static InputStream in    “标准”输入流。 

        static PrintStream out    “标准”输出流。 

System.err和System.out的区别？

        1、java API，文档中给出的解释是：out为“标准输出流”，err为“标准错误输出流”；  

        2、在IDEA里运行时差别就是，二者显示的颜色有所区别，err输出显示为红色 ；      

        3、err.println 输出的字符串位置会随机出现。但 err.println 输出的字符串之间的相对位置不会变，System.out 在JVM和操作系统都具有缓存功能，就是你输出的东西不一定实时输出，有时候会积攒到一定数量才会输出，System.err会实时输出，单独使用的话可能感觉不到，如果两种方式混合使用就会发现了。

在IDEA中测试如下所示：

2.3 方法摘要

        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)    从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 
        
        static long currentTimeMillis()    该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。此方法常用于计算时间差。 

        static void exit(int status)    终止当前正在运行的 Java 虚拟机，其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

        static void gc()    运行垃圾回收器，该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。 

        static Properties getProperties()    确定当前的系统属性。 

        static String getProperty(String key)    该方法的作用是获得系统中属性名为key的属性对应的值。 

        static void setErr(PrintStream err)    重新分配“标准”错误输出流。 

        static void setIn(InputStream in)    重新分配“标准”输入流。 

        static void setOut(PrintStream out)    重新分配“标准”输出流。 

        static void setProperties(Properties props)    将系统属性设置为 Properties 参数。 

        static String setProperty(String key, String value)    设置指定键指示的系统属性。 

        static void setSecurityManager(SecurityManager s)    设置系统安全性。 

系统中常见的属性名以及属性的作用如下表所示：

三、Runtime 运行时环境类

3.1 Runtime类概述

        所在包：java.lang

        类的定义：
                public class Runtime
                    extends Object

        每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接，这个类的主要功能是取得一些与运行时有关的环境属性或者创建新的进程等操作。

        应用程序不能创建自己的 Runtime 类实例，可以通过 getRuntime 方法获取当前运行时。 

        在Runtime类定义的时候它的构造方法已经被私有化了，这就属于单例设计模式的应用，因为要保证在整个进程里只有唯一的一个Runtime类的对象。所以在Runtime类里面提供有一个static型的方法，这个方法可以取得Runtime类的实例化对象：public static Runtime getRuntime()。

3.2 方法摘要

        static Runtime getRuntime()    返回与当前 Java 应用程序相关的运行时对象。 

        Process exec(String command)    在单独的进程中执行指定的字符串命令。 

public class RuntimeTest {
	public static void main(String[] args) throws IOException, InterruptedException {
		Runtime runtime = Runtime.getRuntime();
        
        // 打开记事本程序，并返回一个进程
		Process process = runtime.exec("C:\\Windows\\notepad.exe");
		Thread.sleep(3000); //让当前程序停止3秒。
		process.destroy();
	}
}

        long freeMemory()    返回 Java 虚拟机中的空闲内存量。 

        long maxMemory()    返回 Java 虚拟机试图使用的最大内存量。 

        long totalMemory()    返回 Java 虚拟机中的内存总量。 

public class RuntimeTest {
	public static void main(String[] args) throws IOException{
		Runtime runtime = Runtime.getRuntime();
        System.out.println("Java虚拟机中的空闲内存量:"+runtime.freeMemory());
        System.out.println("Java虚拟机试图使用的最大内存量:"+ runtime.maxMemory());
        System.out.println("返回Java虚拟机中的内存总量:"+ runtime.totalMemory());

        String str = "";
        for(int i = 0; i < 1000; i++) {
            str += i;  // 产生大量垃圾
        }

        System.out.println("Java虚拟机中的空闲内存量:"+runtime.freeMemory());
        System.out.println("Java虚拟机试图使用的最大内存量:"+ runtime.maxMemory());
        System.out.println("返回Java虚拟机中的内存总量:"+ runtime.totalMemory());
	}
}

四、Math 数学运算类

4.1 Math类概述

        所在包：java.lang

        类的定义：
                public final class Math
                    extends Object

        Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 

        用于数学运算的工具类，属性和行为都是静态的，该类是final不允许继承。

4.2 字段摘要

        static double E        比任何其他值都更接近 e（即自然对数的底数）的 double 值。 

        static double PI    比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。 

4.3 方法摘要

        static double abs(double/float/int/long a)    返回 double/float/int/long 值的绝对值。 

        static double ceil(double a)    返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。 
    
        static double floor(double a)    返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。 

        static double max(double/float/int/long a, double/float/int/long b)    返回两个 double/float/int/long 值中较大的一个。 
        
        static double min(double/float/int/long a, double/float/int/long b)    返回两个 double/float/int/long 值中较小的一个。 

        static double pow(double a, double b)    返回第一个参数的第二个参数次幂的值。 

        static double random()    返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 
                求n - m的随机整数  (int)(Math.random()*(m-n)+n)

        static long round(double a)    返回最接近参数的 long。 

        static int round(float a)    返回最接近参数的 int。 

        static double sqrt(double a)    返回正确舍入的 double 值的正平方根。 

五、Date 日期类

5.1 Date类概述

        所在包：java.util

        类的定义:
                public class Date
                    extends Object
                    implements Serializable, Cloneable, Comparable
     
        类 Date 表示特定的瞬间，精确到毫秒。 

        在 JDK 1.1 之前，类 Date 有两个其他的函数。它允许把日期解释为年、月、日、小时、分钟和秒值。它也允许格式化和解析日期字符串。不过，这些函数的 API 不易于实现国际化。从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和解析日期字符串。Date 中的相应方法已废弃。 

5.2 Date构造函数

        Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。    

        Date(long date)    分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

5.3 方法摘要

        boolean after(Date when)    测试此日期是否在指定日期之后。 

        boolean before(Date when)    测试此日期是否在指定日期之前。 

        Object clone()    返回此对象的副本。 

        int compareTo(Date anotherDate)    比较两个日期的顺序。 

        boolean equals(Object obj)    比较两个日期的相等性。 

        long getTime()    返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 

        int hashCode()    返回此对象的哈希码值。 

        注:其他方法都是过期方法

public class DateTest {
    public static void main(String[] args) {
        //日期对象转成毫秒值
        Date d1 = new Date();
        long time1 = d1.getTime();
        long time2 = System.currentTimeMillis(); //毫秒值

        //毫秒值转成具体的日期
        long time = 1322709921312l;
        Date d2 = new Date();
        d2.setTime(time);
    }
}

六、SimpleDateFormat日期格式化类

6.1 SimpleDateFormat类概述

        所在包：java.text

        类的定义：
                public class SimpleDateFormat
                    extends DateFormat

        SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。 

        SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来创建日期-时间格式器。每一个这样的类方法都能够返回一个以默认格式模式初始化的日期/时间格式器。

6.2 模式字母

        日期和时间格式由日期和时间模式 字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到 'z' 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''" 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在解析时与输入字符串进行匹配。 

        定义了以下模式字母（所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留）：

字母	日期或时间元素	表示	示例
G	Era 标志符	Text	AD
y	年	Year	1996; 96
M	年中的月份	Month	July; Jul; 07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday; Tue
a	Am/pm 标记	Text	PM
H	一天中的小时数（0-23）	Number	0
k	一天中的小时数（1-24）	Number	24
K	am/pm 中的小时数（0-11）	Number	0
h	am/pm 中的小时数（1-12）	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978
z	时区	General time zone	Pacific Standard Time; PST; GMT-08:00
Z	时区	RFC 822 time zone	-0800

6.3 构造函数

        SimpleDateFormat()    用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。 

        SimpleDateFormat(String pattern)    用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。 

6.4 方法摘要

        Date parse(String source)    从给定字符串的开始解析文本，以生成一个日期。 

        String format(Date date)     将一个 Date 格式化为日期/时间字符串。 

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatTest {
    public static void main(String[] args) throws ParseException {
        // 将日期字符串转换成日期对象 使用的就是DateFormat方法中的 Date parse(String source);
        String str_time = "2011/10/25";
        DateFormat df1 = new SimpleDateFormat("yyyy/MM/dd"); //SimpleDateFormat作为可以指定用户自定义的格式来完成格式化
        Date date1 = df1.parse(str_time);

        // 将日期对象转换成字符串的方式 DateFormat类中的format方法
        // 创建日期格式对象
        DateFormat df = new SimpleDateFormat(); //该对象的建立内部会封装一个默认的日期格式 
        //如果想要自定义日期格式的话 可使用SimpleDateFormat的构造函数 将具体的格式作为参数传入到构造函数中 必须要参与格式对象文档
        df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //调用DateFormat中的format方法 对已有的日期对象进行格式化
        String str_time1 = df.format(date1);
        System.out.println(str_time1);
    }
}

七、Calendar 日历类

7.1 Calendar类概述

        所在包: java.util

        所在类:
                public abstract class Calendar
                    extends Object
                    implements Serializable, Cloneable, Comparable

        Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。 

        该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为 protected。 

        与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化： 
                 Calendar rightNow = Calendar.getInstance();

        Calendar类是个抽象类，因此本身不能被实例化，然而在此却创建了Calendar 的对象，但并不是抽象类可以创建对象。这个对象并不是Calendar 自身实例，而是其子类实例，这是在getInstance方法内部其实是实例化了GregorianCalendar 对象并返回了。    

7.2 字段摘要

        static int ALL_STYLES    指示所有风格名称的 getDisplayNames 的风格说明符，比如 "January" 和 "Jan"。
    
        static int AM    指示从午夜到中午之前这段时间的 AM_PM 字段值。 

        static int AM_PM    get 和 set 的字段数字，指示 HOUR 是在中午之前还是在中午之后。 

        static int APRIL    指示在格里高利历和罗马儒略历中一年中第四个月的 MONTH 字段值。 

        protected  boolean areFieldsSet    如果 fields[] 与当前的设置时间同步，则返回 true。 

        static int AUGUST    指示在格里高利历和罗马儒略历中一年中第八个月的 MONTH 字段值。 

        static int DATE        get 和 set 的字段数字，指示一个月中的某天。

        static int DAY_OF_MONTH        get 和 set 的字段数字，指示一个月中的某天。 

        static int DAY_OF_WEEK        get 和 set 的字段数字，指示一个星期中的某天。 

        static int DAY_OF_WEEK_IN_MONTH        get 和 set 的字段数字，指示当前月中的第几个星期。 

        static int DAY_OF_YEAR        get 和 set 的字段数字，指示当前年中的天数。 

        static int DECEMBER        指示在格里高利历和罗马儒略历中一年中第十二个月的 MONTH 字段值。 

        static int DST_OFFSET    get 和 set 的字段数字，以毫秒为单位指示夏令时的偏移量。 

        static int ERA        指示年代的 get 和 set 的字段数字，比如罗马儒略历中的 AD 或 BC。 

        static int FEBRUARY        指示在格里高利历和罗马儒略历中一年中第二个月的 MONTH 字段值。 

        static int FIELD_COUNT    get 和 set 可识别的不同字段的数量。 

        protected  int[] fields        此日历当前设置时间的日历字段值。 

        static int FRIDAY    指示 Friday 的 DAY_OF_WEEK 字段值。 

        static int HOUR        get 和 set 的字段数字，指示上午或下午的小时。 

        static int HOUR_OF_DAY        get 和 set 的字段数字，指示一天中的小时。 

        protected  boolean[] isSet    通知是否设置了该日历某一指定日历字段的标志。 

        protected  boolean isTimeSet    如果 time 值是一个有效值，则返回 true。 

        static int JANUARY    指示在格里高利历和罗马儒略历中一年中第一个月的 MONTH 字段值。 

        static int JULY        指示在格里高利历和罗马儒略历中一年中第七个月的 MONTH 字段值。 

        static int JUNE        指示在格里高利历和罗马儒略历中一年中第六个月的 MONTH 字段值。 

        static int LONG        指示长名称的 getDisplayName 和 getDisplayNames 的风格说明符，比如 "January"。 

        static int MARCH    指示在格里高利历和罗马儒略历中一年中第三个月的 MONTH 字段值。 

        static int MAY        指示在格里高利历和罗马儒略历中一年中第五个月的 MONTH 字段值。 

        static int MILLISECOND        get 和 set 的字段数字，指示一秒中的毫秒。 

        static int MINUTE    get 和 set 的字段数字，指示一小时中的分钟。 

        static int MONDAY    指示 Monday 的 DAY_OF_WEEK 字段值。 

        static int MONTH    指示月份的 get 和 set 的字段数字。 

        static int NOVEMBER        指示在格里高利历和罗马儒略历中一年中第十一个月的 MONTH 字段值。 

        static int OCTOBER        指示在格里高利历和罗马儒略历中一年中第十个月的 MONTH 字段值。 

        static int PM    指示从中午到午夜之前这段时间的 AM_PM 字段值。 

        static int SATURDAY        指示 Saturday 的 DAY_OF_WEEK 字段值。 

        static int SECOND    get 和 set 的字段数字，指示一分钟中的秒。 

        static int SEPTEMBER    指示在格里高利历和罗马儒略历中一年中第九个月的 MONTH 字段值。 

        static int SHORT    指示短名称的 getDisplayName 和 getDisplayNames 的风格说明符，比如 "Jan"。 

        static int SUNDAY    指示 Sunday 的 DAY_OF_WEEK 字段值。 

        static int THURSDAY        指示 Thursday 的 DAY_OF_WEEK 字段值。 

        protected  long time    日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间 1970 年 1月 1 日 0:00:00 后经过的时间。 

        static int TUESDAY    指示 Tuesday 的 DAY_OF_WEEK 字段值。 

        static int UNDECIMBER    指示一年中第十三个月的 MONTH 字段值。 

        static int WEDNESDAY    指示 Wednesday 的 DAY_OF_WEEK 字段值。 

        static int WEEK_OF_MONTH    get 和 set 的字段数字，指示当前月中的星期数。 

        static int WEEK_OF_YEAR        get 和 set 的字段数字，指示当前年中的星期数。 

        static int YEAR        指示年的 get 和 set 的字段数字。 

        static int ZONE_OFFSET    get 和 set 的字段数字，以毫秒为单位指示距 GMT 的大致偏移量。 

7.3 方法摘要

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

        boolean after(Object when)    判断此 Calendar 表示的时间是否在指定 Object 表示的时间之后，返回判断结果。

        boolean before(Object when)        判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。 

        int compareTo(Calendar anotherCalendar)    比较两个 Calendar 对象表示的时间值（从历元至现在的毫秒偏移量）。 

        boolean equals(Object obj)    将此 Calendar 与指定 Object 比较。 

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

        static Calendar getInstance()    使用默认时区和语言环境获得一个日历。 

        Date getTime()    返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。 

        long getTimeInMillis()    返回此 Calendar 的时间值，以毫秒为单位。 

        TimeZone getTimeZone()    获得时区。 

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

        void set(int year, int month, int date)    设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。 

        void set(int year, int month, int date, int hourOfDay, int minute)    设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。 

        void set(int year, int month, int date, int hourOfDay, int minute, int second)    设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。 

        void setTime(Date date)        使用给定的 Date 设置此 Calendar 的时间。 

public static void method(){
    Calendar c = Calendar.getInstance();
    System.out.println(c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH)+1) + "月"
    + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日"
    + "星期" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
}

public static String getNum(int num){
    return num > 9 ? num + "" : "0" + num;
}

public static String getWeek(int index){
    //查表法 建立数据的对应关系
    //最好 数据个数是确定的 而且有对应关系 如果对应关系的一方 是数字 而且可以作为角标 那么可以通过数组来作为表
    String[] weeks = {"","日","一","二","三","四","五","六"};
    return weeks[index];
} 

八、Properties 类

8.1 Properties类的简介

        所在包: java.util

        类的定义:
                public class Properties
                    extends Hashtable
                
        Properties（Java.util.Properties），该类主要用于读取Java的配置文件，不同的编程语言有自己所支持的配置文件，配置文件中很多变量是经常改变的，为了方便用户的配置，能让用户够脱离程序本身去修改相关的变量设置。就像在Java中，其配置文件常为.properties文件，是以键值对的形式进行参数配置的。

8.2 方法摘要

        String getProperty(String key)    用指定的键在此属性列表中搜索属性。 

        void list(PrintStream/PrintWriter out)    将属性列表输出到指定的输出流。  

        void load(InputStream/Reader inStream)    从输入流中读取属性列表（键和元素对）。 

        Enumeration propertyNames()    返回属性列表中所有键的枚举，如果在主属性列表中未找到同名的键，则包括默认属性列表中不同的键。  

        Object setProperty(String key, String value)    调用 Hashtable 的方法 put。 

//获取当前的系统属性。 
Properties properties = System.getProperties();
		
properties.list(System.out);

读取配置文件

Properties pps = new Properties();

pps.load(new FileInputStream("src/file.properties"));

Enumeration fileName = pps.propertyNames();

while (fileName.hasMoreElements()) {
    String strKey = (String) fileName.nextElement();
    String strValue = pps.getProperty(strKey);
    System.out.println(strKey + "\t" + strValue);
}

file.properties:

name=zhangsan
age=25
address=beijing

九、DecimalFormat 类

9.1 DecimalFormat 类简介

         所在包: java.text

        类的定义:
                public class DecimalFormat extends NumberFormat

        DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。该类设计有各种功能，使其能够解析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、定点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。 

9.2 模式字符

        模式中的很多字符都是按字面解释的；在解析期间对其进行匹配，在格式化期间则不经改变地输出。另一方面，特殊字符代表了其他字符、字符串或字符类。如果要将其作为字面量出现在前缀或后缀中，那么除非另行说明，否则必须对其加引号。 

        下列字符用在非本地化的模式中。已本地化的模式使用从此格式器的 DecimalFormatSymbols 对象中获得的相应字符，这些字符已失去其特殊状态。两种例外是货币符号和引号，不将其本地化。 

符号	位置	本地化？	含义
0	数字	是	阿拉伯数字
#	数字字	是	阿拉伯数字，如果不存在则显示为 0
.	数字	是	小数分隔符或货币小数分隔符
-	数字	是	减号
,	数字	是	分组分隔符
E	数字	是	分隔科学计数法中的尾数和指数。在前缀或后缀中无需加引号。
;	子模式边界	是	分隔正数和负数子模式
%	前缀或后缀	是	乘以 100 并显示为百分数
\u2030	前缀或后缀	是	乘以 1000 并显示为千分数
¤ (\u00A4)	前缀或后缀	否	货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。如果出现在某个模式中，则使用货币小数分隔符，而不使用小数分隔符。
'	前缀或后缀	否	用于在前缀或或后缀中为特殊字符加引号，例如 "'#'#" 将 123 格式化为 "#123"。要创建单引号本身，请连续使用两个单引号："# o''clock"。

9.3 DecimalFormat 类方法

        DecimalFormat(String pattern)    使用给定的模式和默认语言环境的符号创建一个 DecimalFormat。
    
        public final String format(long number)    格式规范。 
    
        public Number parse(String source)throws ParseException        解析给定字符串开头的文本，生成一个数值。此方法不可以使用给定字符串的全部文本。 

import java.text.DecimalFormat;

public class Test_DecimalFormat {

    public static void main(String[] args) {
        double money = 13213321.3364223;

        //DecimalFormat(String pattern) 使用给定的模式和默认语言环境的符号创建一个 DecimalFormat。
        //把数值转换为指定的字符串格式
        //保留两位小数
        DecimalFormat df = new DecimalFormat(".00");
        String format = df.format(money);
        System.out.println(format);

        //整数部分,每三位添加一个逗号
        DecimalFormat df1 = new DecimalFormat("##,###.00");
        String format1 = df1.format(money);
        System.out.println(format1);

        double d = 13.2252;
        DecimalFormat df2 = new DecimalFormat("###.00");
        String format2 = df2.format(d);
        System.out.println(format2);

        //把数值以百分比方式显示
        double n = 0.05;
        DecimalFormat df3 = new DecimalFormat("0%");
        String format3 = df3.format(n);
        System.out.println(format3);

        //把数值以千分比方式显示
        DecimalFormat df4 = new DecimalFormat("0\u2030");
        String format4 = df4.format(n);
        System.out.println(format4);

        //钱带货币符号
        DecimalFormat dfn = new DecimalFormat("\u00A4##,###.00");
        String formatn = dfn.format(money);
        System.out.println(formatn);
    }

}

十、BigInteger 与 BigDecimal 类

10.1 BigInteger类

        Integer类作为int的包装类，能存储的最大整型值为2^31-1，Long类也是有限的，最大为2^63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

        java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

构造方法：

        BigInteger(String val)    将 BigInteger 的十进制字符串表示形式转换为 BigInteger。

常用成员方法：

        BigInteger abs()    返回其值是此 BigInteger 的绝对值的 BigInteger。 
    
        BigInteger add(BigInteger val)    返回其值为 (this + val) 的 BigInteger。 
    
        BigInteger subtract(BigInteger val)        返回其值为 (this - val) 的 BigInteger。 
    
        BigInteger multiply(BigInteger val)        返回其值为 (this * val) 的 BigInteger。 
    
        BigInteger divide(BigInteger val)    返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
    
        BigInteger remainder(BigInteger val)    返回其值为 (this % val) 的 BigInteger。 
    
        BigInteger[] divideAndRemainder(BigInteger val)        返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。 
    
        BigInteger pow(int exponent)    返回其值为 (thisexponent) 的 BigInteger 

10.2 BigDecimal类

        一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。

        BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

构造方法：

        BigDecimal(double val)    将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。

        BigDecimal(String val)    将 BigDecimal 的字符串表示形式转换为 BigDecimal。

常用成员方法：

        BigDecimal add(BigDecimal augend)    返回一个 BigDecimal，其值为 (this + augend)，其标度为 max(this.scale(), augend.scale())。 

        BigDecimal subtract(BigDecimal subtrahend)    返回一个 BigDecimal，其值为 (this - subtrahend)，其标度为 max(this.scale(), subtrahend.scale())。 

        BigDecimal multiply(BigDecimal multiplicand)    返回一个 BigDecimal，其值为 (this × multiplicand)，其标度为 (this.scale() + multiplicand.scale())。 

        BigDecimal divide(BigDecimal divisor)    返回一个 BigDecimal，其值为 (this / divisor)，其首选标度为 (this.scale() - divisor.scale())；如果无法表示准确的商值（因为它有无穷的十进制扩展），则抛出 ArithmeticException。 

        BigDecimal divide(BigDecimal divisor, int roundingMode)        返回一个 BigDecimal，其值为 (this / divisor)，其标度为 this.scale()。 

        BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)    返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度。 

public void testBigInteger() {
    BigInteger bi = new BigInteger("12433241123");
    BigDecimal bd = new BigDecimal("12435.351");
    BigDecimal bd2 = new BigDecimal("11");
    System.out.println(bi);
    // JAVA中如果用BigDecimal做除法的时候一定要在divide方法中传递第二个参数，定义精确到小数点后几位，否则在不整除的情况下，结果是无限循环小数时，就会抛出以上异常。
    // System.out.println(bd.divide(bd2));
    System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
    System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
}

十一、面试题

1、什么是包装类?
    Java中的数据类型分为基本数据类型和引用数据类型,其中基本数据类型是不具有对象特征的;
    包装类的产生就是为了解决基本数据类型存在的这样一些问题,通过包装类可以让基本数据类型获取对象一样的特征,行使对象相关的权力。

2、八种基本数据类型及其包装类（*）?
    八种基本数据类型: byte、short、int、long、float、double、boolean、char
    包装类: Byte、Short、Integer、Long、Float、Double、Boolean、Character

3、Number类的作用?
    抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。
    提取了对数值操作的共性;

4、包装类、基本数据类型、字符串的相互转换?（*）?
    基本数据类型 -> 包装类:
        1、通过包装类的构造器,手动装箱
        2、自动装箱
        3、通过包装类的静态valueOf()

    基本数据类型 -> 字符串:
        1、通过String.valueOf()
        2、拼接空字符串
        3、包装类静态toString()

    包装类 -> 基本数据类型:
        1、通过成员方法xxxValue
        2、自动拆箱

    包装类 -> 字符串类型:
        1、通过String.valueOf()
        2、通过包装类成员toString()

    字符串 -> 基本数据类型:
        1、包装类的静态方法parseXxx()
        2、包装类的构造器传递字符串,然后自动拆箱

    字符串 -> 包装类:
        通过包装类的构造器,构造器里面传递字符串类型

5、什么是装箱和拆箱（*）?
    装箱: 把基本数据类型转换成包装类,分为自动装箱和手动装箱
        //自动装箱
        Integer i1 = 10;
        //手动装箱
        Integer i2 = new Integer(10);
    拆箱: 把包装类转换成基本数据类型,分为自动拆箱和手动拆箱
        //自动拆箱
        int i3 = i2;
        //手动拆箱
        int i4 = i2.intValue();

6、包装类代码阅读题?

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);// 1.0

Object o2;
if (true){
    o2 = new Integer(1);
}else{
    o2 = new Double(2.0);
}
System.out.println(o2);// 1


public class WrapperClassTest {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j); // false

        //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);// true

        Integer x = 128;//相当于new了一个Integer对象
        Integer y = 128;
        System.out.println(x == y);// false
    }
}

7、System.err和System.out的区别?
    out为“标准输出流”,err为“标准错误输出流”；
    在IDEA里运行时差别就是,二者显示的颜色有所区别,err输出显示为红色;
    System.err会实时输出; System.out在JVM和操作系统都具有缓存功能，就是你输出的东西不一定实时输出;

8、请简单阐述Runtime类?
    每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。
    可以通过 getRuntime 方法获取当前运行时。
    private static Runtime currentRuntime = new Runtime();
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    private Runtime() {}
    以上代码解释: 私有化构成函数,不让外部程序创建对象; 在类内部实例化Runtime实例,而且是静态,保证了只有一个Runtime实例;而且提供了对应的方法获取该实例;

9、Math类的ceil()、floor()、random()、round()的作用（*）?
    ceil() 向上取整,获取大于等于参数的最小整数
    floor() 向下取整,获取小于等于参数的最大整数
    random() 获取0-1的伪随机数,包含0不包含1
    round() 四舍五入

10、SimpleDateFormat的作用（*）?
    把日期对象转换为指定格式字符串: 通过SimpleDateFormat类的format()
    把指定格式字符串转换为日期对象: 通过SimpleDateFormat类的parse()