【笔试/面试题】中科创达——9.28（持续更新ing）

1. 线程与进程的区别

　　进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。

　　线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。也是指进程内的一个执行单元,是进程内的可调度实体。

　　线程与进程的区别:

　　(1)地址空间：进程内的一个执行单元，进程至少有一个线程，它们共享进程的地址空间，而进程有自己独立的地址空间；
　　(2)资源拥有：进程是资源分配和拥有的单位，同一个进程内的线程共享进程的资源；
　　(3)线程是处理器调度的基本单位,但进程不是；
　　(4)二者均可并发执行。

　　参考：

http://blog.chinaunix.net/uid-21411227-id-1826748.html

http://www.cnblogs.com/flashsky/articles/642720.html

http://289972458.iteye.com/blog/1325189

http://www.cnblogs.com/lmule/archive/2010/08/18/1802774.html

2. OSI七层网络模型

　　OSI(Open System Interconnection)，开放式系统互联参考模型。是一个逻辑上的定义，一个规范，它把网络协议从逻辑上分为了7层。每一层都有相关、相对应的物理设备，比如常规的路由器是三层交换设备，常规的交换机是二层交换设备。

　　OSI 七层模型的每一层都具有清晰的特征。基本来说，第七至第四层处理数据源和数据目的地之间的端到端通信，而第三至第一层处理网络设备间的通信。另外， OSI 模型的七层也可以划分为两组：上层（层 7 、层 6 和层 5 ）和下层（层 4 、层 3 、层 2 和层 1 ）。 OSI 模型的上层处理应用程序问题，并且通常只应用在软件上。最高层，即应用层是与终端用户最接近的。 OSI 模型的下层是处理数据传输的。物理层和数据链路层应用在硬件和软件上。最底层，即物理层是与物理网络媒介（比如说，电线）最接近的，并且负责在媒介上发送数据。
　　各层的具体描述如下：
　　第七层：应用层

　　　　定义了用于在网络中进行通信和数据传输的接口 - 用户程式；提供标准服务，比如虚拟终端、文件以及任务的传输和处理；　　

　　第六层：表示层

　　　　掩盖不同系统间的数据格式的不同性；指定独立结构的数据传输格式；数据的编码和解码；加密和解密；压缩和解压缩　　

　　第五层：会话层

　　　　管理用户会话和对话；控制用户间逻辑连接的建立和挂断；报告上一层发生的错误　　

　　第四层：传输层

　　　　管理网络中端到端的信息传送；通过错误纠正和流控制机制提供可靠且有序的数据包传送；提供面向无连接的数据包的传送；　　

　　第三层：网络层

　　　　定义网络设备间如何传输数据；根据唯一的网络设备地址路由数据包；提供流和拥塞控制以防止网络资源的损耗　　

　　第二层：数据链路层

　　　　定义操作通信连接的程序；封装数据包为数据帧；监测和纠正数据包传输错误　　

　　第一层：物理层

　　　　定义通过网络设备发送数据的物理方式；作为网络媒介和设备间的接口；定义光学、电气以及机械特性。

　　参考：

http://blog.chinaunix.net/uid-9688646-id-3074970.html

http://baike.baidu.com/link?url=EmAlbOwfYeqfWKj4PNN6aIKwuoK5GFCs-8f8mjkXI_evSdXxTTPsTuJCvxq30FfB

http://www.cnblogs.com/cutepig/archive/2007/10/11/921427.html

3.DHCP为客户机提供的项目

4.Internet内部保留IP地址

　　IP地址是IP网络中数据传输的依据，它标识了IP网络中的一个连接，一台主机可以有多个IP地址。IP分组中的IP地址在网络传输中是保持不变的。　　

　　1.基本地址格式　

　　　现在的IP网络使用32位地址，以点分十进制表示，如172.16.0.0。地址格式为：IP地址=网络地址＋主机地址或 IP地址=主机地址＋子网地址＋主机地址。　网络地址是由Internet权力机构（InterNIC）统一分配的，目的是为了保证网络地址的全球唯一性。主机地址是由各个网络的系统管理员分配。因此，网络地址的唯一性与网络内主机地址的唯一性确保了IP地址的全球唯一性。

