java字符串String&StringBuffer

 

7.1 String
类
7.2
StringBuffer
类

7.1 String
类
String类（字符串类）的对象是一经创建便不能变动内容的
字符串常量，在前面的程序中我们已经多次使用了字符串常
量，例如输出语句中的参数之一"Input a Integer data/n"就是字符
串常量，只是当时并未明确提出这个概念。在学习String类的知
识之前，我们先强调一点，那就是请读者把本章学习字符串常
量与我们在第二章学习过的字符常量加以区分。字符常量是用
单引号括起的单个字符，例如，'A'，'/n'等。而字符串常量是用
双引号括起的字符序列，例如，"A"，"/n"，"Java Now"等。在
Java语言中，字符串常量通常是作为String类的对象而存在的，
有专门的数据成员来表明它的长度。本节主要讨论String类对象
的创建、使用和操作。

7.1.1
创建String
对象
Java语言规定字符串常量必须用双引号括起，一个串可以
包含字母、数字和各种特殊字符，如+、-、*、/、$等。在我们
前面的程序范例中已多次使用过字符串常量，例如下面的语句：
System.out.println("OK！");
中的"OK！"就是字符串常量。Java的任何字符串常量都是String
类的对象，只不过在没有明确命名时，Java自动为其创建一个匿
名String类的对象，所以，它们也被称为匿名String类的对象。我
们可以用下面的方法创建String类的对象。例如：
String c1="Java"；

语句创建String类的对象c1，并通过赋值号将匿名String类
的对象"Java"赋值给c1引用。String类的对象一经创建，便有一
个专门的数据成员来记录它的长度。

7.1.2 String
类的构造方法
表7.1 String
类的构造方法
构 造 方 法说 明
public String( ) 创建一个空字符串对象
public String(String value) 用串对象value创建一个新的字符串对象，value可
以是字符串或String类的对象。
public String(char value[ ]) 用字符数组value[ ]来创建字符串对象。
public String(char value[ ],int offset,int
count)
从字符数组value中下标为offset的字符开始，创
建有count个字符的串对象。
public String(byte ascii[ ]) 用byte型字符串数组ascii，按缺省的字符编码方
案创建串对象。
public String(byte ascii[ ] ， int offset int
count))
从字节型数组ascii中下标为offset的字符开始，按
缺省的字符编码方案创建count个字符的串对象。
public String(StringBuffer Buffer) 构造一个新的字符串，其值为字符串的当前内容。

【示例程序c7_1.java】 String类的7种构造方法的使用。
import java.io.*;
public class c7_1
{
public static void main(String[ ] args)
{//字符数组型的字符串
char charArray[ ]={'b','i','r','t','h',' ','d','a','y'};
//字节数组型的字符串，其中每个字节的值代表汉字的国际机内码
//汉字的国际机内码（GB2312码），两个字节的编码构成一个汉字。
//数组构成“面向对象”4个汉字。-61与-26组合成汉字“面”，其余类推

byte byteArray[ ]={-61, -26, -49, -14, -74, -44, -49, -13};
StringBuffer buffer;
String s,s1,s2,s3,s4,s5,s6,s7,ss;
s=new String("hello"); //用字符串创建一个新的字符串对象s
ss="ABC";//用字符串赋给String类型的对象引用
//用StringBuffer创建一个字符串对象buffer
buffer=new StringBuffer("Welcom to java programming! ");
s1=new String( ); //创建一个空字符串对象

s2=new String(s); //用串对象s创建一个新的字符串对象s2
s3=new String(charArray); //用字符数组创建字符串对象s3
//用字符串数组中下标为6开始的3个字符创建字符串对象s4
s4=new String(charArray,6,3);
//用字符串数组byteArray按缺省的字符编码方案创建串对象s5
s5=new String(byteArray);
//从前面创建的字节型数组byteArray下标为2的字节开始，取连续的4个字
节创建串对象
// s6，即取{-49, -14, -74, -44}
s6=new String(byteArray,2,4);

//构造一个新的字符串对象s7，其值为字符串buffer的当前内容
s7=new String(buffer);
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
System.out.println("s4="+s4);
System.out.println("s5="+s5);
System.out.println("s6="+s6);
System.out.println("s7="+s7);
System.out.println("ss="+ss);
System.out.println("buffer="+buffer);
}
}

运行结果如下：
s1=
s2=hello
s3=birth day
s4=day
s5=面向对象
s6=向对
s7=Welcom to java programming!
ss=ABC
buffer=Welcom to java programming!

