Java学习笔记（三）—— 基础语法

末蓝、 2021-09-27 04:12 570阅读 0赞

看了一些网上的资料发现Java和c的语法是类似的，也有一些不同，之前看的那本书讲到输入输出时已经是两百多页了，，，果断换书。看的这本《Java面向对象程序设计》，目前自我感觉良好。总结如下。

适合有C语言基础和面向对象编程概念。

一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

*  **对象**：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
 *  **类**：类是一个模板，它描述一类对象的行为和状态。
 *  **方法**：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
 *  **实例变量**：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

编写Java程序时，应注意以下几点：

*  **大小写敏感**：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
 *  **类名**：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
 *  **方法名**：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
 *  **源文件名**：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
 *  **主方法入口**：所有的Java 程序由**public static void main(String \[\]args)**方法开始执行。

### 标识符 ###

Java标识符比c多了一个‘$’，并且这个符号可以作为标识符的开头，并且，Java的字符集为Unicode，就是说，这里面的字符都可以作为Java的‘字母’，也包括汉字，如：‘$surk’、‘ab$3d’、‘\_ad2$’，‘这是一个标识符’ 。

Java中变量主要有：局部变量、类变量（静态变量）、成员变量（非静态变量）。

### Java的八种基本类型： ###

<table style="width:623px;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#d8d8d8;width:53.25pt;"> &nbsp;分 &nbsp;类 </td> 
 <td style="background-color:#d8d8d8;width:53.25pt;"> 数据类型 </td> 
 <td style="background-color:#d8d8d8;width:53.25pt;"> 关键字 </td> 
 <td style="background-color:#d8d8d8;width:53.25pt;"> 占用字节 </td> 
 <td style="background-color:#d8d8d8;width:59.75pt;"> 缺省数值 </td> 
 <td style="background-color:#d8d8d8;width:117pt;"> 取 值 范 围 </td> 
 </tr> 
 <tr> 
 <td colspan="1" style="background-color:#c3bd96;width:53.25pt;"> 整型类 </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 字节型 </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> byte </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 1 </td> 
 <td style="background-color:#f2dbdb;width:59.75pt;"> 0 </td> 
 <td style="background-color:#f2dbdb;width:117pt;"> -2^7～2^7-1 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 短整型 </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> short </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 2 </td> 
 <td style="background-color:#f2dbdb;width:59.75pt;"> 0 </td> 
 <td style="background-color:#f2dbdb;width:117pt;"> -2^15～2^15-1 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 整型 </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> int </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 4 </td> 
 <td style="background-color:#f2dbdb;width:59.75pt;"> 0 </td> 
 <td style="background-color:#f2dbdb;width:117pt;"> -2^31～2^31-1 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 长整型 </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> long </td> 
 <td style="background-color:#f2dbdb;width:53.25pt;"> 8 </td> 
 <td style="background-color:#f2dbdb;width:59.75pt;"> 0L </td> 
 <td style="background-color:#f2dbdb;width:117pt;"> -2^63～2^63-1 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#c3bd96;width:53.25pt;"> 文本类 </td> 
 <td style="background-color:#e5b8b7;width:53.25pt;"> 字符型 </td> 
 <td style="background-color:#e5b8b7;width:53.25pt;"> char </td> 
 <td style="background-color:#e5b8b7;width:53.25pt;"> 2 </td> 
 <td style="background-color:#e5b8b7;width:59.75pt;"> ′\u 0000′ </td> 
 <td style="background-color:#e5b8b7;width:117pt;"> ′\u 0000′ ～ ′\u FFFF′ </td> 
 </tr> 
 <tr> 
 <td colspan="1" style="background-color:#c3bd96;width:53.25pt;"> 浮点类 </td> 
 <td style="background-color:#d99594;width:53.25pt;"> 浮点型 </td> 
 <td style="background-color:#d99594;width:53.25pt;"> float </td> 
 <td style="background-color:#d99594;width:53.25pt;"> 4 </td> 
 <td style="background-color:#d99594;width:59.75pt;"> 0.0F </td> 
 <td style="background-color:#d99594;width:117pt;"> -3.4E38~3.4E38 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#d99594;width:53.25pt;"> 双精度型 </td> 
 <td style="background-color:#d99594;width:53.25pt;"> double&nbsp; </td> 
 <td style="background-color:#d99594;width:53.25pt;"> 8 </td> 
 <td style="background-color:#d99594;width:59.75pt;"> 0.0D </td> 
 <td style="background-color:#d99594;width:117pt;"> -1.7E308~1.7E308 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#c3bd96;width:53.25pt;"> 逻辑类 </td> 
 <td style="background-color:#943734;width:53.25pt;"> 逻辑型 </td> 
 <td style="background-color:#943734;width:53.25pt;"> boolean </td> 
 <td style="background-color:#943734;width:53.25pt;"> 1 </td> 
 <td style="background-color:#943734;width:59.75pt;"> False </td> 
 <td style="background-color:#943734;width:117pt;"> True、False </td> 
 </tr> 
 </tbody> 