　　2.保留地址的分配　

　　根据用途和安全性级别的不同，IP地址还可以大致分为两类：公共地址和私有地址。公用地址在Internet中使用，可以在Internet中随意访问。私有地址只能在内部网络中使用，只有通过代理服务器才能与Internet通信。　一个机构或网络要连入Internet，必须申请公用IP地址。但是考虑到网络安全和内部实验等特殊情况，在IP地址中专门保留了三个区域作为私有地址，其地址范围如下：　　

　　A类：10.0.0.0/8：　　　　10.0.0.0～10.255.255.255 　　

　　B类：172.16.0.0/12：　　172.16.0.0～172.31.255.255 　　

　　C类：192.168.0.0/16：　 192.168.0.0～192.168.255.255

　　使用保留地址的网络只能在内部进行通信，而不能与其他网络互连。因为本网络中的保留地址同样也可能被其他网络使用，如果进行网络互连，那么寻找路由时就会因为地址的不唯一而出现问题。但是这些使用保留地址的网络可以通过将本网络内的保留地址翻译转换成公共地址的方式实现与外部网络的互连。这也是保证网络安全的重要方法之一。

　　3.特殊IP地址

　　就像我们每个人都有一个身份证号码一样，网络里的每台电脑(更确切地说，是每一个设备的网络接口)都有一个IP地址用于标示自己。我们可能都知道这些地址由四个字节组成，用点分十进制表示以及它们的A，B，C分类等，然而，在总数大约为四十多亿个可用IP 地址里，你知道下面一些常见的有特殊意义地址吗？

　　一、0.0.0.0

　　严格说来，0.0.0.0已经不是一个真正意义上的IP地址了。它表示的是这样一个集合：所有不清楚的主机和目的网络。这里的“不清楚”是指在本机的路由表里没有特定条目指明如何到达。对本机来说，它就是一个“收容所”，所有不认识的“三无”人员，一律送进去。如果你在网络设置中设置了缺省网关，那么Windows系统会自动产生一个目的地址为0.0.0.0的缺省路由。

　　二、255.255.255.255

　　限制广播地址。对本机来说，这个地址指本网段内(同一广播域)的所有主机。如果翻译成人类的语言，应该是这样：“这个房间里的所有人都注意了！”这个地址不能被路由器转发。

　　三、127.0.0.1

　　本机地址，主要用于测试。用汉语表示，就是“我自己”。在Windows系统中，这个地址有一个别名“Localhost”。寻址这样一个地址，是不能把它发到网络接口的。除非出错，否则在传输介质上永远不应该出现目的地址为“127.0.0.1”的数据包。

　　四、224.0.0.1

　　组播地址，注意它和广播的区别。从224.0.0.0到239.255.255.255都是这样的地址。224.0.0.1特指所有主机，224.0.0.2特指所有路由器。这样的地址多用于一些特定的程序以及多媒体程序。如果你的主机开启了IRDP (Internet路由发现协议，使用组播功能)功能，那么你的主机路由表中应该有这样一条路由。 www.2cto.com

　　五、169.254.x.x

　　如果你的主机使用了DHCP功能自动获得一个IP地址，那么当你的DHCP服务器发生故障，或响应时间太长而超出了一个系统规定的时间，Wingdows系统会为你分配这样一个地址。如果你发现你的主机IP地址是一个诸如此类的地址，很不幸，十有八九是你的网络不能正常运行了。

参考：

http://www.2cto.com/net/201207/140711.html

http://blog.csdn.net/zhangyang0402/article/details/5070860

5.串行通信的方向性结构

　　串行数据通信的方向性结构有三种，即单工、半双工和全双工。

（1）单工数据传输只支持数据在一个方向上传输；

（2）半双工数据传输允许数据在两个方向上传输，但是，在某一时刻，只允许数据在一个方向上传输，它实际上是一种切换方向的单工通信；