7.1.3 String
类的常用方法
表7.2 Java.lang.String
常用成员方法
成 员 方 法功 能 说 明
public int length( ) 返回当前串对象的长度
public char charAt(int index) 返回当前串对象下标int index处的字符
public int indexof(int ch)
返回当前串内第一个与指定字符ch相同的下标，若找不
到，则返回-1
public int indexOf(String str,
int fromIndex)
从当前下标fromIndex处开始搜索，返回第一个与指定字
符串str相同的第一个字母在当前串中的下标，若找不
到，则返回-1
public String substring(int beginIndex) 返回当前串中从下标beginIndex开始到串尾的子串
public String substring(int beginIndex,
int endIndex)
返回当前串中从下标beginIndex开始到下标endIndex-1的
子串
public boolean equals(Object obj) 当且仅当obj不为null且当前串对象与obj有相同的字符串
时，返回true否则返回flase

表7.2 Java.lang.String
常用成员方法
public boolean equalsIgnoreCase(String s) 功能与equals类似，equalsIgnoreCase 在比较字符串时忽略大小写
public int compareTo(String another_s) 比较两字符串的大小。返回一个小于、等于或大于零的整数。返
回的值取决于此字符串是否小于、等于或大于another_s
public String concat(String str) 将字符串str连接在当前串的尾部，返回新的字符串
public String replace(char oldCh,
char newCh) 将字符串的字符oldCh替换为字符串newCh
public String toLowerCase( ) 将字符串中的大写字符转换为小写字符
public String toUpperCase( ) 将字符串中的小写字符转换为大写字符
public static String valueOf(type variable) 返回变量variable值的字符串形式。type可以是字符数组
public static String valueOf(char [ ] data,
int offset,int count) 返回字符数组data从下标offset开始的count个字符的字符串
public static String valueOf(Object obj) 返回对象obj的字符串
public String toString ( ) 返回当前字符串

7.1.4
访问字符串对象
用于访问字符串对象的信息常用到的成员方法为：
length( )：返回当前串对象的长度。
charAt（int index）：返回当前串对象下标 index处的字符。
indexOf（int ch）：返回当前串内第一个与指定字符ch相同
的下标，若找不到，则返回-1。例如，“abcd”. IndexOf(“c”); //值
为2。“abcd”. IndexOf(“Z”); //值为-1。

indexOf（String str, int fromIndex）：从当前下标fromIndex
处开始搜索，返回第一个与指定字符串str相同的第一个字母在
当前串中的下标，若找不到，则返回-1。例如，"abcd".
IndexOf("cd",0); //值为2。
substring(int beginIndex)：返回当前串中从下标beginIndex开
始到串尾的子串。例如，String s="abcde".subString(3); //s 值为
"de"。
public String substring(int beginIndex,int endIndex)：返回当
前串中从下标beginIndex开始到下标endIndex-1的子串。例如，
String s="abcdetyu".subString(2,5); //s 值为"cde"。

【示例程序c7_2.java】
public class c7_2
{
public static void main(String args[ ])
{ String s1="Java Application";
char cc[ ]={'J','a','v','a',' ','A','p','p','l','e','t'};
int len=cc.length;// 返回当前串对象的长度
int len1=s1.length( );
int len2="ABCD".length( );

char c1="12ABG".charAt(3);// 返回当前串对象下标int index处的字符
char c2=s1.charAt(3);
// char c3=cc.charAt(1);错，不能这样用
//返回当前串内第一个与指定字符ch相同的下标
int n1="abj".indexOf(97);
int n2=s1.indexOf('J');
int n3="abj".indexOf("bj",0);
int n4=s1.indexOf("va",1);
//返回当前串中的子串
String s2="abcdefg".substring(4);

String s3=s1.substring(4,9);
System.out.println("s1="+s1+" len="+len1);
System.out.println("cc="+cc+" len="+len); //不能这样打印cc数组元素的内容
System.out.println("ABCD=ABCD"+" len="+len2);
System.out.println("c1="+c1+" c2="+c2);
System.out.println("n1="+n1+" n2="+n2);
System.out.println("n3="+n3+" n4="+n4);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
}
}

