常用类库

StringBuffer类

在java中，字符串使用String类进行表示，但是String类所表示的字符串有个最大的问题：“字符串常量一旦声明则不可改变，而字符串对象可以改变，但是改变的是其内存地址的指向”。所以String类不适于被频繁修改，在这种情况下就可以使用StringBuffer类，而在StringBuffer类中使用**append()**方法进行数据的连接。
范例：

常见的面试题有：
一个类是否可以继承String类？
不能继承。String类使用了final定义，所以不可以被其他类继承。

String类和StringBuffer类有哪些联系：

通过比对发现这两个类都实现了CharSequence接口，该接口如下：

虽然这两个类都是同一个接口的子类，不过这两个类对象之间却不能互相直接转型，必须通过public StringBuffer(String str)构造方法或toString()方法实现实例化对象的转换，
方法一(构造方法)：

方法二（toString()）：

StringBuffer除了可以改变内容这一个特点之外，也同样定义了许多String类中没有的方法。

字符串的反转操作：public StringBuffer reverse()。
替换指定范围内的数据：public StringBuffer replace(int start,int end, String str)。
在指定位置上插入数据：public StringBuffer insert(int offset, 数据类型 变量)。
常见的面试题：请解释String和StringBuffer的区别。
String 的内容不可改变，而StringBuffer 的内容可以改变。如果需要对字符串数据进行频繁修改，只能使用StringBuffer 类。

Runtime类

在每一个JVM进程中，都会存在一个运行时的操作类的对象，而对象的所属的类型就是Runtime类。这个类只有私有化的构造方法，是标准的单例设计模式。既然是单例设计模式则在这个类中就一定存在一个static型的方法，可以取得本类的实例化对象：public static Runtime getRuntime()。

Runtime类中还有一个非常重要的方法：public void gc()，它在运行垃圾收集器吗，释放垃圾空间，即调用此方法后所产生的垃圾空间将被释放。

常见面试题：什么叫gc()？ Java是如何处理的？

System类

此类属于操作类，这个操作类提供一些系统的支持操作，常用方法如下：

关于数组拷贝：
arraycopy()方法格式解析
System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，长度)；

System类的currentTimeMills()方法来统计一个操作所花费的时间。
范例：

如果希望在一个对象收尾时执行一些收尾公祖，则对象所有的类可以实现一个finalize()方法，此方法有Object类定义。
对象回收：protected void finalize() throws Throwable。
提问：为什么finalize() 方法上抛出的是Throwable？
答：在进行对象回收前，有可能代码会产生异常(Exception)，或者由于JVM的一些问题产生（Error），但是不管出现任何的异常或者是错误，都不会导致程序中断执行，这样写只是为了强调finalize()方法的完善性。

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

日期操作类

日期时间类：java.util.Date

java.util.Date类的主要操作方法如下所示：

取得当前的日期时间。

关于long和日期时间的转换。

日期格式化操作类：SimpleDateFormat

虽然使用java.util.Date 类可以明确地取得当前的日期时间，但是最终数据的显示格式并不方便阅读，故考虑格式化操作，而这一操作就需要用过java.text.SimpleDateFormat 类完成。

将日期变为字符串，格式化显示，代码范例：

import java.util.Date;

public class Date_Demo{
public static void main(String[] args){
		  Date date = new Date(); 
		  SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); 
		  String str =sdf.format(date); 
		  System.out.println(str);
		  }
}

将字符串变为日期格式，代码范例：

import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;

public class Date_Demo{
public static void main (String[] args) throws ParseException{
String str = "1981-09-19 12:12.122";//字符串
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
	Date date = sdf.parse(str);//将字符串变为日期
	System.out.println(date);
	}
}

随机数类：Random

导入import java.util.Random;包

格式：
Random rd = new Random();

数学公式类Math

导入java.lang.Math包，在这个类中的所有方法都是static型的方法，而这个类中只强调一个方法round()，public static long round(double a)表示四舍五入。
格式：
Math.round(15.5);//计算结果：16

大数字操作类

1、基本的大数字操作方法


BigInteger代码演示：

2、大小数操作类：BigDecimal
使用这个类最方便的操作就是可以进行准确位数的四舍五入计算，如下表：

数组操作类：Arrays

Arrays是一个定义在java.util包中专门进行数组的操作类，在这个类中定义了所有的与数组有关的基本操作：二分查找、相等判断、数组填充等。如下图所示：

比较器

如果想为一组对象进行排序，那么必须有一个可区分出对象大小的关系操作，这个操作在java中就是利用比较器完成的，java中提供了两种比较器支持：java.lang.Comparable 和 java.util.Comparator。

常用的比较器（Comparable）

Comparable接口的定义：

public interface Comparable<T>{
public int compareTo (T o);
}

用户覆写此方法时只需要返回3种结构：1 (>0) , -1 (<0) , 0 (=0)。

实现比较器的范例：

import java.util.Arrays;

class Person implements Comparable<Person> {
	private String name;
	private int age;

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name= " + name + "，age= " + age + "]\n";
	}

	@Override
	public int compareTo(Person o) {
		if (this.age > o.age) {
			return 1;
		} else if (this.age < o.age) {
			return -1;
		} else {
			return 0;
		}
	}
}

public class Comparable_Demo {
	public static void main(String[] args) {
		Person per[] = new Person[] { new Person("张三", 20), new Person("李四", 19), new Person("王五", 21) };
		Arrays.sort(per);
		System.out.println(Arrays.toString(per));
	}
}

