对 java.lang 的研究

研究
本篇文章讨论那些由java.lang定义的类和接口。
正如你所知道的那样，java.lang被自动导入所有的程序。它所包含的类和接口对所有实际的Java程序都是必要的。它是Java最广泛使用的包。
java.lang包括了下面这些类：
Boolean Long StrictMath (Java 2,1.3)
Byte Math String
Character Number StringBuffer
Class Object System
ClassLoader Package (Java 2) Thread
Compiler Process >ThreadGroup
Double Runtime ThreadLocal (Java 2)
Float >RuntimePermission (Java 2) Throwable
>InheritableThreadLocal (Java 2) SecurityManager Void
>Integer >Short >
另外还有两个由Character定义的类：Character.Subset和Character.UnicodeBlock，它们是在Java 2中新增加的。
java.lang也定义了如下的接口：
? Cloneable
? Comparable
? Runnable
其中Comparable接口是在Java 2中新增加的。
java.lang中的几个类包含了过时的方法，其中的大多数可以追溯到Java 1.0。在Java2中仍然提供了这些方法，用于支持逐渐减少的老程序，而这些方法在新程序中不被推荐使用。大多数的过时方法出现在Java 2之前，因此在这里不讨论这些方法。而在Java 2中出现的那些过时的方法将被提及。
Java 2也在java.lang包中增加了几个新的类和方法，这些新类和方法被说明如下。

1、简单类型包装器

在本书的第1部分，我们提到因为性能的原因，Java使用简单的类型，例如整型（int）和字符（char）。这些数据类型不是对象层次结构的组成部分。它们通过值传递给方法而不能直接通过引用传递。而且，也没有办法使两种方法对整型（int）引用同一实例（same instance）。有时需要对这些简单的类型建立对象表达式。例如在第15章中讨论的仅仅处理对象的枚举类；如果要将简单类型存储到这些类中的一个，需要在类中包装简单类型。为了满足这种需要，Java提供了与每一个简单类型相应的类。本质上，这些类在类中包装（wrap）简单类型。因此，它们通常被称作类型包装器（wrappers）。

1.1、  Number

抽象类Number定义了一个由包装数字类型字节型（byte），短整型（short），整型（int），长整型（long），浮点型（float）和双精度型（double）的类实现的超类。Number有返回上面不同数字格式的对象值的抽象方法。也就是，doubleValue( )方法返回双精度（double）值，floatValue( )方法返回浮点（float）值等。这些方法如下：
byte byteValue( )
double doubleValue( )
float floatValue( )
int intValue( )
long longValue( )
short shortValue( )
这些方法的返回值可以被舍入。
Number有6个具体的子类包含了6种数字类型的显式值：双精度型（Double），浮点型（Float），字节型（Byte），短整型（Short），整型（Integer）和长整型（Long）。

1.2、  Double和Float
   
双精度（Double）和浮点（Float）分别是对类型double和类型float的浮点值的包装器。浮点（Float）构造函数如下所示：
Float(double num)
Float(float num)
Float(String str) 引发NumberFormatException异常
正如你所看到的，浮点（Float）对象可以由类型float或类型double的值创建。它们也能由浮点数的字符串表达式创建。
双精度（Double）构造函数如下：
Double(double num)
Double(String str) 引发NumberFormatException异常
双精度（Double）对象可以被双精度（double）值或包含了浮点值的字符串创建。
由浮点（Float）定义的方法在表14-1中列出。由双精度（Double）定义的方法在表14-2中列出。浮点（Float）和双精度（Double）都定义了下面的常数：
MAX_VALUE 最大正值
MIN_VALUE 最小正值
NaN 非数字
POSITIVE_INFINITY 正无穷
NEGATIVE_INFINITY 负无穷
TYPE 浮点（float）或双精度（double）的类（Class）对象 
 表1 由Float定义的方法