</table>

Java中默认的整数类型是int，如果要定义为long ，则要在数值后加上L或者l

默认的浮点型是双精度浮点，如果要定义float，则要在数值后面加上f或者F

一个字节等于8位，1个字节等于256个数。

一个英文字母或者阿拉伯数字占一个字节

一个汉字占2个字节

### 关键字 ###

下面列出了Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

<table> 
 <tbody> 
 <tr> 
 <th>类别</th> 
 <th>关键字</th> 
 <th>说明</th> 
 </tr> 
 <tr> 
 <td>访问控制</td> 
 <td>private</td> 
 <td>私有的</td> 
 </tr> 
 <tr> 
 <td>protected</td> 
 <td>受保护的</td> 
 </tr> 
 <tr> 
 <td>public</td> 
 <td>公共的</td> 
 </tr> 
 <tr> 
 <td>类、方法和变量修饰符</td> 
 <td>abstract</td> 
 <td>声明抽象</td> 
 </tr> 
 <tr> 
 <td>class</td> 
 <td>类</td> 
 </tr> 
 <tr> 
 <td>extends</td> 
 <td>扩允,继承</td> 
 </tr> 
 <tr> 
 <td>final</td> 
 <td>最终值,不可改变的</td> 
 </tr> 
 <tr> 
 <td>implements</td> 
 <td>实现（接口）</td> 
 </tr> 
 <tr> 
 <td>interface</td> 
 <td>接口</td> 
 </tr> 
 <tr> 
 <td>native</td> 
 <td>本地，原生方法（非Java实现）</td> 
 </tr> 
 <tr> 
 <td>new</td> 
 <td>新,创建</td> 
 </tr> 
 <tr> 
 <td>static</td> 
 <td>静态</td> 
 </tr> 
 <tr> 
 <td>strictfp</td> 
 <td>严格,精准</td> 
 </tr> 
 <tr> 
 <td>synchronized</td> 
 <td>线程,同步</td> 
 </tr> 
 <tr> 
 <td>transient</td> 
 <td>短暂</td> 
 </tr> 
 <tr> 
 <td>volatile</td> 
 <td>易失</td> 
 </tr> 
 <tr> 
 <td>程序控制语句</td> 
 <td>break</td> 
 <td>跳出循环</td> 
 </tr> 
 <tr> 
 <td>case</td> 
 <td>定义一个值以供switch选择</td> 
 </tr> 
 <tr> 
 <td>continue</td> 
 <td>继续</td> 
 </tr> 
 <tr> 
 <td>default</td> 
 <td>默认</td> 
 </tr> 
 <tr> 
 <td>do</td> 
 <td>运行</td> 
 </tr> 
 <tr> 
 <td>else</td> 
 <td>否则</td> 
 </tr> 
 <tr> 
 <td>for</td> 
 <td>循环</td> 
 </tr> 
 <tr> 
 <td>if</td> 
 <td>如果</td> 
 </tr> 
 <tr> 
 <td>instanceof</td> 
 <td>实例</td> 
 </tr> 
 <tr> 
 <td>return</td> 
 <td>返回</td> 
 </tr> 
 <tr> 
 <td>switch</td> 
 <td>根据值选择执行</td> 
 </tr> 
 <tr> 
 <td>while</td> 
 <td>循环</td> 
 </tr> 
 <tr> 
 <td>错误处理</td> 
 <td>assert</td> 
 <td>断言表达式是否为真</td> 
 </tr> 
 <tr> 
 <td>catch</td> 
 <td>捕捉异常</td> 
 </tr> 
 <tr> 
 <td>finally</td> 
 <td>有没有异常都执行</td> 
 </tr> 
 <tr> 
 <td>throw</td> 
 <td>抛出一个异常对象</td> 
 </tr> 
 <tr> 
 <td>throws</td> 
 <td>声明一个异常可能被抛出</td> 
 </tr> 
 <tr> 
 <td>try</td> 
 <td>捕获异常</td> 
 </tr> 
 <tr> 
 <td>包相关</td> 
 <td>import</td> 
 <td>引入</td> 
 </tr> 
 <tr> 
 <td>package</td> 
 <td>包</td> 
 </tr> 
 <tr> 
 <td>基本类型</td> 
 <td>boolean</td> 
 <td>布尔型</td> 
 </tr> 
 <tr> 
 <td>byte</td> 
 <td>字节型</td> 
 </tr> 
 <tr> 
 <td>char</td> 
 <td>字符型</td> 
 </tr> 
 <tr> 
 <td>double</td> 
 <td>双精度浮点</td> 
 </tr> 
 <tr> 
 <td>float</td> 
 <td>单精度浮点</td> 
 </tr> 
 <tr> 
 <td>int</td> 
 <td>整型</td> 
 </tr> 
 <tr> 
 <td>long</td> 
 <td>长整型</td> 
 </tr> 
 <tr> 
 <td>short</td> 
 <td>短整型</td> 
 </tr> 
 <tr> 
 <td>变量引用</td> 
 <td>super</td> 
 <td>父类,超类</td> 
 </tr> 
 <tr> 
 <td>this</td> 
 <td>本类</td> 
 </tr> 
 <tr> 
 <td>void</td> 
 <td>无返回值</td> 
 </tr> 
 <tr> 
 <td>保留关键字</td> 
 <td>goto</td> 
 <td>是关键字，但不能使用</td> 
 </tr> 
 <tr> 
 <td>const</td> 
 <td>是关键字，但不能使用</td> 
 </tr> 
 <tr> 
 <td>null</td> 
 <td>空</td> 
 </tr> 
 </tbody> 
