第4课 运算符、表达式和字符串
运算符是Java程序中重要的因素之一，运算符的种类很多种，如算术运算符、位运算符、关系运算符、逻辑运算符等，将操作数和运算符连接起来，就形成了表达式，组成一个符合Java语法规则的式子，运算符和表达式都是程序的基础。本课将详细讲解运算符、表达式和字符串。
4.1 本课学习目标
在本课的内容中，将详细讲解Java运算符、表达式和字符串，本课的具体学习目标如下：
● Java运算符。
● 表达式。
● 运算符优先级。
4.2 Java运算符
Java运算符大致可以细分为算术运算符、位运算符、关系运算符、逻辑运算符和其他运算符，下面对其进行讲解。
4.2.1 算术运算符
算术运算符号主要用于算术表达式，其功能和用法与数学中的含义一样，它有基本算术运算符、取余运算符等，如表4-1所示。
表4-1 算术运算符
1.基本运算符
加/减法和数学的运算一样，不进行讲解，这里讲解一下“*”和“/”，下面将通过一段代码来先讲解除法，代码如下：
public abstract class ChengFa {
public static void main(String args[])
{
int a=231;
int b=4;
System.out.println(a/b);
}
}
执行后，结果是57，如图4-1所示。
图4-1 除法
这说明整数相除，只保留整数部分，其小数部分不会保留，下面再看看下面这一段代码：
public class ChengFa1
{
public static void main(String args[])
{
System.out.println(623/100*100);
}
}
执行后，得到的效果是600，如图4-2所示。
图4-2 乘除结合
从上面的图中运行效果，可以看出，运算符都遵循一个原则，从左到右依次进行计算。
在程序中的算术运算遵循数学中的一切规则，如下面的代码：
public class ChengFa2 {
public static void main(String args[])
{
int a=2008;
System.out.println(a/0);
}
}
这段程序将不会得到任何结果，因为除数为“0”，在数学的运算中，如果除数为“0”，则这个除法运算将没有任何意义，如果要执行，将得到如图4-3所示的结果。
图4-3 除法的除数为零执行的结果
下面再给出一段代码，它和上面的一段代码十分相似，但是运行得到的结果全然不同，代码如下：
public class ChengFa3 {
public static void main(String args[])
{
double a=2008;
System.out.println(a/0);
}
}
执行后的结果如图4-4所示。
图4-4 双精度数除以0的结果
用户也许看出来了问题，如果是int数据除以0，将是一个错误，如果double除以0，它显示一个英语单词“Infinity”，这个单词的中文意思是无穷大，用户在学习时，一定要注意除数为0的情况，不一定都是错误无意义，在双精度下，它是有意义的。
2.求余运算符
“%”符号在Java的程序中代表求余数，它和除号一样，任何整数都不能对0求余，对正整数求模很容易，如过出现负数求模，那又是什么样子的呢？请阅读下面的代码：
public class YuShu {
public static void main(String args[])
{
int a=17%2;
int b=-17%-2;
int c=17%-2;
int d=-17%2;
System.out.println("a=17%2的余数"+a);
System.out.println("b=-17%-2的余数"+b);
System.out.println("c=17%-2的余数"+c);
System.out.println("d=-17%2的余数"+d);
}
}
执行的结果如图4-5所示。
图4-5 求余数的结果
由上面的执行结果，求余遵循x%y=x%|y|。
实例探索和读者练习：
在上述的程序中，求余的方法是十分简单的，用户只需记住x%y=x%|y|公式，就可以准确地判断出求余的结果。
读者根据x%y=x%|y|公式，判断下面的程序执行后的结果，其代码如下：
public class YuShu1
{
public static void main(String[] args) {
int x=1237%5;
int y=117%-5;
int z=-517%-5;
int m=-317%5;
System.out.println("x=1237%5的余数"+x);
System.out.println("y=117%-5的余数"+y);
System.out.println("z=-517%-5的余数"+z);
System.out.println("m=-317%5的余数"+m);
}
}
3.Java中的递增和递减
“++”、“--”每执行一次，变量将会增加1或者减少1，它可以放在变量的前面，也可以放在变量的后面，无论哪一种都能改变变量的结果，但它们有一些不同，其代码如下：
public class DiText
{
public static void main(String args[])
{
int a=7199;
int b=2009;
System.out.println(a++);
System.out.println(a);
System.out.println(++a);
System.out.println(b--);
System.out.println(b);
System.out.println(--b);
}
}
将上面的代码执行，得到如图4-6所示的结果。
图4-6 递增和递减
根据执行的结果，可以看出，a++是先执行程序才加1，++a是先加1再执行程序，a--是先执行再减1，--a是先减1再执行程序。“system.out.println(a++)；”它应是先执行再加1，所以它输出的值应该是初始值7199，“system.out.println(a)；”因为前一句话将其加1，所以结果有所变化，结果为7200，“system.out.println(++a)”是先加1，再执行程序，执行的结果是7201，后面的程序以同样的道理得到结果，初学者应该多多理解。下面将通过一些实例练习来巩固这个知识点。
实例探索和读者练习：
在上述的程序中，递增和递减十分简单，但是初学者很容易被混淆，不知道程序的结果，建议初学者在这个知识点上下苦功夫，打好基础。读者可以根据下面的代码，给出结果，其代码如下：
public class DiTextone
{
public static void main(String args[])
{
int x=2000;
int y=2000;
int x1=2000;
int y1=2000;
System.out.println(x++);
System.out.println(++y);
System.out.println(x1--);
System.out.println(--y1);
}
}
4.2.2 逻辑运算符和关系运算符
在Java程序中，关系运算符（Relation Openator）和逻辑运算符（Logical Operator）十分重要，关系运算符是指值与值之间的相互关系。逻辑运算符是指可以用真值和假值连接在一起的方法。因此关系运算符产生的结果是真或假，所以它们经常与逻辑运算符一起使用就出于这一原因。我们这里对这两种运算符进行讨论。
1.关系运算符
关系运算符用来确定一个操作数和另外一个操作数之间的关系，如表4-2 所示，列出了在Java中的关系运算符，通过这些关系运算符，它将会产生一个结果，这个结果是一个布尔值，即true和flase，在Java中任何类型的数据都可以用“==”进行比较是不是相等，用“！=”比较不等，只有数字才能比较大小，关系运算的结果可以直接赋予布尔变量。
表4-2 关系运算符
实例6：下面通过两个代码来认识关系运算符，通过第一段代码进行比较数字的大小，第二个代码是将不同类型的数字进行比较，第一段代码如下：
public class GuanXiText
{
public static void main(String args[])
{
boolean a=78>79;
System.out.println("78>79 is "+a);
}
}
执行代码，得到结果是“78>79 is false”，如图4-7所示。
图4-7 比较数据
第二段代码如下：
public class GuanXiText1
{
public static void main(String args[])
{
char a='A';
char b='K';
int c=63;
System.out.println(a>b);
System.out.println(a>c);
}
}
执行完成后，得到结果是“flase”、“true”，如图4-8所示。
图4-8 关系进行比较
从第二段代码可以看出，字符可以出现在比较运算符中，当字符与数字进行比较时，Java将采用字符作为数值，把该字符与字符进行比较。
实例探索和读者练习：
在上述实例中，用户对关系远算符号进行了认识，明白哪些数据类型可以比较异同，哪些数据可以比较大小。
下面通过一段代码，读者根据关系运算符的知识，给出结果，其代码如下：
public class GuanXiText2
{
public static void main(String args[])
{
char a='k';
char b='k';
char c='A';
int d=100;
int e=101;
System.out.println(a==b);
System.out.println(b==c);
System.out.println(b!=c);
System.out.println(d<e);
}
}
2.逻辑运算符
布尔逻辑运算符是最常见的逻辑运算符，用于对boolean型操作数进行布尔逻辑运算，在Java中的布尔逻辑运算符如表4-3所示。
表4-3 逻辑运算符
逻辑运算符与关系运算符的结果一样，都是booleam类型的值。
在Java程序设计中，“&&”和“||”布尔逻辑运算符不总是对运算符右边的表达式求值，如果使用逻辑与“&”和逻辑或“|”，则表达式的结果可以由运算符左边的操作数单独决定，关于表达式将在后面进行讲解，通过如表4-4 所示的运算符，用户可以清楚地认识到常用的逻辑运算符号“&&”、“||”、“！”3种符号进行运算后的结果。
表4-4 逻辑运算符
实例7：认识了逻辑运算符，也懂得了逻辑运算符的判断，下面通过一段代码来巩固逻辑运算符，其代码如下。
public class LuoJi
{
public static void main(String[] args)
{
int d=10;
int k=12;
int j=111;
System.out.println(d>k||k<j);
System.out.println(d>k&&k<j);
System.out.println(!(d>k));
}
}
执行程序后，得到如图4-9所示的结果。
图4-9 逻辑运算符
实例探索和读者练习：
在上述实例中，明白了逻辑与、逻辑或与逻辑非之间的关系，它们执行后的结果与表4-5一一对应。
表4-5 位运算符
下面将给出一个代码，用户可以根据表4-5，判断出结果，然后用户将代码输入到计算机中进行编译并执行，其源代码如下：
public class LuoJiOne
{
public static void main(String[] args)
{
int d=101;
int k=121;
int j=123;
System.out.println(d<k||k<j);
System.out.println(d<k||k>j);
System.out.println(d>k||k>j);
System.out.println(d>k||k<j);
System.out.println(!(k>j));
}
}
4.2.3 位运算符
位运算符是用来对二进制进行操作的，位运算符一般分为两种：位逻辑运算符和移位运算符，如表4-5所示是Java中的位运算符。
如表4-6所示的是操作数A和操作数B按位逻辑运算的结果。
表4-6 位逻辑运算结果
下面讲解一下移位运算符，移位运算符把数字的位向右或向左移动，产生一个新数字，移位运算符只能用在整数型上，不能用在浮点型上，要确定移位的结果，必须将数字转换为二进制，如9>>2；这样一个数字首先要将转换为二进制，然后再进行移位，通过下面一段来代码来讲解，其代码如下：
public class Wei {
public static void main(String args[])
{
int a=9;
System.out.println(a);
a=a>>2;
System.out.println(a);
}
}
这个代码运行结果是9、2，这个方法十分简单，9转换为二进制表示：
00000000000000000000000000001001
向后面移动两位，则新的数字是：
00000000000000000000000000000010
可知道9>>2=2，这个跟上面的代码符合。
位逻辑运算符有3种，基本用法与右移运算符差不多，学到这里也许有人会问，那缺少的部分填什么，学过二进制的人都知道，最左边的符号表示符号，当最左边位是1，数字是负数，当是0时，该数字是整数，向左移动，使得符号位移出边界，右边的空缺位置总是被填充0。
4.2.4 赋值运算符
赋值运算符在前面已经讲过，它其实是一个很简单的赋值，将一个值赋给一个变量，赋值运算看上去十分简单，其实不如想象的那么简单，如下面一段代码：
public class Fu {
public static void main(String args[])
{
byte a=5;
byte b=8;
byte c=a+b;
System.out.println(c);
}
}
运行这段代码的时候，编译会出错，这时因为a+b被Java自动提升为int整型，将一个整型赋值给一个字符型，就会产生类型不匹配的错误，如图4-10所示。
图4-10 运行出错
其代码如下：
float d=4.0f；
在Java程序中，浮点数默认值为double型，如果要把一个浮点数赋值给float型变量，有下面3种形式：
float a=（float）4.0；
float a=4.0f；
float a=4.0F；
4.2.5 条件运算符
条件运算符是一种特殊的运算符，与前面所讲解运算符有很大不同，在Java程序中，提供了一个三元运算符，这跟后面讲解的if语句有相似之处，条件运算符的目的是决定把哪个值赋给前面的变量，其基本结构如下：
变量=（布尔表达式）？为true时所赋予的值：为false时所赋予的值；
实例8：通过下面一段代码，用户可加深对上面条件运算符的理解，其代码如下：
public class TiaoJian{
public static void main(String args[])
{
double chengji=60;
String jieguo=(chengji>=60)?"我及格了":"没有及格";
System.out.println(jieguo);
}
}
执行完成后，结果如图4-11所示。
图4-11 条件运算符
实例探索和读者练习：
在上述实例中，用户可根据条件运算符的结构语句判断出，它们的结果是“我及格了”。如果条件为真，则应该取第一个值，如果条件为假，则应该取第二个值。
下面将给出一段代码，读者判断出结果，然后将代码输入到计算机中进行编译并执行，查看结果是否与自己判断的相同，其源代码如下：
public class TiaoJianOne
{
public static void main(String args[])
{
double chengji=70;
String Tiao=(chengji>=90)?"我已经很优秀了":"我现在不是很优秀了，我还需要努力！";
System.out.println(Tiao);
}
}
4.3 表达式
将同类型的数据（如常量、变量、函数等），用运算符号按一定的规则连接起来的、有意义的式子称为表达式。在Java程序中，表达式往往与运算符结合，形成复杂而实用的表达式，所以本节将重点讲解表达式、运算符与表达式的结合。
4.3.1 认识表达式
在前面的章节中，多多少少接触了一些表达式，但是用户对表达式还十分的迷糊，下面将仔细讲解表达式。
在程序代码内部，每个表达式都有自己对应的数据类型，例如int n = 10，int m = 10;都是带着数据类型的表达式，在实际的程序代码中，大部分的表达式不能单独成为代码中的一行，否则程序会提示语法错误，例如：
int a = 10;
int b = 20;
a + b;//不能单独成行
在表达式中，能够单独成行的运算符包括赋值运算符和递增、递减运算符。
4.3.2 表达式的优先级
将运算符和操作数连接起来就是表达式，组成符合Java语法的式子，称为Java表达式，一个变量名和常量名都可以形成简单的表达式，Java运算符是有严格的优先级的，它和代数中先乘/除，后加/减的原则一样，按优先级从高到低进行运算，如表4-7所示。
表4-7 运算符的优先级
4.3.3 算术运算符与表达式
在前面的一节中，用户已经了解算术运算符，这里将通过一个实例来学习算术运算符和表达式的综合运用。
实例9：通过下面一段代码，用户可加深对上面条件运算符的理解，其代码如下：
public class YunSuan {
public static void main(String args[])
{
int a=231;
int b=4;
double h=56.0;
System.out.println(a+h/b);
}
}
这段代码是有加，有除，根据上面一节中讲解的运算符的优先级可以知道，这次输出的结果是245，先将程序编译，然后再执行，如图4-12所示。
图4-12 算术运算符和表达式的结果
实例探索和读者练习：
在上面的一个实例中，可以看出算术运算符组成的表达式是先乘/除，再加/减，跟代数中的式子一样，读者可通过下面一段代码进行巩固，先读懂程序，给出答案，然后将程序输入到计算机中进行编译并执行，看是否与自己的答案相同，其代码如下：
public class YunSuanOne {
public static void main(String args[])
{
int a=11;
int b=121;
int c=25;
double h=41.0;
System.out.println(a-b+c+h*b);
}
}
4.3.4 关系运算符与表达式
关系运算符与表达式是用来判断真和假的，结果是true或false，下面将通过一个实例，认识关系运算符和表达式的综合运用。
实例10：通过下面一段代码，来加深关系运算符和表达式的认识，其代码如下：
public class GuanXi {
public static void main(String args[])
{
int a=231;
int b=4;
int h=56;
int k=45;
int x=a+h/b;
int y=h+k;
System.out.println(x);
System.out.println(y);
System.out.println(x==y);
}
}
执行后，得到的结果如图4-13所示。
图4-13 关系运算符和表达式的判断
实例探索和读者练习：
在上面的一个实例中，首先是算术运算符组成的表达式是先乘/除，再加/减，跟代数中的式子一样，先算出x和y，再比较x==y是否相等，然后得到false结果。
读者可通过下面一段代码进行巩固，先读懂程序，给出答案，然后将程序输入在计算机中进行编译并执行，看是否与自己的答案相同，其代码如下：
public class GuanXiOne {
public static void main(String args[])
{
int aa=231;
int bb=4;
int hh=56;
int kk=45;
int xx=aa-bb+kk;
int yy=bb*kk/bb+hh;
System.out.println(xx);
System.out.println(yy);
System.out.println(xx!=yy);
}
}
4.3.5 位运算符与表达式
位运算符对于初学者是一个比较复杂的运算，因为用户通常要进行十进制到二进制的运算，二进制到十进制的运算，然后再结合一些表达式，将变得更加复杂，下面通过一个实例来讲解位运算和表达式。
实例11：通过下面一段代码，来加深位运算符和表达式的认识，其代码如下：
public class WeiBiao
{
public static void main(String args[])
{
int a=18;
int b=67;
int x=a>>2;
int y=x+b;
System.out.println(x);
System.out.println(y);
}
}
执行后的结果如图4-14所示。
图4-14 位运算
实例探索和读者练习：
在上面的一个实例中得到的结果读者可通过下面一段代码进行巩固，先读懂程序，给出答案，然后将程序输入到计算机中进行编译并执行，看是否与自己的答案相同，其代码如下：
public class WeiBiaoOne {
public static void main(String args[])
{
int a=27;
int b=67;
int x=a>>2;
int y=x+b;
System.out.println(x);
System.out.println(y);
}
}
4.4 字符串
用户在学习字符串连接运算和表达式之前，首先要明白什么是字符串，怎么对字符串进行初始化。在Java中，字符串是对象，由文字组成，下面将仔细讲解字符串的初始化，还有跟字符串息息相关的String方法和String Buffer方法，明白操作字符串的一些表达式。
4.4.1 初始化
在Java中，可以使用new关键字来创建String实例：
String s=new String（）;
通过上面的这段代码，用户就创建了一个String类，并把它赋给变量，但它还是一个空的字符串，接下来就为这个字符串赋值。
s=”I am a person Chongqing”
在程序中，用户可以将两句代码合并，就可以产生一种简单的字符串表示：
String s=new String（”I am a person Chongqing”）;
除了上面的表示方法，还有一种字符串进行表示：
String s=（”I am a person Chongqing”）;
实例12：下面将通过一段实例代码认识字符串，其代码如下：
public class ZiFu {
public static void main(String[] args) {
String a=new String("我相信,");
String b="我一定能够学会JAVA";
String c=a+b;
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
执行完成，得到的结果如图4-15所示。
图4-15 字符串的初始化
实例探索和读者练习：
在上面的一个实例中，通过不同的方法实现了程序的实例化，然后将两个字符相加，下面通过一段代码让读者领会字符串的初始化，读者可根据程序判断结果，然后将代码输入到计算机中进行编译并执行，看是否与自己的答案相同，其代码如下：
public class ZiFuOne {
public static void main(String[] args) {
String Aa=new String("望长城内外,");
String Bb="惟余莽莽，";
String Cc="大河上下，";
String Dd="顿时涛涛。";
String Ee=Aa+Bb+Cc+Dd;
System.out.println(Aa);
System.out.println(Bb);
System.out.println(Cc);
System.out.println(Dd);
System.out.println(Ee);
}
}
4.4.2 String类方法
在Java程序中，有两个类是可以对字符串进行操作，一个是String，另一个是StringBuffer，前者是对不变的字符串进行操作，不能直接对其修改，下面来讲解第一个类String的方法。
1.String索引方法
方法的格式如下：
public char charAt（int index）
这个方法返回位于String指定索引处的字符，但用户一定要记住String索引是从零开始的，下面将通过一段代码说明，代码如下：
public class StringOne {
public static void main(String args[])
{
String x="goodperson";
System.out.println(x.charAt(5));
}
}
在这个程序中，有一个字符串变量“x”，然后给它一个值是“goodperson”的字符串，通过倒数第3行取这个字符串的脚码为“5”的字符，因为脚码是从“0”开始的。
初学者很错误地认为是字母“p”，可真正的结果是脚码为“5”，实际上是第6个字母，执行后，得到如图4-16所示。
图4-16 索引方法执行后的结果
2.String追加方法
第一个是字符串索引方法，下面讲解一个字符串的一个追加方法，字符串的追加，顾名思义是在字符串的末尾再添加字符串，追加字符串是一个比较常用的方法，希望用户牢牢记住，其格式如下：
Public String concat（String S）
熟悉了格式，下面将通过一段代码来讲解字符串的追加，其代码如下：
public class StringZui {
public static void main(String args[])
{
String x="中国.重";
System.out.println(x.concat("庆，美丽的雾都！"));
}
}
上面一段程序很清楚，用concat方法将字符串“庆，美丽的雾都！”追加到变量x的后面，所以输出的值应该是“中国.重庆，美丽的雾都！”，执行程序，如图4-17所示。
图4-17 追加后的结果
3.String比较方法
该方法用于比较字符串是不是相同，返回的结果只有两个，分别是“true”或“flase”，如果比较的字符串相同，则返回的是“true”，不同则返回“flase”，String字符串是比较的格式如下：
public Boolean equalsIgnoreCase(String s)
下面通过一个例子讲解，其代码如下：
public class StringBi {
public static void main(String args[])
{
String x="no";
String xx="NO";
String y="no";
String z="Yes";
System.out.println(x.equalsIgnoreCase(xx));
System.out.println(x.equalsIgnoreCase(y));
System.out.println(x.equalsIgnoreCase(z));
}
}
执行后，得到如图4-18所示的结果。
图4-18 比较后的结果
TIPS
在字符串比较的时候，出现的字母是不区分大小写的，例如String x=“no”、Sting xx=“NO”，这两个字符串，它们是相同的，所以进行比较，返回的值是“true”。
4.String求字符串长度方法
这个方法主要用户求取字符串的长度，是String最常用的一个方法，其格式如下：
public int length（）
下面通过一个例子来讲解求字符串的长度：
public class StringChang {
public static void main(String args[])
{
String x="hello";
String y="长江三峡";
String yy="C长江三峡";
String z="my heart will go on";
System.out.println(x.length());
System.out.println(y.length());
System.out.println(yy.length());
System.out.println(z.length());
}
}
执行后的结果如图4-19所示。
图4-19 求长的结果
TIPS
用户在求长的时候，一定要注意空格、汉字、字母和标点符号之间的区别，它们四者之间，length方法都是同等的，这个方法只是字符串求的长度，并不是求字符串占的宽度，初学者一定要注意。
5.String替换字符串的方法
该方法的格式如下：
public String replace（char old，char new）
下面通过一个例子，来认识这个方法，其代码如下：
public class StringTi {
public static void main(String args[])
{
String x="爱你一万年";
String y=x.replace('爱','恨');
System.out.println(y);
}
}
执行后的结果，应该是“恨你一万年”，执行编译并运行，得到结果如图4-20所示。
图4-20 替换执行后的结果
6.String字符串的截取方法
字符串截取有两种方法，下面进行讲解。
第一种方法的格式如下：
public String substring（int begin）
第二种方法的格式如下：
public String substring（int begin，int end）
这两个方法都可以截取一段字符串，下面通过一个例子来讲解这两种方法，其代码如下：
public class StringJie {
public static void main(String args[])
{
String x="重庆位于中国的中西部，是西部经济文化中心！";
String y=x.substring(8);
String z=x.substring(12,16);
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}
执行后，得到的结果如图4-21所示。
图4-21 执行得到的结果
通过上面程序的程序初学者应该认识到，第一个方法，是从参数位置规定的地方起，直到最后一个字符；第二个方法有两个参数，第一个参数截取字符的开始位置，第二个参数是截取字符的结束位置。
7.String字符串的大转小的方法
该方法的格式如下：
public String toLowerCase()
这个方法可以将字符串出现的字符转换为小写，例如下面一段代码
public class StringDa {
public static void main(String args[])
{
String x="I Don't KNow!";
String y=x.toLowerCase();
System.out.println(x);
System.out.println(y);
}
}
执行后，结果如图4-22所示。
图4-22 大写字母转小写字母
8.String字符串的小转大的方法
这个方法和上面的方法恰恰相反，它的格式如下；
Public String toUpperCase()
下面仍然通过一个例子来讲解，其代码如下：
public class StringXiao {
public static void main(String args[])
{
String x="I am chinese";
String y=x.toUpperCase();
System.out.println(x);
System.out.println(y);
}
}
执行后结果如图4-23所示。
图4-23 小写字母转大写字母
9.String转义字符方法
在Java中的所有对象都必须有toString()方法，它将对象转换成String的形式，其转义字符的格式如下：
public String tostring()
下面通过一个例子来讲解转义字符，其代码如下：
public class StringZhuan {
public static void main(String args[])
{
String x="javagood";
String y=x.toString();
System.out.println(x);
System.out.println(y);
}
}
执行后，结果如图4-24所示。
图4-24 转义字符的方法
这个方法看上去没有变化，实际上这个方法对程序影响至关重要。
10.String除空白符的方法
在字符串中可能有空白符，而在一些特定的环境中，并不需要这样的空白，这时候就需要去除空白，其格式如下：
pbulic String trim()
下面通过一个例子来讲解这个去除空白的方法，其代码如下：
public class StringKong {
public static void main(String args[])
{
String x=" 千言万语都来不及说我的泪 ";
String y=x.trim();
System.out.println(x);
System.out.println(y);
}
}
执行结果如图4-25所示。
图4-25 去除空白的结果
4.4.3 StringBuffer类方法
StringBuffer是Java中另一种对字符串操作的类，当需要对字符串进行大量的修改时，使用StringBuffer类，在对字符串进行操作时，倒底是使用String还是StringBuffer，这需要根据遇到的情况而定，没有一个固定的思维，上面一节讲解了String，这一节将讲解StringBuffer。
1.StringBuffer追加方法
在String里，讲解了一个字符串的追加方法concat，这一章将讲解StringBuffer追加的方法，前者只能追加字符串，而后者可以追加任何数据类型，StringBuffer的格式如下：
public synchronized StringBuffer append
下面通过一个例子来讲解StringBuffer追加的方法，也请读者朋友注意对比这个方法与前面讲解concat的异同，其代码如下：
public class StringBufferTian {
public static void main(String args[])
{
StringBuffer x1 = new StringBuffer("南山办公");
x1.append("是优秀的办公软件");
System.out.println(x1);
StringBuffer x2 = new StringBuffer("南山办公");
x2.append(9.5);
System.out.println(x2);
}
}
执行程序后，得到如图4-26所示的运行结果。
图4-26 添加数据类型的方法
2.StringBuffer插入方法
该方法的格式如下：
public synchronized StringBuffer insert（int offset，String s）
这个方法的意思是，将第2个参数的内容添加到第一个参数指定的位置，换句话说，第一个参数表示要插入的起始位置，第2 个参数是需要插入的内容，它可以是包括String的任何数据类型，下面通过代码讲解，其代码如下：
public class StringbufferCha {
public static void main(String args[])
{
StringBuffer sb1 = new StringBuffer("我爱中国。");
sb1.insert(2,"我的祖国，");
System.out.println(sb1);
}
}
执行后，结果如图4-27所示。
图4-27 插入方法
3.StringBuffer颠倒方法
这种方法主要将字符颠倒过来，如“谁是英雄”，颠倒过来就变成“雄英是谁”，它的格式如下：
public synchronized StringBuffer reverse()
下面通过一个例子加深对这个颠倒方法的理解，其代码如下：
public class StringBufferDian {
public static void main(String args[])
{
StringBuffer ch = new StringBuffer("天下第一");
ch.reverse();
System.out.println(ch);
}
}
执行后，得到颠倒的效果如图4-28所示。
图4-28 颠倒好的效果
4.StringBuffer转义字符方法
在String类中讲了一个转字符的方法toString，下面讲解这个方法与它差不多，以形式返回调用该方法的StringBuffer的值，其格式如下：
public String toString()
下面通过一个例子来理解这个方法，其格式如下：
public class StringBufferZhuan {
public static void main(String args[]){
StringBuffer zr = new StringBuffer("谁是真正的王者编程语言");
zr.toString();
System.out.println(zr);
}
}
执行后，仍然保持不变，依然是“谁是真正的王者编程语言”，如图4-29所示。
图4-29 转义后的结果
4.4.4 链接方法
在字符串进行操作的时候，经常使用字符串的链接的方法，链接就是多个字符串链接在一起，形成一个字符串，格式如下：
Result=method1（）.methood2().methood3()
这个方法是将计算第一个method1的结果，然后将这个结果作为第2个method的对象，再进行计算，依次类推，下面通过一段代码讲解：
public class ZifuLian {
public static void main(String args[])
{
String a="good";
String b=a.concat("idea").toUpperCase().replace('G','g');
System.out.println(b);
}
}
执行这段代码后，结果应该是gOODIDEA，如图4-30所示。
图4-30 链接字符串
4.5 本课回顾和网络关键词
在本课的内容中，首先向用户讲解了Java运算符，让用户明白运算符的作用与使用方法，接着向用户讲解了表达式，在这一节里，讲解了表达式的优先级和运算符的一些相关知识，最后本章讲解了在Java中比较重要的一个知识点——字符串。在本节的内容中，将本课所讲解释的知识点进行重要回顾，并归纳与总结出本课知识点的网络关键词。
1.本课回顾
在本课的内容主要讲解了Java的运算符、表达式，以及表达式与运算符的应用，最后讲解了Java中常见的一种对象——字符串，回顾本课内容，主要的知识点概括如下。
（1）Java的运算符。
Java运算符在程序中是不可缺少的元素，其主要知识点如下。
● 算术运算符。
● 逻辑运算符。
● 关系运算符。
● 位运算符。
● 赋值运算符。
● 条件运算符。
（2）表达式。
表达式是程序中不可或缺的一部分，下面将表达式的知识点回顾一下，其主要知识点如下。
● 认识表达式。
● 表达式的优先级。
● 算术运算符与表达式。
● 关系运算符与表达式。
● 位运算符与表达式。
（3）字符串。
字符串是Java程序中重要的对象，要操作字符串类通常使用一些类方法，在本节中，读者可以应用到String类和StringBuffer类的一些方法去实现一些功能，回顾一下，其主要知识点如下。
● 字符串的初始化。
● String类方法。
● StringBuffer类方法。
● 字符串的链接方法。
2.本课网络关键词
在下面的内容中，将对本课中的主要知识点进行收集整理，总结出本课知识点的网络关键词。
本课知识点的网络关键词有：“运算符”、“算术运算符”、“关系运算符”、表达式”、“优先级”、“字符串”、“字符串初始化”、“String类方法”、“StringBuffer”类方法、“链接方法”。
通过整理上述网络关键词，读者可以在百度、Google或Yahoo中获取上述关键词的基本知识。有的关键词还可以继续细分并且可以获取每个知识点的对应使用实例，读者可以通过获取的实例来加深对知识的理解。
希望通过本课内容的学习，读者不但能够掌握Java的运算符、表达式和字符串的基本知识，对其有一个初步的认识，为进入本书后面知识的学习打下坚实的基础。