运行结果:
s1=Java Application len=16
cc=[C@310d42 len=11
ABCD=ABCD len=4
c1=B c2=a
n1=0 n2=0
n3=1 n4=2
s2=efg
s3= Appl

7.1.5
字符串比较
常用的字符串比较成员方法有：equals( )、
equalsIgnoreCase( )及compareTo( )。它们的用法及功能如下：
当前串对象.equals(模式串对象)：当且仅当当前串对象与模
式串对象的长度相等且对应位置的字符(包括大小写)均相同时，
返回true，否则返回flase。例如表达式
"Computer".equals("computer")
的结果为flase，因为第一个字符的大小写不同。

当前串对象.equalsIgnoreCase(模式串对象)：
equalsIgnoreCase( )与equals( )方法的功能类似，不同之处是不
区分字母的大小写。例如表达式
"Computer".equalsIgnoreCase ("computer")
的结果为true。
当前串对象.compareTo(模式串对象)：当前串对象与模式
串对象比较大小，返回当前串对象与模式串对象的长度之差或
第一个不同字符的unicode码值之差。

【示例程序c7_3.java】 字符串比较运算的成员方法的使用。
public class c7_3
{
public static void main(String args[ ])
{ String s1="Java";
String s2="java";
String s3="Welcome";
String s4="Welcome";
String s5="Welcoge";
String s6="student";

boolean b1=s1.equals(s2);//s1为当前串对象，s2为指定对象
boolean b2=s1.equals("abx");
boolean b3=s3.equals(s4);
boolean b4=s1.equalsIgnoreCase(s2);
int n1=s3.compareTo(s4);
int n2=s1.compareTo(s2);
int n3=s4.compareTo(s5);
int d1=s6.compareTo("st");
int d2=s6.compareTo("student");
int d3=s6.compareTo("studentSt1");
int d4=s6.compareTo("stutent");
System.out.println("s1="+s1+"/ts2="+s2);

System.out.println("s3="+s3+"/ts4="+s4);
System.out.println("s5="+s5);
System.out.println("equals: (s1==s2)="+b1+"/t(s1==abx)="+b2);
System.out.println("equals: (s3==s4)="+b3);
System.out.println("equalsIgnoreCase: (s1==s2)="+b4);
System.out.println("(s3==s4)="+n1+"/t(s1<s2)="+n2);
System.out.println("(s4>s5)="+n3);
System.out.println("d1="+d1+"/td2="+d2);
System.out.println("d3="+d3+"/td4="+d4);
}
}

运行结果:
s1=Java s2=java
s3=Welcome s4=Welcome
s5=Welcoge
equals: (s1==s2)=false (s1==abx)=false
equals: (s3==s4)=true
equalsIgnoreCase: (s1==s2)=true
(s3==s4)=0 (s1<s2)=-32
(s4>s5)=6
d1=5 d2=0
d3=-3 d4=-16

7.1.6
字符串操作
字符串操作是指用已有的字符串对象产生新的字符串对象。
常用的成员方法有concat( )、replace( )、toLowerCase( )、
toUpperCase( )。
【示例程序c7_4.java】 字符串的连接、替换和字母大小写转
换操作。
public class c7_4
{
public static void main(String args[ ])
{ String s1="Java";
String s2="java";
String s3="Welcome";

String s4="Welcome";
String s5="Welcoge";
String sc1=s3.concat(s1);// sc1值为"Welcome Java "
String sc2=s1.concat("abx");
String sr1=s3.replace('e','r');//s3中的字符'e'换成'r'
String w1=s5.toLowerCase( );//s5中的大写换小写
String u2=s2.toUpperCase( );//s2中的小写换大写
System.out.println("s1="+s1+"/ts2="+s2);
System.out.println("s3="+s3+"/ts4="+s4);

System.out.println("s5="+s5);
System.out.println("s3+s1="+sc1);
System.out.println("s1+abx="+sc2);
System.out.println("s3.replace('e','r')="+sr1);
System.out.println("s5.toLower="+w1);
System.out.println("s2.toUpper="+u2);
}
}

运行结果：
s1=Java s2=java
s3=Welcome s4=Welcome
s5=Welcoge
s3+s1=WelcomeJava
s1+abx=Javaabx
s3.replace('e','r')=Wrlcomr
s5.toLower=welcoge
s2.toUpper=JAVA

7.1.7
其他类型的数据转换成字符串
String类中的valueOf(参数)成员方法可以将参数类型的数据
转换成字符串，这些参数的类型可以是：boolean，char，int，
long，float，double和对象。
【示例程序c7_5.java】 将其他类型数据转换成字符串。
public class c7_5
{
public static void main(String args[ ])
{ double m1=3.456;
String s1=String.valueOf(m1); 将double型值转换成字符串
char[ ] cc={'a','b','c'};

String s2=String.valueOf(cc);//将字符数组转换成字符串
boolean f=true;
String s3=String.valueOf(f); //将布尔值转换成字符串
char[ ] cs={'J','a','v','a'};
String s4=String.valueOf(cs,2,2);
System.out.println("m1="+m1+"/ts1="+s1);
System.out.println("s2="+s2);
System.out.println("f="+f+"/ts3="+s3);
System.out.println("s4="+s4);
}
}

运行结果:
m1=3.456 s1=3.456
s2=abc
f=true s3=true
s4=va

【示例程序c7_6.java】 valueOf(对象)成员方法与toString( )
成员方法联用，返回对象的字符表示。
class A1
{ int x,y;
A1(int x,int y){this.x=x;this.y=y;}
public String toString( ){return ("/tx="+x+"/t,y="+y);}
}
public class c7_6
{
public static void main(String args[ ])

{ A1 p=new A1(2,6);//调用构造方法初始化
// String.valueOf(p)返回p对象的字符表示。valueOf(p)引用
//toString( )成员方法，p对象可用toString( )成员方法转换成字符串
String str=String.valueOf(p);
System.out.println("str="+str);
}
}
运行结果：
str= x=2 , y=6

7.1.8 main
方法中的参数
在Java应用程序中我们必须写public static void main(String[ ]
args)主方法。main方法中有一个参数是字符串数组args，这个数
组的元素args[0],args[1]……args
的值都是字符串。args就是命
令行的参数。在Java解释器解释用户的字节码文件时，可以包括
需要传给main方法的参数。一般形式为：
java 类文件名 字符串1 字符串2 …… 字符串n
其中，类文件名和各字符串间用空格分隔。

【示例程序c7_7.java】 运行时需要输入参数的main方法。
public class c7_7
{
public static void main(String[ ] args)
{
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
}
}

运行时输入“java c7_7 Hello World Let's Java!”命令，则有
如下的结果：
Hello
World
Let's
Java!

7.2
StringBuffer
类
StringBuffer类（字符串缓冲器类）也是java.lang.Object的子
类。与String类不同，StringBuffer类是一个在操作中可以更改其
内容的字符串类，即一旦创建StringBuffer类的对象，在操作中可
以更改和变动字符串的内容。也就是说对于StringBuffer类的对象
不仅能进行查找和比较等操作，也可以做添加、插入、修改之类
的操作。

7.2.1
创建StringBuffer
对象
表7.3
StringBuffer
构造方法
构 造 方 法功 能 说 明
public StringBuffer ( ) 创建一个空字符串缓冲区，默认初始长度为16个字符
public StringBuffer(int length) 用length指定的初始长度创建一个空字符串缓冲区
public StringBuffer(String str) 用指定的字符串str创建一个字符串缓冲区，其长度为str的长度再加16
个字符

7.2.2
StringBuffer
类的常用方法
表7.4
Java.lang.StringBuffer
常用成员方法
成 员 方 法功 能 说 明
public int length( ) 返回当前缓冲区中字符串的长度
public char charAt(int index) 返回当前缓冲区中字符串下标 index处的字
符
public void setcharAt(int index,char ch) 将当前缓冲区中字符串下标 index处的字符
改变成字符ch的值
public int capacity( ) 返回当前缓冲区长度
public StringBuffer append(Object obj) 将obj.toString( )返回的字符串添加到当前
字符串的未尾
public StringBuffer append(type variable) 将变量值转换成字符串再添加到当前字符
串的未尾，type可以是字符数组、串和各
种基本类型

表7.4
Java.lang.StringBuffer
常用成员方法
public StringBuffer append (char[ ]str,int
offset,int len)
将数组从下标offset开始的len个字符
依次添加到当前字符串的未尾
public StringBuffer insert(int offset,Object
obj)
将obj.toString( )返回的字符串插入当
前字符下标offset处
public StringBuffer insert(int offset, type
variable)
将变量值转换成字符串，插入到当前
字符数组下标为offset的位置处
public String toString( ) 将可变字符串转化为不可变字符串

7.2.3
StringBuffer
类的测试缓冲区长度的方法
StringBuffer类提供了length( )、charAt( )和capacity( )等成员
方法来测试缓冲区长度。
【示例程序c7_8.java】 测试缓冲区长度。
public class c7_8
{
public static void main(String[ ] args)
{
StringBuffer buf1=new StringBuffer( );//创建一个空字符串缓冲区
// 指定初始长度为16创建一个空字符串缓冲区
StringBuffer buf2=new StringBuffer(10);

//用指定的"hello"串创建一个字符串缓冲区
StringBuffer buf3=new StringBuffer("hello");
//返回当前字符串长度
int len1=buf1.length( );
int len2=buf2.length( );
int len3=buf3.length( );
//返回当前缓冲区长度
int le1=buf1.capacity( );
int le2=buf2.capacity( );
int le3=buf3.capacity( );

//从buf3字符串中取下标为3的字符
char ch=buf3.charAt(3);
//使用StringBuffer的toString方法将三个StringBuffer
//对象转换成String对象输出
System.out.println("buf1="+buf1.toString( ));
System.out.println("buf2="+buf2.toString( ));
System.out.println("buf3="+buf3.toString( ));
System.out.println("len1="+len1+"/tlen2="+len2+"/tlen3="+len3);
System.out.println("le1="+le1+"/tle2="+le2+"/tle3="+le3);
System.out.println("ch="+ch);
}
}

运行结果:
buf1=
buf2=
buf3=hello
len1=0 len2=0 len3=5
le1=16 le2=10 le3=21
ch=l

7.2.4
StringBuffer
类的append( )
方法
StringBuffer类提供了append(Object obj)、append(type
variable)和append (char[ ]str, int offset, int len)成员方法。读者可根
据参数选用其中一种方法，将参数转换为字符串添加到当前字符
串后面。
【示例程序c7_9.java】 将给定字符串添加到当前字符串后面。
public class c7_9
{
public static void main(String[ ] args)
{

Object x="hello";
String s="good bye";
char cc[ ]={'a','b','c','d','e','f'};
boolean b=false;
char c='Z';
long k=12345678;
int i=7;
float f=2.5f;
double d=33.777;
StringBuffer buf=new StringBuffer( );

buf.append(x); buf.append(' '); buf.append(s);
buf.append(' '); buf.append(cc); buf.append(' ');
buf.append(cc,0,3); buf.append(' ');buf.append(b);
buf.append(' '); buf.append(c); buf.append(' ');
buf.append(i); buf.append(' '); buf.append(k);
buf.append(' '); buf.append(f); buf.append(' ');
buf.append(d);
System.out.println("buf="+buf);
}
}
运行结果:
buf=hello good bye abcdef abc false Z 7 12345678 2.5 33.777

7.2.5
StringBuffer
类的insert( )
方法
StringBuffer类提供了insert(int offset, Object obj)和insert(int
offset, type variable) 成员方法用于插入字符串到当前字符串中，
其中的参数offset指出插入的位置。
【示例程序c7_10.java】 将各种数据转换成字符串插入到当
前字符串的第0个位置。
public class c7_10
{
public static void main(String[ ] args)
{
Object y="hello";
String s="good bye";

char cc[ ]={'a','b','c','d','e','f'};
boolean b=false;
char c='Z';
long k=12345678;
int i=7;
float f=2.5f;
double d=33.777;
StringBuffer buf=new StringBuffer( );
buf.insert(0,y); buf.insert(0,' '); buf.insert(0,s);
buf.insert(0, ' '); buf.insert(0,cc); buf.insert(0,' ');
buf.insert(0,b); buf.insert(0,' '); buf.insert(0,c);

buf.insert(0, ' '); buf.insert(0,i); buf.insert(0,' ');
buf.insert(0,k); buf.insert(0,' '); buf.insert(0,f);
buf.insert(0,' '); buf.insert(0,d);
System.out.println("buf="+buf);
}
}
运行结果如下：
buf=33.777 2.5 12345678 7 Z false abcdef good bye hello

7.2.6
StringBuffer
类的setcharAt
( )
方法
setcharAt(int index,char ch)方法是将当前字符串下标 index处
的字符改变成字符ch的值。
【示例程序c7_11.java】
public class c7_11
{
public static void main(String[ ] args)
{ StringBuffer buf=new StringBuffer("hello there");
System.out.println("buf="+buf.toString( ));
System.out.println("char at 0: "+buf.charAt(0));

buf.setCharAt(0,'H'); //将buf串下标为0的字符改写为'H'
buf.setCharAt(6,'T'); //将下标为6的字符改写为'T'
System.out.println("buf="+buf.toString( ));
}
}
运行结果如下：
buf=hello there
char at 0: h
buf=Hello There