方法 描述
byte byteValue（） 返回调用对象的值（字节型）
int compareTo（Float f） 将调用对象的数值与f中的数值进行比较，如果两者相等，返回0。如果调用对象的值小于f的值，则返回负值。如果调用对象的值大于f的值，则返回正值（在Java 2中新增加的）
int compareTo（object obj） 当obj是类Float中的对象时，该方法与compareTo（Float）的功能相同。否则，引发一个ClassCastException异常（在Java 2中新增加的）
double doubleValue（） 返回调用对象的值(双精度型)
boolean equals（Object FloatObj） 如果float调用对象与FloatObj相等，则返回true。否则返回false
static int float ToIntBits（float num） 返回与num相应的与IEEE兼容的单精度位模式
Float floatValue（） 返回调用对象的值（浮点型）
int hashCode（） 返回调用对象的散列值
static float intBitsToFloat（int num） 返回由num指定的，与IEEE兼容的单精度位模式的等价浮点（float）值
int intValue（） 返回整型（int）形式的调用对象值
boolean isInfinite（） 如果调用对象包含有无穷大值，则返回true。否则返回false
static boolean isInfinite（float num） 如果num指定了一个无穷大值，则返回true。否则返回false
boolean isNaN（） 如果调用对象中包含了非数字值，则返回true。否则返回false
static boolean isNaN（float num） 如果num指定了一个非数字值，则返回true。否则返回false
long longValue() 返回调用对象的值（长整型）
static float parseFloat（String str）   throws NumberFormatException 以10为基数，返回包含在由str指定的字符串中的数字的等价浮点值（在Java 2中新增加的）
short shortValue（） 返回调用对象值（短整型）
String toString（） 返回调用对象的等价字符串形式
static String to String（float num） 返回由num指定的值的等价字符串
static Float valueOf（String str）   throws NumberForamtException 返回包含了由str中的字符串指定的值的float对象

表2  由Double定义的方法
方法 描述
byte byteValue（） 返回调用对象的值（字节型）
int compareTo（Double d） 将调用对象的值与d的数值进行比较。如果这两个值相等，则返回0。如果调用对象的数值小于d的数值，则返回负值。如果调用对象的数值大于d的数值，则返回正值（在Java 2中新增加的）
Int compareTo（Object obj） 如果obj属于类Double，其操作与compareTo（Double）相同。否则，引发一个ClassCastException异常（在Java 2中新增加的）
static long doubleToLongBits（double num） 返回与num相应的与IEEE兼容的双精度位模式
double doubleValue（） 返回调用对象的值（双精度）
boolean equals（Object DoubleObj） 如果double调用对象与DoubleObj相等，则返回true。否则，返回false
float floatValue（） 返回调用对象的值（浮点型）
int hashcode（） 返回调用对象的散列码
int intValue（） 返回调用对象的值（整型）
boolean isInfinite（） 如果调用对象包含了一个无穷大值，则返回true。否则，返回false
static boolean isInfinite（double num） 如果num指定了一个无穷大值，则返回true。否则，返回false
boolean is NaN（） 如果调用对象包含了一个非数字值，则返回true。否则，返回false
static boolean isNaN（double num） 如果num指定了一个非数字值，则返回true。否则，返回false
static double longBitsToDouble（long num） 返回由num指定的，与IEEE兼容的双精度位模式的双精度（double）等价值
long longValue（） 返回调用对象的值（长整型）
static double parseDouble（String str）   throws NumberFormatException 以10为基数，返回包含在由str指定的字符串中的数字的等价双精度（double）形式（在Java 2中新增加的）
short shortValue（） 返回调用对象的值（短整型）
String toString（） 返回调用对象的等价字符串形式
Static String toString（double num） 返回由num指定的值的等价字符串形式
Static Double valueOf（String str）   throws NumberFormatException 返回包含了由str中的字符串指定的值的double对象
在下面的例子中创建两个double对象--一个通过使用双精度（double）值实现，另一个通过传递一个可以被解析为双精度（double）的字符串来实现。
class DoubleDemo {
  public static void main(String args[]) {
    Double d1 = new Double(3.14159);
    Double d2 = new Double("314159E-5");

    System.out.println(d1 + " = " + d2 + " -> " + d1.equals(d2));
  }
}
正如从下面的输出中可以看到的那样，如同通过equals( )方法返回true，两种构造函数创建相同的双精度（double）实例。
3.14159 = 3.14159 -> true
理解isInfinite( )和isNaN( )
浮点（Float）和双精度（Double）提供了isInfinite( )和isNaN( )方法，这些方法会有助于操作两个特殊的双精度（double）和浮点（float）值，这些方法检验两个由IEEE浮点规范定义的独特的值：无穷和NaN（非具体数字）。当被检验的值为无穷大或无穷小值时，isInfinite( )方法返回true。当被检验值为非数字时，isNaN( )方法返回true。
在下面的例子中构造了两个Double对象；一个是无穷，另一个是非数字：
// Demonstrate isInfinite() and isNaN()
class InfNaN {
  public static void main(String args[]) {
    Double d1 = new Double(1/0.);
    Double d2 = new Double(0/0.);

    System.out.println(d1 + ": " + d1.isInfinite() + ", " + d1.isNaN());
    System.out.println(d2 + ": " + d2.isInfinite() + ", " + d2.isNaN());
  }
}
程序运行产生如下的输出：
Infinity: true, false
NaN: false, true