（3）全双工数据通信允许数据同时在两个方向上传输，因此，全双工通信是两个单工通信方式的结合，它要求发送设备和接收设备都有独立的接收和发送能力。

　　并行通信传输中有多个数据位，同时在两个设备之间传输。发送设备将这些数据位通过对应的数据线传送给接收设备，还可附加一位数据校验位。接收设备可同时接收到这些数据，不需要做任何变换就可直接使用。并行方式主要用于近距离通信。计算机内的总线结构就是并行通信的例子。这种方法的优点是传输速度快，处理简单。
　　串行数据传输时，数据是一位一位地在通信线上传输的，先由具有几位总线的计算机内的发送设备，将几位并行数据经并--串转换硬件转换成串行方式，再逐位经传输线到达接收站的设备中，并在接收端将数据从串行方式重新转换成并行方式，以供接收方使用。串行数据传输的速度要比并行传输慢得多，但对于覆盖面极其广阔的公用电话系统来说具有更大的现实意义。串行传输和并行传输的区别

　　从技术发展的情况来看，串行传输方式大有彻底取代并行传输方式的势头，USB取代IEEE 1284，SATA取代PATA，PCI Express取代PCI……

　　从原理来看，并行传输方式其实优于串行传输方式。通俗地讲，并行传输的通路犹如一条多车道的宽阔大道，而串行传输则是仅能允许一辆汽车通过的乡间公路。以古老而又典型的标准并行口(Standard Parallel Port)和串行口(俗称COM口)为例，并行接口有8根数据线，数据传输率高；而串行接口只有1根数据线，数据传输速度低。在串行口传送1位的时间内，并行口可以传送一个字节。当并行口完成单词“advanced”的传送任务时，串行口中仅传送了这个单词的首字母“a”。

根据组成字符的各个二进制位是否同时传输，字符编码在信源/信宿之间的传输分为并行传输和串行传输两种方式。

1、并行传输：字符编码的各位（比特）同时传输。
　　特点：

（1）传输速度快:一位（比特）时间内可传输一个字符；

（2）通信成本高:每位传输要求一个单独的信道支持；因此如果一个字符包含8个二进制位，则并行传输要求8个独立的信道的支持；

（3）不支持长距离传输:由于信道之间的电容感应，远距离传输时，可靠性较低。

2、串行传输：将组成字符的各位串行地发往线路。

　　特点：

（1）传输速度较低，一次一位；

（2）通信成本也较低，只需一个信道。

（3）支持长距离传输，目前计算机网络中所用的传输方式均为串行传输。

方式：串行传输有两种传输方式

1、同步传输

2、异步传输

参考：

http://caizhenzhou.blog.163.com/blog/static/538655732010025330330/

http://ab540703592.blog.163.com/blog/static/1853816120070173345581/

6.线程生命周期

一、线程的生命周期

　　线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

　　(1)生命周期的五种状态

　　新建（new Thread） 当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。例如：Thread t1=new Thread();

　　就绪（runnable） 线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();

　　运行（running） 线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

　　死亡（dead） 当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

　　　　自然终止：正常运行run()方法后终止

　　　　异常终止：调用stop()方法让一个线程终止运行

　　堵塞（blocked） 由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

　　　　正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

　　　　正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

　　　　被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

二、常用方法

void run() 创建该类的子类时必须实现的方法

void start() 开启线程的方法

static void sleep(long t) 释放CPU的执行权，不释放锁

static void sleep(long millis,int nanos)

final void wait()释放CPU的执行权，释放锁

final void notify()

static void yied()可以对当前线程进行临时暂停（让线程将资源释放出来）

三、结束线程

（1）结束线程原理：就是让run方法结束。而run方法中通常会定义循环结构，所以只要控制住循环即可

（2）方法----可以boolean标记的形式完成，只要在某一情况下将标记改变，让循环停止即可让线程结束

（3）public final void join()//让线程加入执行，执行某一线程join方法的线程会被冻结，等待某一线程执行结束，该线程才会恢复到可运行状态

四、临界资源：多个线程间共享的数据称为临界资源