</table>

## ##

### 转义字符 ###

转义符是指一些有特殊含义的、很难用一般方式表达的字符，如回车、换行等。所有的转义符以反斜线(\\)开头，后面跟着一个字符来表示某个特定的转义符，如下表所示。

<table style="width:426.1pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#d8d8d8;width:213.05pt;"> 引用方法 </td> 
 <td style="background-color:#d8d8d8;width:213.05pt;"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \b </td> 
 <td style="vertical-align:top;width:213.05pt;"> 退格 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \t </td> 
 <td style="vertical-align:top;width:213.05pt;"> 水平制表符Tab </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \n </td> 
 <td style="vertical-align:top;width:213.05pt;"> 换行 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \f </td> 
 <td style="vertical-align:top;width:213.05pt;"> 表格符 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \r </td> 
 <td style="vertical-align:top;width:213.05pt;"> 回车 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \' </td> 
 <td style="vertical-align:top;width:213.05pt;"> 单引号 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \" </td> 
 <td style="vertical-align:top;width:213.05pt;"> 双引号 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:213.05pt;"> \\ </td> 
 <td style="vertical-align:top;width:213.05pt;"> 反斜杠 </td> 
 </tr> 
 </tbody> 
</table>

### 注释 ###

Java支持三种注释：

>  *  行注释：//注释内容
>  *   段注释：/\*注释内容\*/
>  *  文档注释：/\*\*注释内容\*/

### 继承 ###

在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。

## ##

### 接口 ###

在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

## ##

### **Java编程规范** ###

*  package的命名: package 的名字由全部小写的字母组成，例如：com.runoob。
 *  class和interface的命名: class和interface的名字由大写字母开头而其他字母都小写的单词组成，例如：Person，RuntimeException。
 *  class变量的命名: 变量的名字用一个小写字母开头，后面的单词用大写字母开头,例如：index，currentImage。
 *  class 方法的命名: 方法的名字用一个小写字母开头，后面的单词用大写字母开头,例如：run()，getBalance()。
 *  staticfinal变量的命名: static final变量的名字所有字母都大写，并且能表示完整含义。例如：PI，PASSWORD。
 *  参数的命名: 参数的名字和变量的命名规范一致。
 *  数组的命名: 数组应该总是用这样的方式来命名：byte\[\] buffer。
 *  package语句：由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同因此同名的类有可能发生冲突。为了解决这一问题，Java提供包来管理类名空间，包实 提供了一种命名机制和可见性限制机制。

## ##

### 输入输出 ###

**Scanner**

输入时可以用Scanner来创建对象：

Scanner reader = new Scanner(System.in);

然后reader对象调用方法**next(),nextBoolean(),nextByte(),nextDouble(),nextInt(),nextFloat(),nextShort(),nextLong()**，读取在命令行输入的各种基本类型数据。如：

int a=reader.nextInt(),b=reader.nextInt();

**System.out.println() 和 System.out.print()**

输出时System.out.println()和System.out.print()可以输出字符、表达式的值，区别在于前者输出时会自动输出一个换行，后者不会，允许使用并置符号“+”来连接前后。如：

int x=1;
    System.out.println("x="+x);    //输出x=1