1.3、 Byte, Short, Integer 和 Long

Byte，Short，Integer，和Long类分别是字节型（byte），短整型（short），整型（int）和长整型（long）整数类型的包装器。它们的构造函数如下：
Byte(byte num)
Byte(String str) 引发一个NumberFormatException异常 
Short(short num)
Short(String str) 引发一个NumberFormatException异常 
Integer(int num)
Integer(String str) 引发一个NumberFormatException异常
Long(long num)
Long(String str) 引发一个NumberFormatException异常 
正如你能看到的，这些对象可由数值或含有有效整数值的字符串创建。
由这些类定义的方法列在表14-3到表14-6中。正如你能看到的，它们定义方法以便从字符串解析整数和将字符串转换为整数。为方便起见，这些方法提供的变量可以用来指定radix，也称为基数。通常二进制（binary）的基数是2，八进制（octal）的基数是8，十进制（decimal）的基数是10，而十六进制（hexadecimal）的基数为16。
表3  由Byte定义的方法
方法 描述
byte byteValue（） 返回调用对象值（字节型）
int compareTo（Byte b） 将调用对象的数值与b的数值进行比较。如果这两个数值相等，则返回0。如果调用对象的数值小于b的数值，则返回负值。如果调用对象的数值大于b的数值，则返回正值（在Java 2中新增加的）
int compareTo（Object obj） 如果obj属于类Byte，其操作与compareTo（Byte）相同。否则，引发一个ClassCastException异常（在Java 2中新增加的）
static Byte decode（String str）   throws NumberFormatException 返回一个包含了由str中的字符串指定的值的Byte对象
double doubleValue（） 返回调用对象值（双精度度型）
boolean equals（Object ByteObj） 如果Byte调用对象与ByteObj相等，则返回true。否则，返回false
float floatValue（） 返回调用对象值（浮点型）
int hashCode（） 返回调用对象的散列码
int intValue（） 返回调用对象值（整型）
long longValue（） 返回调用对象值（长整型）
static byte parseByte（String str）   throws NumberFormatException 以10为基数，返回包含在由str指定的字符串中的数字的等价字节（byte）形式
static byte parseByte（String str，int radix）   throws NumberFormatException 以指定的基数（radix）为底，返回包含在由str指定的字符串中的数字的等价字节
short shortValue（） 返回调用对象值（短整型）
String toString（） 返回一个包含了调用对象的等价十进制形式的字符串
static String toString（byte num） 返回一个包含了num的等价十进制形式的字符串
static Byte valueOf（String str）   throws NumberFormatException 返回一个包含了由str中的字符串指定的值的Byte对象
static Byte valueOf（String str，int radix）   throws NumberFormatException 以指定的基数（radix）为底，返回一个包含了由str中的字符串指定的值的Byte对象
表4  由Short定义的方法
方法 描述
byte byteValue（） 返回调用对象值（字节型）
int compareTo（Short s） 将调用对象的数值和s的数值进行比较。如果这两个值相等，则返回0。如果调用对象的数值小于s的数值，则返回负值 如果调用对象的数值大于s的数值，则返回正值（在Java 2中新增加的）
int compareTo（Object obj） 如果obj属于类Short，其操作与compareTo（Short）相同。否则，引发一个ClassCastException异常（在Java 2中新增加的）
static Short decode（String str） throws NumberFormatException 返回一个包含了由str中的字符串指定值的Short对象
double doubleValue（） 返回调用对象值（双精度型）
boolean equals（Object ShortObj） 如果整型（Interger）调用对象与ShortObj相等，则返回true。否则，返回false
float floatValue（） 返回调用对象值（浮点值）
int hashCode（） 返回调用对象的散列码
int intValue（） 返回调用对象值（整型）
long longValue（） 返回调用对象值（长整型）
static short parseShort（String str）  throws   NumberFormatException 以10为基数，返回包含在由str指定的字符串中的数字的等价短整型（Short）数
static short parseShort（String str，int radix）  throws NumberFormatException 以指定的基数（radix）为底，返回包含在由str指定的字符串中的数字的等价短整型（Short）数
short shortValue（） 返回调用对象值（短整型）
String toString（） 返回一个包含了调用对象的等价十进制形式的字符串
static String to String（short num） 返回一个包含了num的等价十进制形式的字符串
static Shortvalue Of（Stringstr）throws   NumberFormatException 以10为基数，返回一个包含了由str中的字符串指定的值的Short对象
static Short valueOf（String str，int radix） throws  NumberFormatException 以指定的基数（radix）为底，返回一个包含了由str中的字符串指定的值的Short对象
表5  由Integer定义的方法
方法 描述
byte byteValue（） 返回调用对象值（字节型）
int compareTo（Integer i） 将调用对象的数值与i的数值进行比较。如果这两个值相等，则返回0。如果调用对象的数值小于i的数值，则返回负值。如果调用对象的数值大于i的数值，则返回正值（在Java 2中新增加的）
int compareTo（Object obj） 如果obj属于类Integer，其操作与compareTo（Integer）相同。否则，引发一个ClassCastException异常（在Java 2中新增加的）
static Integer decode（String str）   throws NumberFormatException 返回一个包含了由str中的字符串指定值的Integer对象
double doubleValue（） 返回调用对象值（双精度型）
boolean equals（Object IntegerObj） 如果调用Interger对象与IntegerObj相等，则返回true。否则，返回false
float floatValue（）static Integer getInteger （String propertyName） 返回调用对象值（浮点型） 返回与由propertyname指定的环境属性相关联的值，调用失败返回null
static Integer getInteger （String propertyName，int default） 返回与由propertyname指定的环境属性相关联的值，调用失败返回default值
static Integer getInteger （String propertyName，Integer default） 返回与由propertyname指定的环境属性相关联的值，调用失败返回default值
int hashCode（） 返回调用对象的散列码
int intValue（） 返回调用对象值（整型）
long longValue（） 返回调用对象值（长整型）
static int parseInt（String str）   throws NumberFormatException 以10为基数，返回包含在由str指定的字符串中的数字的等价整数（integer）值
static int parseInt（String str，int radix）   throws NumberFormatException 以指定的基数（radix）为底，返回包含在由str指定的字符串中的数字的等价整数值
short shortValue（） 返回调用对象值（短整型）
static String toBinaryString（int num） 返回一个包含了num的等价二进制形式的字符串
static String toHexString（int num） 返回一个包含了num的等价十六进制形式的字符串
static String toOctalString（int num） 返回一个包含了num的等价八进制形式的字符串
String toString（） 返回一个包含了调用对象的等价十进制形式的字符串
static String toString（int num） 返回一个包含了num的等价十进制形式的字符串
static String toString（int num，int radix） 以指定的基数（radix）为底，返回一个包含了num的等价十进制形式的字符串
static Integer valueOf（String str）   throws NumberFormatException 返回一个包含了由str中的字符串指定的值的Integer对象
static Integer valueOf（String str，int radix）   throws NumberFormatException 以指定的基数（radix）为底，返回一个包含了由str中的字符串指定的值的Integer对象

