java基础类库 BaseClassLibrary
StringBuffer 类的特点
StringBuffer,StringBuilder,String 类之间的关系
StringBuffer 类
String 类有哪些特点?
字符串常量就是String 类的匿名对象,一旦字符串定义则不可改变
String 类对象可以使用直接赋值或者构造方法实例化,前者可以自动入池,又不会产生垃圾空间
在实际的开发之中,肯定都要求使用到String类,可是String有一个天生的短板:不可改变,所以如果要想面对经常修改的环境下只能够使用StringBuffer 类
在String类中可以使用“+”来实现字符串的连接操作,而在 StringBuffer 类中可以使用 append() 方法实现“+”的功能
如方法定义如下:
public StringBuffer append(数据类 变量)
范例:利用StringBuffer 修改字符串
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
StringBuffer buf = newStringBuffer();
buf.append("Hello").append("World!!!"); //连接字符串
fun(buf); //修改字符串的内容
System.out.println(buf);
}public static void fun(StringBuffer temp){ //引用传递
temp.append("\n该学习了!");
}
}
此时的执行结果之中发现字符串的内容已经得到了改变,所以StringBuffer适合与修改,而String不适合修改
原则:在开发之中95%的情况下使用的都应该是String(String只是不适合于频繁修改),所以不可能通过循环操作SQL,但是如果真的是进行连接操作,还建议使用“+”。如果真的是循环修改,还是使用StringBuffer 好
现在字符串类有两个类:StringBuffer,String,那么这两个什么关系呢?
查看文档观察继承结构:
String 类:
public final class Stringextends Objectimplements Serializable, Comparable, CharSequence
StringBuffer 类
public final class StringBufferextends Objectimplements Serializable, CharSequence
发现String和StringBuffer类都是 CharSequence 接口的子类,所以在日后一定要记住,String或StringBuffer都是可以向上转型为 CharSequence 接口实例化
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
String str = "nul" + "kong" + "空";
CharSequence cs= str; //向上转型
System.out.println(cs.subSequence(5, 8));
}
}
但是现在出现了一个问题,String 与StringBuffer 类的对象该如何互相转换呢?
对于这两个类对象的互相转换就可以利用一下原则完成:
1.String 转换为StringBuffer 这种转换有两种操作途径:
利用StringBuffer 类的构造方法: public StringBuffer(String str)
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
String str = "nul" + "kong" + "空";
StringBuffer s= newStringBuffer(str);
System.out.println(s);
}
}
StringBuffer 类存在有 append() 方法:public StringBuffer append(String str)
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
String str = "nul" + "kong" + "空";
StringBuffer s= newStringBuffer();
s.append(str);
System.out.println(s);
}
}
2.StringBuffer 变为 String
所有类都存在有 toString() 方法,利用此方法可以将 StringBuffer内容变为 String
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
StringBuffer s = new StringBuffer("Hello");
String str=s.toString();
System.out.println(str);
}
}
利用“+”实现所有数据类型向String的转换
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
StringBuffer s = new StringBuffer("Hello");
String str= "" +s;
System.out.println(str);
}
}
虽然在开发之中要进行字符串的操作都是以String类为主,可是你永远不要忽略一点: StringBuffer 类也提供有一些好的操作方法方便用户
范例:在自定位置追加新的内容
方法: public StringBuffer insert(int offset,数据类型 变量)
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
StringBuffer s = new StringBuffer("Hello");
s.insert(5, "!!!");
System.out.println(s);
}
}
范例:反转
方法: public StringBuffer reverse()
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
StringBuffer s = new StringBuffer("Hello");
System.out.println(s.reverse());
}
}
范例:删除指定范围的数据
方法:public StringBuffer delete(int start,int end)
packagecn.mysterious.study3;public classStringBufferClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
StringBuffer s = new StringBuffer("Hello! World!");
s.delete(6, 12);
System.out.println(s);
}
}
以上的 三个操作方法是掌握 StringBuffer 类的主要操作
StringBuffer 类在 JDK1.0 的时候提供的,而在JDK1.5之后有提供了一个 StringBuilder 类,这两个类单看文档都一样
StringBuffer 属于线程安全的操作,但是性能不高,而StringBuilder属于非线程安全的操作,性能高
面试题:请解释 StringBuffer,StringBuilder,String 类的区别?
String 类的内容一旦声明则不可改变,而 StringBuilder和StringBufffer的内容可以改变
StringBuffer,StringBuilder,String 都属于 CharSequence 接口的子类
StringBufffer 是从JDK1.0提供的,属于线程安全的操作,而StringBuilder 是从JDK1.5之后提供的,属于非线程安全的操作
总结:
字符串的操作首选的一定是 String类,可改变的时候再选择 StringBuffer,StringBuilder 多个线程访问同一资源时必须使用 StringBuffer
Runtime 类
Runtime 类的设计特点
Runtime 类的使用
在每个java进程之中都会存在有一个 Runtime 类的对象
由于此类的对象是由java进程自己维护,所以在整个 Runtime 类设计的过程之中,只为用户提供了唯一的一个实例化对象,所以这个类所使用的是单例设计模式构造方法被私有化了
所以其类的内部一定会提供有一个 static 方法取得本类的实例化对象
取得 Runtime 类对象: public static Runtime getRuntime()
那么取得对象之后可以做什么呢?
在 Runtime 类中定义有如下可以取得内存大小的方法
空闲内存大小: public long freeMemory()
最大可用内存大小: public long maxMemory()
总共可用内存大小: public long totalMemory()
范例:取得内存空间大小
packagecn.mysterious.study3;public classRuntimeClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
Runtime run = Runtime.getRuntime(); //取得 Runtime 类的实例化对象
System.out.println("MAX = " +run.maxMemory());
System.out.println("TOTAL = " +run.totalMemory());
System.out.println("FREE = " +run.freeMemory());
}
}/*结果:
MAX = 937951232
TOTAL = 64487424
FREE = 63144784*/
面试题:java如何调整可用内容的大小?
java中的划分主要有两个组成部分:
堆内存:保存的实例化对象的内容,每个JVM进程之中,对象的堆内存空间都会由垃圾收集器自动的管理内存回收问题
非堆内存( Eden + Front Space + To Space):主要用于产生新的对象
所有方法的全局方法区
所有的 static 的全局数据区
永生代:负责存放反射对象的操作空间
如果要想调整内存大小主要调整的就是堆内存空间,它的调整有如下三个参数:
-Xms :初始分配大小,为物理内存的1/64,最多不超过1G
-Xmx :最大分配内存,为物理内存的1/4
-Xmn :年轻代堆内存大小
范例:设置参数
java -Xms1024M -Xmx1024M -Xmn521M ???(这里是文件的名称)
在 Runtime 类中提供有垃圾的收集机制: public void gc()
范例:垃圾回收
packagecn.mysterious.study3;public classRuntimeClass {public static voidmain(String[] args) {//TODO Auto-generated method stub
Runtime run = Runtime.getRuntime(); //取得 Runtime 类的实例化对象
System.out.println("1.MAX = " +run.maxMemory());
System.out.println("1.TOTAL = " +run.totalMemory());
System.out.println("1.FREE = " +run.freeMemory());
String str= " ";for (int i = 0; i < 2000; i++) {
str+=i;
}
System.out.println("2.MAX = " +run.maxMemory());
System.out.println("2.TOTAL = " +run.totalMemory());
System.out.println("2.FREE = " +run.freeMemory());
run.gc();//执行垃圾收集
System.out.println("3.MAX = " +run.maxMemory());
System.out.println("3.TOTAL = " +run.totalMemory());
System.out.println("3.FREE = " +run.freeMemory());
}
}
那么回收到底经历过哪些问题呢?
简单点说:
新的对象保存在Eden区中,之后此对象保存在年轻代区;而后在进行GC 之后所有被保留下来的年轻代中的对象(从GC,MinorGC),将保存在旧生代(主GC,Majo)
如果再有新的对象,从年轻代回收,在找到旧生代,最后都没有空间了,进行垃圾的全部扫描(Full GC)
面试题:请问什么是GC?如何操作?
GC指的是垃圾收集,对于GC操作利用利用 Runtime 类中的 gc() 方法手工释放,或者是利用系统自动进行释放
总结
Runtime 使用了单例设计模式,每个JVM进程只会存在有一个 Runtime 类对象
Runtime 了提供有 gc() 方法,可以进行垃圾收集处理
System 类
System 类的基本使用
内存释放操作
说到System 类一定会首先想到两个方法:
输出:System.out.println()
数组拷贝:System.arraycopy()
完整定义: public static void arraycopy(Object src, int srcPos,Object dest, int destPos,int length)
在System 类中定义有取得当前日期时间的方法: public static long currentTimeMillis()
范例:利用此方法实现操作花费的时间内的统计
packagecn.mysterious.study3;public classSystemClass {public static void main(String[] args) throwsInterruptedException {//TODO Auto-generated method stub
long stasrt =System.currentTimeMillis();
Thread.sleep(2000);long end =System.currentTimeMillis();
System.out.println("计算花费时间:" + (end -stasrt));
}
}
但是在 System 类中定义有这样的一个方法: public static void gc() ,但是这个方法并不是实现的新的方法,而是继续调用了 Runtime 类中的 gc() 方法
在新的对象实例化的时候可以利用构造方法进行相应的处理操作,但是在某一个对象回收之后,那么该如何在回收前给他一些处理的机会呢?
在 Object 类中提供有一个对象回收前的释放操作:
方法: protected void finalize() throws Throwable
此处可以抛出 Error 或 Exception ,但是不管抛出谁,最终都一定要被回收
范例:观察对象回收
packagecn.mysterious.study3;classperson{public voidPerson(){
System.out.println("降临!");
}
@Overrideprotected void finalize() throwsThrowable {//TODO Auto-generated method stub
System.out.println("挂了!");throw new Exception("再活500年!");
}
}public classSystemClass {public static void main(String[] args) throwsInterruptedException {
person per= newperson();
per= null;
System.gc();
}
}
面试题:请解释 final finally finalize 的区别?
final :定义不能够被继承的父类,不能够被子类所覆盖的方法,定义常量
finally :是在异常处理中进行异常处理的统一出口
finalize :是 Object 类的一个方法( protected void finalize() throw Throwable ),是在对象回收前进行对象收尾操作的
总结:
System.currentTimeMillis();
gc 永远只有一个方法,在 Runtime 类中定义的
对象克隆
克隆的操作实现
写代码的过程之中很少能够见到这样的操作
对象克隆指的就是复制对象,在 Object 类中提供有一个对象克隆的操作:
方法: protected Object clone()throws CloneNotSupportedException
由于所有的类对象都可能出现克隆的情况,所以此方法的返回值是 Object
protected 只能够在同一包或不同包的子类中访问
克隆方法会抛出一个异常,如果要克隆对象所在的类没有实现 Cloneable 接口,那么会抛出此异常
但是打开 Cloneable 接口之后会发现,在这个接口里面没有定义任何的操作方法,因为它是一个标识接口,表示一种能力
范例:实现克隆操作
packagecn.mysterious.study3;class Person implements Cloneable{ //表示本类对象可以克隆
privateString name;private intage;public Person(String name,intage){this.name =name;this.age =age;
}public void setAge(intage) {this.age =age;
}
@OverridepublicString toString() {//TODO Auto-generated method stub
return "姓名:" + this.name + ",年龄:" + this.age;
}
@Overrideprotected Object clone() throwsCloneNotSupportedException {//TODO Auto-generated method stub
return super.clone(); //调用父类中的方法
}
}public classSystemClass {public static void main(String[] args) throwsException {
Person per1= new Person("林",15);
Person per2=(Person) per1.clone();
per2.setAge(20);
System.out.println(per1);
System.out.println(per2);
}
}
对象考虑的关键是在于 Cloneable 接口的使用
总结:
标识接口的最大特征在于表示一种能力,而不会定义方法
protected 权限