实现了COmparable接口就可以通过Arrays类的 sort()方法进行数组排序了。以后不管是何种情况下，只要牵扯到对象数组排序的操作，永远都要使用比较器Comparable。

挽救的比较器（Comparator）

Comparator接口定义：

public interface Comparator<T>{
public int compare(T o1,T o2)；
public boolean equals(Object  obj)；
}

在comparator()方法上存在两个参数用于比较大小，而想要使用这个接口，需要单独定义一个比较规则类。
使用Comparator比较：public static void sort(T[] a, Comparator<? super T> c)

class PersonComparator implements Comparator<Person>{
@Override
public int compare(Person o1,Person o2){
if(o1.getAge() > o2.getAge()){
	return 1;
}else if (o1.getAge() < o2.getAge()){
	return -1;
}else{
	return 0;
		}
	}
}
public class TestDemo{
	public static void main(String[] args)throws Exception{
		Person per[] = new Person[]{new Person("张三",20),new Person("李四",19)
		,new Person("王五",21)};
		Arrays.sort(per,new PersonComparator());
		System.out.println(Arrays.toString(per));
	}
}

常见面试题：请解释Comparable 比较器和 Comparator 比较器的区别。
java.lang.Comparable 是在一个类定义时默认实现好的接口，里面只有一个compareTo()方法；
java.util.Comparator 是需要单独定义一个比较的规则类，里面有两个方法：compare() 和 equals()。

对象克隆

克隆就是对象的复制操作，在Object类中存在一个clone()方法。
克隆方法：protected Object clone() throws CloneNotSupportedException。
异常意为（不支持的克隆异常）

class Person{
	private String name;
	private int age;
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	 public String toString() {
		 return "Person [name= " + name + "，age= " + age + "]\n";
	 }
	@Override
	protected Object clone()throws CloneNotSupportedException {
		return super.clone();
	}
}

public class Clone_Demo {
public static void main(String[] args)throws Exception {
	Person per = new Person ("张三",20);
	Person p = (Person)per.clone();
	p.setName("王五");
	System.out.println(per);
	System.out.println(p);
	}
}

正则表达式

常用的正则匹配符号

String类对正则的支持

反射机制

反射：就是一种查找的方法，通过对象找到类。
映射：就是指的是一对一的关系。

反射的思想就是与正常“正”的思想，从类产生实例化对象，相反，“反”体现在通过对象去找到相应的类。

反射的深入应用

1、调用构造

范例：通过反射调用指定参数的构造实例化对象

package extendexer;

import java.lang.reflect.Constructor;

class Person{
	private String name;
	private int age;
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person[name=" +name +",age=" +age+"]";
	}
}

public class Fanshe_Test {
public static void main(String[] args)throws Exception {
	Class<?> cls = Class.forName("extendexer.Person");
	//取得指定参数类型的构造方法，传递两个参数类型的Class对象。
	Constructor<?> cons = cls.getConstructor(String.class,int.class);
	Object obj = cons.newInstance("张三",13);
	System.out.println(obj);
	}
}

程序结果：Person[name= 张三,age= 20]
本程序通过getConstructor()方法取得了一个指定参数类型的构造方法，而后利用Con身体乳投入类中的newInstance()方法设置了两个参数的内容，这样就相当于调用了类中有两个参数的构造方法。

注意： 反射机制在开发中处处使用，所以要尽可能的提供无参构造。
在任何的框架开发技术中心，其核心都是利用了“XML解析+反射机制”这一概念完成的，载入后学习开源框架的开发中，可以发现很多配置都要求写出类的完整名称（包 . 类名称），这种配置都是要通过反射机制的方式进行对象实例化后使用的。

2、调用普通方法

代码范例：取得一个类中所定义的全部方法。

class Person{
//略
}
public class TestDemo{
public static void main(String[] args)throws Exception{
	Class<?> cls = Class.forName("extendexer.Person");
	Method met[] = Class.getMethods();
	for(int x=0;x<met.length;x++){
		System.out.println(met[x]);
		}
	}
}

取得Method类对象后可以直接利用反射调用类中的方法，调用方法为：

之前调用类中的方法时使用的都是“对象 . 方法”，但是现在有了反射后可以直接利用Object类调用指定子类的操作方法。

范例：利用反射调用Person类中的setName()、getName()方法。

package extendexer;

import java.lang.reflect.Method;

class Person {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

public class Fanshe_Test {
	public static void main(String[] args) throws Exception {
		Class<?> cls = Class.forName("extendexer.Person");
		// 取得指定参数类型的构造方法，传递两个参数类型的Class对象。
		Object obj = cls.newInstance();
		String attribute = "name";
		Method setMet = cls.getMethod("set" + initcap(attribute), String.class);
		Method getMet = cls.getMethod("get" + initcap(attribute));
		setMet.invoke(obj, "張三");
		System.out.println(getMet.invoke(obj));
	}

	public static String initcap(String str) {
		return str.substring(0, 1).toUpperCase().concat(str).substring(1);
	}
}

运行结果：张三

本程序并没有明确地声明Person类的对象类型，全部的操作都是利用Object类完成的，而利用了Method类中的invoke()方法就可以使用反射的方式进行类中普通方法的调用。

3、调用成员

类中最后一个组成部分就是成员（Field，也可以成为属性），如果要通过反射取得类的成员可以使用下表所列出的方法完成。