表6  由Long定义的方法
方法 描述
byte byteValue（） 返回调用对象值（字节型）
int compareTo（Long l） 将调用对象的数值和l的数值进行比较，如果这两个值相等，则返回0。如果调用对象的数值小于l的数值，则返回负值。如果调用对象的数值大于l的数值，则返回正值（在Java 2中新增加的）
int compareTo（Object obj） 如果obj属于类long，其操作与compareTo（Long）相同。否则，引发一个ClassCastException异常（在Java 2中新增加的）
static Long decode（String str）   throws NumberFormatException 返回一个包含了由str中的字符串指定的值的Long对象
double doubleValue（） 返回调用对象值（双精度型）
boolean equals（Object LongObj） 如果调用Long对象与LongObj相等，则返回true。否则，返回false
float floatValue（） 返回调用对象值（浮点型）
static Long getLong（String propertyname） 返回与由propertyname指定的环境属性相关联的值，调用失败则返回null
static Long getLong（String propertyname， long default） 返回与由propertyname指定的环境属性相关联的值，调用失败则返回default的值
static long getLong（String propertyname， Long default） 返回与由propertyname指定的环境属性相关联的值，调用失败则返回default的值
int hashcode（） 返回调用对象的散列码
int intValue（） 返回调用对象值（整型）
long longValue（） 返回调用对象值（长整型）
static long parseLong（String str）   throws NumberFormatException 以10为基数，返回包含在由str指定的字符串中的数字的等价长整型（Long）数
static long parseLong（String str，int radix）   throws NumberFormatException 以指定的基数（radix）为底，返回包含在由str指定的字符串中的数字的等价长整型（Long）数
short shortValue（） 返回调用对象值（短整型）
static String toBinaryString（long num） 返回一个包含了num的等价二进制形式的字符串
static String toHexString（long num） 返回一个包含了num的等价十六进制形式的字符串
static String toOctalString（long num） 返回一个包含了num的等价八进制形式的字符串
String toString（） 返回一个包含了调用对象的等价十进制形式的字符串
static String toString（long num） 返回一个包含了num的等价十进制形式的字符串
static String toString（long num，int radix） 以指定的基数（radix）为底，返回一个包含了num的等价十进制形式的字符串
static Long valueOf（String str）   throws NumberFormatException 返回一个包含了由str中的字符串指定的值的Long对象
static Long valueOf（String str，int radix）   throws NumberFormatException 以指定的基数（radix）为底，返回一个包含了由str中的字符串指定的值的Long对象
定义下面的常数：
MIN_VALUE 最小值
MAX_VALUE 最大值
TYPE 字节（Byte），短整型（short），整型（int）或长整型（long）的类（Class）对象
数字和字符串的转换
程序设计中一个最常见的任务是将一个数字的字符串表达式转换成内部的二进制格式。幸运的是Java提供了一个方便的方法去完成这项任务。Byte，Short，Integer和Long类分别提供了parseByte( )，parseShort( )，parseInt( )和parseLong( )方法。这些方法返回与调用它们的数值字符串相应的字节（byte），短整型（short），整型（int）和长整型（long）值（在Float和Double类中也有相似的方法）。
下面的程序说明了parseInt( )方法。该程序完成对用户输入的一系列整数的求和。在程序中通过使用readLine( )方法读取整数，使用parseInt( )方法将这些字符串转换成与之相应的整型（int）值。
/* This program sums a list of numbers entered
   by the user.  It converts the string representation
   of each number into an int using parseInt().
*/

