Java常用类库（一）

StringBuffer类

String类的特点：

String类的对象有两种实例化方式，一种是直接赋值，只会开辟一块堆内存空间，而且对象可以自动入池，另外一种方式使用构造方法完成，会开辟两块空间，有一块空间将成为垃圾，并且不会自动入池，但是可以通过intern()方法手工入池；
字符串常量一旦声明则不可改变，而字符串对象可以改变，但是改变的是其内存地址的指向；

通过以上的几个特点就可以清楚的发现，String类是表示字符串使用最多的类，但是其不适合于被频繁修改的字符串操作上，所以在这种情况下，往往可以使用StringBuffer类，

即：StringBuffer类方便用户进行内容的修改。在String类之中使用“+”作为数据库的连接操作，而在StringBuffer类之中使用append()方法进行数据的连接。

范例：使用StringBuffer操作，StringBuffer的内容可以改变

public class TestDemo {
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("Hello ").append("World ."); // 连接内容
		fun(buf);
		System.out.println(buf);
	}
	public static void fun(StringBuffer temp) {
		temp.append("\n").append("Hello");
	}
}

StringBuffer类在日后主要用于频繁修改字符串的操作上，但是在任何的开发之中，面对字符串的操作，98%都先考虑String，只有那2%会考虑StringBuffer。

String、StringBuffer比较

String类	StringBuffer类
public final class String extends Object implements Serializable, Comparable, CharSequence	public final class StringBuffer extends Object implements Serializable, CharSequence

String和StringBuffer类都实现了一个CharSequence接口，所以CharSequence最简单的理解做法就是传字符串，但是虽然这两个类是同一个接口的子类，不过这两个类对象之间却不能互相直接转型。

操作一：将String变为StringBuffer

方法一：直接利用StringBuffer类的构造方法，public StringBuffer(String str)

public class TestDemo {
   	public static void main(String[] args) throws Exception {
   		String str = "Hello World ." ;
   		StringBuffer buf = new StringBuffer(str);
   		System.out.println(buf);
   }
}

方法二：利用StringBuffer类的append()方法

public class TestDemo {
	public static void main(String[] args) throws Exception {
		String str = "Hello World ." ;
		StringBuffer buf = new StringBuffer();
		buf.append(str) ;
		System.out.println(buf);
	}
}

操作二：将StringBuffer变为String

利用StringBuffer类的toString()方法完成

public class TestDemo {
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("Hello World .") ;
		String str = buf.toString() ;
		System.out.println(str); 
	}
}

在StringBuffer类特有方法

字符串反转操作，public StringBuffer reverse()

public class TestDemo {
public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("Hello World .") ;
		System.out.println(buf.reverse()); 
	}
}

替换指定范围内的数据，public StringBuffer replace(int start, int end, String str)

public class TestDemo {
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("Hello World .") ;
		System.out.println(buf.replace(6, 12, "Hello")); 
	}
}

在指定位置上插入数据，public StringBuffer insert(int offset, 数据类型变量)

public class TestDemo {
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("World .").insert(0, "Hello ") ;
		System.out.println(buf); 
	}
}

面试题：请解释String和StringBuffer的区别？

String的内容不可改变，而StringBuffer的内容可以改变。

Runtime类

简介

在每一个JVM进程之中，都会存在一个运行时的操作类的对象，而这对象所属的类型就是Runtime类。
Runtime类之中并没有构造方法定义，其构造方法实际上存在只是不被外部看见而已，因为构造方法被私有化了，这是一个标准的单例设计模式，既然是单例设计模式则在这个类就一定会存在一个static型的方法，可以取得本类的实例化对象：public static Runtime getRuntime()。
而当取得了这个类的实例化对象之后，可以利用这个类取得一些JVM的信息，例如：
- 取得最大可用内存：public long maxMemory()；
- 总共可以使用的内存：public long totalMemory()；
- 空闲的内存：public long freeMemory()。
取得内存信息的时候所有的数据返回的类型是long，long型数据的使用基本两种情况：表示文件大小、表示日期时间。

扫描二维码关注公众号，回复： 9305462 查看本文章

重要方法

在Runtime类有一个非常重要的方法：public void gc()，运行垃圾收集器，释放垃圾空间。

