1 StringBuffer类
String类是在所有项目开发之中一定会使用到的一个功能类，并且这个类拥有如下的几个特点：
（1）每一个字符串的常量都属于一个String类的匿名对象，并且不可以更改；
（2）String有两个常量池：静态常量池和运行时常量池。
（3）String类对象实例化建议使用直接赋值的形式完成，这样可以直接将对象保存在对象池之中以方便下次重用。
虽然String类很好用，但是如果认真去思考也会发现其最大的弊端：内容不允许修改，虽然大部分情况下都不会涉及到字符串内容的频繁修改，但是依然可能会存在有这样的情况，所以为了解决此问题，专门提供了一个StringBuffer类，可以提供字符串内容的修改处理。
StringBuffer并不像String类那样拥有两种对象实例化的方式，StringBuffer必须像普通类对象那样首先进行对象实例化，而后才可以调用方法执行处理，而这个时候可以考虑使用StringBuffer类中的如下方法：
（1）构造方法：public StringBuffer()
（2）构造方法：public StringBuffer(String str)
（3）数据追加：public java.lang.AbstractStringBuilder append(数据类型 obj)，相当于字符串中的"+"操作
范例：观察String类对象引用传递与StringBuffer类对象引用传递对比
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
String str = "Hello ";
StringBuffer sbf = new StringBuffer("Hello ");
changeString(str);
changeStringBuffer(sbf);
System.out.println("String: " + str);
System.out.println("StringBuffer: " + sbf);
}
public static void changeString(String temp) {
temp += "World!";
}
public static void changeStringBuffer(StringBuffer sbf) {
sbf.append("World!");
}
}
/*
String: Hello
StringBuffer: Hello World!
*/
实际上大部分情况下，很少会出现有字符串内容的改变，这种改变指的并不是针对静态常量池的改变
范例：分析一个问题
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
String strA = "lks loves hhy";
String strB = "lks " + "loves " + "hhy";
System.out.println("strA == strB: " + (strA==strB)); //true
}
}
/*
strA == strB: true
*/
这个时候的strB对象的内容并不算是改变，或者更加严格的意义上来讲，对于现在的strB当程序编译之后会变为如下的形式。
StringBuffer strC = new StringBuffer("lks").append(" loves").append(" hhy");
所有的"+"再编译之后都变为了StringBuffer中的append()方法，并且来讲在程序之中StringBuffer与String类的对象之间本来就可以直接互相转换：
（1）String类对象变为StringBuffer可以依靠StringBuffer类的构造方法或者使用append()方法。
（2）所有的类对象都可以通过toString()方法将其变为Sting类型。
在StringBuffer类里面除了可以支持有字符串内容的修改之外，实际上也提供有一些String类所不具有的方法：
（1）插入数据：public StringBuffer insert(int offset, 数据类型 b)
（2）删除指定范围的数据：public StringBuffer delete(int start, int end)
（3）字符串内容反转：public StringBuffer reverse()
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
StringBuffer strC = new StringBuffer("lks").append(" loves").append(" hhy");
System.out.println(strC.reverse());
}
}
/*
yhh sevol skl
*/
实际上与StringBuffer类还有一个类似的功能类：StringBuilder类，这个类是在JDK 1.5的时候提供的，该类中提供的方法与StringBuffer功能相同，最大的区别在于StringBuffer类中的方法属于线程安全的，全部使用了synchronized关键字进行了标注，而StringBuilder属于非线程安全的。
面试题：请解释String、StringBuffer和StringBuilder的区别？
（1）String类是字符串的首选类型，其最大的特点是内容不允许修改。
（2）StringBuffer与StringBuilder类的内容允许修改；
（3）StringBuffer是在JDK 1.0的时候提供的，属于线程安全的操作，而StringBuilder是在JDK 1.5的之后提供的，属于非线程安全的操作。
2 CharSequence接口
CharSequence是一个描述字符串结构的接口，在这个接口里面一般可以发现有三种常见的子类：
（1）public final class StringBuffer extends Object implements Serializable, CharSequence
（2）public final class String extends Object implements Serializable, Comparable<String>, CharSequence
（3）public final class StringBuilder extends Object implements Serializable, CharSequence
现在只要有字符串就可以为CharSequence接口实例化。
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
CharSequence chse = "love you";
System.out.println(chse);
}
}
/*
love you
*/
CharSequence本身是一个接口，在该接口之中也定义有如下操作方法：
（1）获取指定索引字符：char charAt(int index)
（2）获取字符串长度：int length()
（3）截取部分字符串：CharSequence subSequence(int start, int end)
范例：字符串的截取
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
CharSequence chse = "love you";
System.out.println(chse.subSequence(5, 8));
}
}
/*
you
*/
以后只要看见了CharSequence描述的就是一个字符串。
3 AutoCloseable接口
AutoCloseable主要是日后进行资源开发的处理，以实现资源的自动关闭（释放资源），例如，在以后进行文件、网络、以及数据库开发的过程之中由于服务器的资源有限，所以使用之后一定要关闭资源，这样才可以被更多的使用者所使用。
下面为了更好地说明资源的问题，将通过一个消息的发送处理来完成。
范例：手工实现资源处理
package cn.victor.demo;
interface IMessage{
public abstract void send();
}
class Message implements IMessage{
private String msg;
public Message() {}
public Message(String msg) {
this.msg = msg;
}
public void send() {
System.out.println(this.msg);
}
public void open() {
System.out.println("[Message Send]: begin send");
}
public void close() {
System.out.println("[Message Close]: close send");
}
}
public class JavaAPIDemo {
public static void main(String[] args) {
Message msg = new Message("love you");
msg.open();
msg.send();
msg.close();
}
}
/*
[Message Send]: begin send
love you
[Message Close]: close send
*/
此时有位设计师说了，既然所有的资源完成处理之后都必须进行关闭操作，能否实现一种自动关闭的功能？在这种要求下，推出了AutoCloseable接口，这个接口是在JDK 1.7的时候提供的，并且该接口只提供了一个方法：
（1）关闭方法：void close() throws Exception
要想实现自动关闭处理，除了要使用AutoCloseable之外，还需要结合有异常处理语句才可以正常调用。
范例：实现自动关闭处理
package cn.victor.demo;
interface IMessage extends AutoCloseable{
public abstract void send();
}
class Message implements IMessage{
private String msg;
public Message() {}
public Message(String msg) {
this.msg = msg;
}
public void send() {
System.out.println(this.msg);
}
public void open() {
System.out.println("[Message Send]: begin send");
}
public void close() {
System.out.println("[Message Close]: close send");
}
}
public class JavaAPIDemo {
public static void main(String[] args) {
try(IMessage msg = new Message("love you")){
((Message)msg).open();
msg.send();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4 Runtime类
Runtime描述的是运行时的状态，也就是说在整个的JVM之中，Runtime是唯一一个与JVM运行状态有关的类，并且都会默认提供有一个该类的实例化对象。
由于在每一个JVM进程只允许提供一个Runtime类的对象，所以这个类的构造方法被默认私有化了，那么就证明该类使用的是单例设计模式，并且单例设计模式一定会提供有一个static方法获取本类实例。
由于Runtime类属于单例设计模式，如果要想获取实例化对象，那么就可以依靠类中的getRuntime()方法完成。
通过这个类中的public int availableProcessors()方法可以获取本机的CPU内核数：public int availableProcessors()
（1）获取实例化对象：
范例：获取Runtime类对象
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
Runtime run = Runtime.getRuntime();
System.out.println(run.availableProcessors()); //获取可用进程数
}
}
除了以上方法之外，在Runtime类里面还提供有以下四个重要的操作方法：
（1）获取最大可用内存空间：public long maxMemory()，默认的配置为本机系统内存的4分之一。
（2）获取可用内存空间：public long totalMemory(), 默认的配置为本机系统内存的64分之一。
（3）获取空闲内存空间：public long freeMemory()
（4）手工进行GC处理：public void gc()
范例：观察内存状态
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
Runtime run = Runtime.getRuntime();
System.out.println(run.availableProcessors());
System.out.println("[1]MaxMemory: " + run.maxMemory());
System.out.println("[1]TotalMemory: " + run.totalMemory());
System.out.println("[1]FreeMemory: " + run.freeMemory());
String str = "lks";
for(int i = 0; i < 50000; i++) {
str += i; //创建大量对象
}
System.out.println("**************************************");
System.out.println("[2]MaxMemory: " + run.maxMemory());
System.out.println("[2]TotalMemory: " + run.totalMemory());
System.out.println("[2]FreeMemory: " + run.freeMemory());
run.gc(); //手动回收对象
System.out.println("**************************************");
System.out.println("[3]MaxMemory: " + run.maxMemory());
System.out.println("[3]TotalMemory: " + run.totalMemory());
System.out.println("[3]FreeMemory: " + run.freeMemory());
}
}
面试题：请问什么是GC？如何处理？
（1）GC（Garbage Collector）垃圾收集器，是可以由系统自动调用的垃圾释放功能，或者使用Runtime类中的gc()手工调用。
5 System类
System类是一直陪伴着我们学习的程序类，之前使用的系统输出采用的就是System类中的方法，除了这些方法之外，在System类中也定义有其他方法：
（1）数组拷贝：public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
（2）获取当前的日期时间数值：public static long currentTimeMillis()
（3）进行垃圾回收：public static void gc()
范例：操作耗时的统计
package cn.victor.demo;
public class JavaAPIDemo {
public static void main(String[] args) {
long start = System.currentTimeMillis();
String str = "lks";
for(int i = 0; i < 50000; i++) {
str += i; //创建大量对象
}
long end = System.currentTimeMillis();
System.out.println(end-start);
}
}
在System类里面会发现也提供有一个gc()方法，但是这个gc()方法并不是重新定义的新方法，而是继续调用Runtime类中的gc()操作。
6 Cleaner类
Cleaner是在JDK 1.9之后提供的一个对象的清理操作，其主要的功能是进行finialize()方法的替代。在C++语言里面有两种特殊的函数：构造函数、析构函数（对象手工回收），在Java里面所有的垃圾空间都是通过GC自动回收的，所以很多情况下是不需要使用这类析构函数的，也正是因为如此，所以Java并没有提供这方面的支持。
但是Java本身依然提供了给用户收尾的操作，每一个实例化对象在回收之前至少给他一个喘息的机会，最初实现对象收尾处理的方法是Object类中提供的finialize()方法，这个方法的定义如下：
@Deprecated(since="9")
protected void finalize() throws Throwable
该替换指的是不建议继续使用这个方法了，而是说子类可以继续使用这个方法名称。但是这个方法最大的特点是抛出了一个Throwable异常类型，而这个异常类型分为两个子类型：Error、Exception，平常所处理的都是Exception。
范例：观察传统回收
package cn.victor.demo;
class Member {
public Member() {
System.out.println("[Object create]");
}
@Override
protected void finalize() throws Throwable {
// TODO Auto-generated method stub
System.out.println("[recycle]");
throw new Throwable("[NO!!!]");
}
}
public class JavaAPIDemo {
public static void main(String[] args) throws Throwable {
Member mem = new Member();
mem = null; //成为垃圾
System.gc(); //手动执行垃圾回收器
System.out.println("[Everything normal]");
}
}
但是从JDK 1.9开始，这一操作已经不建议使用了，而对于对象的回收与释放，从JDK 1.9开始建议开发者使用AutoCloseable或者使用Cleaner类进行回收处理。
package cn.victor.demo;
import java.lang.ref.Cleaner;
import java.lang.ref.Cleaner.Cleanable;
class Member implements Runnable{
public Member() {
System.out.println("[Object create]");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("[recycle]");
}
}
class MemberCleaner implements AutoCloseable{
private static final Cleaner cleaner = Cleaner.create();
public Member member;
public Cleaner.Cleanable cleanable;
public MemberCleaner() {
this.member = new Member();
this.cleanable = cleaner.register(this, this.member);
}
@Override
public void close() throws Exception {
// TODO Auto-generated method stub
this.cleanable.clean();
}
}
public class JavaAPIDemo {
public static void main(String[] args) throws Throwable {
try(MemberCleaner mem = new MemberCleaner()){
//your code
System.out.println("[Everything normal]");
}catch(Exception e) {
}
}
}
在新一代的清除回收处理的过程之中，更多的情况下考虑的是多线程的使用，即，为了防止有可能造成的延迟处理，所以许多对象回收前的处理都是单独通过一个线程完成的。
7 对象克隆
所谓对象克隆指的就是对象的复制，而且属于全新的复制。即使用已有对象内容创建一个新的对象，如果要想进行对象的克隆需要使用到Object类中提供的clone()方法。
所有的类都会继承Object父类，所以所有的类一定会有clone()方法，但是并不是所有的类都希望被克隆。所以如果要想实现对象克隆，那么对象所在的类需要实现一个接口Cloneable，此接口并没有任何的方法提供，是因为它描述的是一种能力。
范例：实现对象克隆
package cn.victor.demo;
class Member implements Cloneable{
private String name;
private int age;
public Member() {}
public Member(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "name: " + this.name + "; age: " + this.age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
}
public class JavaAPIDemo {
public static void main(String[] args) throws Throwable {
Member memA = new Member("lks", 23);
Member memB = (Member)memA.clone(); //use clone
Member memC = memA; //don't use clone
System.out.println(memA == memB); //false
System.out.println(memA == memC); //true
}
}
如果在开发之中不是非常特别的需求下，很少会出现有对象克隆的需求。
