/**
     * 读取文本文件内容
     * @param filePathAndName 带有完整绝对路径的文件名
     * @param encoding 文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    public String readTxt(String filePathAndName,String encoding) throws IOException{
     encoding = encoding.trim();
     StringBuffer str = new StringBuffer("");
     String st = "";
     try{
      FileInputStream fs = new FileInputStream(filePathAndName);
      InputStreamReader isr;
      if(encoding.equals("")){
       isr = new InputStreamReader(fs);
      }else{
       isr = new InputStreamReader(fs,encoding);
      }
      BufferedReader br = new BufferedReader(isr);
      try{
       String data = "";
       while((data = br.readLine())!=null){
         str.append(data+" ");
       }
      }catch(Exception e){
       str.append(e.toString());
      }
      st = str.toString();
     }catch(IOException es){
      st = "";
     }
     return st;     
    }

    /**
     * 新建目录
     * @param folderPath 目录
     * @return 返回目录创建后的路径
     */
    public String createFolder(String folderPath) {
        String txt = folderPath;
        try {
            java.io.File myFilePath = new java.io.File(txt);
            txt = folderPath;
            if (!myFilePath.exists()) {
                myFilePath.mkdir();
            }
        }
        catch (Exception e) {
            message = "创建目录操作出错";
        }
        return txt;
    }
   
    /**
     * 多级目录创建
     * @param folderPath 准备要在本级目录下创建新目录的目录路径 例如 c:myf
     * @param paths 无限级目录参数，各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:myfac
     */
    public String createFolders(String folderPath, String paths){
        String txts = folderPath;
        try{
            String txt;
            txts = folderPath;
            StringTokenizer st = new StringTokenizer(paths,"|");
            for(int i=0; st.hasMoreTokens(); i++){
                    txt = st.nextToken().trim();
                    if(txts.lastIndexOf("/")!=-1){
                        txts = createFolder(txts+txt);
                    }else{
                        txts = createFolder(txts+txt+"/");   
                    }
            }
       }catch(Exception e){
           message = "创建目录操作出错！";
       }
        return txts;
    }

   
    /**
     * 新建文件
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @return
     */
    public void createFile(String filePathAndName, String fileContent) {
     
        try {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            FileWriter resultFile = new FileWriter(myFilePath);
            PrintWriter myFile = new PrintWriter(resultFile);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
            resultFile.close();
        }
        catch (Exception e) {
            message = "创建文件操作出错";
        }
    }

    /**
     * 有编码方式的文件创建
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @param encoding 编码方式 例如 GBK 或者 UTF-8
     * @return
     */
    public void createFile(String filePathAndName, String fileContent, String encoding) {
     
        try {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            PrintWriter myFile = new PrintWriter(myFilePath,encoding);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
        }
        catch (Exception e) {
            message = "创建文件操作出错";
        }
    }

    /**
     * 删除文件
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public boolean delFile(String filePathAndName) {
     boolean bea = false;
        try {
            String filePath = filePathAndName;
            File myDelFile = new File(filePath);
            if(myDelFile.exists()){
             myDelFile.delete();
             bea = true;
            }else{
             bea = false;
             message = (filePathAndName+"
删除文件操作出错");
            }
        }
        catch (Exception e) {
            message = e.toString();
        }
        return bea;
    }
   

    /**
     * 删除文件夹
     * @param folderPath 文件夹完整绝对路径
     * @return
     */
    public void delFolder(String folderPath) {
        try {
            delAllFile(folderPath); //删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File(filePath);
            myFilePath.delete(); //删除空文件夹
        }
        catch (Exception e) {
            message = ("删除文件夹操作出错");
        }
    }
   
   
    /**
     * 删除指定文件夹下所有文件
     * @param path 文件夹完整绝对路径
     * @return
     * @return
     */
    public boolean delAllFile(String path) {
     boolean bea = false;
        File file = new File(path);
        if (!file.exists()) {
            return bea;
        }
        if (!file.isDirectory()) {
            return bea;
        }
        String[] tempList = file.list();
        File temp = null;
        for (int i = 0; i < tempList.length; i++) {
            if (path.endsWith(File.separator)) {
                temp = new File(path + tempList[i]);
            }else{
                temp = new File(path + File.separator + tempList[i]);
            }
            if (temp.isFile()) {
                temp.delete();
            }
            if (temp.isDirectory()) {
                delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
                delFolder(path+"/"+ tempList[i]);//再删除空文件夹
                bea = true;
            }
        }
        return bea;
    }

    /**
     * 复制单个文件
     * @param oldPathFile 准备复制的文件源
     * @param newPathFile 拷贝到新绝对路径带文件名
     * @return
     */
    public void copyFile(String oldPathFile, String newPathFile) {
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPathFile);
            if (oldfile.exists()) { //文件存在时
                InputStream inStream = new FileInputStream(oldPathFile); //读入原文件
                FileOutputStream fs = new FileOutputStream(newPathFile);
                byte[] buffer = new byte[1444];
                while((byteread = inStream.read(buffer)) != -1){
                    bytesum += byteread; //字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        }catch (Exception e) {
            message = ("复制单个文件操作出错");
        }
    }
   

    /**
     * 复制整个文件夹的内容
     * @param oldPath 准备拷贝的目录
     * @param newPath 指定绝对路径的新目录
     * @return
     */
    public void copyFolder(String oldPath, String newPath) {
        try {
            new File(newPath).mkdirs(); //如果文件夹不存在 则建立新文件夹
            File a=new File(oldPath);
            String[] file=a.list();
            File temp=null;
            for (int i = 0; i < file.length; i++) {
                if(oldPath.endsWith(File.separator)){
                    temp=new File(oldPath+file[i]);
                }else{
                    temp=new File(oldPath+File.separator+file[i]);
                }
                if(temp.isFile()){
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(newPath + "/" +
                    (temp.getName()).toString());
                    byte[] b = new byte[1024 * 5];
                    int len;
                    while ((len = input.read(b)) != -1) {
                        output.write(b, 0, len);
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if(temp.isDirectory()){//如果是子文件夹
                    copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
                }
            }
        }catch (Exception e) {
            message = "复制整个文件夹内容操作出错";
        }
    }

    /**
     * 移动文件
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFile(String oldPath, String newPath) {
        copyFile(oldPath, newPath);
        delFile(oldPath);
    }
   

    /**
     * 移动目录
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFolder(String oldPath, String newPath) {
        copyFolder(oldPath, newPath);
        delFolder(oldPath);
    }
    public String getMessage(){
        return this.message;
    }
}

很多朋友在深入的接触 JAVA 语言后就会发现这样两个词：反射 (Reflection) 和内省 (Introspector) ，经常搞不清楚这到底是怎么回事，在什么场合下应用以及如何使用？今天把这二者放在一起介绍，因为它们二者是相辅相成的。

反射

相对而言，反射比内省更容易理解一点。用一句比较白的话来概括，反射就是让你可以通过名称来得到对象 ( 类，属性，方法 ) 的技术。例如我们可以通过类名来生成一个类的实例；知道了方法名，就可以调用这个方法；知道了属性名就可以访问这个属性的值。

还是写两个例子让大家更直观的了解反射的使用方法：

上面的两个例子是比较常用方法。看到上面的例子就有人要发问了：为什么要这么麻烦呢？本来一条语句就完成的事情干吗要整这么复杂？没错，在上面的例子中确实没有必要这么麻烦。不过你想像这样一个应用程序，它支持动态的功能扩展，也就是说程序不重新启动但是可以自动加载新的功能，这个功能使用一个具体类来表示。首先我们必须为这些功能定义一个接口类，然后我们要求所有扩展的功能类必须实现我指定的接口，这个规定了应用程序和可扩展功能之间的接口规则，但是怎么动态加载呢？我们必须让应用程序知道要扩展的功能类的类名，比如是 test.Func1 ，当我们把这个类名 ( 字符串 ) 告诉应用程序后，它就可以使用我们第一个例子的方法来加载并启用新的功能。这就是类的反射，请问你有别的选择吗？

       关于方法的反射建议大家看我的另外一篇文章《 利用 Turbine 的事件映射来扩展 Struts 的功能 》，地址是： http://www.javayou.com/article/CSDN/extend_struts.html 。这篇文章详细介绍了如果通过反射来扩展 Struts 框架的功能。

内省

内省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中。

一般的做法是通过类 Introspector 来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器（ PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，然后我们就可以通过反射机制来调用这些方法。下面我们来看一个例子，这个例子把某个对象的所有属性名称和值都打印出来：

Web 开发框架 Struts 中的 FormBean 就是通过内省机制来将表单中的数据映射到类的属性上，因此要求 FormBean 的每个属性要有 getter/setter 方法。但也并不总是这样，什么意思呢？就是说对一个 Bean 类来讲，我可以没有属性，但是只要有 getter/setter 方法中的其中一个，那么 Java 的内省机制就会认为存在一个属性，比如类中有方法 setMobile ，那么就认为存在一个 mobile 的属性，这样可以方便我们把 Bean 类通过一个接口来定义而不用去关心具体实现，不用去关心 Bean 中数据的存储。比如我们可以把所有的 getter/setter 方法放到接口里定义，但是真正数据的存取则是在具体类中去实现，这样可提高系统的扩展性。

总结

将 Java 的反射以及内省应用到程序设计中去可以大大的提供程序的智能化和可扩展性。有很多项目都是采取这两种技术来实现其核心功能，例如我们前面提到的 Struts ，还有用于处理 XML 文件的 Digester 项目，其实应该说几乎所有的项目都或多或少的采用这两种技术。在实际应用过程中二者要相互结合方能发挥真正的智能化以及高度可扩展性。

在字符串匹配问题中，我们期待察看串T中是否含有串P。
其中串T被称为目标串，串S被称为模式串。

2 朴素匹配算法

进行字符串匹配，最简单的一个想法是：

public   class  SimpleMatch  {
   public   int  StringMatch(String target,String patten)  {
       int  tl  =  target.length();
       int  pl  =  patten.length();
       int  i  =   0 ;
       int  j  =   0 ;
       while (i  <  tl  -  pl  &&  j  <  pl)  {
           if (patten.charAt(j)  ==  target.charAt(i + j))
              j ++ ;
           else   {
              j  =   0 ;
              i ++ ;
          }
      }
       if (j  ==  pl)
           return  i;
       return   - 1 ;
  }
  
   public   static   void  main(String[] args) {
      String t  =   " 123456789 " ;
      String p  =   " 456 " ;
      SimpleMatch sm  =   new  SimpleMatch();
      System.out.println(sm.StringMatch(t, p));
  }
}

可以看见，这个算法（假定m>>n）的复杂度是O(mn)，其中m是T的长度，n是P的长度。这种算法的缺陷是匹配过程中带有回溯——准确地说是T串存在回溯，也就是当匹配不成功的时候，之前进行的匹配完全变为无用功，所有的比较需要重新开始。

3 KMP算法

KMP算法是D.E.Knuth、J.H.Morris和V.R.Pratt提出的无回溯的字符串匹配算法，算法的核心思想就是设法在匹配失败的时候，尽量利用之前的匹配结果，消除T串的回溯问题。那么如何消除回溯呢？请看下面的例子：

假设P=abacd，如果T=abax...，当从头开始匹配到字符c时，若c=x，显然，匹配过程继续；当c≠x时，按照朴素的匹配算法，T串会发生回溯，之后T串会从第2个字符b开始重新匹配，而不是从匹配失败的字符x开始继续。但是显然，对于上述的匹配过程，T串不需要从b开始重新匹配，它只需要从x开始和P的b字符继续匹配即可。如下：
匹配过程：
P=abacd
T=abax....
     ^----比较到此处时发生匹配失败
朴素匹配算法：
P= abacd
T=abax...
   ^----回溯到b，重新开始和P的匹配
KMP算法：
P=  abacd
T=abax...
     ^----T串不回溯，从x处继续匹配

现在的问题是，按照KMP算法，匹配失败的时候，P串需要重新调整位置，但是调整的依据是什么？Knuth等人发现，P调整位置的依据和P的构造有关，和T无关。具体来说，定义失效函数：f(j)=k，其中0<=k<=j，且k是使得p₀p₁...p_k-1 = p_j-k+1p_j-k+2...p_j成立的最大整数。建立失效函数的算法如下：
public void Build() {
 if(pattern == null)
  throw new Exception("KMP Exception : null pattern");
 array = new int[pattern.Length];
 int i = 0, s = pattern.Length;
 if(s > 1)
  array[0] = 0;
 for(i = 1; i < s; i++) {
  if(pattern[i] == pattern[array[i - 1]])
   array[i] = array[i - 1] + 1;
  else
   array[i] = 0;
 }
}

匹配过程如下：
public int Match(String target, int start) {
 if(array == null || pattern == null || target == null)
  return -1;
 int target_index = start;
 int pattern_index = 0;
 int token_length = target.Length;
 int pattern_length = pattern.Length;
 while(target_index < token_length && pattern_index < pattern_length) {
  if(target[target_index] == pattern[pattern_index]) {
   target_index++;
   pattern_index++;
  } else {
   if(pattern_index == begin)
    target_index++;
   else
    pattern_index = array[pattern_index - 1];
  }
 }
 if(pattern_index == pattern_length)
  return target_index - pattern_length;
 return -1;
}

4 支持通配符?和*的KMP算法

KMP算法虽然能够进行字符串匹配，但是，在实践中字符串匹配往往还要支持通配符，MS系统中最常见的通配符是?和*。其中，?可以代表一个字符（不能没有），*可以代表任意多个字符（可以为空）。经典的KMP算法针对通配符是无能为力的，但是经过简单的改造，KMP算法也可以识别通配符。

首先是?，根据?的功能，?表示任意字符，也就是说在匹配过程中，?永远匹配成功。因此对匹配函数的修改十分简单：
...
 while(target_index < token_length && pattern_index < pattern_length) {
  if(target[target_index] == pattern[pattern_index]|| pattern[pattern_index] == '?') {
   target_index++;
   pattern_index++;
  } else {
...
建立失效函数的过程和匹配过程类似，修改如下：
...
 for(i = 1; i < s; i++) {
  if(pattern[i] == pattern[array[i - 1]]|| pattern[i] == '?' || pattern[array[i - 1]] == '?')
   array[i] = array[i - 1] + 1;
...

本质上，?并没有修改算法，而仅仅修改了匹配规则——遇到?则一定匹配。然而*与此不同，*的作用是匹配任意多个字符，显然我们不能简单的修改匹配过程而满足要求。如果我们重新思考*的作用，我们会发现*的另一个作用就是分割P串，即如果P=P₁*P₂，那么与其说*代表匹配任意多个字符，不如说P的匹配条件是在匹配P₁子串后再匹配P₂子串。

现在回顾失效函数的作用，如果当匹配到P的j+1位时匹配失败，那么重新开始匹配的时候，P串的位置调整到f(j)位，直到P串的位置调整到0，则匹配重新开始。但当P=P₁*P₂，假如P₁已经匹配成功，而在P₂中发生匹配失败，那么P串要需要调整位置，但P串无论如何调整，此时也不应该调整到0，最多调整到P₂的开始处，因为P₁已经匹配，只需匹配P₂即可。假如P=abcab*abcab，失效函数应该是（注意之前提到*的作用）：
a b c a b * a b c a b
0 0 0 1 2 - 6 6 6 7 8

因此，要想让KMP支持*，那么关键是要重新设计失效函数的建立算法，如下：
public void Build() {
 if(pattern == null)
  throw new Exception("KMP Exception : null pattern");
 array = new int[pattern.Length];
 int i = 0, s = pattern.Length;
 if(s > 1)
  array[0] = 0;
 int begin = 0;
 for(i = 1; i < s; i++) {
  if(pattern[i] == '*') {
   array[i] = i;
   begin = i + 1;
  } else if(pattern[i] == pattern[array[i - 1]] || pattern[i] == '?' || pattern[array[i - 1]] == '?')
   array[i] = array[i - 1] + 1;
  else
   array[i] = begin;
 }
} 

算法中begin表示每段字符串的开始位置。此外，匹配过程也应该进行相应的修改，因为字符*对于匹配没有任何帮助，它属于占位符，因此需要跳过，匹配算法如下：
public int Match(String target, int start) {
 if(array == null || pattern == null || target == null)
  return -1;
 int target_index = start;
 int pattern_index = 0;
 int token_length = target.Length;
 int pattern_length = pattern.Length;
 int begin = 0;
 while(target_index < token_length && pattern_index < pattern_length) {
  if(pattern[pattern_index] == '*') {
   begin = pattern_index + 1;
   pattern_index++;
  } else if(target[target_index] == pattern[pattern_index] || pattern[pattern_index] == '?') {
   target_index++;
   pattern_index++;
  } else {
   if(pattern_index == begin)
    target_index++;
   else
    pattern_index = array[pattern_index - 1];
  }
 }
 if(pattern_index == pattern_length)
  return target_index - pattern_length + begin;
 return -1;
}

5 正则语言和确定状态自动机

一个数字逻辑的问题：设计一个识别11011的电路，解这个问题的关键就是设计出这个电路的DFA，如下：

仔细看看这个状态机，是不是和KMP的算法有几分类似呢？这并不是巧合，因为KMP算法中的失效函数总可以等价的转化为一个DFA。当然KMP的DFA远比识别11011的DFA要复杂，原因在于KMP接受的输入是全体字符集合，识别11011的DFA只接受0和1这两个输入。我们知道，一个正则语言和一个DFA是等价的，而KMP计算失效函数的算法，实际上等价于求DFA的过程，f(j)的值实际上表明状态j+1接受到不正确的字符时应该回溯到的状态（注意此时输入流并没有前进）。普通的字符串都能看成是一个正则语言，含有通配符?和*的字符串也可以等价的转换为一个正则表达式。但是，正则语言的集合远比KMP算法所能支持的模式集合的更大，期间原因还是刚才提过的输入问题。试想P=p₁p₂...p_n，当匹配到p_j的时候，如果下一个输入字符正是p_j，那么状态机进入下一个状态，如果不是p_j，那么状态机按照实效函数的指示转移到状态f(j-1)，也就是说KMP状态机的每个状态只能根据输入是否为p_j来进行转移。而正则表达式所对应的状态机则有所不同，如果正则语言L=l₁l₂...l_n，假设这些都是字母，当匹配到l_j位的时候，如果下一个输入字符正是l_j，那么状态机进入下一个状态，否则它还可以根据输入的值进行转移，例如l_j=c₁时转换到状态x，l_j=c₂时状态转换到y等等。

6 结语

字符串匹配问题是老问题了，并没有太多新意可言，只不过虽然KMP算法十分简单，但它的内在含义还是十分深刻的。横向比较KMP、DFA和正则语言、正则表达式我们会发现，它们之间存在很多的关联，而这种比较也有利于我们更好的理解这些算法，或者改进这些算法。最后说一句，试图利用目前的框架使得KMP算法支持全部种类的通配符（对应于正则表达式就是x?、x*、x+、{m,n}等等）是不可能，而我们也不需要这么做，因为我们还有正则表达式嘛。

版权声明：本文可以自由转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:langm
原文:http://www.matrix.org.cn/resource/article/44/44056_NoClassDefDoundErr.html
关键字:NoClassDefDoundErr ClassNotFoundException

在读这篇文章之前，你最好了解一下Java的Exception机制。

也许你在开发的过程中经常地见到ClassNotFoundException和NoClassDefFoundErr这两个异常，每每看到之后，都会一概而论的是类没有找到，但有些时候见到他们的时候又有些疑惑（至少我是这样），为什么Java要用两个异常来表示类定义没有找到那？他们之间有什么区别那？

正巧今天我又碰到了这个问题，顺便的仔细研究了一下这两个异常的区别。
首先：
ClassNotFoundException直接继承与Exception，它是一个checked的异常。
NoClassDefFoundErr 继承自Error->LinkageError ，它是一个unchecked的异常。

下面让我们看一下两个异常在API文档中的说明

ClassNotFoundException：
当应用尝试用字符串名称通过下面的方法装载一个类时这个类的定义却没有找到时会抛出的异常。
Class.forName
ClassLoader.findSystemClass
ClassLoader.loadClass

NoClassDefFoundErr：
当JVM或者ClassLoader实例尝试装载一个类的定义（这通常是一个方法调用或者new表达式创建一个实例过程的一部分）而这个类定义并没有找时所抛出的错误。
当编译的时候可以找到这个类的定义，但是以后这个类不再存在。

这比较显而易见了吧，读好文档是很重要的事情。这里我就说一下我对这两个类的区别的理解。

ClassNotFoundException异常只出现在你的应用程序主动的装载类的过程中，这个异常很多时候出现在我们的应用框架在初始化或者运行中动态装载已配置的类的过程中。这种情况下我们应该首先检查我们的配置或者参数是否错误，是否企图装载一个并不存在的类，如果配置没有错误，我们就应该查看Classpath是否配置错误而导致ClassLoader无法找到这个类，也应该检查要装载的类是否在一个jar包中而我们在引入这个jar包的过程中是否有遗漏或错误（这里jar包的版本也是一个需要格外注意的问题，很多时候混乱的jar包版本会造成太多的麻烦）。

NoClassDefFoundErr异常一般出现在我们编译环境和运行环境不一致的情况下，就是说我们有可能在编译过后更改了Classpath或者jar包所以导致在运行的过程中JVM或者ClassLoader无法找到这个类的定义（我曾经在编译后作了一次jar包的清理，然后应用就送给了我一个这样的礼物）。

我们经常用SDK开发应用，开发的过程中要引入很多jar包，有些SDK也会设定自己的Classpath。编译过程结束后在运行的过程中就要将已开发的应用和所有引入的jar包拷贝到应用服务器的相应目录下才可以运行，而应用服务器使用的Classpath也很有可能与SDK的不同，在这个过程中就有很大的几率造成双方环境不一致。所以很多开发者就会遇到在SDK中可以编译，运行也没有问题，但是同样的程序放到应用服务器上就出现NoClassDefFoundErr这个异常这种情况，这是让初学者很挠头的一个问题。

以上就是我对这两个异常的一点个人理解，希望对各位开发者有所帮助，可以让各位开发者在以后的开发过程中能够更快的找到问题所在。祝开发顺利

捕获错误最理想的是在编译期，最好在试图运行程序以前。然而，并非所有错误都能在编译期间侦测到。有些问题必须在运行期间解决。让错误的缔结者通过一定的方法预先向接收者传递一些适当的信息，使其知道可能发生什么样的错误以及该如何处理遇到的问题，这就是Java的异常控制机制。
“异常”（Exception）这个词表达的是一种正常情况之外的“异常”。在问题发生的时候，我们可能不知具体该如何解决，但肯定知道已不能不顾一切地继续下去。此时，必须坚决地停下来，并由某人、某地指出发生了什么事情，以及该采取何种对策。异常机制的另一项好处就是能够简化错误控制代码。我们再也不用检查一个特定的错误，然后在程序的多处地方对其进行控制。此外，也不需要在方法调用的时候检查错误（因为保证有人能捕获这里的错误）。我们只需要在一个地方处理问题：“异常控制模块”或者“异常控制器”。这样可有效减少代码量，并将那些用于描述具体操作的代码与专门纠正错误的代码分隔开。一般情况下，用于读取、写入以及调试的代码会变得更富有条理。
若某个方法产生一个异常，必须保证该异常能被捕获，并获得正确对待。Java的异常控制机制的一个好处就是允许我们在一个地方将精力集中在要解决的问题上，然后在另一个地方对待来自那个代码内部的错误。那个可能发生异常的地方叫做“警戒区”，它是一个语句块，我们有必要派遣警探日夜监视着。生成的异常必须在某个地方被捕获和进行处理，就象警察抓到嫌疑犯后要带到警署去询问。这个地方便是异常控制模块。
“警戒区”是一个try关键字开头后面用花括号括起来的语句块，我们把它叫作“try块”。当try块中有语句发生异常时就掷出某种异常类的一个对象。异常被异常控制器捕获和处理，异常控制器紧接在try块后面，且用catch关键字标记，因此叫做“catch块”。catch块可以有多个，每一个用来处理一个相应的异常，因为在“警戒区”内可能发生的异常种类不止一个。所以，异常处理语句的一般格式是：
try {
  // 可能产生异常的代码
  }
 catch (异常对象 e) {
   //异常 e的处理语句
 }catch (异常对象 e1) {
   //异常 e的处理语句
 }catch (异常对象 e2) {
   //异常 e的处理语句
 }

即使不使用try-catch结构，发生异常时Java的异常控制机制也会捕获该异常，输出异常的名称并从异常发生的位置打印一个堆栈跟踪。然后立即终止程序的运行。下面的例子发生了一个“零除”异常，后面的hello没有被打印。

例1 没有作异常控制的程序。

///
public class Exception1 {
    public static void main(String args[]) {
    int b = 0;
    int a = 3 / b;
    System.out.println( "Hello!" );
  }
}
///

输出结果：
java.lang.ArithmeticException: / by zero
at Exception1.main(Exception1.java:5)
Exception in thread "main" Exit code: 1
There were errors

但是如果使用了try-catch来处理异常，那么在打印出异常信息后，程序还将继续运行下去。下面是处理了的代码。

///
// Exception2.java
public class Exception2 {
  public static void main(String args[]) {
   try {  
    int b = 0;  
    int a = 3 / b;
    }
   catch(ArithmeticException e) {
     e.printStackTrace
    }
    System.out.println( "Hello!" );
  }
}
///

输出结果：
Exception:
java.lang.ArithmeticException: / by zero
   at Exception2.main(Exception1.java:5)
Hello!

与前例不同的是，Hello!被输出了。这就是try-catch结构的用处，它使异常发生和处理后程序得以“恢复”而不是“中断”。

2 异常类、异常规范和throw语句

为了使异常控制机制更出色地发挥它的功效，Java设计者几乎所以可能发生的异常，预制了各色各样的异常类和错误类。它们都是从“可掷出”类Throwable继承而来的，它派生出两个类Error和Exception。由Error派生的子类命名为XXXError，其中词XXX是描述错误类型的词。由Exception派生的子类命名为XXXException，其中词XXX是描述异常类型的词。Error类处理的是运行使系统发生的内部错误，是不可恢复的，唯一的办法只要终止运行运行程序。因此，客户程序员只要掌握和处理好Exception类就可以了。
Exception类是一切异常的根。现成的异常类非常之多，我们不可能也没有必要全部掌握它。好在异常类的命名规则大致描述出了该类的用途，而异常类的方法基本是一样的。下面给出lang包中声明的部分异常类。

RuntimeException            运行时异常
NullPointerException        数据没有初始化就使用
IndexOutOfBoundsException   数组或字符串索引越界
NoSuchFieldException        文件找不到
NoSuchMethodException       方法没有定义
ArithmeticException         非法算术运行

在其他包中也有相关的异常类，例如io包中有IOEception类。利用异常的命名规则，你可以使用下面的DOS命令在包所在的目录查看有什么异常类可用：
    DIR *Eception.class 
对于运行时异常RuntimeException，我们没必要专门为它写一个异常控制器，因为它们是由于编程不严谨而造成的逻辑错误。只要让出现终止，它会自动得到处理。需要程序员进行异常处理的是那些非运行期异常。
Throwable有三个基本方法：

• String getMessage()   获得详细的消息。

• String toString()     返回对本类的一段简要说明，其中包括详细的消息（如果有的话）。

• void printStackTrace()  或  void printStackTrace(PrintStream)
  打印出调用堆栈路径。调用堆栈显示出将我们带到异常发生地点的方法调用的顺序。

因为Exception类是一切异常的根，所以对任何一个现有的异常类都可以使用上述方法。

异常规范 和 throws

java库程序员为了使客户程序员准确地知道要编写什么代码来捕获所有潜在的异常，采用一种叫做throws的语法结构。它用来通知那些要调用方法的客户程序员，他们可能从自己的方法里“掷”出什么样的异常。这便是所谓的“异常规范”，它属于方法声明的一部分，即在自变量（参数）列表的后面加上throws 异常类列表。例如
    void f() throws tooBig, tooSmall, divZero { 方法体}
若使用下述代码：
    void f() [ // ...
它意味着不会从方法里“掷”出异常（除类型为RuntimeException的异常以外，它可能从任何地方掷出）。
如果一个方法使用了异常规范，我们在调用它时必须使用try-catch结构来捕获和处理异常规范所指示的异常，否则编译程序会报错而不能通过编译。这正是Java的异常控制机制的杰出贡献，它对可能发生的意外及早预防从而加强了代码的健壮性。
在使用了异常规范的方法声明中，库程序员使用throw语句来掷出一个异常。throw语句的格式为：
    thrownew XXXException();
由此可见，throw语句掷出的是XXX类型的异常的对象（隐式的句柄）。而catch控制器捕获对象时要给出一个句柄 catch(XXXException e)。
我们也可以采取“欺骗手段”，用throw语句“掷”出一个并没有发生的异常。编译器能理解我们的要求，并强迫使用这个方法的用户当作真的产生了那个异常处理。在实际应用中，可将其作为那个异常的一个“占位符”使用。这样一来，以后可以方便地产生实际的异常，毋需修改现有的代码。下面我们用“欺骗手段”给出一个捕获异常的示例程序。

例2 本例程演示异常类的常用方法。

///
public class ExceptionMethods {
  publicstaticvoid main(String[] args) {
    try {
      thrownew Exception("Here's my Exception");
    } catch(Exception e) {
      System.out.println("Caught Exception");
      System.out.println(
        "e.getMessage(): " + e.getMessage());
      System.out.println(
        "e.toString(): " + e.toString());
      System.out.println("e.printStackTrace():");
      e.printStackTrace();
    }
  }
}
///

该程序输出如下：
Caught Exception
e.getMessage(): Here's my Exception
e.toString(): java.lang.Exception: Here's my Exception
e.printStackTrace():
java.lang.Exception: Here's my Exception
        at ExceptionMethods.main

在一个try区中潜在的异常可能是多种类型的，那时我们需要用多个catch块来捕获和处理这些异常。但异常发生时掷出了某类异常对象，Java依次逐个检查这些异常控制器，发现与掷出的异常类型匹配时就执行那以段处理代码，而其余的不会被执行。为了防止可能遗漏了某一类异常控制器，可以放置一个捕获Exception类的控制器。Exception是可以从任何类方法中“掷”出的基本类型。但是它必须放在最后一个位置，因为它能够截获任何异常，从而使后面具体的异常控制器不起作用。下面的示例说明了这一点。

例3 本例程演示多个异常控制器的排列次序的作用。

///
public class MutilCatch {
  private staticvoid test(int i) {
    try {
    int x = i;
    if (x>0)
      throw new ArithmeticException ( "this is a Arithmetic Exception!" );
    else if (x<0)
      throw new NullPointerException ( "this is a NullPointer Exception!" );
    else
       throw new Exception( "this is a Exception!" );
    } catch (ArithmeticException e) {
        System.out.println(e.toString());
    } catch (NullPointerException e) {
        System.out.println(e.toString());
    } catch (Exception e) {
        System.out.println(e.toString());
    }
   }
  public static void main(String[] args) {
    test(-1); test(0); test(1);
  }
  }
///

运行结果：
java.lang.NullPointerException: this is a NullPointer Exception!
java.lang.Exception: this is a Exception!
java.lang.ArithmeticException: this is a Arithmetic Exception!
如果你把捕获Exception的catch放在前面，编译就通不过。

3 用finally清理

我们经常会遇到这样的情况，无论一个异常是否发生，必须执行某些特定的代码。比如文件已经打开，关闭文件是必须的。但是，在try区内位于异常发生点以后的代码，在发生异常后不会被执行。在catch区中的代码在异常没有发生的情况下不会被执行。为了无论异常是否发生都要执行的代码，可在所有异常控制器的末尾使用一个finally从句，在finally块中放置这些代码。（但在恢复内存时一般都不需要，因为垃圾收集器会自动照料一切。）所以完整的异常控制结构象下面这个样子：

try { 警戒区域 }
catch (A a1) { 控制器 A }
catch (B b1) { 控制器 B }
catch (C c1) { 控制器 C }
finally { 必须执行的代码}

///
// FinallyWorks.java
// The finally clause is always executed
public class FinallyWorks {
  staticint count = 0;
  publicstaticvoid main(String[] args) {
    while(true) {
      try {
        // post-increment is zero first time:
        if(count++ == 0)
          thrownew Exception();
        System.out.println("No exception");
      } catch(Exception e) {
        System.out.println("Exception thrown");
      } finally {
        System.out.println("in finally clause");
        if(count == 2) break; // out of "while"
      }
    }
  }
}
///

运行结果：
Exception thrown
in finally clause
No exception
in finally clause
一开始count=0发生异常，然后进入finally块；进入循环第二轮没有异常，但又执行一次finally块，并在其中跳出循环。
下面我们给出一个有的实用但较为复杂一点的程序。我们创建了一个InputFile的类。它的作用是打开一个文件，然后每次读取它的一行内容。

例5 读文本文件并显示到屏幕上。

///
//: Cleanup.java
// Paying attention to exceptions in constructors
import java.io.*;

class InputFile {
  private BufferedReader in;
  InputFile(String fname) throws Exception {
    try {
      in = new BufferedReader(new FileReader(fname));
      // Other code that might throw exceptions
    } catch(FileNotFoundException e) {
      System.out.println("Could not open " + fname);
      // Wasn't open, so don't close it
      throw e;
    } catch(Exception e) {
      // All other exceptions must close it
      try {
        in.close();
      } catch(IOException e2) {
        System.out.println("in.close() unsuccessful");
      }
      throw e;
    } finally {
      // Don't close it here!!!
    }
  }
  String getLine() {
    String s;
    try {
      s = in.readLine();
    } catch(IOException e) {
      System.out.println("readLine() unsuccessful");
      s = "failed";
    }
    return s;
  }
  void cleanup() {
    try {
      in.close();
    } catch(IOException e2) {
      System.out.println("in.close() unsuccessful");
    }
  }
}
publicclass Cleanup {
  publicstaticvoid main(String[] args) {
    try {
      InputFile in = new InputFile("Cleanup.java");
      String s;
      int i = 1;
      while((s = in.getLine()) != null)
        System.out.println(""+ i++ + ": " + s);
      in.cleanup();
    } catch(Exception e) {
      System.out.println( "Caught in main, e.printStackTrace()");
      e.printStackTrace();
    }
  }
}
///

运行后输出的前2行是：
1: //: Cleanup.java
2: // Paying attention to exceptions in constructors
3: import java.io.*;

简要说明 InputFile的类包含一个构建器和两个方法cleanup和getLine。构建器要打开一个文件fname，首先要捕获FileNotFoundException类异常。在它的处理代码中再掷出这个异常(throw e;)。在更高的控制器中试图关闭文件，并捕捉关闭失败的异常IOException。cleanup()关闭文件，getLine()读文件的一行到字符串，它们都用了异常处理机制。Cleanup是主类，在main()中首先创建一个InputFile类对象，因为它的构建器声明时用了异常规范，所以必须用try-catch结构来捕获异常。

4 创建自己的异常类

虽然Java类库提供了十分丰富的异常类型，能够满足绝大多数编程需要。但是，在开发较大的程序时，也有可能需要建立自己的异常类。要创建自己的异常类，必须从一个现有的异常类型继承——最好在含义上与新异常近似。创建一个异常相当简单，只要按如下格式写两个构建器就行：

class MyException extends Exception {
    public MyException() {}
    public MyException(String msg) {
    super(msg);
  }
}
这里的关键是“extends Exception”，它的意思是：除包括一个Exception的全部含义以外，还有更多的含义。增加的代码数量非常少——实际只添加了两个构建器，对MyException的创建方式进行了定义。请记住，假如我们不明确调用一个基础类构建器，编译器会自动调用基础类默认构建器。在第二个构建器中，通过使用super关键字，明确调用了带有一个String参数的基础类构建器。

例6 本例程演示建立和应用自己的异常类。

///
//: Inheriting.java
// Inheriting your own exceptions
class MyException extends Exception {
  public MyException() {}
  public MyException(String msg) {
    super(msg);
  }
}
publicclass Inheriting {
  publicstaticvoid f() throws MyException {
    System.out.println(
      "Throwing MyException from f()");
    thrownew MyException();
  }
  publicstaticvoid g() throws MyException {
    System.out.println(
      "Throwing MyException from g()");
    thrownew MyException("Originated in g()");
  }
  publicstaticvoid main(String[] args) {
    try {
      f();
    } catch(MyException e) {
      e.printStackTrace();
    }
    try {
      g();
    } catch(MyException e) {
      e.printStackTrace();
    }
  }
}
/// 

输出结果：
Throwing MyException from f()
MyException
at Inheriting.f(Inheriting.java:14)
at Inheriting.main(Inheriting.java:22)
Throwing MyException from g()
MyException: Originated in g()
at Inheriting.g(Inheriting.java:18)
at Inheriting.main(Inheriting.java:27)

class MyException2 extends Exception {
  public MyException2() {}
  public MyException2(String msg) {
    super(msg);
  }
  public MyException2(String msg, int x) {
    super(msg);
    i = x;
  }
  public int val() { return i; }
  private int i;
}

本章小结：

1. 应用异常控制机制进行异常处理的格式是
   try{要监控的代码} 
   catch(XXXException e) {异常处理代码} 
   finally {必须执行的代码} 
2. 不知道有什么异常类好用时可查阅相关包中有哪些XXXException.class文件。而用Exception可捕获任何异常。 
3. 在方法声明中使用了throws关键字的必须进行异常控制，否则会报编译错误。 
4. 也可以创建自己的异常类。

      J2SE 1.5 以前的版本要求直接使用 XML 解析器来装载配置文件并存储设置。虽然这并非是一件困难的事情，并且解析器是平台的标准部分，但是额外的工作总是有点让人烦。最近更新的 java.util.Properties 类现在提供了一种为程序装载和存储设置的更容易的方法： loadFromXML(InputStream is) 和 storeToXML(OutputStream os, String comment) 方法。

Properties 基本知识
如果不熟悉 java.util.Properties 类，那么现在告诉您它是用来在一个文件中存储键-值对的，其中键和值是用等号分隔的，如清单 1 所示。

清单 1. 一组属性示例

foo=bar
fu=baz

将清单 1 装载到 Properties 对象中后，您就可以找到两个键（ foo 和 fu ）和两个值（ foo 的 bar 和 fu 的 baz ）了。这个类支持带 \u 的嵌入 Unicode 字符串，但是这里重要的是每一项内容都当作 String 。

清单 2 显示了如何装载属性文件并列出它当前的一组键和值。只需传递这个文件的 InputStream 给 load() 方法，就会将每一个键-值对添加到 Properties 实例中。然后用 list() 列出所有属性或者用 getProperty() 获取单独的属性。

清单 2. 装载属性

import java.util.*;
import java.io.*;

public class LoadSample {
  public static void main(String args[]) throws Exception {
    Properties prop = new Properties();
    FileInputStream fis =
      new FileInputStream("sample.properties");
    prop.load(fis);
    prop.list(System.out);
    System.out.println("\nThe foo property: " +
        prop.getProperty("foo"));
  }
}

运行 LoadSample 程序生成如清单 3 所示的输出。注意 list() 方法的输出中键-值对的顺序与它们在输入文件中的顺序不一样。 Properties 类在一个散列表（hashtable，事实上是一个 Hashtable 子类）中储存一组键-值对，所以不能保证顺序。

清单 3. LoadSample 的输出

-- listing properties --
fu=baz
foo=bar

The foo property: bar

XML 属性文件
这里没有什么新内容。 Properties 类总是这样工作的。不过，新的地方是从一个 XML 文件中装载一组属性。它的 DTD 如清单 4 所示。

清单 4. 属性 DTD

<?xml version="1.0" encoding="UTF-8"?>
<!-- DTD for properties -->
<!ELEMENT properties ( comment?, entry* ) >
<!ATTLIST properties version CDATA #FIXED "1.0">
<!ELEMENT comment (#PCDATA) >
<!ELEMENT entry (#PCDATA) >
<!ATTLIST entry key CDATA #REQUIRED>

如果不想细读 XML DTD，那么可以告诉您它其实就是说在外围 <properties> 标签中包装的是一个 <comment> 标签，后面是任意数量的 <entry> 标签。对每一个 <entry> 标签，有一个键属性，输入的内容就是它的值。清单 5 显示了 清单 1中的属性文件的 XML 版本是什么样子的。

清单 5. XML 版本的属性文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Hi</comment>
<entry key="foo">bar</entry>
<entry key="fu">baz</entry>
</properties>

如果清单 6 所示，读取 XML 版本的 Properties 文件与读取老格式的文件没什么不同。

清单 6. 读取 XML Properties 文件

import java.util.*;
import java.io.*;

public class LoadSampleXML {
  public static void main(String args[]) throws Exception {
    Properties prop = new Properties();
    FileInputStream fis =
      new FileInputStream("sampleprops.xml");
    prop.loadFromXML(fis);
    prop.list(System.out);
    System.out.println("\nThe foo property: " +
        prop.getProperty("foo"));
  }
}

关于资源绑定的说明
虽然 java.util.Properties 类现在除了支持键-值对，还支持属性文件作为 XML 文件，不幸的是，没有内置的选项可以将 ResourceBundle 作为一个 XML 文件处理。是的， PropertyResourceBundle 不使用 Properties 对象来装载绑定，不过装载方法的使用是硬编码到类中的，而不使用较新的 loadFromXML() 方法。

运行清单 6 中的程序产生与原来的程序相同的输出，如 清单 2所示。

保存 XML 属性
新的 Properties 还有一个功能是将属性存储到 XML 格式的文件中。虽然 store() 方法仍然会创建一个类似 清单 1 所示的文件，但是现在可以用新的 storeToXML() 方法创建如 清单 5 所示的文件。只要传递一个 OutputStream 和一个用于注释的 String 就可以了。清单 7 展示了新的 storeToXML() 方法。

清单 7. 将 Properties 存储为 XML 文件

import java.util.*;
import java.io.*;

public class StoreXML {
  public static void main(String args[]) throws Exception {
    Properties prop = new Properties();
    prop.setProperty("one-two", "buckle my shoe");
    prop.setProperty("three-four", "shut the door");
    prop.setProperty("five-six", "pick up sticks");
    prop.setProperty("seven-eight", "lay them straight");
    prop.setProperty("nine-ten", "a big, fat hen");
    FileOutputStream fos =
      new FileOutputStream("rhyme.xml");
    prop.storeToXML(fos, "Rhyme");
    fos.close();
  }
}

运行清单 7 中的程序产生的输出如清单 8 所示。

清单 8. 存储的 XML 文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Rhyme</comment>
<entry key="seven-eight">lay them straight</entry>
<entry key="five-six">pick up sticks</entry>
<entry key="nine-ten">a big, fat hen</entry>
<entry key="three-four">shut the door</entry>
<entry key="one-two">buckle my shoe</entry>
</properties>

结束语
使用 XML 文件还是使用老式的 a=b 类型的文件完全取决于您自己。老式文件从内存的角度看肯定是轻量级的。不过，由于 XML 的普遍使用，人们会期望 XML 格式流行起来，因为它已经被广泛使用了，只不过没有用到 Properties 对象。选择完全在您。分析软件包 private XMLUtils 类的源代码以获得关于所使用的 XML 解析的更多信息。

PTest.java
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
 * 实现properties文件的读取
 * @author bbflyerwww
 * @date 2006-08-02
 */
public class PTest {
    public static void main(String[] args) {
        try {
            long start = System.currentTimeMillis();
            InputStream is = new FileInputStream("conf.properties");
            Properties p = new Properties();
            p.load(is);
            is.close();
            System.out.println("SIZE : " + p.size());
            System.out.println("homepage : " + p.getProperty("homepage"));
            System.out.println("author : " + p.getProperty("author"));
            System.out.println("school : " + p.getProperty("school"));
            System.out.println("date : " + p.getProperty("date"));
            long end = System.currentTimeMillis();
            System.out.println("Cost : " + (end - start));
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }
}

在java中，（对象）内存地址的比较，是通过==完成的。比如 

if (obj1  ==  obj2) ... {
    ...
}

这样的语句中，我们认为，如果obj1和obj2的内存地址相同，则返回true

而equals()通常是比较内容的。这里说“通常” ，是因为在最根本的Object类中，equal()函数做的是地址的比较。而在其他几乎所有的类中，equals()都经过重载，进行内容的比较。

而在说equals()的时候我们还涉及hashCode()是因为在有些应用中（比如，HashMap的key是对象），必须在重载equals()的同时重载hashCode()。因为java中默认(Object)的hashCode是根据对象的地址计算得到的。

我们通常不会注意到这个问题，因为我们通常所使用的key都是简单类型，或者是String, Long等一些特殊的对象（其特殊性请参看笔者在写java 浅拷贝和深拷贝时的讨论），这时候，这个问题被我们无意间绕过了

有人已经概括了这种我们忽略了的情况：“如果你想将一个对象A放入另一个收集（集合）对象B里，或者使用这个对象A为查找一个元对象在收集对 象B里位置的钥匙（key），并支持是否容纳（isContains()），删除收集对象B里的元对象（remove()?）这样的操作，那么，equals()和hashCode()函数必须开发者自己定义。” （括号为笔者添加）

为了便于理解，举一段程序为例：

import  java.util. * ;
public   class  Person ... {

int  id;
String name;

// define getter and setter here, omited

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

public   boolean  equals(Object o) ... {
        if ( this == o)  return   true ;
     if (o  instanceof  Person)
     return  ( this .id  ==  ((Person)o).id)  &&  ( this .name.equals(((Person)o).name));
    }

/**/ /*          
public int hashCode(){
    return id*37;
}
*/

public   static   void  main(String args[])  ... {
    Person p1  =   new  Person( 1 , " aaa " );
    Person p2  =   new  Person( 1 , " aaa " );
    Map map  =   new  HashMap();

    map.put(p2,p1);
    Person value  =  (Person)map.get(p1);
    System.out.println(value.name);
  }
}

这段代码的结果是什么？答案是nullPointerExcetpion.

而把hashCode()的注释去除，程序就可以返回正确的结果了。为什么呢？因为：

Map.put(key,value)时根据key.hashCode生成一个内部hash值，根据这个hash值将对象存放在一个table中

Map.get(key)会比较key.hashCode和equals方法，当且仅当这两者相等时，才能正确定位到table。而我们说过，默认的java是对地址进行比较的。

它包括两个类：Pattern和Matcher Pattern
一个Pattern是一个正则表达式经编译后的表现模式。
Matcher
一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。

首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式，然后一个Matcher实例在这个给定的Pattern实例的模式­控制下进行字符串的匹配工作。

以下我们就分别来看看这两个类：

2.Pattern类:
Pattern的方法如下： static Pattern compile(String regex)
将给定的正则表达式编译并赋予给Pattern类
static Pattern compile(String regex, int flags)
同上，但增加flag参数的指定，可选的flag参数包括：CASE
INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ
int flags()
返回当前Pattern的匹配flag参数.
Matcher matcher(CharSequence input)
生成一个给定命名的Matcher对象
static boolean matches(String regex, CharSequence input)
编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配,该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并­不需要生成一个Matcher实例。

String pattern()
返回该Patter对象所编译的正则表达式。
String[] split(CharSequence input)
将目标字符串按照Pattern里所包含的正则表达式为模进行分割。

String[] split(CharSequence input, int limit)
作用同上，增加参数limit目的在于要指定分割的段数，如将limi设为2，那么目标字符串将根据正则表达式分为割为两段。

一个正则表达式，也就是一串有特定意义的字符，必须首先要编译成为一个Pattern类的实例，这个Pattern对象将会使用matcher()方法来生成一­个Matcher实例，接着便可以使用该
Matcher实例以编译的正则表达式为基础对目标字符串进行匹配工作，多个Matcher是可以共用一个Pattern对象的。

现在我们先来看一个简单的例子，再通过分析它来了解怎样生成一个Pattern对象并且编译一个正则表达式，最后根据这个正则表达式将目标字符串进行分割：

import java.util.regex.*;
public class Replacement{
public static void main(String[] args) throws Exception {
// 生成一个Pattern,同时编译一个正则表达式
Pattern p = Pattern.compile("[/]+");
//用Pattern的split()方法把字符串按"/"分割
String[] result = p.split(
"Kevin has seen《LEON》seveal times,because it is a good film."
+"/
凯文已经看过《这个杀手不太冷》几次了，因为它是一部"
+"好电影。/名词:凯文。");
for (int i=0; i<result.length; i++)
System.out.println(result[i]);

Kevin has seen《LEON》seveal times,because it is a good film.
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。
名词:凯文。

很明显，该程序将字符串按"/"进行了分段，我们以下再使用
split(CharSequence input, int
limit)方法来指定分段的段数，程序改动为：
tring[] result = p.split("Kevin has seen《LEON》seveal times,because
it is a good film./
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。"，2);

这里面的参数"2"表明将目标语句分为两段。

输出结果则为：

Kevin has seen《LEON》seveal times,because it is a good film.
凯文已经看过《这个杀手不太冷》几次了，因为它是一部好电影。/名词:凯文。

由上面的例子，我们可以比较出java.util.regex包在构造Pattern对象以及编译指定的正则表达式的实现手法与我们在上一篇中所介绍的Jaka­rta-ORO
包在完成同样工作时的差别，Jakarta-ORO
包要先构造一个PatternCompiler类对象接着生成一个Pattern对象，再将正则表达式用该PatternCompiler类的compile(­)方法来将所需的正则表达式编译赋予Pattern类：

PatternCompiler orocom=new Perl5Compiler();

Pattern pattern=orocom.compile("REGULAR EXPRESSIONS");

PatternMatcher matcher=new Perl5Matcher();

但是在java.util.regex包里，我们仅需生成一个Pattern类，直接使用它的compile()方法就可以达到同样的效果:
Pattern p = Pattern.compile("[/]+");

因此似乎java.util.regex的构造法比Jakarta-ORO更为简洁并容易理解。

3.Matcher类:
Matcher方法如下： Matcher appendReplacement(StringBuffer sb,
String replacement)
将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里。

StringBuffer appendTail(StringBuffer sb)
将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

int end()
返回当前匹配的子串的最后一个字符在原目标字符串中的索引位置
。
int end(int group)
返回与匹配模式里指定的组相匹配的子串最后一个字符的位置。

boolean find()
尝试在目标字符串里查找下一个匹配子串。
boolean find(int start)
重设Matcher对象，并且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串。

String group()
返回当前查找而获得的与组匹配的所有子串内容
String group(int group)
返回当前查找而获得的与指定的组匹配的子串内容
int groupCount()
返回当前查找所获得的匹配组的数量。
boolean lookingAt()
检测目标字符串是否以匹配的子串起始。
boolean matches()
尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。

Pattern pattern()
返回该Matcher对象的现有匹配模式，也就是对应的Pattern
对象。
String replaceAll(String replacement)
将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。

String replaceFirst(String replacement)
将目标字符串里第一个与既有模式相匹配的子串替换为指定的字符串。

Matcher reset()
重设该Matcher对象。
Matcher reset(CharSequence input)
重设该Matcher对象并且指定一个新的目标字符串。
int start()
返回当前查找所获子串的开始字符在原目标字符串中的位置。

int start(int group)
返回当前查找所获得的和指定组匹配的子串的第一个字符在原目标字符串中的位置。

（光看方法的解释是不是很不好理解？不要急，待会结合例子就比较容易明白了）

一个Matcher实例是被用来对目标字符串进行基于既有模式（也就是一个给定的Pattern所编译的正则表达式）进行匹配查找的，所有往Matcher的输­入都是通过CharSequence接口提供的，这样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作。

我们分别来看看各方法的使用：

★matches()/lookingAt ()/find()：
一个Matcher对象是由一个Pattern对象调用其matcher()方法而生成的，一旦该Matcher对象生成,它就可以进行三种不同的匹配查找操作­：

matches()方法尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。

lookingAt
()方法将检测目标字符串是否以匹配的子串起始。
find()方法尝试在目标字符串里查找下一个匹配子串。

以上三个方法都将返回一个布尔值来表明成功与否。

★replaceAll ()/appendReplacement()/appendTail()：
Matcher类同时提供了四个将匹配子串替换成指定字符串的方法：

replaceAll()
replaceFirst()
appendReplacement()
appendTail()

replaceAll()与replaceFirst()的用法都比较简单，请看上面方法的解释。我们主要重点了解一下appendReplacement()­和appendTail()方法。

appendReplacement(StringBuffer sb, String replacement)
将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里，而appendTai­l(StringBuffer
sb)
方法则将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。

例如，有字符串fatcatfatcatfat,假设既有正则表达式模式为"cat"，第一次匹配后调用appendReplacement(sb,"dog"­),那么这时StringBuffer
sb的内容为fatdog，也就是fatcat中的cat被替换为dog并且与匹配子串前的内容加到sb里，而第二次匹配后调用appendReplaceme­nt(sb,"dog")，那么sb的内容就变为fatdogfatdog，如果最后再调用一次appendTail（sb）,那么sb最终的内容将是fatd­ogfatdogfat。

还是有点模糊？那么我们来看个简单的程序：
//该例将把句子里的"Kelvin"改为"Kevin"
import java.util.regex.*;
public class MatcherTest{
public static void main(String[] args)
throws Exception {
//生成Pattern对象并且编译一个简单的正则表达式"Kelvin"
Pattern p = Pattern.compile("Kevin");
//用Pattern类的matcher()方法生成一个Matcher对象
Matcher m = p.matcher("Kelvin Li and Kelvin Chan are both working in
Kelvin Chen's KelvinSoftShop company");
StringBuffer sb = new StringBuffer();
int i=0;
//使用find()方法查找第一个匹配的对象
boolean result = m.find();
//使用循环将句子里所有的kelvin找出并替换再将内容加到sb里
while(result) {
i++;
m.appendReplacement(sb, "Kevin");
System.out.println("第"+i+"次匹配后sb的内容是："+sb);
//继续查找下一个匹配对象
result = m.find();

看了上面这个例程是否对appendReplacement()，appendTail()两个方法的使用更清楚呢，如果还是不太肯定最好自己动手写几行代码测­试一下。

★group()/group(int group)/groupCount()：
该系列方法与我们在上篇介绍的Jakarta-ORO中的MatchResult
.group()方法类似(有关Jakarta-ORO请参考上篇的内容)，都是要返回与组匹配的子串内容，下面代码将很好解释其用法：

import java.util.regex.*;

public class GroupTest{
public static void main(String[] args)
throws Exception {
Pattern p = Pattern.compile("(ca)(t)");
Matcher m = p.matcher("one cat,two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
System.out.println("该次查找获得匹配组的数量为："+m.groupCount());
for(int i=1;i<=m

Matcher对象的其他方法因比较好理解且由于篇幅有限，请读者自己编程验证。

4．一个检验Email地址的小程序：
最后我们来看一个检验Email地址的例程，该程序是用来检验一个输入的EMAIL地址里所包含的字符是否合法，虽然这不是一个完整的EMAIL地址检验程序，­它不能检验所有可能出现的情况，但在必要时您可以在其基础上增加所需功能。

import java.util.regex.*;
public class Email {
public static void main(String[] args) throws Exception {
String input = args[0];
//检测输入的EMAIL地址是否以
非法符号"."或"@"作为起始字符
Pattern p = Pattern.compile("^\.|^\@");
Matcher m = p.matcher(input);
if (m
//检测是否以"www."为起始
p = Pattern.compile("^www\.");
m = p.matcher(input);
if (m
//检测是否包含非法字符
p = Pattern.compile("[^A-Za-z0-9\.\@_\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
while(result) {
//如果找到了非法字符那么就设下标记
deletedIllegalChars = true;
//如果里面包含非法字符如冒号双引号等，那么就把他们消去，加到SB里面
m.appendReplacement(sb, "");
result = m.find();

那么输出结果将会是：EMAIL地址不能以'www.'起始

如果输入的EMAIL为@k...@163.net

则输出为：EMAIL地址不能以'.'或'@'作为起始字符

当输入为：cgjmail...@163.net

那么输出就是：

输入的EMAIL地址里包含有冒号、逗号等非法字符，请修改
您现在的输入为: cgjmail...@163.net
修改后合法的地址应类似: cgjm...@163.net

5．总结：
本文介绍了jdk1.4.0-beta3里正则表达式库--java.util.regex中的类以及其方法，如果结合与上一篇中所介绍的Jakarta-OR­O
API作比较，读者会更容易掌握该API的使用，当然该库的性能将在未来的日子里不断扩展，希望获得最新信息的读者最好到及时到SUN的网站去了解。

6．结束语：
本来计划再多写一篇介绍一下需付费的正则表达式库中较具代表性的作品，但觉得既然有了免费且优秀的正则表达式库可以使用，何必还要去找需付费的呢，相信很多读者­也是这么想的:，所以有兴趣了解更多其他的第三方正则表达式库的朋友可以自己到网上查找或者到我在参考资料里提供的网址去看看。

参考资料

java.util.regex的帮助文档
Dana Nourie 和Mike McCloskey所写的Regular Expressions and the
Java™ Programming Language
需要更多的第三方正则表达式资源以及基于它们所开发的应用程序请看http://www.meurrens.org/ip-Links/java/regex/index.html

关于作者
陈广佳 Kevin
Chen,汕头大学电子信息工程系工科学士，台湾大新出版社珠海区开发部，现正围绕中日韩电子资料使用JAVA开发电子词典等相关项目。可通过E-mail:c­gjm...@163.net于他联系。

本文以一条龙的形式一次性解决问题。

类是广泛的概念，表示一个有共同性质的群体。如：人类。

代码：
       // 声明一个类“Human”
            class Human{
            private String name;
            public String getName(){
                               return name;
                                              }
           public void setName(String value){
                                         this.name = value;
                                                  }
                                  //......
                               }

对象指的是具体的一个实实在在的东西。如、张三、李四。

代码：
                          Human zhangsan = new Human();

图：
    

图中我们怎么创建张三和李四呢？？我们前面的代码好像还没涉及，恩好，看下面

Human human = new Human();

程序执行到这里之后，java虚拟机将会在内存中创建一个 Human 对象，并将这个对象的引用赋给 human 变量。

接着：human.setName("张三"); human.setName("李四");好了对象（实例）创建好了，呵呵！

图：
     

“人”是一个基类，则“男人”是“人”的一个子类。如果“张三”是一个“男人”，也就是说“张三”是“男人”的一个对象，那么显然“张三”也是“人”这个基类的一个对象。
   class nanren extends  human(String args[ ]){
           //.............
        }

方法是类的行为，如人会笑、会坐、会走路 一样。

图：
     
        
 

                                                                      爷爷2   》老爸2  》 儿子2
     而不能是：爷爷2  》 儿子1

这样就乱套了 ，是不，闹笑话；所以，类规定了不继承关系，防止乱套，使结构变得清晰。

所以，当我们使用树型结构时，使用类。

由于，在生活中还有许多这样的情况，如，张三是中国人，那张三他也是美国人双重身份。
                   
                                                                   再如，李四是java工程师,也是厨师。
那怎么办？？

我们可以这么做：
规定多个身份
public interface zhengjian{
interface China(){
public void China_L(){
//.................
                             }
                           }
interface  USA(){
public  void USA_L(){
//...........
           }
}

public class zhangsan extends zhengjian implements Chna , USA{
public void China_L(){
// ......
}
public void USA_L(){
// ......
}
}

当张三去美国时，老美叫他拿个绿证来看：

zhangsan.USA_L();

呵呵，再举个例子大家就清楚了：

HP有“三星”和“IBM”两种，我通常而言不可能一个HP是既是“三星”又是“IBM”的吧~~~~~~~~类
          “家庭式”和“办公式”两种，但往往我们能买到拥有两种款式相结合厂品是吧    ~~~~~~~~~~~接口

中国人说起来，类有点“封建世袭制”，接口有点“违反常理乱伦”，呵呵开个玩笑。

这样说完大家再去看些相关文章就会觉得很容易了 呵呵

剩下抽象类就简单了，那是抽象类（abstract）他还是类（class)，只不过是抽象的罢了。

抽象类对某具体类型的部分实现------抽象类是对具体的抽象方法特征包括：方法的名字、参数的数目、参数的类型。

不包括：返回类型、参数名字、和抛出的异常。

java接口（抽象类）用来声明一个新的类型,Java设计师应当主要使用接口和抽象类将软件单位与内部和外部耦合(软件工程中内容)起来。

在理想的情况下，一个具体类应当只实现接口和抽象类中声明的方法，而不应当给出多余的方法！

抽象类仅提供一个类的部分实现。抽象类可以有实例变量、以及一个或多个构造函数。

人这个概念够抽象了吧！
public  abstract   class   Human{...}  

男人也是 
public   abstract   class  man{...}   

有一点必须讲清：接口不能继承抽象类，接口只能继承实实在在的类，

如，我可以为某个HP厂品（类）规定一种规范（接口），但由于各个厂家推陈出新，所以，我很难对某一类型厂品规定，“家庭型hp”就很难下个结论（接口）。


从软件优化角度来考虑类和接口问题。类class条理清楚内聚性好，用于软件模块内部实现（汽车的内部机

械）；接口interface很灵活耦合性好，用于模块外部实现（如，汽车操作板的按钮）。从而实现强内聚、松耦合

的软件设计思想。

2.如何编写线程安全的代码
很多书籍里都详细讲解了如何这方面的问题，他们主要讲解的是如何同步线程对共享资源的使用的问题。主要是对synchronized关键字的各种用法，以及锁的概念。
Java1.5中也提供了如读写锁这类的工具类。这些都需要较高的技巧，而且相对难于调试。

但是，线程同步是不得以的方法,是比较复杂的,而且会带来性能的损失。等效的代码中，不需要同步在编写容易度和性能上会更好些。
我这里强调的是什么代码是始终为线程安全的、是不需要同步的。如下:
1)常量始终是线程安全的，因为只存在读操作。
2)对构造器的访问(new 操作)是线程安全的，因为每次都新建一个实例，不会访问共享的资源。
3)最重要的是:局部变量是线程安全的。因为每执行一个方法，都会在独立的空间创建局部变量，它不是共享的资源。局部变量包括方法的参数变量。
struts user guide里有：
Only Use Local Variables - The most important principle that aids in thread-safe coding is to use only local variables, not instance variables , in your Action class.
译:只使用用局部变量。--编写线程安全的代码最重要的原则就是，在Action类中只使用局部变量，不使用实例变量。

总结：
在Java的Web服务器环境下开发，要注意线程安全的问题。最简单的实现方式就是在Servlet和Struts Action里不要使用类变量、实例变量，但可以使用类常量和实例常量。
如果有这些变量，可以将它们转换为方法的参数传入，以消除它们。
注意一个容易混淆的地方：被Servlet或Action调用的类中(如值对象、领域模型类)中是否可以安全的使用实例变量？如果你在每次方法调用时
新建一个对象，再调用它们的方法，则不存在同步问题---因为它们不是多个线程共享的资源，只有共享的资源才需要同步---而Servlet和Action的实例对于多个线程是共享的。
换句话说，Servlet和Action的实例会被多个线程同时调用，而过了这一层,如果在你自己的代码中没有另外启动线程，且每次调用后续业务对象时都是先新建一个实例再调用，则都是线程安全的。