在有了前边的基础知识之后，本章将介绍程序中最常用的系统类为了简化程序设计的过程，Java系统事先设计并实现了一些常用功能的标准类，诸如，Object、System、数组类、字符串类、日期类、数学处理类等等，我来为大家科普一下关于java从入门到精通电子版第五版?下面希望有你要的答案，我们一起来看看吧!
java从入门到精通电子版第五版
第六章 系统常用类在有了前边的基础知识之后，本章将介绍程序中最常用的系统类。为了简化程序设计的过程，Java系统事先设计并实现了一些常用功能的标准类，诸如，Object、System、数组类、字符串类、日期类、数学处理类等等。
6.1 常用的基础类6.1.1 Objcet类在Java中Object类是所有类的父类（直接的或间接的），也就是说Java中所有其他的类都是从Object类派生而来的。下边列出Object类几个主要方法：
1）boolean equals(Object obj) 用来比较两个对象是否相同，相同时返回true，否则返回false。
2）Class getClass() 获取当前对象所属类的信息，返回的是Class对象。
3）String toString() 返回对象本身的相关信息，返回值是字符串。
4）Object clone() 创建且返回一个本对象的复制对象（克隆）。
5）void wait() 该线程等待，直到另一个线程叫醒它。
6）int hashCode() 返回对象的哈希码值。
7）void notify() 叫醒该对象监听器上正在等待的线程。
由于继承性，这些方法对于其他类的对象都是适用的。因此，在后边章节中对类的介绍时，将不再重述这些方法而直接使用它们。
6.1.2 System类System类是最基础的类，它提供了标准的输入/输出、运行时系统（Runtime）信息。下边我们简要介绍它的属性和常用的方法。
1）属性
System类提供了如下三个属性：
(1) final static PrintStream out 用于标准输出（屏幕）；
(2) final static InputStream in 用于标准输入（键盘）；
(3) final static PrintStream err 用于标准错误输出（屏幕）。
这三个属性同时又是对象，在前边的例子中已经多次使用过它们。
2）几个常用方法
(1) static long currentTimeMillis() 用来获取1970年1月1日0时到当前时间的微秒数。
(2) static void exit(int status) 退出当前java程序。status为0时表示正常退出，非0时表示因出现某种形式的错误而退出。
(3) static void gc() 回收无用的内存空间进行重新利用。
(4) static void arraycopy(Object src,int srcPos, Object dest,int destPos, int length) 将数组 src中srcpos位置开始的length个元素复制到dest数组中以destPos位置开始的单元中。
(5) static String setProperty(String key, String value) 设置由key指定的属性值为value。
(6) static String getProperties(String properties) 返回properties属性的值。表6.1列出了可以使用的属性。
表6.1 属性
属性
说明
java.version
Java 运行环境版本
java.vendor
Java 运行环境vendor
java.vendor.url
Java vendor URL
java.home
Java 安装目录
java.vm.specification.version
JVM 规范版本
java.vm.specification.vendor
JVM 规范vendor
java.vm.specification.name
JVM 规范名
java.vm.version
JVM实现版本
java.vm.vendor
JVM实现vendor
java.vm.name
JVM实现名
java.specification.version
Java 运行环境规范版本
java.specification.vendor
Java 运行环境规范vendor
java.specification.name
Java 运行环境规范名
java.class.version
Java类格式版本号
java.class.path
Java 类路径
java.library.path
装入库时的路径表
java.io.tmpdir
默认的临时文件路径
java.compiler
JIT 编译器使用的名
java.ext.dirs
目录或延伸目录的路径
os.name
操作系统名
os.arch
操作系统结构
os.version
操作系统版本
file.separator
文件分割符 (UNIX为"/")
path.separator
路径分割符 ( UNIX为":")
line.separator
行分隔符 (UNIX 为"\n")
user.name
用户的帐户名
user.home
用户的基目录
user.dir
用户的当前工作目录
下边我们举例说明某些方法的应用。
例6.1 获取系统相关信息。
/*程序名DisplayPropertyExam6_1.java*/
class DisplayProperty
{
public static void main(String args[]) //main()方法
{
//显示相关的属性信息
System.out.println(System.getProperty("java.version"));
System.out.println(System.getProperty("file.separator"));
System.out.println(System.getProperty("java.vm.version"));
System.out.println(System.getProperty("os.version"));
System.out.println(System.getProperty("os.name"));
System.out.println(System.getProperty("java.class.path"));
System.out.println(System.getProperty("java.specification.vendor"));
}
}
大家可以将要查看的属性放入程序输出语句中，运行程序，查看属性值。
例6.2 设置目录属性，将临时文件存储目录设置为d:/temp，用户工作目录设置为d:\userwork。
/*程序名Set_dirExam6_2.java*/
public class Set_dir
{
public static void main(String args[])
{
System.out.println("原临时文件存储目录名称:" System.getProperty("java.io.tmpdir"));
System.out.println("现将将其设置为d:/temp");
System.setProperty("java.io.tmpdir", "d:/temp");
System.out.println("原用户工作目录名称:" System.getProperty("user.dir"));
System.out.println("现将将其设置为d:/userwork");
System.setProperty("user.dir", "d:/userwork");
System.out.println("新的临时文件存储目录:" System.getProperty("java.io.tmpdir"));
System.out.println("新的用户工作目录名称:" System.getProperty("user.dir"));
}
}
注意：System类不进行实例化，它的属性和方法均是static型，可直接用类名引用。在程序的开头也不需要“import java.lang.System”语句，系统默认它的存在。
6.1.3 Runtime类每个Java应用程序在运行时都有一个Runtime对象，用于和运行环境交互。Java JVM自动生成Runtime对象，得到Runtime对象后，就可以获取当前运行环境的一些状态，如系统版本、用户目录、内存使用情况等。Runtime类常用的方法如下：
1) static Runtime getRuntime() 返回和当前Java应用程序关联的运行时对象。
2) Process exec(String command) 在一个单独的进程中执行由command指定的命令。
3) Process exec(String[] cmdarray) 在一个单独的进程中执行由cmdarra指定的带有参量的命令。
4) Process exec(String[] cmdarray, String[] envp, File dir) 在一个单独的进程中，以envp中环境变量设置的环境和dir设置的工作目录执行由cmdarray指定的带有参量命令。
5) void load(String filename) 作为动态库装入由filename指定的文件。
6) void loadLibrary(String libname) 以libname指定的库名装入动态库。
7) void traceInstructions(boolean on) 能够/禁止指令跟踪。
8) void traceMethodCalls(boolean on) 能够/禁止方法调用跟踪。
9) void exit(int status) 结束程序执行，status表示结束状态。
10) long freeMemory() 返回Java系统当前可利用的空闲内存。
11) long maxMemory() 返回JVM所期望使用的最大内存量。
12) long totalMemory() 返回Java系统总的内存。
注意：applet不能调用该类任何的方法。
下边举一个简单的例子说明Runtime类的应用。
例6.3 测试系统内存的大小，并在Java中装入记事本程序notepad.exe编辑文本文件。
/*程序名RuntimeAppExam6_3.java*/
class RuntimeApp
{
public static void main(String args[]) throws Exception
{
Runtime rt = Runtime.getRuntime(); //创建对象
System.out.println("最大内存: " rt.maxMemory());
System.out.println("总内存: " rt.totalMemory());
System.out.println("可用内存: " rt.freeMemory());
rt.exec("notepad");//调用记事本程序
}
}
6.1.4 基本数据类型类如前所述，每一种基本数据类型都对应有相应的类包装，这些类提供了不同类型数据的转换及比较等功能。下边简要介绍一下Integer类。对于其他的基本类型类及细节说明，需要时可查阅相应的手册。
1）Integer类的常用属性
(1) static int MAX_VALUE 最大整型常量2147483647。
(2) static int MIN_VALUE 最小整型常量-2147483648。
(3) static int SIZE 能表示的二进制位数32。
2）构造器
(1) Integer(int value) 以整数值构造对象。
(2) Integer(String s) 以数字字符串构造对象。
3）常用方法
(1) byte byteValue() 返回整数的字节表示形式。
(2) short shortValue() 返回整数的short表示形式。
(3) int intValue() 返回整数的int表示形式。
(4) long longValue() 返回整数long的表示形式。
(5) float floatValue() 返回整数float的表示形式。
(6) double doubleValue() 返回整数double的表示形式。
(7) int compareTo(Integer anotherInteger) 与另一个整数对象相比较，若相等返回0；若大于比较对象，返回1；否则返回-1。
(8) static Integer decode(String nm) 把字符串nm译码为一个整数。
(9) static int parseInt(String s) 返回字符串的整数表示形式。
(10) static int parseInt(String s, int radix) 以radix为基数返回字符串s的整数表示形式。
(11) static String toBinaryString(int i) 返回整数i的二进制字符串表示形式。
(12) static String toHexString(int i) 返回整数i的十六进制字符串表示形式。
(13) static String toOctalString(int i) 返回整数i的八进制字符串表示形式。
(14) static String toString(int i) 返回整数i的字符串表示形式。
(15) static String toString(int i, int radix) 以radix为基数返回i的字符串表示形式。
(16) static Integer valueOf(String s) 返回字符串s的整数对象表示形式。
(17) static Integer valueOf(String s, int radix) 以radix为基数返回字符串s的整数对象表示形式。
(18) static int bitCount(int i) 返回i 的二进制表示中”1”位的个数。
下边我们写一个简单的例子看一下Integer类及方法的应用。
例6.4 输出整数668的各种进制数的表示。
//IntegerAppExam6_4.java
public class IntegerApp
{
public static void main(String [] args)
{
int n=668;
System.out.println("十进制表示：" n);
System.out.println("二进制表示：" Integer.toBinaryString(n));
System.out.println("八进制表示：" Integer.toOctalString(n));
System.out.println("十二进制表示：" Integer.toString(n,12));
System.out.println("十六进制表示：" Integer.toHexString(n));
System.out.println("二进制表示中1位的个数：" Integer.bitCount(n));
}
}
编译、运行程序，结果如图6-1所示。
图6-1 例6.4运行结果
6.1.5 Math类Math类提供了用于数学运算的标准方法及常数。
1）属性
(1) static final double E=2.718281828459045；
(2) static final double PI=3.141592653589793；
2）常用方法
(1) static 数据类型 abs(数据类型 a) 求a的绝对值。其中数据类型可以是int、long、float和double。这是重载方法。
(2) static 数据类型 max(数据类型 a, 数据类型 b) 求a，b中的最大值。数据类型如上所述。
(3) static 数据类型 min(数据类型 a, 数据类型 b) 求a，b中的最小值。数据类型如上所述。
(4) static double acos(double a) 返回Arccosa的值。
(5) static double asin(double a) 返回Arcsina的值。
(6) static double atan(double a) 返回Arctga的值。
(7) static double cos(double a) 返回cosa的值。
(8) static double exp(double a) 返回ea的值。
(9) static double log(double a) 返回lna的值。
(10) static double pow(double a, double b) 求ab的值。
(11) static double random() 产生0～１之间的随机值，包括0而不包括1。
(12) static double rint(double a) 返回靠近a的且等于整数的值，相当于四舍五入去掉小数部分。
(13) static long round(double a) 返回a 靠近long的值.。
(14) static int round(float a) 返回a靠近int的值。
(15) static double sin(double a) 返回sina的值。
(16) static double sqrt(double a) 返回a的平方根。
(17) static double tan(double a) 返回tga的值。
(18) static double toDegrees(double angrad) 将angrad表示的弧度转换为度数。
(19) static double toRadians(double angdeg) 将angdeg表示的度数转换为弧度。
Math类提供了三角函数及其它的数学计算方法，它们都是static型的，在使用时直接作为类方法使用即可，不需要专门创建Math类的对象。
6.2 数组数组是一种构造型的数据类型。数组中的每个元素具有相同的数据类型，且可以用数组名和下标来唯一地确定。数组是有序数据的集合。在Java语言中，提供了一维数组和多维数组。带一个下标的数组称为一维数组，带多个下标的数组称为多维数组。
6.2.1 一维数组和其他变量一样，数组必须先声明定义，而后赋值，最后被引用。
1．一维数组的声明
一维数组声明的一般格式如下：
数据类型 数组名[ ]；
或：数据类型 [] 数组名；
其中：
1）数据类型说明数组元素的类型，可以是Java中任意的数据类型。
2）数组名是一个标识符，应遵照标识符的命名规则。
例如：
int intArray[]； //声明一个整型数组
String strArray[]; //声明一个字符串数组
数组的声明只是说明了数组元素的数据类型，系统并没有为其安排存储空间。要使用数组，还必须为其定义大小（安排存储空间）。
2．一维数组大小的定义及初始化
一般情况下，使用new运算符定义数组大小，例如下边的程序语句：
int intArray[]; //声明一个整型数组
intArray = new int[5]; //定义数组可以存放5个整数元素
String strArray[ ]; //声明一个字符串数组
String strArray = new String[3]; //定义数组可以存放三个字符串元素
//为数组中每个元素赋值
intArray[0]=1; //数组下标从0开始
intArray[1]=2;
intArray[2]=3;
intArray[3]=4;
intArray[4]=5;
strArray[0]="How";
strArray[1]="are";
strArray[2]="you";
通常我们也采用如下方式为数组元素赋初值并由初值的个数确定数组的大小：
int intArray[]={1,2,3,4};
String stringArray[]={"abc", "How", "you"};
以达到和上边同样的目的。
3．一维数组元素的引用
如前所述，以数组名和下标引用数组元素，数组元素的引用方式为：
数组名[下标]
其中：
1）下标可以为整型常数或表达式，下标值从0开始。
2）数组是作为对象处理的，它具有长度（length）属性，用于指明数组中包含元素的个数。因此数组的下标从0开始到length-1结束。如果在引用数组元素时，下标超出了此范围，系统将产生数组下标越界的异常（ArrayIndexOutOfBoundsException）。
下边我们举例说明数组的应用。
例6.5 计算一组同学一门功课的平均成绩、最高成绩和最低成绩。
/** 这是计算一组同学一门成绩情况的程序，使用数组score存放各同学的成绩
* 变量 average 存放平均值、max存放最高成绩、min存放最低成绩。
* 程序的名称为：Avg_Max_minExam6_5.java
*/
public class Avg_Max_Min
{
public static void main(String [] args)
{
int [] score = {72,89,65,58,87,91,53,82,71,93,76,68};
float average=0.0f;
float max=score[0]; //设置比较基值
float min=score[0]; //设置比较基值
for(int i=0; i<score.length;i )
{
average =score[i];
if (max<score[i]) max=score[i];
if (min>score[i]) min=score[i];
}
average/=score.length;
System.out.println("average=" average " Max=" max " Min=" min);
}
}
编译运行程序，结果如图6-2所示。
图6-2 例6.5运行结果
6.2.2 二维及多维数组在Java语言中，多维数组是建立在一维数组基础之上的，以二维数组为例，可以把二维数组的每一行看作是一个一维数组，因此可以把二维数组看作是一维数组的数组。同样也可以把三维数组看作二维数组的数组，以此类推。在通常的应用中一维、二维数组最为常见，更多维数组只应用于特殊的场合。下边我们仅介绍二维数组。
1． 二维数组的声明
声明二维数组的一般格式如下：
数据类型 数组名[ ][ ]；
或：数据类型 [ ][ ] 数组名;
和一维数组类似，二维数组的声明只是说明了二维数组元素的数据类型并没有为其分配存储空间。
2. 二维数组大小的定义及初始化
我们可以如下的方式定义二维数组的大小并为其赋初值。
1） 先声明而后定义最后再赋值
例如下边的程序语句：
int matrix[][]; //声明二维整型数组matrix
matrix = new int[3][3]; //定义matrix包含3×3九个元素
matrix[0][0]=1; //为第一个元素赋值
matrix[0][1]=2; //为第二个元素赋值
matrix[0][2]=3; //为第三个元素赋值
matrix[1][0]=4; //为第四个元素赋值
………………
matrix[2][2]=9; //为第九个元素赋值
2) 直接定义大小而后赋值
例如下边的程序语句：
int matrix=new int[3][3];//定义二维整型数组matrix包含3×3九个元素
matrix[0][0]=1; //为第一个元素赋值
………………
matrix[2][2]=9; //为第九个元素赋值
3） 由初始化值的个数确定数组的大小
在元素个数较少并且初值已确定时通常采用此种方式，例如：
int matrix[][]={{1,2,3},{4,5,6},{7,8,9}};//由元素个数确定3行3列
3．二维数组元素的应用
下边我们举例说明二维数组的应用。
例6.6 两个矩阵相乘。设有三个矩阵A、B、C，A和B矩阵相乘，结果放入C中，即 C=A×B。要求：
A[l][m] × B[m][n] = C[l][n] 即矩阵A的列数应该等于B矩阵的行数，结果矩阵C的行数等于A矩阵的行数，列数等于B矩阵的列数。
C矩阵元素的计算公式为：
C[i][j]=∑(a[i][k]*b[k][j]） （其中： i=0~l , j=0~n , k=0~m）
程序参考代码如下：
/* 这是求两个矩阵乘积的程序。程序名称：ProductOfMatrix.java */
public class ProductOfMatrixExam6_6
{
public static void main(String args[])
{
int A[][]=new int [2][3]; //定义A为2行3列的二维数组
int B[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//B为3行4列
int C[][]=new int[2][4]; //C为2行4列
System.out.println("***Matrix A***");
for(int i=0;i<2;i )
{
for(int j=0; j<3 ;j )
{
A[i][j]=(i 1)*(j 2); //为A各元素赋值
System.out.print(A[i][j] " "); //输出A的各元素
}
System.out.println();
}
System.out.println("***Matrix B***");
for(int i=0;i<3;i )
{ //输出B的各元素
for(int j=0; j<4 ;j ) System.out.print(B[i][j] " ");
System.out.println();
}
System.out.println("***Matrix C***");
for(int i=0;i<2;i )
{
for(int j=0;j<4;j )
{//计算C[i][j]
C[i][j]=0;
for(int k=0;k<3;k ) C[i][j] =A[i][k]*B[k][j];
System.out.print(C[i][j] " "); //输出C[i][j]
}
System.out.println();
}
}
}
编译、运行程序，结果如图6-3所示。
图6-3 例6.6运行结果
4. 不同长度的二维数组
在解线形方程组、矩阵运算等应用中，使用二维数组一般是相同长度的，即每行的元素个数是相等的。但有时我们会遇到类似三角形的阵列形式，如表3.1九九乘法表。
表3.1 九九乘法表
1
2
3
4
5
6
7
8
9
1
1
2
2
4
3
3
6
9
4
4
8
12
16
5
5
10
15
20
25
6
6
12
18
24
30
36
7
7
14
21
28
35
42
49
8
8
16
24
32
40
48
56
64
9
9
18
27
36
45
54
63
72
81
要存储乘法表的值需要一个三角数组。在Java中，由于把二维数组看作是一维数组的数组，因此可以把二维数组的每一行作为一个一维数组分别定义，并不要求二维数组每一行的元素个数都相同。例如：
int a[][] = new int[2][ ]; //说明a是二维数组，有2行
a[0] = new int[3]; //a[0]定义第1行，有3列
a[1] = new int[5]; //a[1]定义第2行，有5列
下边就以九九乘法表为例说明不同长度二维数组的应用。
例6.7 存储并输出九九乘法表。
/** 存储并输出九九乘法表程序，主要说明不同长度二维数组的应用
* 程序的名字：Multiplication_tableExam6_7.java **/
public class Multiplication_table
{
public static void main(String [] args)
{
int mulTable[][] = new int [9][];//定义二维数组有9行
for(int i=1; i<=9; i )
{
mulTable[i-1]= new int[i]; //定义各行的大小
for(int j=1; j<=i; j ) mulTable[i-1][j-1]=i*j;//计算乘法表
}
//输出九九乘法表
System.out.println(" |\t1\t2\t3\t4\t5\t6\t7\t8\t9");
System.out.println("-- ---------------------------------- ------------------------------------");
for(int i=0; i<9; i )
{
System.out.print(" " (i 1) "|");
for(int j=0; j<mulTable[i].length; j )
System.out.print("\t" mulTable[i][j]);
System.out.println(" ");
}
}
}
编译、运行程序，请查看运行结果。
6.2.3 数组（Arrays）类数组是程序中常用的一种数据结构。在java.util类包中提供了Array（数组）类，用于对数组进行诸如排序、比较、转换、搜索等运算操作。
Array类提供众多的类方法（静态方法）对各种类型的数组进行运算操作，下边列出一些常用的类方法供大家使用时参考，如果使用其他的方法可参阅JDK文档。
1） static void sort(数据类型 [] d) 用于对数组d进行排序（升序），数据类型是除boolean之外的任何数据类型。
2） static void sort(数据类型 [] a, int start,int end) 对数组a中指定范围从start到end位置之间的数据元素进行排序。当start大于end时引发IllegalArgumentException异常。当超界时，引发ArrayIndexOutOfBoundsException异常。
3）static void fill(数据类型 [] a,数据类型 value) 设置a数组各个元素的值为value。
4）static void fill(数据类型 [] a,int start,int end,数据类型 value) 设置a数组中从start到end位置的元素的值为value。
5）static int binarySeach(数据类型[] a,数据类型 key) 利用二进制搜索数组(排过序)内元素值为key的所在位置。
6）static boolean equals(数据类型[] d1,数据类型[] d2) 判断d1和d2两数组是否相等。
我们只要掌握类方法的引用即可对数组进行相关的运算操作。类方法的一般引用格式如下： 类名.方法名（参量表）；
下边我们举例说明其应用。
例6.8 将一组学生的单科成绩放在数组中，分别将排序前和排序后的数据输出，并搜索最靠近平均值的位置。
//Array_SortExam6_8.java
import java.util.Arrays; //引入java.util.Arrays类
public class Array_Sort
{
public static void main(String[] args)
{
int[] score={87,76,64,89,96,78,81,78,69,95,58,92,86,79,54};
int average=0;
System.out.println("排序前:");
for(int i=0; i<score.length; i )
{
average =score[i]; //求总成绩
System.out.print(score[i] " ");
}
average/=score.length; //求平均成绩
Arrays.sort(score); //排序
System.out.println("\n 排序后：");
for(int i=0; i<score.length; i ) System.out.print(score[i] " ");
//输出搜索平均值的位置
System.out.println("\n" average "的位置是:"
Arrays.binarySearch(score,average));
}
}
编译、运行程序，结果如图6-4所示。
图6-4 例6.8运行结果
例6.9 对二维数组指定的行进行排序并观察输出结果。
/**
* 本例主要演示对数组中部分数据进行排序，即对二维数组中的行
* 程序名为 SortArrayExam6_9.java
*/
public class PartSort
{
public static void main(String[] args)
{
int[][] intNum={{73,85,67,72},{56,43,92,80,84,75},{54,67,54, 98,72}};
System.out.println("排序之前的数组：:");
for(int i=0; i<intNum.length;i )
{
for(int j=0; j<intNum[i].length; j )
System.out.print(intNum[i][j] " "); //输出数组元素值
System.out.println(" ");
}
SortArray.sort(intNum[1]); //调用排序方法对第二行进行排序
System.out.println("\n排序之后的数组：");
for(int i=0; i<intNum.length;i )
{
for(int j=0; j<intNum[i].length; j )
System.out.print(intNum[i][j] " ");
System.out.println();
}
}
}
编译、运行程序，结果如图6-5所示。我们可以观察一下第二行数据的变化情况。
图6-5 例6.9运行结果
6.3 字符串如前所述，字符是一基本的数据类型，而字符串是抽象的数据类型，只能使用对象表示字符串。前边我们已经对字符串进行了简单处理及其操作。下边我们将详细介绍用于字符串处理的类及其应用。
6.3.1 String类String类是最常用的一个类，它用于生成字符串对象，对字符串进行相关的处理。
1． 构造字符串对象
在前边我们使用字符串时，是直接把字符串常量赋给了字符串对象。其实String类提供了如下一些常用的构造函数用来构造字符串对象：
1）String() 构造一个空的字符串对象。
2）String( char chars[ ] ) 以字符数组chars的内容构造一个字符串对象。
3）String( char chars[ ], int startIndex, int numChars ) 以字符数组chars中从startIndex位置开始的numChars个字符构造一个字符串对象。
4）String(byte [] bytes) 以字节数组bytes的内容构造一个字符串对象。
5）String(byte[] bytes, int offset, int length) 以字节数组bytes中从offset位置开始的length个字节构造一个字符串对象。
还有一些其他的构造函数，使用时可参考相关的手册。
下面的程序片段以多种方式生成字符串对象：
String s=new String() ; //生成一个空串对象
char chars1[]={'a','b','c'}; //定义字符数组chars1
char chars2[]={'a','b','c','d','e'};//定义字符数组chars2
String s1=new String(chars1);//用字符数组chars1构造对象s1
String s2=new String(chars2,0,3);//用chars2前3个字符构造对象
byte asc1[]={97,98,99};//定义字节数组asc1
byte asc2[]={97,98,99,100,101};//定义字节数组asc2
String s3=new String(asc1);//用字节数组asc1构造对象s3
String s4=new String(asc2,0,3);//用字节数组asc2前3个字节构造对象s4。
2．String类对象的常用方法
String类也提供了众多的方法用于操作字符串，以下列出一些常用的方法：
1）public int length() 此方法返回字符串的字符个数。
2） public char charAt(int index) 此方法返回字符串中index位置上的字符，其中index 值的 范围是0~length-1。例如：
String str1=new String(“This is a string.”); //定义字符串对象str1
int n=str1.length(); //获取字符串str1的长度n=17
char ch1=str1.charAt(n-2); //获取字符串str1倒数第二个字符,ch1=’g’
3）public int indexOf(char ch) 返回字符ch在字符串中第一次出现的位置。
4）public lastIndexOf(char ch) 返回字符ch在字符串中最后一次出现的位置。
5）public int indexOf(String str) 返回子串str在字符串中第一次出现的位置。
6）public int lastIndexOf(String str) 返回子串str在字符串中最后一次出现的位置。
7）public int indexOf(int ch,int fromIndex) 返回字符ch在字符串中fromIndex位置以后第一次出现的位置。
8）public lastIndexOf(in ch ,int fromIndex) 返回字符ch在字符串中fromIndex位置以后最后一次出现的位置
9）public int indexOf(String str,int fromIndex) 返回子串str在字符串中fromIndex位置后第一次出现的位置。
10）public int lastIndexOf(String str,int fromIndex) 返回子串str在字符串中fromIndex位置后最后一次出现的位置。例如：
String str2=new String(“too wonderful for words;most intriguing.”) ;
int n=str2.indexOf(‘o’); // n=1
n=str2.lastIndexOf(‘o’); // n=25
n=str2.indexOf(“wo”); // n=4
n=str2.lastIndexOf(“wo”); // n=18
n=str2.indexOf(‘o’,16); // n=19
n=str2.indexOf(‘r’,21); // n=32
11）public String substring(int beginIndex) 返回字符串中从beginIndex位置开始的字符子串。
12）public String substring(int beginIndex, int endIndex) 返回字符串中从beginIndex位置开始到endIndex位置(不包括该位置)结束的字符子串。例如：
String str3=new String(“it takes time to know a person”);
String str4=str3.substring(16); //str4=” know a person”
String str5=str3.substring(3,8); //str5=”takes”
13）public String contact(String str) 用来将当前字符串与给定字符串str连接起来。
14）public String replace(char oldChar,char newChar) 用来把串中所有由oldChar指定的字符替换成由newChar指定的字符以生成新串。
15）public String toLowerCase() 把串中所有的字符变成小写且返回新串。
16）public String toUpperCase() 把串中所有的字符变成大写且返回新串。
17）public String trim() 去掉串中前导空格和拖尾空格且返回新串。
18）public String[] split(String regex) 以regex为分隔符来拆分此字符串。
文字（字符串）处理在应用系统中是很重要的一个方面，应该熟练掌握字符串的操作。限于篇幅还有一些方法没有列出，需要时请参阅相关的手册。
3. 字符串应用示例
例6.10 生成一班20位同学的学号并按每行5个输出。
/* 程序名：StringOp1.java */
public class StringOp1
{
public static void main(String [] args)
{
int num=101;
String str="20060320";
String[] studentNum=new String[20]; //存放学号
for(int i=0; i<20; i )
{
studentNum[i]=str num; //生成各学号
num ;
}
for(int i=0; i<20; i )
{
System.out.print(studentNum[i] " ");
if((i 1)%5==0) System.out.println(" ");//输出5个后换行
}
}
}
程序运行结果如图6-6所示。
图6-6 例6.10运行结果
注意：由于字符串的连接运算符" "使用简便，所以很少使用contact()方法进行字符串连接操作。当一个字符串与其他类型的数据进行" "运算时，系统自动将其他类型的数据转换成字符串。例如：
int a=10,b=5;
String s1=a ” ” b ”=” a b;
String s2=a ” ” b ”=” (a b);
System.out.println(s1); // 输出结果： 10 5=105
System.out.println(s2); // 输出结果： 10 5=15
大家可以思考一下s1和s2的值为什么不一样。
例6.11 给出一段英文句子，将每一个单词分解出来放入数组元素中并排序输出。
/*本程序的主要目的是演示对象方法的使用。程序名：UseStringMethod.java */
import java.util.Arrays; //引入数组类Arrays
public class UseStringMethod
{
public static void main(String [] args)
{
String str1="The String class represents character strings. All string literals in Java programs, such as \"abc\", are implemented as instances of this class.";
String [] s =new String[50]; //定义数组含50个元素
str1=str1.replace('\"',' '); //将字符串中的转义字符\”替换为空格
str1=str1.replace(',',' '); //将字符串中的,号字符替换为空格
str1=str1.replace('.',' '); //将字符串中的.字符替换为空格
//System.out.println(str1); //输出处理后的字符串
int i=0,j;
while((j=str1.indexOf(" "))>0) //查找空格,若找到,则空格前是一单词
{ s[i ]=str1.substring(0,j); //将单词取出放入数组元素中
str1=str1.substring(j 1); //在字符串中去掉取出的单词部分
str1=str1.trim(); //去掉字符串的前导空格
}
Arrays.sort(s,0,i); //在上边析取了i 个单词，对它们进行排序
for(j=0; j<i; j )
{ System.out.print(s[j] ” ”); //输出各单词
if((j 1)%5==0) System.out.println();
}
System.out.println();
}
}
程序运行结果如图6-7所示。
图6-7 例6.11运行结果
6.3.2 StringBuffer类在字符串处理中，String类生成的对象是不变的，即String中对字符串的运算操作不是在源字符串对象本身上进行的，而是使用源字符串对象的拷贝去生成一个新的字符串对象，其操作的结果不影响源串。
StringBuffer中对字符串的运算操作是在源字符串本身上进行的，运算操作之后源字符串的值发生了变化。StringBuffer类采用缓冲区存放字符串的方式提供了对字符串内容进行动态修改的功能，即可以在字符串中添加、插入和替换字符。StringBuffer类被放置在java.lang类包中。
1. 创建StringBuffer类对象
使用StringBuffer类创建StringBuffer对象，StringBuffer类常用的构造方法如下：
1）StringBuffer() 用于创建一个空的StringBuffer对象；
2）StringBuffer(int length) 以length指定的长度创建StringBuffer对象；
3）StringBuffer(String str) 用指定的字符串初始化创建StringBuffer对象。
注意： 与String类不同，必须使用StringBuffer类的构造函数创建对象，不能直接定义StringBuffer类型的变量。
如：StringBuffer sb = ”This is string object!”; 是不允许的。
必须使用：StringBuffer sb= new StringBuffer(”This is string object!”);
由于StringBuffer对象是可以修改的字符串，所以在创建StringBuffer对象时，并不一定都进行初始化工作。
2. 常用方法
1) 插入字符串方法insert()
insert()方法是一个重载方法，用于在字符串缓冲区中指定的位置插入给定的字符串。它有如下形式：
（1）insert(int index, 类型 参量) 可以在字符串缓冲区中index指定的位置处插入各种数据类型的数据（int、double、boolean、char、float、long、String、Object等）。
（2）insert（int index, char [] str, int offset, int len） 可以在字符串缓冲区中index指定的位置处插入字符数组中从下标offset处开始的len个字符。如：
StringBuffer Name=new StringBuffer(“李青青”);
Name.insert(1,”杨”);
System.out.println(Name.toString());//输出：李杨青青
2）删除字符串方法
StringBuffer类提供了如下常用的删除方法：
（1）delete(int start,int end) 用于删除字符串缓冲区中位置在start~end之间的字符。
（2）deleteCharAt(int index) 用于删除字符串缓冲区中index位置处的字符。
如：
StringBuffer Name=new StringBuffer(“李杨青青”);
Name.delete(1,3);
System.out.println(Name.toString());//输出：李青
3) 字符串添加方法 append()
append()方法是一个重载方法，用于将一个字符串添加到一个字串缓冲区的后面，如果添加字符串的长度超过字符串缓冲区的容量，则字符串缓冲区将自动扩充。它有如下形式：
（1）append (数据类型 参量名) 可以向字符串缓冲区添加各种数据类型的数据（int、double、boolean、char、float、long、String、Object等）。
（2）append(char[] str,int offset,int len) 将字符数组str中从offset指定的下标位置开始的len个字符添加到字符串缓冲区中。如：
StringBuffer Name=new StringBuffer(“李”);
Name.append(”杨青青”);
System.out.println(Name.toString());//输出：李杨青青
4) 字符串的替换操作方法 replace()
replace()方法用于将一个新的字符串去替换字串缓冲区中指定的字符。它的形式如下：
replace(int start,int end,String str) 用字符串str替换字符串缓冲区中从位置start到end之间的字符。如：
StringBuffer Name=new StringBuffer(“李杨青青”);
Name.replace(1,3,“ “);
System.out.println(Name.toString());//输出：李 青
5）获取字符方法
StringBuffer提供了如下从字串缓冲区中获取字符的方法：
(1) charAt(int index) 取字符串缓冲区中由index指定位置处的字符；
(2) getChars(int start, int end, char[] dst, int dstStart) 取字符串缓冲区中start~end之间的字符并放到字符数组dst中以dstStart下标开始的数组元素中。
如：
StringBuffer str=new StringBuffer(”三年级一班学生是李军”)
char[] ch =new char[10];
str.getChars(0, 7, ch, 3);
str.getChars(8, 10, ch, 0);
chr[2]=str.charAt(7);
System.out.println(ch); //输出：李军是三年级一班学生
6) 其他几个常用方法
(1) toString() 将字符串缓冲区中的字符转换为字符串。
(2) length() 返回字符串缓冲区中字符的个数。
(3) capacity() 返回字符串缓冲区总的容量。
(4) ensureCapacity(int minimumCapacity) 设置追加的容量大小。
(5) reverse() 将字符串缓冲区中的字符串翻转。如：
StringBuffer str = new StringBuffer("1东2西3南4北5");
str.reverse();
System.out.println(str.toString()); //输出：5北4南3西2东1
(6) lastIndexOf(String str) 返回指定的字符串str在字符串缓冲区中最右边（最后）出现的位置。
(7) lastIndexOf(String str,int fromIndex) 返回指定的字符串str在字符串缓冲区中由fromIndex指定的位置前最后出现的位置。
(8) substring(int start) 取字串。返回字符串缓冲区中从start位置开始的所有字符。
(9) substring(int start, int end) 取字串。返回字符串缓冲区中从位置start开始到end之前的所有字符。
3. 应用举例
例6.12 建立一个学生类，包括学号、姓名和备注项的基本信息。为了便于今后的引用，单独建立一个Student类如下：
/*程序名：Student.java */
package student;
import java.lang.StringBuffer;
public class Student
{
public String studentID; //学号
public String studentName; //姓名
public StringBuffer remarks; //备注
public Student(String ID,String name,String remarks) //构造方法
{
studentID=ID;
studentName=name;
this.remarks=new StringBuffer(remarks);
}
public void display(Student obj) //显示方法
{
System.out.print(obj.studentID " " obj.studentName);
System.out.println(obj.remarks.toString());
}
}
}
例6.13 创建学生对象，对学生的备注项进行修改。
/*程序名：CreateStudent.java */
import Student;
public class CreateStudent
{
public static void main(String args[])
{
Student [] students= new Student[3];
students[0]=new Student("20060120105","张山仁","");
students[1]=new Student("20060120402","李斯文","");
students[2]=new Student("20060120105","王五强","");
students[1].remarks.append(" 2006秋季运动会5000米长跑第一名");
students[2].remarks.insert(0," 2006第一学期数学课代表");
for(int i=0; i<students.length; i )
{
students[i].display(students[i]);
}
}
}
先编译Sudent.java，再编译CreateStudent.java，执行结果如图6-8所示。
图6-8 例6.13运行结果
6.3.3 StringTokenizer类字符串是Java程序中主要的处理对象，在Java.util类包中提供的StringTokenizer（字符串标记）类主要用于对字符串的分析、析取。，如提取一篇文章中的每个单词等。下边我们简要介绍StringTokenizer类的功能和应用。
1. StringTokenizer类的构造器
StringTokenizer类对象构造器如下：
1）StringTokenizer(String str)
2）StringTokenizer(String str, String delim)
3）StringTokenizer(String str, String delim, boolean returnDelims)
其中：
(1) str 是要分析的字符串。
(2) delim 是指定的分界符。
(3) returnDelims 确定是否返回分界符。
可将一个字符串分解成数个单元（Token—标记），以分界符区分各单元。系统默认的分界符是空格“ ”、制表符“\t”、回车符”\r”、分页符”\f”。当然也可指定其它的分界符。
2. 常用方法
StringTokenizer提供的常用方法如下：
1) int countTokens() 返回标记的数目。
2) boolean hasMoreTokens() 检查是否还有标记存在。
3) String nextToken() 返回下一个标记；
4) String nextToken(String delimit) 根据delimit指定的分界符，返回下一个标记。
3. 应用举例
例6.14 统计字符串中的单词个数。
/*程序名TokenExample.java*/
import java.util.StringTokenizer;
class TokenExample
{
public static void main(String[] args)
{
StringTokenizer tk=new StringTokenizer("It is an example");
int n=0;
while(tk.hasMoreTokens())
{
tk.nextToken();
n ;
}
System.out.println("单词个数:" n); //输出单词数
}
}
例6.15 按行输出学生的备注信息。
/*程序名:OutStudentInformation.java */
import student.Student;
import java.util.StringTokenizer;
public class OutStudentInformation
{
public static void main(String args[])
{
Student [] students= new Student[3];
students[0]=new Student("20060120105","张山仁","");
students[1]=new Student("20060120402","李斯文"," 2006秋季运动会5000米长跑第一名 院英语竞赛第二名");
students[2]=new Student("20060120105","王五强"," 2006第一学期数学课代表 一等奖学金");
for(int i=0; i<students.length; i )
{
System.out.println("\n" students[i].studentName "简介:");
StringTokenizer tk=new StringTokenizer(students[i].remarks. toString());
while(tk.hasMoreTokens())
System.out.println(tk.nextToken());
}
}
}
请大家自己运行一下上述的两个例子，加深对字符串处理的认识。
6.4其他常用工具类在前边我们介绍了Java.util包中StringTokenizer和Arrays类，下边再介绍几个常用的工具类。
6.4.1 向量（Vector）类和数组类似，向量也是一组对象的集合，所不同的是，数组只能保存同一类型固定数目的元素，一旦创建，便只能更改其元素值而不能再追加数组元素。尽管可以重新定义数组的大小，但这样做的后果是原数据丢失，相当于重新创建数组。向量既可以保存不同类型的元素，也可以根据需要随时追加对象元素，从某种意义上说，它相当于动态可变的数组。
下边我们简要介绍一下向量的功能和应用。
1. Vector类的构造器
创建Vector对象的构造器如下：
1）Vector() 创建新对象。其内容为空，初始容量为10。
2）Vector( Collection obj) 以类Colloction（集合）的实例obj创建新对象，新对象包含了Collection对象obj的所有的元素内容。
3）Vector( int initialCapacity ) 创建新对象。其内容为空，初始容量由initialCapacity指定。
4）Vector( int initialCapacity, int capacityIncrement ) 创建新对象。其内容为空，初始容量由initialCapacity指定，当存储空间不够时，系统自动追加容量，每次追加量由capacityIncrement指定 。如：
Vector studentVector=new Vector(100,10);
创建对象时，初始容量为100，以后根据使用需要以10为单位自动追加容量。
2. 常用方法
Vector类提供的常用方法如下：
1）添加元素方法 add()
(1) viod add(int index, Object obj) 在向量中由index指定的位置处存放对象obj。
(2) boolean add(Object obj) 在向量的尾部追加对象obj。若操作成功，返回真值，否则返回假值。
(3) boolean addAll(Collection obj) 在向量的尾部追加Collection对象obj。若操作成功，返回真值，否则返回假值。
(4) addAll(int index,Collection obj) 在向量中由index指定的位置处开始存放Collection对象obj的所有元素。
(5) insertElement(Object obj,int index) 在向量中由index指定的位置处存放对象obj。
如：
Vector aVector=new Vector(5)；
aVector.add(0,”aString”);
Integer aInteger=new Integer(12);
aVector.add(1,aInteger);
2) 移除元素方法 remove()
(1) remove(int index) 在向量中移除由index指定位置的元素。
(2) boolean remove(Object obj) 在向量中移除首次出现的obj对象元素。若操作成功，返回真值，否则返回假值。
(3) boolean removeAll(Collection obj) 在向量中移除obj对象的所有元素。若操作成功，返回真值，否则返回假值。
(4) removeAllElements() 在向量中移除所有元素。
3) 获取元素方法
(1) Object get(int index) 获取由index指定位置的向量元素。
(2) Object lastElement() 获取向量中最后一个元素。
(3) Object[] toArray() 将向量中的所有元素依序放入数组中并返回。
4) 查找元素方法 indexOf()
(1) int indexOf(Object obj) 获得obj对象在向量中的位置。
(2) int indexOf(Object obj, int index) 从index位置开始查找obj对象，并返回其位置。
(3) boolean contains(Object obj) 查找向量中是否存在obj对象，若存在返回ture；否则false。
5）其他方法
(1) boolean isEmpty() 测试向量是否为空。
(2) int capacity() 返回向量的当前容量。
(3) int size() 返回向量的大小即向量中当前元素的个数。
(4) boolean equals(Object obj) 将向量对象与指定的对象obj比较是否相等。
注意：向量的容量与向量的大小是两个不同的概念。向量容量是指为存储元素开辟的存储单元，而向量的大小是指向量中现有元素的个数
3. 应用举例
在前边的例子中，我们使用StringTokenizer类和数组的功能统计字符串中单词出现的频度，下边还以析取单词为例，使用向量的功能进行相关的处理。
例6.16 统计一个英文字符串(或文章)中使用的单词数。
程序的基本处理思想和步骤如下：
1）利用StringTokenizer类对象的功能析取单词；
2）为保证唯一性，去掉重复的单词，并将单词存入向量中；
3）利用Voctor类对象的功能，统计单词数。
程序代码如下：
/*程序名WordsVector.java*/
import java.util.*;
class WordsVector
{
public static void main(String[] args)
{
StringTokenizer tk=new StringTokenizer("It is an example for obtaining words . It uses methods in Vector class .");
Vector vec=new Vector(); //定义向量
while(tk.hasMoreTokens())
{
String str=new String(tk.nextToken()); //取单词
if(!(vec.contains(str))) vec.add(str); //若向量中无此单词则写入
}
for(int i=0; i<vec.size(); i ) System.out.print(vec.get(i) " ");//输出各单词
System.out.println("\n字符串中使用了" vec.size() "个单词");
}
}
例6.17 修改上例改用Vector类的功能统计一个英文字符串(或文章)中使用的单词数。
程序的基本思想和处理步骤是：
1）利用StringTokenizer类对象的功能析取单词，并将析取的单词存入向量中；
2）利用Vector类的查找方法定位重复的单词，计数后并移除；
3）将单词的计数插入到向量中单词的后边；
4）输出各单词及出现次数。
程序代码如下：
/*程序名WordCount_vector.java*/
import java.util.*;
class WordCount_Vector
{
public static void main(String[] args)
{
StringTokenizer tk=new StringTokenizer("It is an example for sorting arrays . It uses methods in arrays class");
Vector vec=new Vector();
while(tk.hasMoreTokens()) vec.add(tk.nextToken()); //获取单词放入向量
int i=0;
while(i<vec.size())
{
String str=(String)vec.get(i);
int count =1;
int location=0;
while((location=vec.indexOf(str,i 1))>0) //查找重复的单词
{ count ; //计数
vec.remove(location); //移除重复的单词
}
i ; //移动到单词的下一个位置
vec.insertElementAt(count, i); //将计数插入到单词后边的单元
i ; //移动到下一个单词位置
}
for(i=0;i<vec.size();i=i 2) //输出各单词出现次数
System.out.println(vec.get(i) "单词出现" vec.get(i 1) "次");
}
}
请读者认真阅读上述程序，写出自己认为的结果。然后再输入、编译、运行程序，比较一下结果。也可以按照自己的思想修改程序，只要达到目的即可。类包中的类一般都提供了众多的方法，要完成某一工作，实现的方法并不是唯一的。在介绍类的功能时，限于篇幅，只是介绍了一些常用的方法，不可能全部介绍，因此一定要掌握面向对象程序设计的基本思想和方法，在设计程序的过程中，根据需要可查阅系统提供的帮助文档。
6.4.2 Date类Date类用来操作系统的日期和时间。
1. 常用的构造器
1）Date() 用系统当前的日期和时间构建对象。
2）Date(long date) 以长整型数date构建对象。date 是从1970年1月1日零时算起所经过的毫秒数。
2. 常用的方法
1）boolean after(Date when) 测试日期对象是否在when之后。
2）boolean before(Date when) 测试日期对象是否在when之前。
3）int compareTo(Date anotherDate) 日期对象与anotherDate比较，如果相等返回0值；如果日期对象在anotherDate之后返回1，否则在anotherDate之前返回-1。
4）long getTime() 返回自1970.1.1 00:00:00以来经过的时间（毫秒数）。
5）void setTime(long time) 以time(毫秒数)设置时间。
6.4.3 Calendar类Calendar类能够支持不同的日历系统，它提供了多数日历系统所具有的一般功能，它是抽象类，这些功能对子类可用。
下边我们简要介绍一下Calendar类。
1. 类常数
该类提供了如下一些日常使用的静态数据成员：
1) AM（上午）、 PM（下午）、AM_PM（上午或下午）；
2) MONDAY~ SUNDAY（星期一 ~ 星期天）；
3) JANUARY ~ DECENBER（一月 ~ 十二月）；
4) ERA（公元或公元前）、YEAR（年）、MONTH（月） 、DATE（日）；
5) HOUR（时）、MINUTE（分）、SECOND（秒）、MILLISECOND（毫秒）；
6) WEEK_OF_MONTH（月中的第几周）、 WEEK_OF_YEAR（年中的第几周）；
7) DAY_OF_MONTH（当月的第几天）、DAY_OF_WEEK（星期几）、 DAY_OD_YEAR（一年中第几天）等等。
另外还提供了一些受保护的数据成员，需要时请参阅文档。
2. 构造器
1) protected Calendar() 以系统默认的时区构建Calendar。
2) protected Calendar(TimeZone zone, Locale aLocale) 以指定的时区构建Calendar。
3. 常用方法
1) boolean after(Object when) 测试日期对象是否在对象when表示的日期之后。
2) boolean before(Object when) 测试日期对象是否在对象when表示的日期之前。
3) final void set(int year,int month,int date) 设置年、月、日。
4) final void set(int year,int month,int date,int hour,int minute,int second) 设置年、月、日、时、分、秒。
5) final void setTime(Date date) 以给出的日期设置时间。
6) public int get(int field) 返回给定日历字段的值。
7) static Calendar getInstance() 用默认或指定的时区得到一个对象。
8) final Date getTime() 获得表示时间值（毫秒）的Date对象。
9) TimeZone getTimeZone() 获得时区对象。
10) long getTimeInMillis() 返回该Calendar以毫秒计的时间。
11) static Calendar getInstance(Locale aLocale) 以指定的地点及默认的时区获得一个calendar对象。
12) static Calendar getInstance(TimeZone zone) 以指定的时区获得一个calendar对象。
13) static Calendar getInstance(TimeZone zone, Locale aLocale) 以指定的地点及时区获得一个calendar对象。
该类提供了丰富的处理日期和时间的方法，上边只是列出了一部份，详细内容请参阅API文档。
4.应用举例
Calendar是抽象类，虽然不能直接建立该类的对象，但可以通过该类的类方法获得Calendar对象。
例6.18 使用Calendar类的功能显示日期和时间。
/* 程序名CalendarApp.java*/
import java.util.*;
public class CalendarApp
{
String [] am_pm={"上午","下午"};
public void display(Calendar cal)
{
System.out.print(cal.get(Calendar.YEAR) ".");
System.out.print((cal.get(Calendar.MONTH) 1) ".");
System.out.print(cal.get(Calendar.DATE) " ");
System.out.print(am_pm[cal.get(Calendar.AM_PM)] " ");
System.out.print(cal.get(Calendar.HOUR) ":");
System.out.print(cal.get(Calendar.MINUTE) ":");
System.out.println(cal.get(Calendar.SECOND));
}
public static void main(String args[])
{
Calendar calendar=Calendar.getInstance();// 用默认时区得到对象
CalendarApp testCalendar=new CalendarApp();
System.out.print("当前的日期时间:");
testCalendar.display(calendar); //调用方法显示日期时间
calendar.set(2000,0,30,20,10,5);// 设置日期时间
System.out.print("新设置日期时间:");
testCalendar.display(calendar);
}
}
应该注意到MONTH常数是以0～11计算的，即第1月为0，第12月为11。程序执行结果如图6.3所示。
图6.3 例6.12程序运行结果
6.4.4 GregorianCalendar类GregorianCalendar是一个标准的日历类，它从抽象类Calendar派生而来。下边我们简要介绍该类的功能和应用。
1. 常用构造器
1) GregorianCalendar() 以当地默认的时区和当前时间创建对象。如北京时间时区为Asia/Beijing。
2) GregorianCalendar(int year,int momth,int date) 用指定的year、month、date创建对象。
3) GregorianCalendar(int year,int month,int day,int hour,int minute,int seeond) 用指定的year、month、day 和hour、minute、seeond创建对象。
4) GregorianCalendar(TimeZone zone) 以指定的zone创建对象。
5) GregorianCalendar(Locale locale) 以指定的locale创建对象。
6) GregorianCalendar(TimeZone zone, Locale locale) 以指定的zone与locale创建对象。
2. 常用的方法
GregorianCalendar是Calendar的子类，它实现了父类中的所有的抽象方法并覆盖重写了父类的某些方法，除此之外，自己还定义了一些方法，需要时请查阅相关的文档。下边列出常用的方法：
boolean isLeapYear(int year) 判断某年是否为闰年。
3.应用举例
在实际的应用程序中经常会用到日期和时间，诸如实时控制程序，联机考试的计时程序等等。下边举一个简单的例子说明计时应用。
例6.19 计算并输出21世纪的闰年，计算程序的执行时间。
/*程序名Program_Run_Time.java*/
import java.util.*;
class Program_Run_Time
{
public static void main(String args[]) throws Exception
{
GregorianCalendar gCalendar= new GregorianCalendar();
long millis=gCalendar.getTimeInMillis();
System.out.println("21世纪闰年如下：");
for(int year=2000; year<2100; year )
{
if(gCalendar.isLeapYear(year)) System.out.print(year " ");
}
System.out.print("\n\n程序运行时间为: ");
millis=System.currentTimeMillis()-millis;
System.out.println(millis "微秒");
}
}
6.4.5 Random类在实际生活和工作中，我们会经常遇到随机数的应用，诸如摇奖号码的产生、考试座位的随机编排等等。在前边介绍的Math类的random()方法可以产生0~1之间的随机数。Random类是专门产生伪随机数的类，下边简要介绍Random类功能及应用。
1. 构造器
产生伪随机数是一种算法，它需要一个初始值（又称种子数），种子一样，产生的随机数序列就一样。使用不同的种子数则可产生不同的随机数序列。
1) Random() 以当前系统时钟的时间（毫秒数）为种子构造对象，该构造器产生的随机数序列不会重复。
2) Random(long seed) 以seed为种子构造对象。
2. 常用方法
1) void setSeed(long seed) 设置种子数。
2) void nextBytes(byte[] bytes) 产生一组随机字节数放入字节数组bytes中。
3) int nextInt() 返回下一个int伪随机数。
4) int nextInt(int n) 返回下一个0～n(包括0而不包括n)之间的int伪随机数。
5) long nextLong() 返回下一个long伪随机数。
6) float nextFloat() 返回下一个0.0～1.0之间的float伪随机数。
7) double nextDouble() 返回下一个0.0～1.0之间的double伪随机数。
3. 应用举例
例6.20 为n个学生考试随机安排座位号。
程序的基本处理思想如下：
1）使用一个2行n列的二维数组存放学生信息，第一行存放学号，第二行存放相应的座号；
2）生成学生的学号；
3）编写一个方法使用产生随机数的方式并去掉重复的随机数完成座位排号。
程序参考代码如下：
/*程序名 RandomApp.java */
import java.util.*;
public class RandomApp
{
public void produceRandomNumbers(int[] a)
{
Random rd=new Random(); //创建Random对象
int i=0;
int n=a.length;
L0: while(i<n)
{
int m=rd.nextInt(n 1); //产生0~n 1之间的座号
if(m<=0) continue; //若m<=0,去产生下一个座号
for(int j=0;j<=i;j ) if(a[j]==m) continue L0;//座号存在，去产生下一个
a[i]=m;
i ;
}
}
public static void main(String[] args)
{
int n=30;
int [][] student=new int[2][n];
RandomApp obj=new RandomApp();
for(int i=0;i<n;i )
{ student[0][i]=200602001 i; //生成学号
student[1][i]=0; //座号先置0
}
obj.produceRandomNumbers(student[1]);//调用方法生成座号
for(int i=0;i<n;i ) //输出学号及对应的座号
{
System.out.println(student[0][i] " " student[1][i]);
}
}
}
读者可以编译运行该程序并检验执行结果。
本章小结本章简要介绍了字符串类String、字符串缓冲类StringBuffer、字符串标记类StringTokenizer；数组类Array及向量类Vector；基础类Object、System和Runtime；基本数据类型、Math、Date、Calendar和GregorianCalendar及Random类。它们在Java程序设计中是常用的，是最基本的一些类。
本章重点：这些基础类常用方法的使用，各参数的含义。面向对象的程序设计，主要是对类及对象的处理，全面了解基础类的功能，熟练地掌握运用它们，才能使得程序的编写变得方便、快捷。
习题一、选择题
1．下面的表达式中正确的是 ( ) 。
A．String s=”你好” ; if(s==”你好”) System.out.println(ture);
B．String s=”你好” ; if(s!=”你好”) System.out.println(false);
C．StringBuffer s=”你好” ; if(s.equals(”你好”)) System.out.println(ture);
D．StringBuffer s=new Stringbuffer(”你好”)； if(s.equals(”你好”)) System.out.println(ture);
2．String str ; System.out.println(str.length()); 以上语句的处理结果是 ( )。
A．编译报错 B．运行结果为null C．运行结果为0 D．随机值
3．if("Hunan".indexOf('n')==2) System.out.println("true"); 以上语句运行的结果是( )。
A．报错 B．true C．false D．不显示任何内容
4．执行String［］ s=new String［10］; 代码后，下边哪个结论是正确的 ( )。
A．s［10］为 ″″；B．s［10］为null；C．s［0］为未定义；D．s.length为10
5．已定义数组：int [ ] arr={5,2,9,7,5,6,7,1}; 为数组元素排序的正确语句是（ ）。
A．Arrays.sort(a)；B．Arrays a.sort( )；C．Arrays a=new Arrays.sort( )；D．a.sort (a)
6．下面关于Vector类的说法不正确的是 ( )。
A．类Vector在java.util包中。
B．一个向量（Vector）对象中可以存放不同类型的对象。
C．一个向量（Vector）对象大小和数组一样是固定的。
D．可以在一个向量（Vector）对象插入或删除元素。
7．以下哪个语句产生0~100之间的随机数。 （ ）
A．Math.random(); B．new Random().nextint();
C．Math.random(100); D．new Random().nextInt(100);
8．以下哪个语句获得当前时间。 （ ）
A．System.currentTimeMillis(); B．System.currentTime();
B．Runtime.getRuntime(); D．Runtime.getRuncurrentTime();
二、问答题
1．字符与字符串有什么区别？
2．什么是字符串常量与字符串变量？字符串与字符串缓冲有什么区别？
3．数组与向量有什么区别？数组类有哪些常用方法？
4．简述实用类库及其包含的类。
5．与时间和日期有关的类有哪些？
三、编程题
1．修改例6.2程序, 改用对象的方法比较字符串。
2．统计一篇文档资料中单词的个数（提示文档资料可放在字符串中）。
3．在Vector对象中存放10位学生的姓名、学号、3门成绩并输出。
4．在Java 程序中调用其他可执行的外部程序并执行之，并输出程序的运行时间。
,