import java.io.*;

class ParseDemo {
  public static void main(String args[])
    throws IOException
  {
    // create a BufferedReader using System.in
    BufferedReader br = new
      BufferedReader(new InputStreamReader(System.in));
    String str;
    int i;
    int sum=0;
   
    System.out.println("Enter numbers, 0 to quit.");
    do {
      str = br.readLine();
      try {
        i = Integer.parseInt(str);
      } catch(NumberFormatException e) {
        System.out.println("Invalid format");
        i = 0;
      }
      sum += i;
      System.out.println("Current sum is: " + sum);
    } while(i != 0);
  }
}
为了将一个整数转换为一个十进制的字符串，可以使用在Byte，Short，Integer或Long类中定义的toString( )方法。Integer和Long类还同时提供了toBinaryString( )，toHexString( )和toOctalString( )方法，可以分别将一个值转换成二进制，十六进制和八进制字符串。
下面的程序说明了向二进制，十六进制和八进制的转换：
/* Convert an integer into binary, hexadecimal,
   and octal.
*/
class StringConversions {
  public static void main(String args[]) {
    int num = 19648;

    System.out.println(num + " in binary: " +
                       Integer.toBinaryString(num));

    System.out.println(num + " in octal: " +
                       Integer.toOctalString(num));

    System.out.println(num + " in hexadecimal: " +
                       Integer.toHexString(num));
  }
}
程序的输出结果如下所示：
19648 in binary: 100110011000000
19648 in octal: 46300
19648 in hexadecimal: 4cc0

1.4、 Character

字符（Character）是围绕字符型（char）的一个简单的包装器。字符（Character）的构造函数如下：
Character(char ch)
这里ch指定了被创建的字符（Character）对象所包装的字符。
调用如下的charValue( )方法可以获得包含在字符（Character）对象中的字符型（char）值。
char charValue( )
调用的结果返回字符。
字符（Character）类定义了几个常数，包括下面这些：
MAX_RADIX 最大基数
MIN_RADIX 最小基数
MAX_VALUE 最大字符值
MIN_VALUE 最小字符值
TYPE 字符型（char）的类（Class）对象
字符（Character）包括了几个静态方法，这些方法完成将字符分类并改变它们的大小写。这些方法在表7中列出。下面的例子说明了这些方法。
// Demonstrate several Is... methods.