（1）互斥锁

a.每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

b.Java对象默认是可以被多个线程共用的，只是在需要时才启动“互斥锁”机制，成为专用对象。

c.关键字synchronized用来与对象的互斥锁联系

d.当某个对象用synchronized修饰时，表明该对象已启动“互斥锁”机制，在任一时刻只能由一个线程访问，即使该线程出现堵塞，该对象的被锁定状态也不会解除，其他线程任不能访问该对象。

参考：

http://blog.csdn.net/mayouarebest8621/article/details/6755036

http://blog.163.com/sunflower123_happy/blog/static/1732744212011226104951653/

http://developer.51cto.com/art/200906/132339.htm

7.Synchronize关键字的用法以及在什么情况下使用

　　synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

　　一、synchronized 方法：

　　通过在方法声明中加入 synchronized关键字来声明 synchronized方法。如：
public synchronized void accessVal(int newVal);
synchronized
方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized
方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为
synchronized
的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为
synchronized）。
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized
，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized
将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何
synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized
，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
　　二、synchronized 块：

通过 synchronized关键字来声明synchronized 块。语法如下：

synchronized(syncObject) {
//允许访问控制的代码
}
　　synchronized
块是这样一个代码块，其中的代码必须获得对象 syncObject
（如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

notify()及notifyAll()是Object的方法,与Object的wait()方法配合使用,而且这三个方法必须在同步块中调用.

如下:
在线程1中执行如下代码
...
synchronized(obj1)      //1.进入同步块
{

try {
    ...
    obj1.wait();        //2.进入暂停状态
    }catch
(InterruptedException exp) {}
}

1.当前同步对象(monitor)为obj1,obj1是任一实例,若是同步方法,则同步对象是this.进入同步块后,obj1为锁定状态,锁定状态对obj1本身无任何影响,而其它线程执行到同一代码时,因不能获得锁,处于Block状态,一旦解锁,被block的线程自动继续执行.
2.调用obj1.wait()有两个作用,一是使线程进入等待状态,二是解锁obj1,这时被block的线程将获得锁.线程1要退出等待必须要由其它线程显式的调用obj1.notify()或notifyAll()方法.

如
...
synchronized(obj1)
{
    ...
    obj1.notify();
//3. 向wait的线程发通知信息
    ...
}
...

若其它线程执行到此时,线程1处于wait状态,则wait状态解除,解除后,若线程1若得到锁就能继续执行,若有多个线程处于obj1的wait状态,notify将随机选一个线程激活,而notifyAll是同时解除所有的wait状态.
notifyAll()让等待某个对象K的所有线程离开阻塞状态，
notify()随机地选取等待某个对象K的线程，让它离开阻塞状态。
notify(),notifyAll()非常有用，在一个synchronized(lockObj)块中当调用lockObj.wait()时，线程就已经将锁放开来了，这时当另外一个线程调用lockObj.notify()时，等待的线程就会继续执行下去了。这是一种非常高效的线程同步机制。如果没有他，用sleep()来同步的话就太浪费时间了。
一个简单的例子：
thread1
receive data
thread2 pase received data

lockObj是buf
当buf中没有数据时，thread2中调用buf.wait释放锁，让thread1有机会执行。
当thread1收到数据时，调用buf.notify()通知thread1去处理收到的数据。
如果在同步块入口点阻塞,不须其它线程调用notify(),调了也没效果,同步块能自动获得锁

如果是wait造成了阻塞,须用notfiy()激活,这两个方法是配合使用
notify、notifyAll、wait
:
主要是为了解决持有监视器钥匙的线程暂停等待另一线程完成时可能发生死锁的问题。wait()方法使调用线程等待，直到发生超时或另一线程调用同一对象的notify（）或notifyAll()方法。wait()
方法的用法如下：wait()或wait(long
timeoutPeriodInMilliseconds)前者等待被通知，后者等待超时或通知。线程调用wait()方法时，释放所持有的钥匙让另一等待线程进入监视区。notify()方法只唤醒一个等待线程，而notifyAll()唤醒所有等待该监视器的线程。注意，这些方法只能在监视区内调用。否则会输出一种RuntimeException类型的IllegaMonitorStateException异常状态。
够详细清楚的吧。

