java常用类库

   1.StringBuffer

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

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

StringBuffer类的应用：频繁修改字符串的内容，用String类是不合适的，此时应该用StringBuffer。

    2.Runtime类

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

    每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。应用程序不能创建自己的 Runtime 类实例。

本类的构造方法被私有化了。

可用Runtime类得到内存使用情况。maxMemory()最大内存,freeMemory()当前空闲内存,gc()垃圾回收。

2.1 Runtime与Process类

除了观测内存使用量之外，也可以直接使用Runtime类运行本机的可执行程序，如，调用记事本等。

public Process exec(String command)throws IOException

exec()返回的是Process类对象。

3. 国际化程序

显示不同国家文字。根据不同的语言环境找到不同的资源文件，之后从资源文件中取出内容，资源文件中的内容都是以key->value形式保存，所以在读取的时候通过key找到对应的value。

三个类：

java.util.Locale：用于表示一个国家的语言类。

java.util.ResourseBundle：用于访问资源文件。

java.text.MessageFormat：格式化资源文件的占位符。

3.1 Locale类

    Locale表示的是本地，实际上使用的是一个ISO编码的封装类。对于各个国家来说都存在一个唯一的编码，那种编码称为ISO编码，使用Locale可以指定一个具体的国家编码。

如：中国：zh-CN。 英语 -美国：en-US。法语：fr-FR。

3.2 ResourseBundle

    此类是专门完成属性文件读取操作的，读取的时候直接指定文件名称即可（此文件名称一般不需要指定后缀，后缀统一为*.properties）。可以根据Locale所指定的区域码来自动选择所需要的资源文件。

public static final ResourceBundle getBundle(String baseName, Locale locale)                                           Locale locale)

指定操作的资源文件，并传人Locale对象。

资源文件命名最好首字母大写。

3.3 处理动态文本

在资源文件中进行一些动态文本的配置，设置占位符，这些符号中的内容暂时不固定，而是在程序执行的时候由程序进行设置的，要实现这样的功能，则必须使用java.text.MessageFrom类。

在Fromat类中还存在数字格式化的Fromat（NumberFormat）、日期格式化的Fromat（DateFromat）。

占位符使用{数字}的形式表示，第一个内容"{0}"、"{1}"表示第二个内容。

在MessageFormat类中主要用format（）方法，处理动态文本。

public static String format(String pattern,Object... arguments)

3.4 使用一个类代替资源文件

也可以直接使用一个类来存放所有的资源文件内容，但是此类在操作的时候必须继承一个类java.util.ListResourceBundle.

4 System类

System类是一些与系统相关的属性和方法的集合，而且在System类中所有的属性都是静态的，要想引用这些属性和方法，直接使用System类调用。

System类中除了可以进行内容的输出外，还可以通过方法肚饿一个操作的计算时间。

还可以列出本机的全部系统属性。

4.1 对象的垃圾回收

手动调用的时候就是调用System.gc()或者Runtime.getRuntime().gc().但是一个对象在回收之前需要做的一些收尾工作，就必须覆写Object类中的

protected void finalize()throws Throwable

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

5 日期类

java.util.Date类和抽象的java.util.Calendar类。

java.text.DateFormat和java.text.SimpleDateFormat类。格式化Date类对象。

public abstract class DateFormat extends Format

public class SimpleDateFormat extends DateFormat

getDateInstance()和getDateTimeInstance()获得DateFormat实例。

SimpleDateFormat类的功能是完成日期的显示格式化的，如在开发中可能会将一种日期格式变为另一种日期格式。

需要一个模板，在使用SimpleDateFormat时，必须注意的是在构造对象是要传人匹配的模板。

构造方法：

public SimpleDateFormat(String pattern)

转换：

public Date parse(String source)throws ParseException //是DateFormat类继承过来的

格式化：

public final String format(Date date) //是DateFormat类继承过来的

        String strDate = "2015-10-28 09:24:17.382";
        String part1 = "yyyy-MM-dd HH:mm:ss.SSS";
        //第一个模板，从字符串中提取日期数字
        String part2 = "yyyy年MM月dd日  HH时mm分ss秒SSS毫秒";
        //第二个模板，将提取出的日期数字转换为指定格式日期
        Date d = null;
        SimpleDateFormat smd1 = new SimpleDateFormat(part1);
        SimpleDateFormat smd2 = new SimpleDateFormat(part2);
        try{
            d = smd1.parse(strDate);//将给定字符串提取成日期
        }catch(ParseException e){
            e.printStackTrace();
        }
        
        System.out.println(smd2.format(d));//转换形式。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
String date = sdf.format(new Date());

6 Math类和Random

参考API，注意用Math.round（）求四舍五入的时候，是将小数点之后的内容全部忽略。如果需要进行准确位数的四舍五入，需要使用BigDecimal类完成。

java.util.Random类：参考API

7 NumberFormat

数字格式化显示。MessageFormat、DateFormat、NumberFormat是三个Format类的常用子类。

public abstract class NumberFormat extends Format//可以由静态方法getInstance（）获得实例。

常用子类：DecimalFormat，主要用来格式化数字使用，比直接用NumberFormat更加方便，因为可以直接指定按用户自定义的方式进行格式化操作，与DateFormat和SimpleDateFormat类似。要想进行自定义格式化操作，必须指定格式化操作模板。