class IsDemo {
  public static void main(String args[]) {
    char a[] = {'a', 'b', '5', '?', 'A', ' '};

    for(int i=0; i<a.length; i++) {
      if(Character.isDigit(a[i]))
        System.out.println(a[i] + " is a digit.");
      if(Character.isLetter(a[i]))
        System.out.println(a[i] + " is a letter.");
      if(Character.isWhitespace(a[i]))
        System.out.println(a[i] + " is whitespace.");
      if(Character.isUpperCase(a[i]))
        System.out.println(a[i] + " is uppercase.");
      if(Character.isLowerCase(a[i]))
        System.out.println(a[i] + " is lowercase.");
    }
  }
}
程序的输出结果如下所示：
a is a letter.
a is lowercase.
b is a letter.
b is lowercase.
5 is a digit.
A is a letter.
A is uppercase.
  is whitespace.
表7  各种字符（Character）方法
方法 描述
static boolean isDefined（char ch） 如果ch是由Unicode定义的，则返回true，否则，返回false
static boolean isDigit（char ch） 如果ch是一个数字，则返回true，否则，返回false
static boolean isIdentifierIgnorable（char ch） 如果在一个标识符中ch应被忽略，则返回true，否则，返回false
static boolean isISOControl（char ch） 如果ch是一个ISO控制字符，则返回true，否则，返回false
static boolean isJavaIdentifierPart（char ch） 如果ch被做为Java标识符的一部分（除了第一个字符），则返回true。否则，返回false
static boolean isJavaIdentifierStart（char ch） 如果ch被做为Java标识符的首字符，则返回true。否则返回false
static boolean isLetter（char ch） 如果ch是一个字母，则返回true。否则返回false
static boolean isLetterOrDigit（char ch） 如果ch是一个字母或一个数字，则返回true。否则返回false
static boolean isLowerCase（char ch） 当ch是小写字母时，返回true。否则返回false
static boolean isSpaceChar（char ch） 如果ch是Unicode编码的空格字符，则返回true。否则返回false
static boolean isTitleCase（char ch） 如果ch是Unicode编码的标题字符，则返回true。否则返回false
static boolean isUnicodeIdentifierPart （char ch） 如果ch被做为Unicode编码标识符的一部分（除了第一个字符），则返回true。否则，返回false
static boolean isUnicodeIdentifierStart （char ch） 如果ch被做为一个Unicode标识符的首字符，则返回true。否则返回false
static boolean isUpperCase（char ch） 如果ch是一个大写字母，则返回true。否则返回false
static boolean isWhitespace（char ch） 如果ch是一个空白符，则返回true。否则，返回false
static char toLowerCase（char ch） 返回ch的小写等价形式
static char toTitleCase（char ch） 返回ch的标题等价形式
static char toUpperCase（char ch） 返回ch的大写等价形式
字符（Character）定义了如下形式的forDigit( )和digit( )方法：
static char forDigit(int num, int radix)
static int digit(char digit, int radix)
forDigit( )方法返回与num的值关联的数字字符。而转换的基数由radix指定。digit( )方法按照给定的基数，返回与指定字符（该字符可能是一个数字）相关联的整数值。
由Character类定义的另一个方法是compareTo( )，该方法具有如下的两种形式：
int compareTo(Character c)
int compareTo(Object obj)
第一种形式当调用对象与c具有相同值时返回0。当调用对象具有比c小的值时返回一个负值。否则它将返回一个正值。在第二种形式中，当obj是对Character类的一个引用时，其功能与第一种形式一样。否则它将引发一个ClassCastException异常。这些方法是在Java 2中新增加的。
Character类还定义了equals( )和hashCode( )方法。
另两个与字符有关的类是Character.Subset和Character.UnicodeBlock，其中Character.Subset类用于描述Unicode编码的一个子集，而Character.UnicodeBlock类中包含了Unicode 2.0编码的字符块。

1.5、  Boolean

