StringBuffer类
每一个字符串的常量都属于一个String类的匿名对象,并且不可更改
String有两个常量池:静态常量池和运行时常量池
String类对象实例化建议使用直接赋值的形式完成,这样可以直接将对象保存在对象池中,方便下次重用。
String类最大弊端:内容不允许修改。所以专门有提供StringBuffer
可以实现对字符串内容的修改处理。
StringBuffer并不像String类那样拥有两种对象实例化方式,StringBuffer
必须像普通类那样实现进行实例化,而后才可以调用方法执行处理。
- 构造方法:
public StringBuffer();
- 构造方法:
public StringBuffer(String str)
,接受初始化字符串内容 - 数据追加:
public StringBuffer append(数据类型 变量)
,相当于字符串中的+操作
public class StringBufferdemo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer("Hello ");
change(buf);
System.out.println(buf);
}
public static void change(StringBuffer buf) {
buf.append(" World !!");
}
}
大部分情况下,很少会有字符串内容的改变,这种改变指的并不是针对于静态常量池的改变。
String str = "www." + "mldn" + ".cn" ;
所有的“+”在编译之后都变味了StringBuffer
中的append()
方法,并且在程序之中StringBuffer
与String
类之间可以直接相互转换;
String类对象变为StringBuffer
可以依靠StringBuffer
类的构造方法或者使用append()
方法。
所有的类对象都可以通过toString()
方法将其变为String类型。
StringBuffer
提供有String
类中所不具备的方法 :
插入数据:public StringBuffer insert(int offset, 数据类型 b)
public class StringBufferdemo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer();
buf.append(".cn").insert(0, "www.").insert(4, "mldn");
System.out.println(buf);
}
}
删除指定范围的数据:public StringBuffer delete(int start, int end)
public class StringBufferdemo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer();
buf.append("Hello World!").delete(6, 11);
System.out.println(buf);
}
}
Hello !
字符串内容反转:public StringBuffer reverse()
public class StringBufferdemo {
public static void main(String[] args) {
StringBuffer buf = new StringBuffer();
buf.append("Hello World!").reverse();
System.out.println(buf);
}
}
!dlroW olleH
实际上与StringBuffer
类还有一个类似的功能类:StringBuilder
类,JDK1.5提供的,该类提供的方法与StringBuffer相同。最大的区别在于StringBuffer类中的方法属于线程安全的,全部使用了synchronized
进行了标注,而StringBuilder
类属于非线程安全的。
面试题:请解释String、StringBuffer 、Stringbuilder的区别?
- String类是字符串的首选类型,其最大的特点是内容不允许修改;
- StringBuffer于StringBuilder类的内容允许修改;
- StringBuffer是在JDK1.0的时候提供的,属于线程安全的操作,而StringBuilder是JDK1.5后提供的,属于非线程安全的操作。
CharSequence接口
CharSequence是要给描述字符串机构的接口,一般发现有三种常用子类:
String类 | StringBuffer类 | StringBuilder类 |
---|---|---|
public final class String extends Object implements Serializable, Comparable,CharSequence | public final class StringBuffer extends Object implements Serializable,CharSequence | public final class StringBuilder extends Object implements Serializable, CharSequence |
public class JavaAPIDemo {
public static void main(String[] args) {
CharSequence str = "www.asd.asd";
}
}
CharSequence本身是一个接口,在该接口之中也定义有如下操作方法:
- 获取指定索引字符:
public char charAt(int index);
- 获取字符串长度:
public int length();
- 截取部分字符串:
public CharSequence subSequence(int start, int end);
【范例】字符串截取:
public class JavaAPIDemo {
public static void main(String[] args) {
CharSequence str = "www.asd.asd";
CharSequence sub = str.subSequence(4, 7);
System.out.println(sub);
}
}
asd
CharSequence描述的就是一个字符串。
AutoCloseable接口
这个接口是在JDK1.7提供的,并且该接口只有一个方法
关闭方法:public void close() throws Exception ;
要想实现自动关闭处理,除了要使用AutoCloseable
只外,还需要结合异常处理语句才可以正常完成。
写在()里面的流对象对应的类都实现了自动关闭接口AutoCloseable
;
try (创建流对象语句,如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
【范例】实现自动关闭处理
public class JavaAPIDemo {
public static void main(String[] args) throws Exception {
try (IMessage nm = new NetMessage("www.assdd.das");) {
nm.send();
} catch (Exception e) {
}
}
}
interface IMessage extends AutoCloseable {
public void send();// 消息发送
}
class NetMessage implements IMessage {// 实现消息的处理机制
private String msg;
public NetMessage(String msg) {
this.msg = msg;
}
public boolean open() {
System.out.println("【OPEN】获取消息发送链接资源。");
return true;
}
@Override
public void send() {
if (this.open()) {
System.out.println("***发送消息****" + this.msg);
}
}
public void close() throws Exception {
System.out.println("【CLOSE】关闭消息发送通道。");
}
}
AutoCloseable
主要是用于日后进行资源开发的处理上,以实现资源的自动关闭(释放资源),例如:在以后进行文件、网络、数据库开发的过程之中由于服务器的资源有限,所以使用之后一定要关闭资源,这样才可以呗更多的使用者使用。
Runtime类
Runtime描述的是运行时的状态, 也就是说在整个JVM之中,Runtime
类是唯一一个与JVM运行状态有关的类,并且都会默认提供有该类的实例化对象。
由于在每一个JVM进程里面只允许提供有一个Runtime类的对象,所以这个类的构造方法被默认私有化了,证明该类使用的是单例设计模式,并且单例设计模式一定会提供有一个static方法获取本类实例。
由于Runtime类属于单例设计模式,如果要想获取实例化对象,那么就可以依靠类中的getRuntime()
方法完成:
获取实例化对象:public static Runtime getRuntime();
public class JavaAPIDemo {
public static void main(String[] args) throws Exception {
Runtime run = Runtime.getRuntime();//获取实例化对象
System.out.println(run.availableProcessors());
}
}
四个重要操作方法:
- 获取最大可用内存空间:
public long maxMemory()
;默认的配置为本计系统内存的1/4. - 获取可用内存空间:
public long totalMemory()
;默认的配置为本机系统内存的/64 - 获取空闲内存空间:
public long freeMemory()
; - 手工进行GC处理:
public void gc()
。
public class JavaAPIDemo {
public static void main(String[] args) throws Exception {
Runtime run = Runtime.getRuntime();//获取实例化对象
System.out.println("MAX_MEMORY = " + run.maxMemory());
System.out.println("TOTAL_MEMORY = " + run.totalMemory());
System.out.println("FREE_MEMORY = " + run.freeMemory());
}
}
rMAX_MEMORY = 4259315712
TOTAL_MEMORY = 266338304
FREE_MEMORY = 265289728
面试题:什么是GC?如何处理?
- GC(Garbage Collector) 垃圾收集器,是可以由系统自动调用的垃圾释放功能,或者使Runtime类中的gc()手工调用。
System类
System类其它处理方法:
- 数组拷贝:
public static void arraycopy(Object src, int srcPos, Object dest, int destPos,int length);
- 获取当前的日期时间数值:
public static long currentTimeMillis();
- 进行垃圾回收:
public static void gc()
;这个gc()
方法并不是重新定义,而是继续执行Runtime类里面的gc()操作(Runtime.getRuntime().gc()
)。
【范例】操作耗时的统计:
public class JavaAPIDemo {
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
Runtime run = Runtime.getRuntime();//获取实例化对象
String str = "" ;
for (int x = 0; x < 30000; x++) {
str += x;
}
long end = System.currentTimeMillis();
System.out.println("操作耗时: " + (end-start));
}
}
Cleaner类
JDK1.9之后提供的一个对象清理操作,其主要功能是进行finalize()方法的替代。在C++里面由两种特殊的函数:构造函数、析构函数(对象手工回收),在Java里所有的垃圾空间都是通过GC自动回收的,所以很多情况下是不需要使用这类析构函数的,也正是如此,所以Java并没有提供这方面的支持。但Java本身依然提供了给用户收尾的操作,在每一个实例化对象在回收之前给他一个喘息的机会,最初回收处理的方法是Object类中所提供的finalize()
方法。
@Deprecated(since="9")
protected void finalize() throws Throwable
该替换指的是不建议继续使用这个方法了,而是说子类可以继续使用这个方法名称。该方法最大特征是抛出Throwable异常类型,这异常类型分为两个子类型:Error、Exception。
JDK1.9之后建议开发者使用java.lang.ref.Cleaner
类进行回收处理(Cleaner也支持有AutoCloseable处理)。
import java.lang.ref.Cleaner;
public class JavaAPIDemo {
public static void main(String[] args) throws Exception {
try(MemberCleaning mc = new MemberCleaning()) {
//相关代码块
} catch (Exception e) {
}
}
}
class Member implements Runnable{
public Member() {
System.out.println("【構造】在一個風雨交加的夜晚,你誕生了");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("【回收】你還是要被回收的。。。");
}
}
class MemberCleaning implements AutoCloseable{
private static final Cleaner cleaner = Cleaner.create();//创建一个清除处理
private Member member ;
private Cleaner.Cleanable cleanable ;
public MemberCleaning() {
this.member = new Member();//创建新对象
this.cleanable = this.cleaner.register(this,this.member);//注册使用对象
}
@Override
public void close() throws Exception {
this.cleanable.clean();//启动多线程
}
}
【構造】在一個風雨交加的夜晚,你誕生了
【回收】你還是要被回收的。。。
为了防止有可能造成的延迟处理,许多对象回收前的处理都是单独通过一个线程完成的。
对象克隆
指的就是对象的复制,即:使用已有对象内容创建一个新的对象,如果要想进行对象克隆需要使用到Object类中提供的clone()
方法:protected Object clone() throws CloneNotSupportedException;
所有的类都会继承Object
父类,所以所有的累都一定会有clone()方法,但并不是所有的累都希望被克隆。所以如果要想实现克隆,那么对象所在的类需要实现一个Cloneable
接口,此接口并没有任何的方法t提供,是因为它描述的是一种能力。
import java.lang.ref.Cleaner;
public class JavaAPIDemo {
public static void main(String[] args) throws Exception {
Member memberA = new Member("小强", 28) ;
Member memberB = (Member)memberA.clone() ;
System.out.println(memberA);
System.out.println(memberB);
}
}
class Member implements Cloneable{
private String name;
private int age ;
public Member(String name, int age) {
this.name = name;
this.age = age ;
}
@Override
public String toString() {
// super.toString()是为了获取对象编码
return "【" + super.toString() + "】name = " + this.name + "、age = " + this.age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();//调用父类中提供的clone方法
}
}
【javapreactice.Member@5305068a】name = 小强、age = 28
【javapreactice.Member@1f32e575】name = 小强、age = 28
参考资料:https://edu.aliyun.com/roadmap/java?spm=5176.265303.1378567.1.6aa22072N1Mui4