**格式化输出System.out.printf()**

Java还有类似c语言的printf函数用来输出带有格式控制的数据，用法和c相同，特别的，Java的double类型使用“%f”,如：

System.out.printf("%d %f\n",a,b);

## ##

**多实例输入**

使用hasNext()来判断有没有输入,相当于c中的scanf()!=EOF，类似的还有hasNextInt(),hasNextDouble()等，用来判断有无int，double等类型的输入。

Scanner in = new Scanner(System.in);
    while(in.hasNext()) {
        int a = in.nextInt();
        int b = in.nextInt();
        System.out.println(a + b);
    }

### 数组 ###

Java的数组声明和c也差不多，有两种形式：

int[] a;
    int a[];

**声明不等于创建，变量必须被创建才可以被使用**

声明和创建分为两步，这也是Java和c的区别，c在声明变量时自动为其分配内存，Java则需要使用**new**关键字来为变量分配内存。

特别的，Java不允许在方括号中指定元素个数，上面的语句只是声明一个数组a，并未分配内存。所以还须采用new创建，

int a[];
    a=new int[10];
    		
    int a=new int[10];

**初始化**

上面是两种创建方法，这样一维数组就可以使用了，也可以在声明数组时初始化，初始化方面和c差异不大，如：

char ac[]= {'a','v'};

**二维数组**

二维数组的使用同一维数组，只是多了一个方括号，特别的，二维数组相当于多个一维数组组成，这些一维数组长度不必相等，

int x[][] = new int[2][];
    x[0]=new int[10];
    x[1]=new int[5];
    //或
    int x[][]=new int[2][3];

Java还允许这样使用

int size=30;
    int x[]=new int[size];

特别的，**Java中数组属于引用类型**，

x=y;	//这样会把x所指内存空间释放掉，使得x和y指向同一块内存空间，此时x[]={1,2},这时使用x或y实际上是一样的，改变其中一个，另一个也会改变。

**遍历数组**

一种是：同c一样的

int y[]= {3,0,1};
 for(int i = 0;i < y.length;i++) {
 	System.out.println(y[i]);	//3,0,1
 }

另一种是：Java专门的对于遍历数组的优化使用

int y[]= {3,0,1};
    for(int i:y) {
    	System.out.println(i);	//3,0,1
    }

注意：i的类型应该和数组y的类型相同，而且下面这种写法是错误的，

int y[]= {3,0,1};
    int i=0;    //错误
    for(i:y) {
    	System.out.println(i);
    }

变量i必须重新声明，不能使用已有的变量。

**clone()的使用**

那么如何复制数组呢，可以使用循环来复制，也可以使用clone(),如：

char ac[]= {'a','v'};
    char ax[]= {'b'};
    ac=ax.clone();
    System.out.println(ax);    //b
    System.out.println(ac);    //b

**length的使用**

对于一维数组x\[10\],x.length=10，即一维数组的长度，对于二维数组x\[2\]\[3\],x.length=2,即二维数组中一维数组的个数。

**Arrays.toString()的使用**

数组a\[2\]=\{1,2\}; Array.toString(a)可以将整型转换为字符型，需import java.util.\*，如：

int a[]= {1,2};
    System.out.println(Arrays.toString(a));    //[1, 2]

**copyOf()和copyOfRange()**

int y[]= {1,2};
    int z[]=Arrays.copyOf(y,3);	//z[]={1,2,0};
    int z[]=Arrays.copyOf(y,1);	//z[]={1};

int y[]= {1,2};
    int z[]=Arrays.copyOfRange(y,0,3);	//z[]={1,2,0};
    int z[]=Arrays.copyOfRange(y,0,2);	//z[]={1,2};

其中，copyOf（y，newLength）为从y中0位置开始复制长度为newLength，若newLength的值大于原数组则填充默认值。

copyOfRange(y，from，to)为从y中from开始到to-1的位置，若to的值大于原数组则填充默认值。

**Arrays.sort()**

int y[]= {3,0,1};
    Arrays.sort(y);	//y[]={0,1,3};

默认升序排序，貌似没有降序的，，，，倒着看就行，问题不大。

**Arrays.binarySearch()**

Arrays.binarySearch(double\[\] a,double number)可以查找参数number是否在指定数组中，其中a必须是已排好序的数组，若找到则返回位置，否则返回负数。

int y[]= {3,0,1};
    Arrays.sort(y);	//y[]={0,1,3};
    int index=Arrays.binarySearch(y,3);	//index=2

**equals()**

Arrays.equals()用来比较两个数组是否相等，返回逻辑值true或false，如：