Boolean是一个围绕布尔（boolean）值的非常细小的包装器，主要用在通过引用传递布尔（boolean）变量的场合。它包含了常数TRUE和FALSE，这些常数定义了布尔（Boolean）对象的真与假。Boolean也定义了TYPE域，它是boolean的Class对象。在Boolean中定义了如下的构造函数：
Boolean(boolean boolValue)
Boolean(String boolString)
在第一种形式中，boolValue要么是true，要么是false。在第二种形式中，如果在boolString中包含了字符串“true”（无论是大写形式还是小写形式），则新的布尔（Boolean）对象将为真，否则为假。
Boolean定义了如表14-8中列出的方法。
表8  由Boolean定义的方法
方法 描述
boolean booleanValue( )  返回布尔（boolean）等价形式
boolean equals(Object boolObj)  如果调用对象与boolObj相等，则返回true。否则返回false
static boolean getBoolean(String propertyName) 如果由propertyName指定的系统属性为true，则返回true。否则返回false
int hashCode( ) 返回调用对象的散列码
String toString( ) 返回调用对象的字符串等价形式
static Boolean valueOf(String boolString)  如果在boolString中包含了“true”（以大写或小写形式），则返回true。否则返回false

2、 Void

Void类有一个TYPE域，该域保存对类型void的Class对象的引用。这样做将不创建类的实例。

3、Process

抽象类Process封装了一个进程（process）--也就是说一个正在执行的程序。它主要被当作由Runtime类中的exec( )方法所创建的对象的类型的超类。Runtime类将在下面介绍。在抽象类Process中，包含了如下表14-9中列出的抽象方法。
表9  由Process定义的抽象方法
方法 描述
void destroy( ) 中断进程
int exitValue( ) 返回一个从子进程获得的退出码
InputStream getErrorStream( )  返回一个从进程的err输出流中读输入的输入流
InputStream getInputStream( ) 返回一个从进程的out输出流中读输入的输入流
OutputStream getOutputStream( ) 返回一个从进程的in输入流中写输出的输出流
Int waitFor( )   throws InterruptedException 返回由进程返回的退出码。这个方法直到调用它的进程中止，才会返回

4、  Runtime

Runtime类封装了运行时环境。一般不实例化一个Runtime对象。但是可以通过调用静态方法Runtime.getRuntime( )而获得对当前Runtime对象的引用。一旦获得了对当前对象的引用，就可以调用几个控制Java虚拟机的状态和行为的方法。小应用程序（Applets）和其他不可信赖的编码由于没有引起一个安全异常（SecurityException）而不能调用任何的Runtime方法。
表10给出了由Runtime定义的方法。Java 2中不赞成使用方法runFinalizersonExit( )。这种方法是在Java 1.1中增加的，但被认为是一种不稳定的方法。
表10  由Runtime定义的常用方法
方法 描述
void addShutdownHook(Thread thrd) 当Java虚拟机终止时，寄存器thrd作为线程而运行
Process exec(String progName)   throws IOException 将由progName指定的程序作为独立的进程来执行。返回描述新进程的类型Process的对象
Process exec(String progName, String  environment[ ])  throws IOException 将由progName指定的程序作为独立的进程来执行。该独立进程的环境由environment指定。返回描述新进程的类型Process的对象
Process exec(String comLineArray[ ],  String environment[ ])  throws   IOException 将由comLineArray中的字符串指定的命令行作为独立的进程来执行。运行环境由environment指定。返回描述新进程的类型Process的对象
void exit(int exitCode)  暂停执行并且向父进程返回exitCode的值，按照约定，0表示正常中止，所有的其他值表示有某种形式的错误
long freeMemory( )  返回Java运行系统可以利用的空闲内存的大概字节数
void gc( )  初始化垃圾回收站
static Runtime getRuntime( )  返回当前的Runtime对象
void halt(int code)  立即终止Java虚拟机，不执行任何的终止线程和善后处理程序。code的值返回给调用进程（在Java 2的1.3版中新增加的）
void load(String libraryFileName)  载入库中文件由libraryFileName指定的动态库，必须指定它的完全路径
void loadLibrary(String libraryName)  载入库名为libraryName的动态库
boolean removeShutdownHook(Thread thrd)  当Java虚拟机中止，从线程列表中移出thrd的运行。如果成功，也就是说如果线程被移出，则返回true（在Java 2的1.3版中新增加的）
void runFinalization( )  调用未用的但还不是回收站中对象的finalize()方法
long totalMemory( )  返回程序可以利用的内存的总字节数
void traceInstructions(boolean traceOn)  根据traceOn的值，打开或关闭指令跟踪。如果traceOn值为true，跟踪被显示。如果traceOn值为false，跟踪被关闭
void traceMethodCalls(boolean traceOn)  根据traceOn的值，打开或关闭调用跟踪的方法。如果traceOn的值为true，跟踪被显示。如果traceOn的值为false，跟踪被关闭
让我们来看一看Runtime类的两个最普遍的用法：内存管理和执行附加进程。