public class TestDemo {
	public static void main(String[] args) throws Exception {
		Runtime run = Runtime.getRuntime() ;	// 取得对象
		System.out.println("1.MAX_MEMORY：" + run.maxMemory());
		System.out.println("1.TOTAL_MEMORY：" + run.totalMemory());
		System.out.println("1.FREE_MEMORY：" + run.freeMemory());
		String str = "" ;
		for (int x = 0; x < 30000; x++) {
			str += x ;	// 产生垃圾
		}
		System.out.println("2.MAX_MEMORY：" + run.maxMemory());
		System.out.println("2.TOTAL_MEMORY：" + run.totalMemory());
		System.out.println("2.FREE_MEMORY：" + run.freeMemory());
		run.gc() ;
		System.out.println("3.MAX_MEMORY：" + run.maxMemory());
		System.out.println("3.TOTAL_MEMORY：" + run.totalMemory());
		System.out.println("3.FREE_MEMORY：" + run.freeMemory());
	}
}

运行本机程序

使用的方法：public Process exec(String command) throws IOException

此方法返回一个 Process 类的对象实例，那么此类可以用于进程的控制。

销毁进程：public void destroy()

/**
 *运行：notepad.exe
 */
package org.lxh.api.runtimedemo;
public class RuntimeDemo02 {
	public static void main(String[] args) throws Exception {
		Runtime run = Runtime.getRuntime();
		Process pro = run.exec("notepad.exe"); // 运行程序
		Thread.sleep(2000) ;
		pro.destroy() ;
	}
}

面试题：请解释一下什么叫gc()？Java是如何处理的？

GC（Garbage Collector）：垃圾收集器，可以释放掉垃圾空间所占用的内存。在java之中GC有两种方式处理：一种是由JVM不定期的执行GC操作，另外一种是由用户自己手工调用Runtime类的gc()方法进行垃圾空间的释放。

System类

数组排序的方法定义：

之前的格式：System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，长度) ;
System类定义：public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)。

取得当前日期时间的方法：public static long currentTimeMillis()。

使用System类的currentTimeMillis()方法来统计一个操作所花费的时间

public class TestDemo {
	public static void main(String[] args) throws Exception {
		long start = System.currentTimeMillis();
		String str = "";
		for (int x = 0; x < 30000; x++) {
			str += x; // 产生垃圾
		}
		long end = System.currentTimeMillis();
		System.out.println("花费的时间：" + (end - start));
	}
}

在日后的许多开发之中，都会出现自动统计操作时间的功能，出现之后应该可以立刻清楚是通过System.currentTimeMilllis()方法完成的。

System类之中的GC：public static void gc()

这个gc()方法并不是一个新的操作方法，而是间接调用了Runtime类之中的gc()方法，不表示一个重写的方法。
finalize()方法
- 如果说一个对象产生的话，可以通过构造方法处理一些对象产生时的操作，但是，当一个对象被回收了呢没有像C++那样的析构函数（对象回收前的收尾），如果现在希望在一个对象收尾的时候执行一些收尾工作，则对象所在的类可以实现一个finalize()方法，此方法由Object类定义：protected void finalize() throws Throwable。在对象回收之前有可能出现异常或者是错误，但是即使出现了，这些错误或者是异常都不会影响程序的执行，即：不会因为异常而导致程序的中断执行。
```
class Person {
	public Person() {
		System.out.println("出生。。。。。");
	}
	@Override
	protected void finalize() throws Throwable {
		System.out.println("回收。。。。。");
		throw new Exception("祸害人间。"); // 抛异常了
	}
}
public class TestDemo {
	public static void main(String[] args) throws Exception {
		Person per = new Person();
		per = null; // 消失了
		System.gc() ;
	}
}
```

面试题：请解释final、finally、finalize的区别？

final表示终结器，用于定义不能被继承的父类，不能被覆写的方法，常量；
finally是异常处理的出口；
finalize()是Object类定义的一个方法，用于执行对象回收前的收尾操作。

日期操作类

简介

对于简单java类，是可以和数据表进行完整映射的，但是对于数据表的日期型字段却一直没有映射，而在Java之中，如果要想表示出日期型，则使用java.util.Date类完成。

如果要想通过这个类取得当前的日期时间，那么只需要直接实例化Date类对象即可：public Date()。

