第 4章 数组、向量和字符串数组
数组说明
多个变量间存在某种内在联系时，适于用数组来实现
数组是一系列的匿名变量，数组中的元素可通过下标来访问
在 Java中，数组是对象。类 Object中定义的方法都可以用于数组对象。可以说明任何类型的数组
基本类型，类类型，数组等
数组在使用之前必须先说明一维数组的定义
type arrayName[]；
变量名后接方括号
将方括号放到变量名的左面
char s[ ];
int intArray[ ]；
Date dateArray[ ];
Point points[ ];
type[ ] arrayName；
创建数组
静态初始化和动态初始化
静态初始化就是在定义数组的同时对数组元素进行初始化
静态初始化可用于任何元素类型，初值块中每个位置的每个元素对应一个引用。
动态初始化是使用运算符 new为数组分配空间。
数组说明的方括号中的数字表示数组元素个数静态初始化
int intArray[ ]={1,2,3,4};
int[] ages = {34,12,45};
double[] heights = {84.124,78.2,61.5};
boolean[] tired = {true,false,false,true};
String[] names ={“Zhang",“Li",“Wang"};
动态初始化
type[ ] arrayName = new type[arraySize]
type arrayName[ ] = new type[arraySize]
s = new char[20];
复合类型的数组
复合类型的数组需要经过两步进行空间分配
使用运算符 new只是为数组本身分配空间，并没有对数组的元素进行初始化
第一步先创建数组本身：
type arrayName[ ] = new type[arraySize];
第二步分别创建各个数组元素,
arrayName[0] = new type(paramList);
…
arrayName[arraySize-1] = new
type(paramList);
复合类型的数组
points = new Point[100];
points[0] = new Point();
points[1] = new Point();
…
points[99] = new Point();
string stringArrar[];
stringArray = new String[3];
stringArray[0] = new String(“how”);
stringArray[1] = new String(“are”);
Java中没有静态的数组定义，
内存都是通过 new动态分配的。
int intArray[5]; //是错误的数组说明与创建关系
Point类
class Point {
int x,y;
Point ( int x1,int y1) {
x = x1;
y = y1;
}
Point() {
this(0,0);
}
}
数组说明与创建关系
points
(a)
points
Length:100
…
(b)
points
…
Length:100
X:
Y:
(c)
Point [] points;
执行完毕，系统为变量
points分配一个引用空间
points = new Point [100];
执行完毕，系统在内存中分配一个数组对象并把数组引用赋给变量 points
points[1] = new Point ();
数组说明注意
数组引用的类型可以为它所指向元素的父类
正确
错误
Object [] points;
points = new Point [100];
Point [] points;
points = new Object [100];
数组边界
数组下标从 0开始,元素个数 length是数组类中唯一的数据成员变量
new创建数组时系统自动给 length赋值
数组一旦创建完毕，其大小就固定下来
程序运行时可以使用 length进行数组边界检查。
如果发生越界访问，则抛出一个异常数组边界例
int list[] = new int [10];
for (int i = 0; i < list.length; i++) {
// 进行相应处理的代码
}
循环的结束条件中使用
list.length，而不是常数 10。这样做不会引起数组下标越界，
使程序更健壮，修改更方便。
数组元素的引用
数组名加上下标,引用方式为,
index为数组下标，下标从 0开始，一直到 length-1
下标是整型常数或表达式
程序 4-1设给定一组整型数,求它们的平均值
arrayName[index]
arrayName[1],
arrayName[i],
arrayName[6*i]
多维数组
多维数组的定义
Java中没有真正的多维数组，可以建立数组的数组（的数组 …… ），由此得到多维数组
n维数组是 n-1维数组的数组
说明多维数组时使用类型及多对方括号二维数组
二维数组的定义方式：
与一维数组一样，定义对数组元素也没有分配内存空间，要使用运算符 new来分配内存，然后才可以访问每个元素
type arrayName[ ][ ]
type[ ][ ] arrayName
多维数组的初始化
静态初始化
在定义数组的同时为数组分配空间
动态初始化
直接为每一维分配空间
从最高维起（而且必须从最高维开始），分别为每一维分配内存
int intArray[ ][ ]= {{2,3},{1,5},{3,4}};
数组 intArray为一个 3行 2列的数组,它的形式如下：
2 3
1 5
3 4
type arrayName[ ][ ] = new
type[arraylength1][arraylength2]
例如,int a[ ][ ] = new int[2][3]；
type arrayN[ ][ ] = new type [ arrleng1 ][ ];
arrayN [0] = new type [arrleng2];
arrayN [1] = new type [arrleng2];
......
arrayN [arrleng1 - 1] = new type [arrleng2];
二维数组 例一
int twoDim [ ][ ] = new int [4][ ];
twoDim[0] = new int[5];
twoDim[1] = new int[5];
二维数组 例二
String s[ ][ ]=new String[2][ ];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String(“Good”);
s[0][1] = new String(“Luck”);
s[1][0] = new String(“to”);
s[1][1] = new String(“you”);
s[1][2] = new String(“!”);
非矩阵数组
int twoDim[ ][ ] = new int [ 4 ][ ];
twoDim[0] = new int[2];
twoDim[1] = new int[4];
twoDim[2] = new int[6];
twoDim[3] = new int[8]; X X
X X X X
X X X X X X
X X X X X X X X
twoDim数组为 4行，每行的元素个数分别为 2，
4,6,8个矩阵数组
二维矩阵数组的一般说明格式为：
arrayName是数组名,length1和 length2分别为数组各维的大小,type是数组元素的类型。
type arrayName [][] = new type [length1][length2];
二维矩阵数组
int matrix[ ][ ] = new int [4][5];
将创建一个有 4个一维数组的数组,每个一维数组中又有 5个整数,即 4行 5列的整数矩阵 。
该行等价于下列这段代码：
int matrix[ ][ ] = new int [4][ ];
for (int j = 0; j < matrix.length; j++)
matrix[j] = new int[5];
多维数组说明
正确的声明：
int a1[][] = new int [2][3];
int a2[][] = new int [2][];
int []a3[] = new int [4][6];
错误的说明：
int errarr1[2][3];
int errarr2[][] = new int [ ] [ 4 ];
int errarr3[][4] = new int [3][4];
不允许说明静态数组说明顺序应从高维到低维数组维数的指定只能出现在 new
运算符之后多维数组的引用
二维数组引用方式为：
arrayName[index1][index2]
例如：
int myTable[][] = new int[4][3];
myTable[0][0] = 34;
myTable[0][1] = 15;
myTable[0][2] = 26;
多维数组的引用例
int myTable[][] = {
{23,45,65,34,21,67,78},
{46,14,18,46,98,63,88},
{98,81,64,90,21,14,23},
{54,43,55,76,22,43,33}};
for (int row=0;row<4; row++) {
for (int col=0;col<7; col++)
System.out.print(myTable[row][col] + " ");
System.out.println();
}
0 1 2 3 4 5 6
0 23 45 65 34 21 67 78
1 46 14 18 46 98 63 88
2 98 81 64 90 21 14 23
3 54 43 55 76 22 43 33
多维数组的引用例
计算表中各行元素之和并查找其值最大的那个行 程序 4-2
length属性
多维数组的 length属性只返回第一维的长度
int ages[4][7];
ages.length; // 返回 4,而不是 28
可以分别存取每一维的长度，如：
int[][] ages = int ages[4][7];
int[] firstArray = ages[0];
ages.length * firstArray.length; // 返回 28
Arrays类常用的方法
int binarySearch(type a[],type key)
对关键字 key在数组 a中进行二分查找，但要求数组 a必须已经排序（ sort方法 ），否则返回值无意义
boolean equals(type a[],type a2[])
它判定两个数组大小是否相同，并且每一个元素是否相等。 两个 null数组是相等的数组拷贝
System类的 arraycopy() 方法
class ArrayTest{
public static void main(String args[]) {
int elements[] = { 1,2,3,4,5,6 };
int hold[] = {10,9,8,7,6,5,4,3,2,1 };
System.arraycopy(elements,0,hold,0,elements.length);
}
}
Vector类
对应于类似数组的顺序存储的数据结构，
允许不同类型的元素共存于一个变长数组中，可以看作是把不同类型元素按照动态数组进行处理
向量是一组对象的集合
可以看作是一个可变大小的数组
用一个整数类型的次序值来访问 （索引值）
增加或删除了元素，大小也变大或变小概述
适合情况：
需要处理的对象数目不定,序列中的元素都是对象或可以表示为对象；
需要将不同类的对象组合成一个数据序列；
需要做频繁的对象序列中元素的插入和删除；
经常需要定位序列中的对象和其他查找操作 ;
在不同的类之间传递大量的数据；
Vector类
elementData
存放数据元素
elementCount
记录 Vector中元素的实际个数
capacityIncrement
容量增值
Vector构造方法
public Vector()
构造一个空向量
public Vector(int initialCapacity)
以初始存储容量 initialCapacity构造一个空的向量 Vector
public Vector(int initialCapacity,int
capacityIncrement)
以初始存储容量 initialCapacity和容量增量
capacityIncrement构造一个空的向量 Vector
例如,
Vector MyVector = new Vector(100,50)；
Vector类的操作
元素的添加
addElement(Object obj)：将新元素添加到序列尾部
insertElementAt(Object obj,int index)：将指定对象 obj插入到指定位置 index处Vector MyVector = new Vector()；
for (int i=1;i<=10;i++)
{
MyVector.addElement(new Random());
}
MyVector.insertElementAt("middle",5);
元素的删改
setElementAt(Object obj,int index)
将向量序列 index位置处的对象元素设置为 obj
removeElement(Object obj)
删除第一个与指定的 obj对象相同的元素，将后面的元素前提，补上空位
removeElementAt(int index)
删除 index指定位置处的元素，同时将后面的元素前提
removeAllElements()
清除向量序列中的所有元素，向量的大小置为 0
删除修改实例
Vector MyVector = new Vector(100);
for (int i=0;i<10;i++){
MyVector.addElement(“welcome”);
MyVector.addElement(“to”);
MyVector.addElement(“beijing”);
}
while (MyVector.removeElement(“to”));
元素的查找
Object elementAt(int index)
返回指定位置处的元素
boolean contains(Object obj)
检查向量序列中是否包含指定的对象元素 obj
int indexOf (Object obj,int start_index)
从指定的 start_index位置开始向后搜索，返回所找到的第一个与指定对象 obj相同的元素的下标位置。若对象不存在，则返回 -1
int lastIndexOf(Object obj,int start_index)
从指定的 start_index位置开始向前搜索，返回所找到的第一个与指定对象 obj相同的元素的下标位置。若对象不存在，则返回 -1
Vector的其他方法
public final int size()
返回向量中的元素数量
public final boolean contains(Object elem)
判断对象 elem是否在向量中
public final int indexOf(Object elem)
从向量的第一个元素开始查找指定对象，并返回该对象的索引值（如果查找不成功则返回 -1）
Vector的其他方法
capacity(),返回 Vector的容量；
clone(),建立 Vector的备份；
copyInto(Object[]),把 Vector中的元素拷贝到一个数组中；
firstElement(),返回第一个元素；
lastElement(),返回最后一个元素；
isEmpty()：判断是否为空；
setSize(int size),设置 Vector的大小；
trimToSize()：将 Vector的容量下调至最小值
Vector类的使用举例
程序 4-4 使用 Vector类的方法，向向量增加不同类型的元素并输出 Vector元素字符串类型
字符串
内存中连续排列的一个或多个字符
String 处理不变字符串
StringBuffer处理可变字符串字符串说明及初始化
字符串常量
系统为程序中出现的字符串常量自动创建一个
String对象
字符串变量
System.out.println(“This is a String”);
将创建,This is a String”对象
String s1;
StringBuffer sb1;
String s1 = new String();
char chars[] = {'a','b','c'};
String s2 = new String( chars );
String s3 = "Hello World!";
字符串处理 String类
length()
返回字符串中的字符个数
charAt(int index)
返回字符串中 index位置的字符
toLowerCase()
将当前字符串中所有字符转换为小写形式字符串处理 String类
toUpperCase()
将当前字符串中所有字符转换为大写形式
subString(int beginIndex)
当前字符串中从 beginIndex开始到末尾的子串
replace(char oldChar,char newChar)
将当前字符串中出现的所有 oldChar转换为
newChar
字符串处理例
程序 4-5
StringBuffer类
修改一个 StringBuffer类的字符串时，不用再创建一个新的字符串对象，而是直接操作原字符串
分配内存时，除去字符所占空间外，再另加 16个字符大小的缓冲区
StringBuffer的长度（ length)是指存储在其中的字符个数，容量 (capacity)是指缓冲所能容纳的最大字符数连接
String类对象使用 concat(String str)方法将 str
连接在当前字符串的尾部
重载运算符,+”
StringBuffer类对象使用 append()方法实现连接
String s = "This is the ";
String t = s.concat("String.");
t的内容为,"This is the String."
String s = "He is" + age + "years old.";String s = new StringBuffer("He
is").append(age).
append("years old.").toString();
比较
可用方法
使用关系运算符,==”
与 equals()方法不同的是,,= =”判定两字符串对象是否是同一实例，即它们在内存中的存储空间是否相同
compareTo()、
equals()、
equalsIgnoreCase()、
regionMatches()
比较例子
程序 4-6
数组说明
多个变量间存在某种内在联系时，适于用数组来实现
数组是一系列的匿名变量，数组中的元素可通过下标来访问
在 Java中，数组是对象。类 Object中定义的方法都可以用于数组对象。可以说明任何类型的数组
基本类型，类类型，数组等
数组在使用之前必须先说明一维数组的定义
type arrayName[]；
变量名后接方括号
将方括号放到变量名的左面
char s[ ];
int intArray[ ]；
Date dateArray[ ];
Point points[ ];
type[ ] arrayName；
创建数组
静态初始化和动态初始化
静态初始化就是在定义数组的同时对数组元素进行初始化
静态初始化可用于任何元素类型，初值块中每个位置的每个元素对应一个引用。
动态初始化是使用运算符 new为数组分配空间。
数组说明的方括号中的数字表示数组元素个数静态初始化
int intArray[ ]={1,2,3,4};
int[] ages = {34,12,45};
double[] heights = {84.124,78.2,61.5};
boolean[] tired = {true,false,false,true};
String[] names ={“Zhang",“Li",“Wang"};
动态初始化
type[ ] arrayName = new type[arraySize]
type arrayName[ ] = new type[arraySize]
s = new char[20];
复合类型的数组
复合类型的数组需要经过两步进行空间分配
使用运算符 new只是为数组本身分配空间，并没有对数组的元素进行初始化
第一步先创建数组本身：
type arrayName[ ] = new type[arraySize];
第二步分别创建各个数组元素,
arrayName[0] = new type(paramList);
…
arrayName[arraySize-1] = new
type(paramList);
复合类型的数组
points = new Point[100];
points[0] = new Point();
points[1] = new Point();
…
points[99] = new Point();
string stringArrar[];
stringArray = new String[3];
stringArray[0] = new String(“how”);
stringArray[1] = new String(“are”);
Java中没有静态的数组定义，
内存都是通过 new动态分配的。
int intArray[5]; //是错误的数组说明与创建关系
Point类
class Point {
int x,y;
Point ( int x1,int y1) {
x = x1;
y = y1;
}
Point() {
this(0,0);
}
}
数组说明与创建关系
points
(a)
points
Length:100
…
(b)
points
…
Length:100
X:
Y:
(c)
Point [] points;
执行完毕，系统为变量
points分配一个引用空间
points = new Point [100];
执行完毕，系统在内存中分配一个数组对象并把数组引用赋给变量 points
points[1] = new Point ();
数组说明注意
数组引用的类型可以为它所指向元素的父类
正确
错误
Object [] points;
points = new Point [100];
Point [] points;
points = new Object [100];
数组边界
数组下标从 0开始,元素个数 length是数组类中唯一的数据成员变量
new创建数组时系统自动给 length赋值
数组一旦创建完毕，其大小就固定下来
程序运行时可以使用 length进行数组边界检查。
如果发生越界访问，则抛出一个异常数组边界例
int list[] = new int [10];
for (int i = 0; i < list.length; i++) {
// 进行相应处理的代码
}
循环的结束条件中使用
list.length，而不是常数 10。这样做不会引起数组下标越界，
使程序更健壮，修改更方便。
数组元素的引用
数组名加上下标,引用方式为,
index为数组下标，下标从 0开始，一直到 length-1
下标是整型常数或表达式
程序 4-1设给定一组整型数,求它们的平均值
arrayName[index]
arrayName[1],
arrayName[i],
arrayName[6*i]
多维数组
多维数组的定义
Java中没有真正的多维数组，可以建立数组的数组（的数组 …… ），由此得到多维数组
n维数组是 n-1维数组的数组
说明多维数组时使用类型及多对方括号二维数组
二维数组的定义方式：
与一维数组一样，定义对数组元素也没有分配内存空间，要使用运算符 new来分配内存，然后才可以访问每个元素
type arrayName[ ][ ]
type[ ][ ] arrayName
多维数组的初始化
静态初始化
在定义数组的同时为数组分配空间
动态初始化
直接为每一维分配空间
从最高维起（而且必须从最高维开始），分别为每一维分配内存
int intArray[ ][ ]= {{2,3},{1,5},{3,4}};
数组 intArray为一个 3行 2列的数组,它的形式如下：
2 3
1 5
3 4
type arrayName[ ][ ] = new
type[arraylength1][arraylength2]
例如,int a[ ][ ] = new int[2][3]；
type arrayN[ ][ ] = new type [ arrleng1 ][ ];
arrayN [0] = new type [arrleng2];
arrayN [1] = new type [arrleng2];
......
arrayN [arrleng1 - 1] = new type [arrleng2];
二维数组 例一
int twoDim [ ][ ] = new int [4][ ];
twoDim[0] = new int[5];
twoDim[1] = new int[5];
二维数组 例二
String s[ ][ ]=new String[2][ ];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String(“Good”);
s[0][1] = new String(“Luck”);
s[1][0] = new String(“to”);
s[1][1] = new String(“you”);
s[1][2] = new String(“!”);
非矩阵数组
int twoDim[ ][ ] = new int [ 4 ][ ];
twoDim[0] = new int[2];
twoDim[1] = new int[4];
twoDim[2] = new int[6];
twoDim[3] = new int[8]; X X
X X X X
X X X X X X
X X X X X X X X
twoDim数组为 4行，每行的元素个数分别为 2，
4,6,8个矩阵数组
二维矩阵数组的一般说明格式为：
arrayName是数组名,length1和 length2分别为数组各维的大小,type是数组元素的类型。
type arrayName [][] = new type [length1][length2];
二维矩阵数组
int matrix[ ][ ] = new int [4][5];
将创建一个有 4个一维数组的数组,每个一维数组中又有 5个整数,即 4行 5列的整数矩阵 。
该行等价于下列这段代码：
int matrix[ ][ ] = new int [4][ ];
for (int j = 0; j < matrix.length; j++)
matrix[j] = new int[5];
多维数组说明
正确的声明：
int a1[][] = new int [2][3];
int a2[][] = new int [2][];
int []a3[] = new int [4][6];
错误的说明：
int errarr1[2][3];
int errarr2[][] = new int [ ] [ 4 ];
int errarr3[][4] = new int [3][4];
不允许说明静态数组说明顺序应从高维到低维数组维数的指定只能出现在 new
运算符之后多维数组的引用
二维数组引用方式为：
arrayName[index1][index2]
例如：
int myTable[][] = new int[4][3];
myTable[0][0] = 34;
myTable[0][1] = 15;
myTable[0][2] = 26;
多维数组的引用例
int myTable[][] = {
{23,45,65,34,21,67,78},
{46,14,18,46,98,63,88},
{98,81,64,90,21,14,23},
{54,43,55,76,22,43,33}};
for (int row=0;row<4; row++) {
for (int col=0;col<7; col++)
System.out.print(myTable[row][col] + " ");
System.out.println();
}
0 1 2 3 4 5 6
0 23 45 65 34 21 67 78
1 46 14 18 46 98 63 88
2 98 81 64 90 21 14 23
3 54 43 55 76 22 43 33
多维数组的引用例
计算表中各行元素之和并查找其值最大的那个行 程序 4-2
length属性
多维数组的 length属性只返回第一维的长度
int ages[4][7];
ages.length; // 返回 4,而不是 28
可以分别存取每一维的长度，如：
int[][] ages = int ages[4][7];
int[] firstArray = ages[0];
ages.length * firstArray.length; // 返回 28
Arrays类常用的方法
int binarySearch(type a[],type key)
对关键字 key在数组 a中进行二分查找，但要求数组 a必须已经排序（ sort方法 ），否则返回值无意义
boolean equals(type a[],type a2[])
它判定两个数组大小是否相同，并且每一个元素是否相等。 两个 null数组是相等的数组拷贝
System类的 arraycopy() 方法
class ArrayTest{
public static void main(String args[]) {
int elements[] = { 1,2,3,4,5,6 };
int hold[] = {10,9,8,7,6,5,4,3,2,1 };
System.arraycopy(elements,0,hold,0,elements.length);
}
}
Vector类
对应于类似数组的顺序存储的数据结构，
允许不同类型的元素共存于一个变长数组中，可以看作是把不同类型元素按照动态数组进行处理
向量是一组对象的集合
可以看作是一个可变大小的数组
用一个整数类型的次序值来访问 （索引值）
增加或删除了元素，大小也变大或变小概述
适合情况：
需要处理的对象数目不定,序列中的元素都是对象或可以表示为对象；
需要将不同类的对象组合成一个数据序列；
需要做频繁的对象序列中元素的插入和删除；
经常需要定位序列中的对象和其他查找操作 ;
在不同的类之间传递大量的数据；
Vector类
elementData
存放数据元素
elementCount
记录 Vector中元素的实际个数
capacityIncrement
容量增值
Vector构造方法
public Vector()
构造一个空向量
public Vector(int initialCapacity)
以初始存储容量 initialCapacity构造一个空的向量 Vector
public Vector(int initialCapacity,int
capacityIncrement)
以初始存储容量 initialCapacity和容量增量
capacityIncrement构造一个空的向量 Vector
例如,
Vector MyVector = new Vector(100,50)；
Vector类的操作
元素的添加
addElement(Object obj)：将新元素添加到序列尾部
insertElementAt(Object obj,int index)：将指定对象 obj插入到指定位置 index处Vector MyVector = new Vector()；
for (int i=1;i<=10;i++)
{
MyVector.addElement(new Random());
}
MyVector.insertElementAt("middle",5);
元素的删改
setElementAt(Object obj,int index)
将向量序列 index位置处的对象元素设置为 obj
removeElement(Object obj)
删除第一个与指定的 obj对象相同的元素，将后面的元素前提，补上空位
removeElementAt(int index)
删除 index指定位置处的元素，同时将后面的元素前提
removeAllElements()
清除向量序列中的所有元素，向量的大小置为 0
删除修改实例
Vector MyVector = new Vector(100);
for (int i=0;i<10;i++){
MyVector.addElement(“welcome”);
MyVector.addElement(“to”);
MyVector.addElement(“beijing”);
}
while (MyVector.removeElement(“to”));
元素的查找
Object elementAt(int index)
返回指定位置处的元素
boolean contains(Object obj)
检查向量序列中是否包含指定的对象元素 obj
int indexOf (Object obj,int start_index)
从指定的 start_index位置开始向后搜索，返回所找到的第一个与指定对象 obj相同的元素的下标位置。若对象不存在，则返回 -1
int lastIndexOf(Object obj,int start_index)
从指定的 start_index位置开始向前搜索，返回所找到的第一个与指定对象 obj相同的元素的下标位置。若对象不存在，则返回 -1
Vector的其他方法
public final int size()
返回向量中的元素数量
public final boolean contains(Object elem)
判断对象 elem是否在向量中
public final int indexOf(Object elem)
从向量的第一个元素开始查找指定对象，并返回该对象的索引值（如果查找不成功则返回 -1）
Vector的其他方法
capacity(),返回 Vector的容量；
clone(),建立 Vector的备份；
copyInto(Object[]),把 Vector中的元素拷贝到一个数组中；
firstElement(),返回第一个元素；
lastElement(),返回最后一个元素；
isEmpty()：判断是否为空；
setSize(int size),设置 Vector的大小；
trimToSize()：将 Vector的容量下调至最小值
Vector类的使用举例
程序 4-4 使用 Vector类的方法，向向量增加不同类型的元素并输出 Vector元素字符串类型
字符串
内存中连续排列的一个或多个字符
String 处理不变字符串
StringBuffer处理可变字符串字符串说明及初始化
字符串常量
系统为程序中出现的字符串常量自动创建一个
String对象
字符串变量
System.out.println(“This is a String”);
将创建,This is a String”对象
String s1;
StringBuffer sb1;
String s1 = new String();
char chars[] = {'a','b','c'};
String s2 = new String( chars );
String s3 = "Hello World!";
字符串处理 String类
length()
返回字符串中的字符个数
charAt(int index)
返回字符串中 index位置的字符
toLowerCase()
将当前字符串中所有字符转换为小写形式字符串处理 String类
toUpperCase()
将当前字符串中所有字符转换为大写形式
subString(int beginIndex)
当前字符串中从 beginIndex开始到末尾的子串
replace(char oldChar,char newChar)
将当前字符串中出现的所有 oldChar转换为
newChar
字符串处理例
程序 4-5
StringBuffer类
修改一个 StringBuffer类的字符串时，不用再创建一个新的字符串对象，而是直接操作原字符串
分配内存时，除去字符所占空间外，再另加 16个字符大小的缓冲区
StringBuffer的长度（ length)是指存储在其中的字符个数，容量 (capacity)是指缓冲所能容纳的最大字符数连接
String类对象使用 concat(String str)方法将 str
连接在当前字符串的尾部
重载运算符,+”
StringBuffer类对象使用 append()方法实现连接
String s = "This is the ";
String t = s.concat("String.");
t的内容为,"This is the String."
String s = "He is" + age + "years old.";String s = new StringBuffer("He
is").append(age).
append("years old.").toString();
比较
可用方法
使用关系运算符,==”
与 equals()方法不同的是,,= =”判定两字符串对象是否是同一实例，即它们在内存中的存储空间是否相同
compareTo()、
equals()、
equalsIgnoreCase()、
regionMatches()
比较例子
程序 4-6