4.1  内存管理

尽管Java提供了自动垃圾回收，有时也想知道对象堆的大小以及它还剩下多少。可以利用这些信息检验你的代码的效率，或估计对某些类型，有多少对象可以被实例化。为了获得这些值，可以使用totalMemory( )和freeMemory( )方法。
正如我们在第1部分提及的，Java的垃圾回收器周期性地运行将不再使用的对象放入回收站。然而有时想在收集器的下一个指定循环之前收集被丢弃的对象。可以通过调用gc( )方法按照要求运行垃圾回收器。一个好的尝试是调用gc( )方法，然后再调用freeMemory( )方法以获得内存使用的底线。接着执行你的程序，并再一次调用freeMemory( )方法看分配了多少内存。下面的例子说明了这个思想。
// Demonstrate totalMemory(), freeMemory() and gc().

class MemoryDemo {
  public static void main(String args[]) {
    Runtime r = Runtime.getRuntime();
    long mem1, mem2;
    Integer someints[] = new Integer[1000];

    System.out.println("Total memory is: " +
                       r.totalMemory());

    mem1 = r.freeMemory();
    System.out.println("Initial free memory: " + mem1);
    r.gc();
    mem1 = r.freeMemory();
    System.out.println("Free memory after garbage collection: "
                       + mem1);

    for(int i=0; i<1000; i++)
      someints[i] = new Integer(i); // allocate integers

    mem2 = r.freeMemory();
    System.out.println("Free memory after allocation: "
                       + mem2);
    System.out.println("Memory used by allocation: "
                       + (mem1-mem2));

    // discard Integers
    for(int i=0; i<1000; i++) someints[i] = null;

    r.gc(); // request garbage collection

    mem2 = r.freeMemory();
    System.out.println("Free memory after collecting" +
                       " discarded Integers: " + mem2);

  }
}
这个例子的一个输出样本如下（当然，你的实际运行结果可能会与之不同）：
Total memory is: 1048568
Initial free memory: 751392
Free memory after garbage collection: 841424
Free memory after allocation: 824000
Memory used by allocation: 17424
Free memory after collecting discarded Integers: 842640

4.2、  执行其他的程序

在可靠的环境中，可以在你的多任务操作系统中使用Java去执行其他特别繁重的进程（也即程序）。exec( )方法的几种形式允许命名想运行的程序以及它们的输入参数。exec( )方法返回一个Process对象，这个对象可以被用来控制你的Java程序如何与这个正在运行的新进程相互作用。因为Java可以运行在多种平台和多种操作系统的情况下，exec( )方法本质上是依赖于环境的。
下面的例子使用exec( )方法装入Window的简单文本编辑器--notepad。显而易见，这个例子必须在Windows操作系统下运行。
// Demonstrate exec().
class ExecDemo {
  public static void main(String args[]) {
    Runtime r = Runtime.getRuntime();
    Process p = null;

    try {
      p = r.exec("notepad");
    } catch (Exception e) {
      System.out.println("Error executing notepad.");
    }
  }
}
exec( )方法有几个形式可用，而在本例子中展示的是最常用的一种。在新程序开始运行之后，由exec( )方法返回的Process对象可以被Process方法使用。可以使用destroy( )方法杀死子进程。waitFor( )方法暂停你的程序直至子进程结束。当子进程结束后，exitValue( )方法返回子进程返回的值。如果没有问题发生，它通常返回0。下面是前面关于exec( )方法例子的改进版本。例子被修改为等待直至正在运行的进程退出：
// Wait until notepad is terminated.
class ExecDemoFini {
  public static void main(String args[]) {
    Runtime r = Runtime.getRuntime();
    Process p = null;

    try {
      p = r.exec("notepad");
      p.waitFor();
    } catch (Exception e) {
      System.out.println("Error executing notepad.");
    }
    System.out.println("Notepad returned " + p.exitValue());
  }
}
当子进程正在运行时，可以从它的标准输入输出进行读和写。getOutputStream( )方法和getInputStream( )方法返回子进程的标准输入（in）和输出（out）的句柄。