import java.util.Date;
public class TestDemo {
	public static void main(String[] args) throws Exception {
		Date date = new Date();
		System.out.println(date); // Tue Dec 18 10:02:28 CST 2012
	}
}

long和日期时间的转换

在Date对象之中本身是包含了日期时间数据，但是如果要想让其和long数据之间互相转换

方式一：将Date型数据变为long型数据，public long getTime()

import java.util.Date;
public class TestDemo {
	public static void main(String[] args) throws Exception {
		Date date = new Date();
		long num = date.getTime() ;
		System.out.println(num);
	}
}

方式二：将long型变为日期型数据，public Date(long date)

import java.util.Date;
public class TestDemo {
	public static void main(String[] args) throws Exception {
		Date date = new Date(System.currentTimeMillis());	// long --> Date
		System.out.println(date);
	}
}

日期格式化操作类：SimpleDateFormat

在Java之中也可以通过java.text.SimpleDateFormat类完成TO_CHAR()函数的功能和TO_DATE()函数的功能。
核心三个方法：
- 构造方法：public SimpleDateFormat(String pattern)；
- 将日期格式化为字符串：public final String format(Date date)；
- 将字符串格式化为日期：public Date parse(String source) throws ParseException；

标记：

年（yyyy）、月（MM）、日（dd）、时（HH）、分（mm）、秒（ss）、毫秒（SSS）。

/**
 * 将日期转化为字符串
 */
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDemo {
	public static void main(String[] args) throws Exception {
		Date date = new Date(); // 当前日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
		String str = sdf.format(date); // 将日期格式化为字符串
		System.out.println(str);
	}
}

/**
 *将字符串格式化为日期
 */
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDemo {
	public static void main(String[] args) throws Exception {
		String str = "1980-09-19 12:12:12.122";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
		Date date = sdf.parse(str); // 将字符串变为日期
		System.out.println(date);
	}
}

注意
- 完成了以上的代码之后，实际上对于数据表和简单Java类的映射就应该彻底完成了，数据库之中的日期时间可以通过java.util.Date进行表示。
- 字符串可以向基本数据类型（包装类）、日期类型（SimpleDateFormat）进行转换，反过来，基本数据类型（String.valueOf()）和日期类型（SimpleDateFormat）也可以向字符串进行转换。

Calendar 类

Calendar 类是采用手工的方式取得日期，可以通过此类精确到毫秒，此类的定义如下：

public abstract class Calendar extends Object
implements Serializable, Cloneable, Comparable<Calendar>

这个类本身是一个抽象类，抽象类要想实例化肯定使用子类：GregorianCalendar

public class CalendarDemo {
	public static void main(String[] args) {
		
		Calendar calendar = new GregorianCalendar();
		
		System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
		System.out.println("MONTH: " + (calendar.get(Calendar.MONTH) + 1));
		System.out.println("DATE: " + calendar.get(Calendar.DATE));
		System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
		System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
		System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
		System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
	}
}

随机数类：Random

java.util.Random的主要目的是产生随机数

/**
 *产生10个0~100之间的正整数
 */
import java.util.Random;
public class TestDemo {
	public static void main(String[] args) throws Exception {
		Random rand = new Random();
		for (int x = 0; x < 10; x++) {
			System.out.println(rand.nextInt(101));
		}
	}
}

数学公式类：Math

在java.lang.Math类之中定义了所有的与数学有关的基本公式，在这个类之中所有的方法都是static型的方法

强调一个方法：round()，public static long round(double a)，表示四舍五入。

public class TestDemo {
	public static void main(String[] args) throws Exception {
		System.out.println(Math.round(15.5)); // 16
		System.out.println(Math.round(15.51)); // 16
		System.out.println(Math.round(15.6)); // 16
		System.out.println(Math.round(15.2356)); // 15
		System.out.println(Math.round(-15.5)); // -15
		System.out.println(Math.round(-15.51)); // -16
		System.out.println(Math.round(-15.6)); // -16
	}
}

如果现在使用的是Oracle的round()函数，那么对于-15.5的结果一定是-16，但是Java的Math.round()方法不太一样：如果是负数，其小数位的数值小于5的话，那么不会进位，如果大于了5，才会进位。

槑！

发布了109 篇原创文章 · 获赞 47 · 访问量 3万+

私信关注