总之wait()让线程等待，notify()和notifyall()激活某个等待线程，其实就是撤销该线程的中断状态，从而使他们有机会再次运行

有时会遇到如下问题,程序的一部分在写数据,另一部分读数据,但有时会出现读部分超前写部分,
这就是典型的产生者/消耗者问题.

.wait:是一个线程睡眠,直到在相同的对象上调用notify或notifyAll

.notify:启动第一个在相同对象调用wait的线程
   .notifyAll:启动在相同的对象调用wait的所有线程

http://blog.163.com/paraden_lihui_ne/blog/static/4829188420071114901431/

http://developer.51cto.com/art/200906/132360.htm

http://developer.51cto.com/art/200906/132354.htm

8.Overloaded和override的区别，overloaded是否可以改变返回值类型

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

Overload是重载，它用与现有成员相同的名称来声明属性或方法，但参数列表与原始成员不同。
Override 主要用于父类和子类之间的方法重写，即指定属性或方法可以在派生类中重写，其参数列表要求相同。

9.sleep和wait的区别

sleep()方法:
　　当程序运行到Thread.sleep(100L);时,休眠100毫秒,同时交出CPU时间片,100毫秒后,重新进入可运行状态,等待CPU重新分配时间片,而线程交出时间片时,CPU拿到时间片,由操作系统负责在客运行状态的线程中选中并分配时间片

wait()方法:

　　程序在运行时,遇到wait()方法,这时线程进入当前对象的等待队列并交出CPU,等待其他线程notifyALL()时,才能重新回到可运行状态,等待OS分配CPU,带参数的wait()方法我也不是很清楚,以上供楼主参考

10.面向对象的特征

面向对象的三个基本特征是：封装、继承、多态。

（1）封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

（2）继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

实现继承是指使用基类的属性和方法而无需额外编码的能力；
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

（3）多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式：覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

注意：

　　继承与重载：一是子类与父类的关系，二是重载方法的调用问题。

参考：

http://www.cnitblog.com/Lily/archive/2013/01/03/6860.html

http://book.51cto.com/art/200903/114736.htm（这个还把抽象加到面向对象的特征了）

http://blog.csdn.net/cancan8538/article/details/8057095（五种设计原则）

11.String和StringBuffer的区别

String是字符串常量

StringBuffer是字符串变量（线程安全）

StringBuilder是字符串变量（非线程安全）

　　简要的说，String 类型和StringBuffer类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

　　而如果是使用StringBuffer类则结果就不一样了，每次结果都会对StringBuffer对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用StringBuffer，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了StringBuffer对象的拼接，所以这些时候 String 对象的速度并不会比StringBuffer对象慢，而特别是以下的字符串对象生成中， String 效率是远要比StringBuffer快的：

　　String S1 = “This is only a” + “ simple” + “ test”;

　　StringBufferSb = newStringBuilder(“This is only a”).append(“ simple”).append(“ test”);

　　你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个 String S1 = “This is only a” + “ simple” + “test”; 其实就是： String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如： String S2 = “This is only a”; String S3 = “ simple”; String S4 = “ test”; String S1 = S2 +S3 + S4; 这时候 JVM 会规规矩矩的按照原来的方式去做。

　　在大部分情况下StringBuffer> String

　　StringBuffer

　　Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

　　可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

　　StringBuffer上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

　　　　例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

　　在大部分情况下StringBuilder>StringBuffer

　　java.lang.StringBuilde

　　java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与StringBuffer兼容的 API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。两者的方法基本相同。

http://blog.csdn.net/rmn190/article/details/1492013

http://www.360doc.com/content/12/0209/21/3446769_185394457.shtml

http://www.360doc.com/content/09/0614/15/61497_3891709.shtml

http://www.360doc.com/content/09/0614/15/61497_3891771.shtml

12.“==”和object.equal（）的区别

java中的数据类型，可分为两类：