int x[]= {5};
    int y[]= {1,2};
    System.out.println(Arrays.equals(x,y));    //false

## ##

### String类 ###

在Java中String为不可变对象，可以如此定义一个字符串：String s = "abc";，常见的还有两种构造方法，其中第二种String（char a\[\]，startIndex，count）,两个参数分别为字符数组的起始位置和从该位置开始截取的长度。

char ax[]= {'b','d','c'};
    String s = new String(ax);
    System.out.println(s);		//bdc
    String h = new String(ax,1,2);
    System.out.println(h);		//dc

**substring(from,to)**

可以提取字符串从from到to-1的字符，如：

String T="hello";
    System.out.println(T.substring(0,3));	//hel

**重载了"+"**

字符串和字符串之间可以用"+"拼接，

String T="hello";
    String Y="world";
    String U=T+Y;
    System.out.println(U);	//helloworld

**join()**

如果需要把多个字符串放在一起，用一个定界符分隔，可以使用静态方法join方法，如：

String S=String.join("!","s","b","a","g");
    System.out.println(S);    //s!b!a!g

**s.equals(t)**

检测字符串是否相等使用s.equals(t),其中s,t即可以是字符串常量，也可以是字符串变量。

String T="hello";
    String Y="world";
    System.out.println(T.equals(Y));	//false

如果用==比较的话，实际比较的是两个字符串的地址是否相同。

**length()**

确定字符串长度用length()方法，（数组的length是属性，而非方法）。

**toCharArray()**

用来把String类转换为字符数组，这样可以进行对字符串进行"数组名+下标"式的修改，

String sa="hello";
    System.out.println(sa.toCharArray());	//hello
    char sb[];
    sb=sa.toCharArray();
    sb[1]='a';
    System.out.println(sb[1]);	//a

**String.valueOf()**

用来把字符数组转换为字符串，也可以把数值转换为字符串 。

String sa;
    char sb[]= {'a','b','c'};
    sa=String.valueOf(sb);	
    System.out.println(sa);	//abc

**Long类中的toString(long i,int p)**

这个方法可以返回整数i的p进制表示。

System.out.println(Long.toString(10,2));	//1010

**compareTo()**

也可以使用compareTo()来比较字符串是否相等，和C语言中的comcmp()使用方法一样，不在解释。

### StringBuffer 和 StringBuilder ###

这两个可以实现对字符串的增删改。

String 长度大小不可变

StringBuffer 和 StringBuilder 长度可变

StringBuffer 线程安全 StringBuilder 线程不安全

StringBuilder 速度快

通常在99.99%的情况下可以选择用StringBuilder，

**append(),insert(),delete(),replace()**

StringBuilder s = new StringBuilder();
    s.append("abc");
    System.out.println(s);	//abc
    s.insert(1,"qwer");
    System.out.println(s);	//aqwerbc
    s.delete(1,5);
    System.out.println(s);	//abc
    s.replace(0,2,"e");
    System.out.println(s);	//ec

网上淘来几道面试题，，，，关于常量池的

**面试题一：**

String s1 = "abc";            // 常量池
    String s2 = new String("abc");     // 堆内存中
    System.out.println(s1==s2);        // false两个对象的地址值不一样。
    System.out.println(s1.equals(s2)); // true

**面试题二：**

String s1="a"+"b"+"c";
    String s2="abc";
    System.out.println(s1==s2);
    System.out.println(s1.equals(s2));

java 中常量优化机制，编译时 s1 已经成为 **abc** 在常量池中查找创建，s2 不需要再创建。

**面试题三：**

String s1="ab";
    String s2="abc";
    String s3=s1+"c";
    System.out.println(s3==s2);         // false
    System.out.println(s3.equals(s2));  // true

先在常量池中创建 **ab** ，地址指向 **s1**, 再创建 **abc** ，指向 s2。对于 s3，先创建StringBuilder（或 StringBuffer）对象，通过 append 连接得到 **abc** ,再调用 toString() 转换得到的地址指向 **s3**。故 (s3==s2) 为 **false**。

**[Java：String、StringBuffer 和 StringBuilder 的区别][Java_String_StringBuffer _ StringBuilder]**

String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。

StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。

StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。

**基本原则：**

*  如果要操作少量的数据用 String ；
 *  单线程操作大量数据用StringBuilder ；
 *  多线程操作大量数据，用StringBuffer。

参考文章：[打开链接][Link 1]

[Java_String_StringBuffer _ StringBuilder]: http://www.runoob.com/w3cnote/java-different-of-string-stringbuffer-stringbuilder.html
[Link 1]: http://www.runoob.com/java/java-string.html