8 BigInteger和BigDecimal

两个大数类：

整数：java.math.BigInteger

小数：java.math.BigDecimal

9 对象克隆

必须实现Cloneable接口，（Cloneable接口没有内容，属于标示接口）

protected Object clone()throws CloneNotSupportedException

10 Arrays

java.util.Arrays是数组的操作类，定义在java.util包中，主要实现数组元素的查找，数组内容的填充、排序等。

常见的方法：

public static int binarySearch(byte[] a,byte key)//二分查找

public static boolean equals(boolean[] a, boolean[] a2) //比较

public static String toString(boolean[] a)

public static void fill(boolean[] a,boolean val)

11 比较器

Comparable接口的作用：使用Arrays.sort(Object [] obj)排序的时候，对象数组所属的类必须是实现了Comparable<T>接口的类。实现public int comparaTo(Object obj)方法。

比较器的排序原理：

是二叉树排序算法：使用第一个元素作为根节点，之后如果后面的内容比根节点小，则放左子树，大则右子树

class BinaryTree{
    class Node{
        private Comparable data;
        private Node left;
        private Node right;
        public void addNode(Node node){
            if(this.data.compareTo(node.data)>0)
                if(this.left==null)this.left=node;
                else
                    this.left.addNode(node);
            else
                if(this.right==null)this.right=node;
                else
                    this.right.addNode(node);
        }
        public void printNode(){
            
            if(this.left!=null)
                this.left.printNode();
            System.out.print(this.data+"\t");
            if(this.right!=null)
                this.right.printNode();
        }
        public Node(Comparable data) {
            super();
            this.data = data;
        }
        
    }
    private Node root =null;
    public void add(Comparable data){
        Node node = new Node(data);
        if(this.root == null) this.root = node;
        else this.root.addNode(node);
    }
    public void printTree(){
        if(this.root != null){
            this.root.printNode();
        }
        
        
    }
}

Comparator比较器

如果一个类已经开发完成，但是在此类建立的初期并没有实现Comparable这样的接口，此时是无法对对象进行排序操作的，所以为了解决这样的problem（敏感字为何？），java又定义了另一个比较器的操作接口Comparator。

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

一般的为其写一个实现了Comparator<T>接口的比较器。

利用Arrays.sort排序时，增加一个比较器对象。

public static <T> void sort(T[] a,Comparator<? super T> c)

12 观察者设计模式

要想实现观察者模式，必须依靠java.util包中的Observable类和Observer接口。

被观察者继承Observable类,并在需要观察的地方设置：setChanged（），并通知所有观察者：notifyObservers()。

观察者实现Observer接口：update(Observable o, Object arg)只要改变了 observable 对象就调用此方法。应用程序调用Observable对象的notifyObservers（）方法，以便向所有该对象的观察者通知此改变。

参数：o表示Observeable对象，arg表示需要被观察的内容。

13 正则表达式

java.util.regex.Pattern类和java.util.regex.Matcher类，这两个类是正则的核心操作类。

具体参考API。

要想使用必须使用Pattern类和Matcher类。

Pattern主要表示一个规则的意思，即，正则表达式的规则需要在Pattern类中使用。

Matcher类主要表示使用Pattern指定好的验证规则。

Pattern类中没有明确的构造方法供用户使用，则此类的构造方法被私有化了，则可以直接从Pattern类中取得本类实例。

public static Pattern compile(String regex) //用来指定好操作的正则，实例化Pattern类

public Matcher matcher(CharSequence input) //可以为Matcher类实例化，CharSequence是String的父类

public String[] split(CharSequence input) //拆分

Matcher类中：

public boolean matches() //验证字符串

public String replaceAll(String replacement) //字符串替换

具体：

1. 需要一个正则表达式字符串pattern
   

2. 用Pattern p = Pattern.compile(pattern)实例化Pattern对象

3. 用Matcher m = p.matches(str)来实例化一个Matcher对象。验证字符串str与正则表达式。
   

4. 后续操作

String类对正则的支持：

public boolean matches(String regex)

public String replaceAll(String regex, String replacement)

public String[] split(String regex)

这三个方法支持正则表达式。

14 定时调度

定时调度：每当一段时间，程序会自动执行，称为定时调度。

如果要使用定时调度，则必须保证程序始终运行才可以，就是相当于定时调度是在程序之外又启动了一个新的线程。

Time类是一种线程设施，可以用来实现在某一个时间或某一段时间后，安排某一个任务执行一次，或定期重复执行。该功能与TimeTask配合使用。TimeTask类用来实现由Timer安排的一次或重复执行的某一个任务。

每一个Timer对象对应的是一个线程，因此计时器所执行的任务应该迅速完成。否则可能会延迟后续任务的执行，而这些后续的任务完成后才能快速连续执行。

Timer类的schedule()与scheduleAtFixedRate()方法的区别：

schedule（）方法的执行时间间隔永远是固定的，如果之前出现了延迟的情况，之后也会继续按照设定好的时间间隔时间来执行。

scheduleAtFixedRate()方法可以根据出现的延迟时间自动调整下次间隔的执行时间。