java常用类库(StringBuffer类、Runtime类、System类)

 

StringBuffer类

基本操作

StringBuffer是使用缓冲区的，本身也是操作字符的，但是与String不同，String的内容一旦声明则不能改变，改变的只是其内存地址的指向，而StringBuffer的内容是可以改变的。

对于StringBuffer而言，本身是一个具体的操作类，所以不能像String那样采用直接赋值的方式进行对象的实例化，必须通过构造方法完成。

StringBuffer连接字符串的操作：

·当一个字符串的内容需要被经常改变时就要使用StringBuffer

·在StringBuffer中使用append()方法，完成字符串的连接操作。

代码如下：

public class StringBufferDemo01
{
	public static void main(String args[]){
		StringBuffer buf=new StringBuffer();
		buf.append("Hello ");
		buf.append("World").append("!!!!");;
		buf.append(true+"、");
		buf.append(12+"、");
		buf.append(12.3+"、");
		buf.append(12.3f+"、");
		System.out.println(buf);
		//程序输出
		//Hello World!!!!true、12、12.3、12.3、
	}
}

注意：StringBuffer的内容是可以修改的，其有public StringBuffer reverse()方法，为逆序输出当前StringBuffer的内容。

public class StringBufferDemo02
{
	public static void main(String args[]){
		StringBuffer buf=new StringBuffer();
		buf.append("Hello");
		fun(buf);
		System.out.println(buf);	//输出当前StringBuffer内容
		System.out.println(buf.reverse());	//逆序输出内容
	}
	public static void fun(StringBuffer str){	//传递StringBuffer引用
		str.append("123");	//修改StringBuffer的内容
	}
}

Runtime类

Runtime：运行时，是一个封装了JVM进程的类。每一个java程序实际上都是启动了一个JVM进程，那么每一个JVM进程都是对应着一个Runtime实例，此类是由JVM为其实例化的。

Runtime类的常用方法

一旦取得JVM实例之后，以上的类都是可以使用的。

得到JVM信息

每一个Runtime对象都是由JVM进行实例化，所以，可以直接通过此类取得一些信息。

代码实例：(具体的东东请到帮助文档里面自行查找)

public class RuntimeDemo01
{
	public static void main(String args[]){
		Runtime run=Runtime.getRuntime();	//通过Runtime类中的静态方法返回一个Runtime类的实例
		System.out.println("当前JVM最大内存："+run.maxMemory());	//取得当前JVM最大内存
		System.out.println("当前JVM空闲内存："+run.freeMemory());	//取得当前JVM空闲内存
		run.gc();	//执行垃圾回收
		System.out.println("当前JVM空闲内存："+run.freeMemory());	//取得当前JVM空闲内存

	}
}

Runtime和Process类

可以使用Runtime类运行本机的可执行程序，例如：调用记事本

public Process exec(String command) throws IOException

代码如下：

public class RuntimeDemo02
{
	public static void main(String args[]){
		Runtime run=Runtime.getRuntime();	//通过Runtime类中的静态方法返回一个Runtime类的实例
		try{
			run.exec("notepad.exe");	//启动记事本程序
			run.exec("C:\\Program Files\\KuGou7\\kugou7.exe");	//启动本机酷狗音乐
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
}

以上代码启动了一个进程，那么run.exec(String command)返回的是Process类型，那么通过Process类中的destroy()方法可以结束当前进程。

public class RuntimeDemo03
{
	public static void main(String args[]){
		Runtime run=Runtime.getRuntime();	//通过Runtime类中的静态方法返回一个Runtime类的实例
		Process pro=null;
		try{
			pro=run.exec("notepad.exe");	//启动记事本程序
		}catch(Exception e){
			e.printStackTrace();
		}
		try{
			Thread.sleep(3000);		//当前线程休眠3秒钟，记事本打开3秒
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		pro.destroy();	//结束当前进程 关闭记事本
	}
	
}

System类

System.out.println()本身是一个系统提供好的类。而且out.println()方法也是经常使用到的。

System类是一些与系统相关的属性和方法的集合在System类中所有的属性都是静态的。

其中public static void exit(int status)方法和public static void gc()方法之前都有介绍，而public static void gc()实际上就是调用的Runtime类中得gc方法。

public static long currentTimeMills()用法如下：

public class SystemDemo01
{
	public static void main(String args[]){
		long startTime=System.currentTimeMillis();	//取得开始计算之前的时间
		int sum=0;	//声明变量
		for(int i=0;i<400000000;i++){	//执行累加操作
			sum+=i;
		}
		long endTime=System.currentTimeMillis();	//取得计算之后的时间
		System.out.println("操作用时："+(endTime-startTime)+"毫秒");	//取得操作用时
	}
}

列出本机的全部系统属性：

public class SystemDemo02
{
	public static void main(String args[]){
		System.getProperties().list(System.out);
	}
}

效果图如下：

此处得到的是全部的属性，如果想得到指定的属性，通过键值找到value；

public class SystemDemo03{
	public static void main(String args[]){
		System.out.println("系统版本：" + System.getProperty("os.name")
			+ System.getProperty("os.version")
			+ System.getProperty("os.arch")) ;
		System.out.println("系统用户：" + System.getProperty("user.name")) ;
		System.out.println("当前用户目录：" + System.getProperty("user.home")) ;
		System.out.println("当前用户工作目录：" + System.getProperty("user.dir")) ;
	}
};

垃圾对象的回收

一个对象如果不使用，则肯定要等待进行垃圾收集，垃圾收集可以自动调用也可以是手工调用，手工调用的时候就是调用System.gc()或 Runtime.getRuntime().gc();但是，如果一个对象要在被回收之前需要做一些收尾的工作，则就要覆写Object类中的

protected void finalize() throws Throwable()方法：

在对象被回收之前调用，以处理对象回收的若干操作，例如释放资源等。

class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age;
	}
	public String toString(){	// 覆写toString()方法
		return "姓名：" + this.name + "，年龄：" + this.age ;
	}
	public void finalize() throws Throwable{	// 对象释放空间时默认调用此方法
		System.out.println("对象被释放 --> " + this) ;
	}
};
public class SystemDemo04{
	public static void main(String args[]){
		Person per = new Person("张三",30) ;
		per = null ;	// 断开引用
		System.gc() ;		// 强制性释放空间
	}
};

只有强制性调用gc()方法的时候才可以发现对象被调用，当然，如果不调用，则系统也会在一定的时间内进行自动回收。

总结：对象的生命周期：初始化à对象实例化à垃圾收集à对象终结à卸载