1.基本数据类型，也称原始数据类型。

　　byte,short,char,int,long,float,double,boolean ，他们之间的比较，应用双等号（==）,比较的是他们的值。

2.复合数据类型(类)

　　当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

　　对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

public class TestString {

    public static void main(String[] args) {

        String s1 = "Monday";

        String s2 = "Monday";

        if (s1 == s2){

            System.out.println("s1 == s2");

        }

        else{

            System.out.println("s1 != s2");}

        }

}

编译并运行程序，输出：s1 == s2说明：s1 与 s2 引用同一个 String 对象 -- "Monday"!

再稍微改动一下程序，会有更奇怪的发现：

public class TestString {

    public static void main(String[] args) {

        String s1 = "Monday";

        String s2 = new String("Monday");

        if (s1 == s2){

            System.out.println("s1 == s2");

        }else{

            System.out.println("s1 != s2");

        }

        if (s1.equals(s2)) {

            System.out.println("s1 equals s2");

        else{

            System.out.println("s1 not equals s2");

        }

    }

}

我们将s2用new操作符创建程序输出： s1 != s2 s1 equals s2 说明：s1 s2分别引用了两个"Monday"String对象

字符串缓冲池

　　原来，程序在运行的时候会创建一个字符串缓冲池当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1 将s2引用s1所引用的对象"Monday" 第二段程序中，使用了 new 操作符，他明白的告诉程序："我要一个新的！不要旧的！"于是一个新的"Monday"Sting对象被创建在内存中。他们的值相同，但是位置不同，一个在池中游泳一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？

再次更改程序：

public class TestString {

    public static void main(String[] args) {

        String s1 = "Monday";

        String s2 = new String("Monday");

        s2 = s2.intern();

        if (s1 == s2){

            System.out.println("s1 == s2");

        }els{

            System.out.println("s1 != s2");

        }

        if (s1.equals(s2)) {

            System.out.println("s1 equals s2");

        }else{

            System.out.println("s1 not equals s2");

        }

    }

}

这次加入：s2 = s2.intern();
程序输出：
s1 == s2
s1 equals s2
原来，（java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方法没什么用处。但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。
）

http://liaozh2004.iteye.com/blog/222375

http://www.cr173.com/html/18757_1.html

http://www.cnblogs.com/zhxhdean/archive/2011/03/25/1995431.html

13.字符串拼接的方法

代码如下：

import java.util.ArrayList;

import java.util.List; 

import org.apache.commons.lang.StringUtils;

import org.junit.Test;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory; 

public class TestString { 

    private final Logger logger = LoggerFactory.getLogger(this.getClass()); 

    @Test

    public void testPlus() {

        String s = "";

        long ts = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

            s = s + String.valueOf(i);

        }

        long te = System.currentTimeMillis();

        logger.info("+ cost {} ms", te - ts);

    } 

    @Test

    public void testConcat() {

        String s = "";

        long ts = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

            s = s.concat(String.valueOf(i));

        }

        long te = System.currentTimeMillis();

        logger.info("concat cost {} ms", te - ts);

    } 

    @Test

    public void testJoin() {

        List<String> list = new ArrayList<String>();

        long ts = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

            list.add(String.valueOf(i));

        }

        StringUtils.join(list, "");

        long te = System.currentTimeMillis();

        logger.info("StringUtils.join cost {} ms", te - ts);

    } 

    @Test

    public void testStringBuffer() {

        StringBuffer sb = new StringBuffer();

        long ts = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

            sb.append(String.valueOf(i));

        }

        sb.toString();

        long te = System.currentTimeMillis();

        logger.info("StringBuffer cost {} ms", te - ts);

    } 

    @Test

    public void testStringBuilder() {

        StringBuilder sb = new StringBuilder();

        long ts = System.currentTimeMillis();

        for (int i = 0; i < 100000; i++) {

            sb.append(String.valueOf(i));

        }

        sb.toString();

        long te = System.currentTimeMillis();

        logger.info("StringBuilder cost {} ms", te - ts);

    }

}