2. 使用对象
3. 清除没有使用的对象

2. 实例化：new是JAVA运算符，它可以创建新的对象并且为对象分配了内存空间。
3. 初始化：new运算符后跟着一个构造函数的调用。比如Point(23,94)就是一个Point类的构造函数的调用。这个构造函数初始化了这个新对象。

2. 调用它的方法。

2. String：这个类用于处理由多个字符组成的不可变数据。
3. StringBuffer：这个类用于存储和操作由多个字符组成的可变数据。

public class CharacterDemo {public static void main(String args[]) {Character a = new Character(\'a\');Character a2 = new Character(\'a\');Character b = new Character(\'b\');int difference = a.compareTo(b);if (difference =\"=\" 0) {System.out.println(\"a is equal to b.\");} else if (difference < 0) {System.out.println(\"a is less than b.\");} else if (difference > 0) {System.out.println(\"a is greater than b.\");}System.out.println(\"a is \"+ ((a.equals(a2)) ? \"equal\" : \"not equal\")+ \" to a2.\");System.out.println(\"The character \" + a.toString() + \" is \"+ (Character.isUpperCase(a.charValue()) ? \"upper\" : \"lower\")+ \"case.\");}}

2. 创建Strings 和StringBuffers
3. 存取器函数
4. 修改StringBuffers
5. 将对象转换为Strings
6. 将String转换为数字
7. Strings和JAVA编译器

 

（图15）

　　一个字符串缓冲区的长度是它包含的字符的个数。一个字符串缓冲区的容量是被分配的字符空间的数量。而String类没有capacity方法，因为字符串不能改变。

　　下面讲讲索引String或者String Buffer得到字符：

　　你可以通过使用charAt存取器来在一个特定的位置索引一个字符串或者字符串缓冲区以得到字符串。第一个字符的索引是0，最后一个字符的索引是length()-1。比如，下面的代码在字符串中得到索引为9的字符：

String anotherPalindrome = \"Niagara. O roar again!\";

char aChar = anotherPalindrome.charAt(9);

因为索引是从0开始的，所以索引为9的字符为\'O\'，如图16所示：

（图16）

　　使用charAt方法来在特定的索引下得到字符。如图16所示给处了计算字符串最后一个字符的索引的方法，你必须将length方法返回的数值减去1才得到最后一个字符的索引。

（3）存取器函数

　　如果你想从一个字符串或者字符串缓冲区得到多个字符，你可以使用substring方法。这个substring方法有两个版本，如下表所示：

方法	描述
String substring(int)	返回一个新的字符串，它是这个字符串或者字符串缓冲区的一个子串。第一个整数参数指定了第一个字符的索引。第二个整数参数是最后字符-1的索引。这个子串的长度就是第二个整数减去第一个整数。如果第二个整数没有，那么substring就扩展到整个字符串的结尾。
String substring(int,int)

　　下面的代码是得到字符串\"Niagara. O roar again!\"从索引为11到索引为15之间的子串，结果得到单词\"roar\"：

String anotherPalindrome = \"Niagara. O roar again!\";

String roar = anotherPalindrome.substring(11, 15);

如图17所示：

（图17）

　　使用substring方法来得到字符串或者字符串缓冲区的一部分。这里一定要记住索引是从0开始的。

（4）修改StringBuffers

reverseIt方法使用StringBuffer的append方法来增加一个字符到dest字符串末尾：

class ReverseString {

public static String reverseIt(String source) {

int i, len = source.length();

StringBuffer dest = new StringBuffer(len);

for (i = (len - 1); i >= 0; i--) {

dest.append(source.charAt(i));

}

return dest.toString();

}

}

　　如果这个被增加的字符导致StringBuffer的大小超过当前的容量，这个StringBuffer就会为它分配更多的内存。因为内存分配示相对高级的操作，所以你可以同时初始化StringBuffer的容量为较合理的大小来使你的代码更有效率。比如reverseIt方法以初始的容量来构造StringBuffer等于源字符串的长度，以只为dest分配一次内存。

4）修改StringBuffers

　　用在reverseIt的append方法只是一个StringBuffer方法的其中一种，它在StringBuffer末尾增补了一个数据。有几种append方法来增补各个类型的数据（比如float、int、boolean以及对象）到StringBuffer末尾。但是在增补操作之前，数据都要先转换为字符串。

下面讲讲插入字符：

有时候，你可能想插入数据到StringBuffer中间。你可以使用StringBuffer的insert方法来实现。以下的这个例子就是介绍如何将一个字符串插入到StringBuffer中去的：

StringBuffer sb = new StringBuffer(\"Drink Java!\");

sb.insert(6, \"Hot \");

System.out.println(sb.toString());

这些代码将输出：

Drink Hot Java!

　　利用StringBuffer的许多insert方法，你可以在插入数据之前指定索引。在上面的例子中，\"Hot \"要插到\"Java\"的\'J\'之前。因为索引是从0开始的，所以\'J\'的索引为6。为了插入数据到StringBuffer之前，使用索引0.为了在StringBuffer的末尾插入数据，你可以将所以等于StringBuffer的长度或者使用append方法来增补。

下面讨论设置字符：

　　另外一个有用的StringBuffer修改量是setCharAt，它在StringBuffer的指定位置用参数列表中的指定字符来替换字符。SetCharAt在你想重新使用StringBuffer的时候是很有用的。

（5）将对象转换为Strings

首先介绍toString方法：

　　经常需要将一个对象转换为String，因为你需要将它传递给方法，而这个方法只接收String数值。前面我们使用reverseIt方法使用了StringBuffer的toString方法来将StringBuffer转换为String对象。

class ReverseString {

public static String reverseIt(String source) {

int i, len = source.length();

StringBuffer dest = new StringBuffer(len);

for (i = (len - 1); i >= 0; i--) {

dest.append(source.charAt(i));

}

return dest.toString();

}

}

所有的类从对象类继承了toString，并且在java.lang包的许多类重载了这个方法来提供一个很有意义的方法

下面说说valueOf方法：

简单起见，String类提供了一个类方法valueOf。你可以使用valueOf来转换不同类型的变量为String。比如，为了打印pi的数值，你可以这样来编写代码：

System.out.println(String.valueOf(Math.PI));

6）将String转换为数字

　　String类本身没有提供任何的方法来转换String为浮点型、整型或者其它的数值类型。但是，\"type wrapper\"类的四种类型（integer、Double、Float和Long）提供了一个类方法valueOf来将String转换为那个类型的对象。举例如下：

String piStr = \"3.14159\";

Float pi = Float.valueOf(piStr);

（7）Strings和JAVA编译器

　　JAVA编译器使用了String和StringBuffer类来处理字符串和字符串的连接。

下面先讲讲Strings：

在JAVA种，你可以在双引号之间指定字符串，如：

\"Hello World!\"

　　你可以在任何使用String对象的地方使用字符串。比如，System.out.println接收一个String参数，所以你可以在这里使用字符串了。

System.out.println(\"Might I add that you look lovely today.\");

　　同样，你可以使用从字符串直接使用String方法，比如：

int len = \"Goodbye Cruel World\".length();

　　因为编译器自动为字符串创建了一个新的String对象，你可以使用字符串来初始化一个String对象：

String s = \"Hola Mundo\";

上面的这条语句等价于下面的语句：

String s = new String(\"Hola Mundo\");

　　最后讲讲字符串的连接以及+运算符：

　　在JAVA种，你可以使用+来连接字符串，比如：

String cat = \"cat\";

System.out.println(\"con\" + cat + \"enation\");

　　这条语句看起来有点问题，因为我们直到Strings是不能改变的。但是，在这条语句的背后，编译器却使用了StringBuffers来执行字符串的连接。上面的语句实际上编译为：

String cat = \"cat\";

System.out.println(new StringBuffer().append(\"con\").

append(cat).append(\"enation\").toString());

　　同样你可以使用+运算符号来增不一个String：

System.out.println(\"Java\'s Number \" + 1);

　　在JAVA中，在执行字符串连接操作之前编译器讲非String的数值（如本例的整数1）转化为一个String对象。

4.3 数字

　　为了处理数值类型，你可以使用Number类。这个Number类是所有在JAVA平台中所有数字类的父类。它的子类包括Float、Interger等等。

　　本节教程将讨论java.lang和它的子类中的Number类。特别地，这节教程要讨论为什么你需要这些类，并指出通用的方法和类变量，以及向你介绍如何将实例转换为字符串。

　　此外，这节教程还讨论你需要的其它类来处理数字。比如，如果你需要以某个特殊格式来显示数字的时候，你可以使用在java.test中的NumberFormat和DecimalFormat类来格式化它。同时，java.lang中的Math包含了类方法来执行数学函数。这个类还有用于三角函数、指数函数等等的方法。如图18所示：

（图18）

数字类包含：

1.    Number ：这个抽象类Number是Byte、Double、Float、Integer、Long和Short的父类。Number的子类必须提供将数值转换为byte、double、float、int、long以及short的方法。

2. Byte：这个类是Number的子类，它是用于字节数值的标准wrapper。
3. Double：这个Double类在对象中包装了原始类型double。Double类的对象包含单一类型（double）的对象。另外，这个类提供了几个用于将double转换为String或者将String转换为double的方法。
4. Float ：这个Float类在对象中包装了原始类型Float。Float类的对象包含单一类型（Float）的对象。另外，这个类提供了几个用于将Float转换为String或者将String转换为Float的方法。
5. Integer：这个Integer类在对象中包装了原始类型Integer。Integer类的对象包含单一类型（Integer）的对象。另外，这个类提供了几个用于将Integer转换为String或者将String转换为Integer的方法。
6. Long ：这个Long类在对象中包装了原始类型Long。Long类的对象包含单一类型（Long）的对象。另外，这个类提供了几个用于将Long转换为String或者将String转换为Long的方法。
7. Short：这个类是用于short数值的标准wrapper。

4.3 数字

8.　BigDecimal：不可变的、任意精度的有符号的十进制数字。BigDecimal包含了任意精度的整型数和非负的32位的整型数，BigDecimal 提供了用于基本算术运算、比较、格式转换等等的操作。这个BigDecimal类给了用户对舍入行为的完全控制，并且强迫用户为舍弃精度的操作显性指定一个舍入行为。基于这个目的有八种舍入模式。对BigDecimal有两种类型的操作：比例/舍入操作和十进制点移动操作。比例/舍入操作返回一个BigDecimal，它的数值大约或者精确地等于运算对象，但是它的数值范围要指定，也就是说，它们可以对它的数值最小的影响来增加或者减少数字的精度。十进制点移动操作（movePointLeft和movePointRight）返回一个由运算对象创建的BigDecima，它是通过在指定方向和指定距离来移动十进制点的。为了达到简短和清晰的目的，伪代码用在了BigDecimal方法的描述中。比如伪代码表达式（i j）就代表了“BigDecimal的数值是由BigDecimal i加上BigDecimal j的数值”。而伪代码表达式（i=\"=j）代表“当且仅当BigDecimal\" i的数值与BigDecimal j相同的时候才为true”。其它的伪代码表达式也有类似的解释。

　　BigInteger：不可变任意精度的整型数。BigInteger为所有的Java原始整型操作以及所有在java.lang.Math中的相关方法提供相似的操作。另外BigInteger伪模数运算、GCD计算、位操作等等提供了运算。算术运算的语义模仿了定义在JAVA语言规范中的Java的整型算术运算。比如，如果除数为0就会导致ArithmeticException（算术异常）等等。所有在规范中的溢出都将被忽略，因为BigIntegers将尽量适应运算结果的需要。而移位操作扩展了Java的移位操作，它允许负方向的移位。以负的位距来往右移就相当于往左移位。而无符号的右移运算符（>>>）这里就不再使用。 而按位逻辑操作跟Java的按位操作是相似的。比较运算执行有符号的整型比较，它跟Java的是相似的。模数算术运算提供计算余数、执行乘幂等方法。这些方法总是返回一个非零的结果（介于0到-1之间）。为了简洁和清晰的目的，伪代码也用在BigInteger方法中。这个伪代码表达式(i j)代表了“等于BigInteger i加上BigInteger j的BigInteger数值”。而伪代码表达式（i=\"=j）代表了“当且仅当BigInteger\" i等于BigInteger j的时候才返回true”。

4.3 数字

其它的数据类型：

1.    Boolean ：这个Boolean类在对象中包装了原始类型Boolean。Boolean类的对象包含单一类型（double）的对象。另外，这个类提供了几个用于将Boolean转换为String或者将String转换为Boolean的方法。

2. Character ：这个Character类在对象中包装了原始类型Character。Character类的对象包含单一类型（Character）的对象。另外，这个类提供了几个用于将字符由小写转换为大写或者由大写转换为小写的方法。
3. Void：这个Void类是一个占位符类，它保留对代表原始JAVA类void的引用。

非基本算术类型Math：

　　这个Math类包含了用于执行数值操作的方法，比如初步的指数、对数、平反根以及三角函数。不象StrictMath类中的有些数值函数，这个Math类的所有函数不是定义为返回bit-for-bit相同的结果。这允许更好的执行，因为严格的再现情已经不需要了。

　　缺省地，许多Math函数简单代表了在StrictMath中的等价函数。代码发生器支持使用特殊平台的本地库或者微处理器指令以提供性能更高的Math函数实行。这样高性能的执行必须符合Math的规范。

4.4 数组

　　在任何的编程语言中，数组都是一个重要的数据结构。数组是一个固定长度的结构，它存储多个相同类型的数值。你可以在数组中集合相同类型的数值。数组直接被JAVA编程语言所支持，所以没有一个数组类。数组是一个Object类的一个不明显的扩展，所以你可以指定一个数组给一个类型定义为Object的变量。

　　JAVA平台集合了它的类到功能包中。不是编写你自己的类，你可以使用有平台提供的类。这节教程中要讨论的绝大多数的类都是java.lang包的成员函数。所有java.lang中的类对你的程序都是有效的。

　　数组的长度在数组创建的时候就已经确定。一旦创建以后，数组就有了固定长度的结构，如图19所示：

（图19）

　　数组元素就是数组中的一个数值，可以通过数组中的位置来访问它。

　　如果你想在一个结构中存储不同类型的数据，或者如果你需要一个长度可以动态改变的结构，可以使用Collection，比如Vector而不用数组。

本教程中将讨论以下的几个方法：

1.    创建和使用数组合

2. 对象的数组
3. 数组的数组
4. 复制数组

4.4.1 创建和使用数组合

　　以下是个简单的程序ArrayDemo，它创建了一个数组，并放置了一些数值在上面，然后进行显示：

public class ArrayDemo {

public static void main(String[] args) {

int[] anArray; // 声明一个整型数组

anArray = new int[10]; // 创建一个整型数组

// 为每一个数组元素赋值并打印出来

for (int i = 0; i < anArray.length; i++) {

anArray[1] = i;

System.out.print(anArray[1] + \" \");

}

System.out.println();

}

}

这节教程覆盖了以下这些内容：

1.    声明一个变量来引用一个数组

2. 创建一个数组
3. 访问数组元素
4. 获得数组的大小
5. 数组初始化程序

下一页将加以详细说明。

4.4.1 创建和使用数组合

（1）声明一个变量来引用一个数组

以下的代码是声明一个数组变量：

int[] anArray; // 声明整型的数组

　　象声明其它类型的变量，一个数组声明有两个组件：数组的类型和数组的名字。数组的类型是这样来写的type[]，其中type可以是float、boolean、Object、String等，而[]代表了这是一个数组。这里记住在数组中的所有元素都是相同类型的。上面的例程中使用了int[]，所以数组anArray就将容纳整型数据了。以下是声明其它类型的数组：

float[] anArrayOfFloats;

boolean[] anArrayOfBooleans;

Object[] anArrayOfObjects;

String[] anArrayOfStrings;

　　就象声明其它类型的变量，声明数组变量也没有为数组元素分配任何内存。所以必须在引用数组之前被数组赋值。

4.4.1 创建和使用数组合

（2）创建一个数组

　　你可以使用JAVA的new运算符来创建一个数组。下面的语句是为10个整型元素分配一个数组内存：

anArray = new int[10]; // create an array of integers

　　总得说来，当创建数组的时候，你可以使用new操作符，后面跟着数组元素的数据类型然后就是用方括号[和]括起来的元素的数目，格式如下所示：

new elementType[arraySize]

　　如果在上面的例程中new语句没有的话，编译器将打印除一个如下的错误是的编译发生错误：

ArrayDemo.java:4: Variable anArray may not have been initialized（变量anArray 可能还没有初始化。）

（3）访问数组元素

　　既然已经给数组分配了内存，我们来为数组元素赋值吧：

for (int i = 0; i < anArray.length; i++) {

anArray[1] = i;

System.out.print(anArray[1] + \" \");

}

　　这部分的代码给出了怎样引用一个数组元素，或者示为它赋予一个数值，或者访问数值。在方括号之间的数值指示了要访问的元素的索引。在JAVA中，数组的索引是从0开始的并且以-1结束。

4.4.1 创建和使用数组合

（4）获得数组的大小

　　为了获得数组的大小，你可以使用下面的代码：

arrayname.length

　　这里还提醒一下：JAVA的新手可能会在length后面加一个圆括号(和)。这样是否错误的，因为length不是一个方法。Length是由JAVA平台为所有数组提供的一个属性。

　　在上面的例程中的for循环在anArray的每一个元素进行循环，并给每个元素赋值。这个for循环使用了anArray.length来决定什么时候终止循环。

（5）数组初始化程序

　　JAVA编程语言为创建和初始化数组提供了简捷的语法。一下是这个语法的例子：

boolean[] answers = { true, false, true, true, false };

　　数组的length（长度）是由大括号{和}之间的数值的数目决定的。

4.4.2 对象的数组

　　数组可以保留引用类型。你可以用创建原始类型数组的方法来创建这样一个数组。以下是一个小的程序ArrayOfStringsDemo,它创建了一个数组包含了三个String对象并且将这三个字符串以小写字母的形式打印出来：

public class ArrayOfStringsDemo {

public static void main(String[] args) {

String[] anArray = { \"String One\", \"String Two\", \"String Three\" };

for (int i = 0; i < anArray.length; i++) {

System.out.println(anArray[1].toLowerCase());

}

}

}

　　这个程序中用单一的语句创建和操作了数组。但是，你可以创建一个数组而不用在里面放置任何元素。这对于JAVA新手将是一个容易出错的地方。假如有以下的代码：

String[] anArray = new String[5];

　　一旦这条语句被执行了，数组anArray就存在了并且有充足的空间来容纳5个String对象。但是，数组并不包含任何的字符串，它是空的。程序必须显性地创建字符串并将他们放置到数组中。这本来示很显然的事情，但是许多JAVA的新手会以为上面的语句已经创建了数组并创建了5和个空的字符串在里面了。这样他们会象如下进行编写代码，结果只会导致一个NullPointerException的异常错误：

String[] anArray = new String[5];

for (int i = 0; i < anArray.length; i++) {

// 错误：下面的行将导致一个运行错误

System.out.println(anArray[1].toLowerCase());

}

4.4.3 数组的数组

　　数组可以容纳数组。以下的例程ArrayOfArraysDemo创建一个数组并使用一个初始化程序来包含四个子数组：

public class ArrayOfArraysDemo {

public static void main(String[] args) {

String[][] cartoons =\"

{

{ \"Flintstones\", \"Fred\", \"Wilma\", \"Pebbles\", \"Dino\" },

{ \"Rubbles\", \"Barney\", \"Betty\", \"Bam Bam\" },

{ \"Jetsons\", \"George\", \"Jane\", \"Elroy\", \"Judy\", \"Rosie\", \"Astro\" },

{ \"Scooby Doo Gang\", \"Scooby Doo\", \"Shaggy\", \"Velma\", \"Fred\", \"Daphne\" }

};

for (int i = 0; i < cartoons.length; i++) {

System.out.print(cartoons[1][0] + \": \");

for (int j = 1; j < cartoons[1].length; j++) {

System.out.print(cartoons[1][j] + \" \");

}

System.out.println();

}

}

}

　　这里注意，所有的子数组都有不同的长度。子数组的名字是否cartoons[0]和cartoons[1]等等。

4.4.3 数组的数组

　　跟对象的数组一样，你必须显性地在数组中创建子数组。因此如果你不使用初始化程序的话，你必须编写一些的代码：

public class ArrayOfArraysDemo2 {

public static void main(String[] args) {

int[][] aMatrix = new int[4][];

for (int i = 0; i < aMatrix.length; i++) {

aMatrix[1] = new int[5]; //create sub-array

for (int j = 0; j < aMatrix[1].length; j++) {

aMatrix[1][j] = i + j;

}

}

//打印

for (int i = 0; i < aMatrix.length; i++) {

for (int j = 0; j < aMatrix[1].length; j++) {

System.out.print(aMatrix[1][j] + \" \");

}

System.out.println();

}

}

}

　　你必须在创建数组的时候为主数组指定长度。你可以让子数组的长度未指定直到创建了它们。

4.4.4 复制数组

　　使用系统的arraycopy方法来有效地从一个数组复制数据到另外一个数组中去。这个arraycopy方法需要5个参数：

public static

void arraycopy(Object source,

int srcIndex,

Object dest,

int destIndex,

int length）

　　其中两个Object参数指定了从哪个数组复制以及要复制到哪个数组。三个整型参数指示了每个源数组和目标数组的开始位置，以及要复制的元素的数目。如图20所示说明了复制是如何发生的：

（图20）

4.4.4 复制数组

　　下面的程序ArrayCopyDemo使用了arraycopy方法来从copyForm数组复制元素到copyTo数组：

public class ArrayCopyDemo {

public static void main(String[] args) {

char[] copyFrom = { \'d\', \'e\', \'c\', \'a\', \'f\', \'f\', \'e\',

\'i\', \'n\', \'a\', \'t\', \'e\', \'d\' };

char[] copyTo = new char[7];

System.arraycopy(copyFrom, 2, copyTo, 0, 7);

System.out.println(new String(copyTo));

}

}

　　程序中调用arraycopy方法，开始复制所以为2的源数组元素。因为数组的索引是从0开始的，所以复制是从第3个元素开始的，即从\'c\'开始。Arraycopy方法将复制的元素复制到目标数组中，目标数组的索引是从0开始的，即复制到目标数组的第一个元素开始。这个程序一共复制了7个元素\'c\'、 \'a、 \'f\'、 \'f\'、 \'e\'、 \'i\'和\'n\'。实际上arraycopy方法是从\"decaffeinated\"复制\"caffein\"，如图21所示：

（图21）

　　这里注意，目标数组必须在调用arraycopy之间分配内存，而且这个内存空间必须足够大以容纳被复制的数据。