亚洲国产午夜电影在线入口,亚洲国产精品久久久久婷婷老年,91精品国产亚洲爽啪在线影院

全面文�g操作java代码

暗夜�_�� — Wed, 07 Mar 2007 01:09:00 GMT

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class FileOperate {
    private String message;
    public FileOperate() {
    }

    /**
     * ��d��文本文�g内容
     * @param filePathAndName 带有完整�l�对路径的文件名
     * @param encoding 文本文�g打开的编码方�?br />     * @return �q�回文本文�g的内�?br />     */
    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 �q�回目录创徏后的路径
     */
    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 无限�U�目录参敎ͼ�各��目录以单数线区分例如 a|b|c
     * @return �q�回创徏文�g后的路径例如 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 = "创徏目录操作出错�Q?;
       }
        return txts;
    }

    /**
     * 新徏文�g
     * @param filePathAndName 文本文�g完整�l�对路径及文件名
     * @param fileContent 文本文�g内容
     * @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 = "创徏文�g操作出错";
        }
    }

    /**
     * 有编码方式的文�g创徏
     * @param filePathAndName 文本文�g完整�l�对路径及文件名
     * @param fileContent 文本文�g内容
     * @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 = "创徏文�g操作出错";
        }
    }

    /**
     * 删除文�g
     * @param filePathAndName 文本文�g完整�l�对路径及文件名
     * @return Boolean 成功删除�q�回true遭遇异常�q�回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+"
删除文�g操作出错");
            }
        }
        catch (Exception e) {
            message = e.toString();
        }
        return bea;
    }

/**
 * 删除文�g�?br /> * @param folderPath 文�g夹完整绝对�\�?br /> * @return
 */
 public void delFolder(String folderPath) {
 try {
 delAllFile(folderPath); //删除完里面所有内�?br /> String filePath = folderPath;
 filePath = filePath.toString();
 java.io.File myFilePath = new java.io.File(filePath);
 myFilePath.delete(); //删除�I�文件夹
 }
 catch (Exception e) {
 message = ("删除文�g�Ҏ��作出�?);
 }
 }


 /**
 * 删除指定文�g夹下所有文�?br /> * @param path 文�g夹完整绝对�\�?br /> * @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]);//先删除文件夹里面的文�?br /> delFolder(path+"/"+ tempList[i]);//再删除空文�g�?br /> bea = true;
 }
 }
 return bea;
 }

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

/**
 * 复制整个文�g夹的内容
 * @param oldPath 准备拯��的目�?br /> * @param newPath 指定�l�对路径的新目录
 * @return
 */
 public void copyFolder(String oldPath, String newPath) {
 try {
 new File(newPath).mkdirs(); //如果文�g夹不存在则徏立新文�g�?br /> 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()){//如果是子文�g�?br /> copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
 }
 }
 }catch (Exception e) {
 message = "复制整个文�g夹内�Ҏ��作出�?;
 }
 }

    /**
     * �U�d��文�g
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFile(String oldPath, String newPath) {
        copyFile(oldPath, newPath);
        delFile(oldPath);
    }

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

暗夜�_�� 2007-03-07 09:09 发表评论

JAVA语言的反��和内省

暗夜�_�� — Mon, 05 Mar 2007 13:41:00 GMT

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

反射

相对而言�Q�反��比内省更容易理解一炏V��用一句比较白的话来概括，反射��是让你可以通过名称来得到对�?/span> ( �c�，属性，�Ҏ�� ) 的技术。例如我们可以通过�c�d��来生成一个类的实例；知道了方法名�Q�就可以调用�q�个�Ҏ��Q�知道了属性名��可以访问这个属性的倹{�?/span>

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

// 通过�c�d��来构造一个类的实�?br /> Class cls_str = Class.forName( "java.lang.String" );
// 上面�q�句很眼熟，因�ؓ使用�q?/span> JDBC 讉K��数据库的人都用过 J
Object str = cls_str.newInstance();
// 相当�?/span> String str = new String();

// 通过�Ҏ��名来调用一个方�?br /> String methodName = "length" ;
Method m = cls_str.getMethod(methodName, null );
System.out.println( "length is " + m.invoke(str, null ));
// 相当�?/span> System.out.println(str.length());

上面的两个例子是比较常用�Ҏ��。看��C��面的例子��有��发问了：��Z��么要�q�么�ȝ��呢？本来一条语句就完成的事情干吗要整这么复杂？没错�Q�在上面的例子中��实没有必要�q�么�ȝ��。不�q�你惛_��q�样一个应用程序，它支持动态的功能扩展�Q�也��是说程序不重新启动但是可以自动加蝲新的功能�Q�这个功能��用一个具体类来表�C�。首先我们必��Mؓ�q�些功能定义一个接口类�Q�然后我们要求所有扩展的功能�c�d��d��现我指定的接口，�q�个规定了应用程序和可扩展功能之间的接口规则�Q�但是怎么动态加载呢�Q�我们必��让应用�E�序知道要扩展的功能�cȝ��c�d��Q�比如是 test.Func1 �Q�当我们把这个类�?/span> ( 字符�?/span> ) 告诉应用�E�序后，它就可以使用我们�W�一个例子的�Ҏ��来加载�ƈ启用新的功能。这��是�cȝ��反射�Q�请问你有别的选择吗？

关于�Ҏ��的反��徏议大家看我的另外一��文章�?/span> 利用 Turbine 的事件映��来扩展 Struts 的功�?/span> 》，地址是： http://www.javayou.com/article/CSDN/extend_struts.html 。这��文章详�l�介�l�了如果通过反射来扩�?/span> Struts 框架的功能�?/span>

内省

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

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

/*
* Created on 2004-6-29
*/

package demo;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;

/**
* 内省演示例子
* @author liudong
*/

public class IntrospectorDemo {
    String name;
    public static void main(String[] args) throws Exception{
        IntrospectorDemo demo = new IntrospectorDemo();
        demo.setName( "Winter Lau" );

        // 如果不想把父�cȝ��属性也列出来的话，
        // �?/span> getBeanInfo 的第二个参数填写父类的信�?br />         BeanInfo bi = Introspector.getBeanInfo(demo.getClass(), Object. class );
        PropertyDescriptor[] props = bi.getPropertyDescriptors();
        for ( int i=0;i             System.out.println(props[i].getName()+ "=" +
                    props[i].getReadMethod().invoke(demo, null ));
        }

}

    public String getName() {
        return name;
    }

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

Web 开发框�?/span> Struts 中的 FormBean ��是通过内省机制来将表单中的数据映射到类的属性上�Q�因此要�?/span> FormBean 的每个属性要�?/span> getter/setter �Ҏ��。但也�ƈ不��L��q�样�Q�什么意思呢�Q�就是说对一�?/span> Bean �c�L��Ԍ��我可以没有属性，但是只要�?/span> getter/setter �Ҏ��中的其中一个，那么 Java 的内省机制就会认为存在一个属性，比如�c�M��有方�?/span> setMobile �Q�那么就认�ؓ存在一�?/span> mobile 的属性，�q�样可以方便我们�?/span> Bean �c�通过一个接口来定义而不用去兛_��具体实现�Q�不用去兛_�� Bean 中数据的存储。比如我们可以把所有的 getter/setter �Ҏ��攑ֈ�接口里定义，但是真正数据的存取则是在具体�c�M��d��玎ͼ��q�样可提高系�l�的扩展性�?/span>

�ȝ��

��?/span> Java 的反��以及内省应用到�E�序设计中去可以大大的提供程序的��化和可扩展性。有很多��目都是采取�q�两�U�技术来实现其核心功能，例如我们前面提到�?/span> Struts �Q�还有用于处�?/span> XML 文�g�?/span> Digester ��目�Q�其实应该说几乎所有的��目都或多或��的采用�q�两�U�技术。在实际应用�q�程中二者要�怺��l�合方能发挥真正的智能化以及高度可扩展性�?/span>

暗夜�_�� 2007-03-05 21:41 发表评论

暗夜�_�� — Mon, 05 Mar 2007 13:25:00 GMT

1 术语定义

在字�W�串匚w��问题中，我们期待察看串T中是否含有串P�?br />其中串T被称为目标串�Q�串S被称为模式串�?/p>

2 朴素匚w��法

�q�行字符串匹配，最��单的一个想法是�Q?/p>

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));
 }
}

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

3 KMP��法

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

假设P=abacd�Q�如果T=abax...�Q�当从头开始匹配到字符c�Ӟ��若c=x�Q�显�Ӟ��匚w��q�程�l�箋�Q�当c≠x�Ӟ��按照朴素的匹配算法，T串会发生回溯�Q�之后T串会从第2个字�W�b开始重新匹配，而不是从匚w��p�|的字�W�x开始��l�。但是显�Ӟ��对于上述的匹配过�E�，T串不需要从b开始重新匹配，它只需要从x开始和P的b字符�l�箋匚w��卛_��。如下：
匚w��q�程�Q?br />P=abacd
T=abax....
     ^----比较到此处时发生匚w��p�|
朴素匚w��法�Q?br />P= abacd
T=abax...
   ^----回溯到b�Q�重新开始和P的匹�?br />KMP��法�Q?br />P= abacd
T=abax...
     ^----T串不回溯�Q�从x处��l�匹�?/p>

现在的问题是�Q�按照KMP��法�Q�匹配失败的时候，P串需要重新调整位�|�，但是调整的依据是什么？Knuth�{��h发现�Q�P调整位置的依据和P的构造有养I��和T无关。具体来��_��定义失效函数�Q�f(j)=k�Q�其�?<=k<=j�Q�且k是��得p₀p₁...p_k-1 = p_j-k+1p_j-k+2...p_j成立的最大整数。徏立失效函数的��法如下�Q?br />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;
}
}

匚w��q�程如下�Q?br />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 支持通配�W?�?的KMP��法

KMP��法虽然能够�q�行字符串匹配，但是�Q�在实践中字�W�串匚w��往往�q�要支持通配�W�，MS�pȝ��中最常见的通配�W�是?�?。其中，?可以代表一个字�W�（不能没有�Q�，*可以代表��L��多个字符�Q�可以�ؓ�I�）。经典的KMP��法针对通配�W�是无能为力的，但是�l�过��单的攚w��，KMP��法也可以识别通配�W��?/p>

首先�?�Q�根�?的功能，?表示��L��字符�Q�也��是说在匚w��q�程中，?永远匚w��成功。因此对匚w��函数的修改十分简单：
...
while(target_index < token_length && pattern_index < pattern_length) {
 if(target[target_index] == pattern[pattern_index]|| pattern[pattern_index] == '?') {
 target_index++;
 pattern_index++;
 } else {
...
建立失效函数的过�E�和匚w��q�程�c�M��Q�修改如下：
...
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;
...

本质上，?�q�没有修改算法，而仅仅修改了匚w��规则——遇�?则一定匹配。然�?与此不同�Q?的作用是匚w��L��多个字符�Q�显然我们不能简单的修改匚w��q�程而满��求。如果我们重新思�?的作用，我们会发�?的另一个作用就是分割P�Ԍ��卛_��果P=P₁*P₂�Q�那么与其说*代表匚w��L��多个字符�Q�不如说P的匹配条件是在匹配P₁子串后再匚w��P₂子串�?/p>

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

因此�Q�要惌��KMP支持*�Q�那么关键是要重新设计失效函数的建立��法�Q�如下：
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表示每段字符串的开始位�|�。此外，匚w��q�程也应该进行相应的修改�Q�因为字�W?对于匚w��没有��M��帮助�Q�它属于占位�W�，因此需要蟩�q�，匚w��法如下�Q?br />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 正则语言和确定状态自动机

一个数字逻辑的问题：设计一个识�?1011的电路，解这个问题的关键��是设计��个电路的DFA�Q�如下：
500){this.resized=true;this.style.width=500;}" />

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

6 �l�语

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

暗夜�_�� 2007-03-05 21:25 发表评论

NoClassDefDoundErr与ClassNotFoundException区别

暗夜�_�� — Sat, 03 Mar 2007 10:23:00 GMT

作�?langm

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

在读�q�篇文章之前�Q�你最好了解一下Java的Exception机制�?/p>

也许你在开发的�q�程中经常地见到ClassNotFoundException和NoClassDefFoundErr�q�两个异常，每每看到之后�Q�都会一概而论的是�c�L��有找刎ͼ�但有些时候见��C��们的时候又有些疑惑�Q�至��我是这��P��Q��ؓ什么Java要用两个异常来表�C�类定义没有扑ֈ�那？他们之间有什么区别那�Q?/p>

正��y今天我又��到了这个问题，��Z��的仔�l�研�I�了一下这两个异常的区别�?
首先�Q?
ClassNotFoundException直接�l�承与Exception�Q�它是一个checked的异常�?
NoClassDefFoundErr �l�承自Error->LinkageError �Q�它是一个unchecked的异常�?/p>

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

ClassNotFoundException�Q?
当应用尝试用字符串名�U�通过下面的方法装载一个类时这个类的定义却没有扑ֈ�时会抛出的异常�?
Class.forName
ClassLoader.findSystemClass
ClassLoader.loadClass

NoClassDefFoundErr�Q?
当JVM或者ClassLoader实例��试装蝲一个类的定义（�q�通常是一个方法调用或者new表达式创��Z��个实例过�E�的一部分�Q�而这个类定义�q�没有找时所抛出的错误�?
当编译的时候可以找到这个类的定义，但是以后�q�个�c�M��再存在�?/p>

�q�比较显而易见了吧，��d��文档是很重要的事情。这里我��p��一下我对这两个�cȝ��区别的理解�?/p>

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

NoClassDefFoundErr异常一般出现在我们�~�译环境和运行环境不一致的情况下，��是说我们有可能在编译过后更改了Classpath或者jar包所以导致在�q�行的过�E�中JVM或者ClassLoader无法扑ֈ��q�个�cȝ��定义�Q�我曄��在编译后作了一�ơjar包的清理�Q�然后应用就送给了我一个这��L��C�物�Q��?/p>

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

以上��是我对�q�两个异常的一点个人理解，希望对各位开发者有所帮助�Q�可以让各位开发者在以后的开发过�E�中能够更快的找到问题所在。祝开发顺�?/p>

暗夜�_�� 2007-03-03 18:23 发表评论

java异常处理

暗夜�_�� — Sat, 03 Mar 2007 10:14:00 GMT

1 Java的异常控制机�?/font>

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

即��不��用try-catch�l�构�Q�发生异常时Java的异常控制机制也会捕莯��异常�Q�输出异常的名称�q�从异常发生的位�|�打��C��个堆栈跟�t�。然后立即终止程序的�q�行。下面的例子发生了一�?#8220;雉��”异常�Q�后面的hello没有被打印�?/font>

�? 没有作异常控制的�E�序�?/font>

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

输出�l�果�Q?br />java.lang.ArithmeticException: / by zero
at Exception1.main(Exception1.java:5)
Exception in thread "main" Exit code: 1
There were errors

但是如果使用了try-catch来处理异常，那么在打印出异常信息后，�E�序�q�将�l�箋�q�行下去。下面是处理了的代码�?/font>

///
// 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!" );
}
}
///

输出�l�果�Q?br />Exception:
java.lang.ArithmeticException: / by zero
at Exception2.main(Exception1.java:5)
Hello!

与前例不同的是，Hello!被输��Z��。这��是try-catch�l�构的用处，它��异常发生和处理后�E�序得以“恢复”而不�?#8220;中断”�?/font>

2 异常�c�R��异常规范和throw语句

��Z��使异常控制机制更��地发挥它的功效，Java设计者几乎所以可能发生的异常�Q�预制了各色各样的异常类和错误类。它们都是从“可掷�?#8221;�c�Throwable�l�承而来的，它派生出两个�c�Error和Exception。由Error�z��的子�c�d��名�ؓXXXError�Q�其中词XXX是描�q�错误类型的词。由Exception�z��的子�c�d��名�ؓXXXException�Q�其中词XXX是描�q�异常类型的词。Error�c�d��理的是运行�ɾpȝ��发生的内部错误，是不可恢复的�Q�唯一的办法只要终止运行运行程序。因此，客户�E�序员只要掌握和处理好Exception�c�d��可以了�?br />Exception�c�L��一切异常的栏V��现成的异常�c�非�怹�多，我们不可能也没有必要全部掌握它。好在异常类的命名规则大致描�q�出了该�cȝ��用途，而异常类的方法基本是一��L��。下面给出lang包中声明的部分异常类�?/font>

RuntimeException            �q�行时异�?br />NullPointerException        数据没有初始化就使用
IndexOutOfBoundsException   数组或字�W�串索引��界
NoSuchFieldException        文�g找不�?br />NoSuchMethodException       �Ҏ��没有定义
ArithmeticException         非法��术�q�行

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

String getMessage() 获得详细的消息�?
String toString() �q�回�Ҏ��cȝ��一�D늮�要说明，其中包括详细的消息（如果有的话）�?
void printStackTrace() �?#160; void printStackTrace(PrintStream)
打印��用堆栈�\径。调用堆栈显�C�出��我们带到异常发生地点的�Ҏ��调用的顺序�?

因�ؓException�c�L��一切异常的根，所以对��M��一个现有的异常�c�都可以使用上述�Ҏ��?

异常规范 �?/strong> throws

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

�? 本例�E�演�C�异常类的常用方法�?/font>

///
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��Z��潜在的异常可能是多种�c�d��的，那时我们需要用多个catch块来捕获和处理这些异常。但异常发生时掷��Z��某类异常对象�Q�Java依次逐个��查这些异常控制器�Q�发��C��掷出的异常类型匹配时��执行那以段处理代码�Q�而其余的不会被执行。�ؓ了防止可能遗漏了某一�c�d��常控制器�Q�可以放�|�一个捕获Exception�cȝ��控制器。Exception是可以从��M��c�L��法中“�?#8221;出的基本�c�d��。但是它必须攑֜�最后一个位�|�，因�ؓ它能够截获�Q何异常，从而��后面具体的异常控制器不�v作用。下面的�C�Z��说明了这一炏V�?/font>

�? 本例�E�演�C�多个异常控制器的排列次序的作用�?/font>

///
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);
}
}
///

�q�行�l�果�Q?br />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攑֜�前面�Q�编译就通不�q��?/font>

3 用finally清理

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

try { 警戒区域 }
catch (A a1) { 控制�?A }
catch (B b1) { 控制�?B }
catch (C c1) { 控制�?C }
finally { 必须执行的代码}
�? 演示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"
 }
 }
}
}
///

�q�行�l�果�Q?br />Exception thrown
in finally clause
No exception
in finally clause
一开始count=0发生异常�Q�然后进入finally块；�q�入循环�W�二轮没有异常，但又执行一�ơfinally块，�q�在其中跛_��循环�?br />下面我们�l�出一个有的实用但较�ؓ复杂一点的�E�序。我们创��Z��一个InputFile的类。它的作用是打开一个文�Ӟ��然后每次��d��它的一行内宏V�?/font>

�? ��L��本文件�ƈ昄��到屏�q�上�?/font>

///
//: 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();
 }
}
}
///

�q�行后输出的�?行是�Q?br />1: //: Cleanup.java
2: // Paying attention to exceptions in constructors
3: import java.io.*;

��要说�?InputFile的类包含一个构建器和两个方法cleanup和getLine。构建器要打开一个文件fname�Q�首先要捕获FileNotFoundException�c�d��常。在它的处理代码中再掷出�q�个异常(throw e;)。在更高的控制器中试囑օ�闭文�Ӟ��q�捕捉关闭失败的异常IOException。cleanup()关闭文�g�Q�getLine()��L��件的一行到字符�Ԍ��它们都用了异常处理机制。Cleanup是主�c�，在main()中首先创��Z��个InputFile�c�d��象，因�ؓ它的构徏器声明时用了异常规范�Q�所以必��ȝ��try-catch�l�构来捕获异常�?/font>

4 创徏自己的异常类

虽然Java�c�d��提供了十分丰富的异常�c�d��Q�能够满��绝大多数编�E�需要。但是，在开发较大的�E�序�Ӟ��也有可能需要徏立自��q��异常�c�R��要创徏自己的异常类�Q�必��M��一个现有的异常�c�d��l�承——最好在含义上与新异常近伹{��创��Z��个异常相当简单，只要按如下格式写两个构徏器就行：

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

�? 本例�E�演�C�徏立和应用自己的异常类�?/font>

///
//: 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();
 }
}
}
///

输出�l�果�Q?br />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)
创徏自己的异常时�Q�还可以采取更多的操作。我们可��d��额外的构建器及成员：
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;
}

本章��结�Q?/font>

应用异常控制机制�q�行异常处理的格式是
try{要监控的代码}
catch(XXXException e) {异常处理代码}
finally {必须执行的代码}

不知道有什么异常类好用时可查阅相关包中有哪些XXXException.class文�g。而用Exception可捕获�Q何异常�?#160;

在方法声明中使用了throws关键字的必须�q�行异常控制�Q�否则会报编译错误�?#160;

也可以创��q��异常�c�R�?/font>

暗夜�_�� 2007-03-03 18:14 发表评论

暗夜�_�� — Sat, 03 Mar 2007 08:18:00 GMT

Properties �c�d��不是��C��西了�Q�它�?Java �~�程的早期就有了�Q��ƈ且几乎没有什么变化。J2SE �?Tiger 版本增强了这个类�Q�不仅可以用它在单独一行中指定用等号分隔的多个�?值对�Q�还可以用XML 文�g装蝲和保存这些键-值对。在驯服 Tiger的这一期文章中�Q�John Zukowski 展示了如何驾驭这�Ҏ��一代的“彚w��”。请在本文对应的讨论论坛上与作者及其他读者分享您�Ҏ��文的��x��Q�您也可以单��L��章顶部或底部�?讨论来访问该论坛�Q��?

 J2SE 1.5 以前的版本要求直接��?XML 解析器来装蝲配置文�g�q�存储设�|�。虽然这�q��是一件困隄��事情�Q��ƈ且解析器是��^台的标准部分�Q�但是额外的工作��L��有点让�h烦。最�q�更新的 java.util.Properties �cȝ��在提供了一�U��ؓ�E�序装蝲和存储设�|�的更容易的�Ҏ��Q?loadFromXML(InputStream is) �?storeToXML(OutputStream os, String comment) �Ҏ��?

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

清单 1. 一�l�属性示�?/p>
foo=bar
fu=baz

��清�?1 装蝲�?Properties 对象中后�Q�您��可以找��C��个键�Q?foo �?fu �Q�和两个��|�� foo �?bar �?fu �?baz �Q�了。这个类支持�?\u 的嵌�?Unicode 字符�Ԍ��但是�q�里重要的是每一��内定w��当作 String �?

清单 2 昄��了如何装载属性文件�ƈ列出它当前的一�l�键和倹{��只需传递这个文件的 InputStream �l?load() �Ҏ��Q�就会将每一个键-值对��d��?Properties 实例中。然后用 list() 列出所有属性或者用 getProperty() 获取单独的属性�?

清单 2. 装蝲属�?/p>
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"));
}
}

�q�行 LoadSample �E�序生成如清�?3 所�C�的输出。注�?list() �Ҏ��的输��Z��?值对的顺序与它们在输入文件中的顺序不一栗��?Properties �c�d��一个散列表�Q�hashtable�Q�事实上是一�?Hashtable 子类�Q�中储存一�l�键-值对�Q�所以不能保证顺序�?

清单 3. LoadSample 的输�?/p>
-- listing properties --
fu=baz
foo=bar

The foo property: bar

XML 属性文�?br />�q�里没有什么新内容�?Properties �c�L��L��q�样工作的。不�q�，新的地方是从一�?XML 文�g中装载一�l�属性。它�?DTD 如清�?4 所�C��?

清单 4. 属�?DTD

如果不想�l�读 XML DTD�Q�那么可以告诉您它其实就是说在外�? 标签中包装的是一�? 标签�Q�后面是��L��数量�? 标签。对每一�? 标签�Q�有一个键属性，输入的内容就是它的倹{��清�?5 昄��?清单 1中的属性文件的 XML 版本是什么样子的�?

清单 5. XML 版本的属性文�?/p>

Hi
bar
baz

如果清单 6 所�C�，��d�� XML 版本�?Properties 文�g与读取老格式的文�g没什么不同�?

清单 6. ��d�� XML Properties 文�g

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"));
}
}

关于资源�l�定的说�?br />虽然 java.util.Properties �cȝ��在除了支持键-值对�Q�还支持属性文件作�?XML 文�g�Q�不�q�的是，没有内置的选项可以��?ResourceBundle 作�ؓ一�?XML 文�g处理。是的， PropertyResourceBundle 不��?Properties 对象来装载绑定，不过装蝲�Ҏ��的��用是��编码到�c�M��的，而不使用较新�?loadFromXML() �Ҏ��?

�q�行清单 6 中的�E�序产生与原来的�E�序相同的输出，�?清单 2所�C��?

保存 XML 属�?br />新的 Properties �q�有一个功能是��属性存储到 XML 格式的文件中。虽�?store() �Ҏ��仍然会创��Z��个类�?清单 1 所�C�的文�g�Q�但是现在可以用新的 storeToXML() �Ҏ��创徏�?清单 5 所�C�的文�g。只要传递一�?OutputStream 和一个用于注释的 String ��可以了。清�?7 展示了新�?storeToXML() �Ҏ��?

清单 7. ��?Properties 存储�?XML 文�g

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();
}
}

�q�行清单 7 中的�E�序产生的输出如清单 8 所�C��?/p>
清单 8. 存储�?XML 文�g

Rhyme
lay them straight
pick up sticks
a big, fat hen
shut the door
buckle my shoe

�l�束�?br />使用 XML 文�g�q�是使用老式�?a=b �c�d��的文件完全取决于您自己。老式文�g从内存的角度看肯定是轻量�U�的。不�q�，�׃�� XML 的普遍��用，��Z��会期�?XML 格式��行��h��Q�因为它已经被广泛��用了�Q�只不过没有用到 Properties 对象。选择完全在您。分析��Y件包 private XMLUtils �cȝ��源代码以获得关于所使用�?XML 解析的更多信息�?/p>

PTest.java
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 实现properties文�g的读�?br /> * @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();
 }
 }
}

暗夜�_�� 2007-03-03 16:18 发表评论

Hibernate二��~�存

暗夜�_�� — Sat, 03 Mar 2007 02:16:00 GMT
1。hibernate一�U�缓存�ؓsession�l�护的。二�U�缓存�ؓsessionfactory�l�护�?br />2。一�U�缓存持久化的是OID唯一的对象，所以不会存在�ƈ发访问的问题。二�U�缓存存在�ƈ发访问问题。所以二�U�缓存根据访问和修改的频率以及是否集��分�?个等�U�。��M��上说�Q�一�U�缓存保存在内存中，二��可以保存在内存或��盘中，为散列保存�?br />3。一�U�缓存�ؓ必须的，二��为可插入的缓存，其功能�ؓ�W�三�Ҏ��供�?br />4。二�U�缓存保存的为很��修改的对象�Q�因��Z��存在�q�发讉K��问题�Q�所以尽量减��对兑现的修�Ҏ��作，减少写入的脏数据�?br />5。一�U�缓存�ؓsession全程存在�Q�二�U�缓存可以设定过期时间�?br />6。需要在hibernate.cfg.xml中设定��用二�U�缓存。还需要在指定的映��文件中�Q�设定需要被�~�存的实体对象�?br />7。假如映��文件对象所对应的属性�ؓset�c�d��Q�还需要再�ơ指明被�~�存�Q�这样只会��set�c�d��的属性也��是getItems()取出的被�~�存。而其所对应的实体�ƈ未被�~�存�Q�如需要，需要在xml中指明�?

暗夜�_�� 2007-03-03 10:16 发表评论

暗夜�_�� — Fri, 02 Mar 2007 13:46:00 GMT

Java性能的优化（上）

黄伟�?

Java在九十年代中期出��C��后，在赢得赞叹的同时�Q�也引来了一些批评。赢得的赞叹主要是Java的跨�q�_��的操作性，��x��谓的”Write Once,Run Anywhere”.但由于Java的性能和运行效率同C相比�Q�仍然有很大的差距，从而引来了很多的批评�?
对于服务器端的应用程序，�׃��不大涉及到界面设计和�E�序的频�J�重启，Java的性能问题看似不大明显�Q�从而一些Java的技术，如JSP,Se rvlet,EJB�{�在服务器端�~�程斚w��得到了很大的应用�Q�但实际上，Java的性能问题在服务器端依然存在。下面我��分四个斚w��来讨论Java的性能和执行效率以及提高J ava性能的一些方法�?
一�Q�关于性能的基本知�?
1�Q�性能的定�?
在我们讨论怎样提高Java的性能之前�Q�我们需要明�?#8220;性能“的真正含义。我们一般定义如下五个方面作��判性能的标准�?
1�Q?�q�算的性能----哪一个算法的执行性能最�?
2�Q?内存的分�?---�E�序需要分配多��内存，�q�行时的效率和性能最高�?
3�Q?启动的时�?---�E�序启动需要多��时间�?
4�Q?�E�序的可伸羃�?----�E�序在用戯��载过重的情况下的表现�?
5�Q?性能的认�?-----用户怎样才能认识到程序的性能�?
对于不同的应用程序，�Ҏ��能的要求也不同。例如，大部分的应用�E�序在启动时需要较长的旉��Q�从而对启动旉��的要求有所降低�Q�服务器端的应用�E�序通常都分配有较大的内存空��_��所以对内存的要求也有所降低。但是，�q��ƈ不是所�q�两斚w��的性能可以被忽略。其�ơ，��法的性能对于那些把商务逻辑�q�用��C��务性操作的应用�E�序来讲非常重要。�ȝ��来讲�Q�对应用�E�序的要求将军_��对各个性能的优先��?
2�Q�怎样才能提高JAVA的性能
提高JAVA的性能�Q�一般考虑如下的四个主要方面：
�Q?�Q?�E�序设计的方法和模式
一个良好的设计能提高程序的性能�Q�这一点不仅适用于JAVA�Q�也适用也�Q何的�~�程语言。因为它充分利用了各�U�资源，如内存，CPU,高速缓存，对象�~�冲池及多线�E�，从而设计出高性能和可伸羃性强的系�l��?
当然�Q��ؓ了提高程序的性能而改变原来的设计是比较困隄��Q�但是，�E�序性能的重要性常常要高于设计上带来的变化。因此，在编�E�开始之前就应该有一个好的设计模型和�Ҏ��?
�Q?�Q?JAVA布��v的环境�?
JAVA布��v的环境就是指用来解释和执行JAVA字节码的技术，一般有如下五种。即解释指��o技�?Interpreter Technology)�Q�及时编译的技�?Just In Time Compilier Technology), 适应性优化技术（Adaptive Optimization Technology�Q? 动态优化，提前�~�译为机器码的技术（Dynamic Optimization,Ahead Of Time Technology�Q�和�~�译为机器码的技术（Translator Technology�Q?
�q�些技术一般都通过优化�U�程模型�Q�调整堆和栈的大��来优化JAVA的性能。在考虑提高JAVA的性能�Ӟ��首先要找到媄响JAVA性能的瓶颈（B ottleNecks�Q�，在确认了设计的合理性后�Q�应该调整JAVA布��v的环境，通过改变一些参数来提高JAVA应用�E�序的性能。具体内容见�W�二节�?
�Q?�Q?JAVA应用�E�序的实�?
当讨论应用程序的性能问题�Ӟ��大多数的�E�序员都会考虑�E�序的代码，�q�当然是对的�Q�当更重要的是要扑ֈ�影响�E�序性能的瓶颈代码。�ؓ了找到这些瓶颈代码，我们一般会使用一些辅助的工具�Q�如J probe,Optimizit,Vtune以及一些分析的工具如TowerJ Performance�{�。这些辅助的工具能跟�t�应用程序中执行每个函数或方法所消耗掉的时��_��从而改善程序的性能�?
(4) ��g和操作系�l?
��Z��提高JAVA应用�E�序的性能�Q�而采用跟快的CPU和更多的内存�Q��ƈ认�ؓ�q�是提高�E�序性能的唯一�Ҏ��Q�但事实�q��如此。实�늻�验和事实证明�Q�只有遭��C��应用�E�序性能的瓶颈，从而采取适当得方法，如设计模式，布��v的环境，操作�pȝ��的调��_��才是最有效的�?
3�Q�程序中通常的性能瓉��?
所有的应用�E�序都存在性能瓉��Q��ؓ了提高应用程序的性能�Q�就要尽可能的减��程序的瓉��。以下是在JAVA�E�序中经常存在的性能瓉��?

了解了这些瓶颈后�Q�就可以有针�Ҏ��的减少�q�些瓉��Q�从而提高JAVA应用�E�序的性能
4. 提高JAVA�E�序性能的步�?
��Z��提高JAVA�E�序的性能�Q�需要遵循如下的六个步骤�?
a) 明确�Ҏ��能的具体要�?
在实施一个项目之前，必须要明��该��目对于�E�序性能的具体要求，如：�q�个应用�E�序要支�?000个�ƈ发的用户�Q��ƈ且响应时间要�?�U�钟之内。但同时也要明白对于性能的要求不应该同对�E�序的其他要求冲�H��?
b) 了解当前�E�序的性能
你应该了解你的应用程序的性能同项目所要求性能之间的差距。通常的指标是单位旉��内的处理数和响应旉��Q�有时还会比较CPU和内存的利用率�?
c) 扑ֈ��E�序的性能瓉��
��Z��发现�E�序中的性能瓉��Q�通常会��用一些分析工��P��如：TowerJ Application Performance Analyzer或VTune来察看和分析�E�序堆栈中各个元素的消耗时��_��从而正��的扑ֈ��q�改正引��h��能降低的瓶颈代码，从而提高程序的性能。这些工兯��能发现诸如过多的异常处理�Q�垃圑֛�收等潜在的问题�?
d) 采取适当的措施来提高性能
扑ֈ�了引��L��序性能降低的瓶颈代码后�Q�我们就可以用前面介�l�过的提高性能的四个方面，卌��计模式，JAVA代码的实玎ͼ�布��vJAVA的环境和操作�pȝ��来提高应用程序的性能。具体内容将在下面的内容中作详细说明�?
e) 只进行某一斚w��的修�Ҏ��提高性能
一�ơ只改变可能引�v性能降低的某一斚w��Q�然后观察程序的性能是否有所提高�Q�而不应该一�ơ改变多个方面，因�ؓ�q�样你将不知道到底哪个方面的改变提高了程序的性能�Q�哪个方面没有，即不能知道程序瓶颈在哪�?
f) �q�回到步骤c,�l�箋作类似的工作�Q�一直达到要求的性能为止�?

二． JAVA布��v的环境和�~�译技�?
　开发JAVA应用�E�序�Ӟ��首先把JAVA的源�E�序�~�译��Z��q�_��无关的字节码。这些字节码��可以被各种��Z��JVM的技术所执行。这些技术主要分��Z��个大�c�R��即��Z��解释的技术和��Z��提前�~�译为本地码的技术。其�C�意囑֦�下：

具体可分为如下的五类�Q�　　
a) 解释指��o技�?
其结构图和执行过�E�如下：

　JAVA的编译器首先把JAVA源文件编译�ؓ字节码。这些字节码对于JAVA虚拟�?JVM)来讲��是机器的指令码。然后，JAVA的解释器不断的��@环取出字节码�q�行解释�q�执行�?
　�q�样做的优点是可以实现JAVA语言的跨�q�_��Q�同时生成的字节码也比较紧凑。JAVA的一些优点，如安全性，动态性都得保持；但缺�Ҏ��省生成的字节码没有经�q�什么优化，同全部编译好的本地码相比�Q�速度比较慢�?
b) 及时�~�译技术（Just In Time�Q?
　　及时�~�译技术是��Z��解决指��o解释技术效率比较低�Q�速度比较慢的情况下提出的�Q�其�l�构囑֦�下所�C��?

其主要变化是在JAVA�E�序执行之前�Q�又JIT�~�译器把JAVA的字节码�~�译为机器码。从而在�E�序�q�行时直接执行机器码�Q�而不用对字节码进行解释。同时对代码也进行了部分的优化�?
�q�样做的优点是大大提高了JAVA�E�序的性能。同�Ӟ��׃��~�译的结果�ƈ不在�E�序�q�行间保存，因此也节�U�了存储�I�间了加载程序的旉��Q�缺�Ҏ��׃��J IT�~�译器对所有的代码都想优化�Q�因此也��费了很多的旉��?
IBM和SUN公司都提供了相关的JIT产品�?
c) 适应性优化技术（Adaptive Optimization Technology�Q?
同JIT技术相比，适应性优化技术�ƈ不对所有的字节码进行优化。它会跟�t�程序运行的成个�q�程�Q�从而发现需要优化的代码�Q�对代码�q�行动态的优化。对优化的代码，采取8 0/20的策略。从理论上讲�Q�程序运行的旉��长�Q�代码就��优化。其�l�构囑֦�下：

其优�Ҏ��适应性优化技术充分利用了�E�序执行时的信息�Q�发行程序的性能瓉��Q�从而提高程序的性能�Q�其�~�点是在�q�行优化时可能会选择不当�Q�发而降低了�E�序的性能�?
其主要��品又IBM,SUN的HotSpot.
d) 动态优化，提前�~�译为机器码的技术（Dynamic Optimization,Ahead Of Time�Q?
动态优化技术充分利用了JAVA源码�~�译�Q�字节码�~�译�Q�动态编译和静态编译的技术。其输入时JAVA的原码或字节码，而输出是�l�过高度优化的可执行代码和个来动态库的�؜�? Window中是DLL文�g�Q�UNIX中是�׃�n�?a .so文�g)。其�l�构如下�Q?

其优�Ҏ��能大大提高程序的性能�Q�缺�Ҏ��破坏了JAVA的可�U�L��性，也对JAVA的安全带来了一定的隐患�?

Java性能的优化（下）

黄伟�?

三．优化JAVA�E�序设计和编码，提高JAVA�E�序性能的一些方法�?
通过使用一些前面介�l�过的辅助性工��h��扑ֈ��E�序中的瓉��Q�然后就可以对瓶颈部分的代码�q�行优化。一般有两种�Ҏ��Q�即优化代码或更改设计方法。我们一般会选择后者，因�ؓ不去调用以下代码要比调用一些优化的代码更能提高�E�序的性能。而一个设计良好的�E�序能够�_��代码�Q�从而提高性能�?
下面��提供一些在JAVA�E�序的设计和�~�码中，��Z��能够提高JAVA�E�序的性能�Q�而经帔R��用的一些方法和技巧�?
1�Q�对象的生成和大��的调整�?
JAVA�E�序设计中一个普遍的问题��是没有好好的利用JAVA语言本��n提供的函敎ͼ�从而常�怼�生成大量的对象（或实例）。由于系�l�不仅要花时间生成对象，以后可能�q�需花时间对�q�些对象�q�行垃圾回收和处理。因此，生成�q�多的对象将会给�E�序的性能带来很大的媄响�?
�?�Q�关于String ,StringBuffer�Q?和append
JAVA语言提供了对于String�c�d��变量的操作。但如果使用不当�Q�会�l�程序的性能带来影响。如下面的语句：
String name=new String(“HuangWeiFeng”);
System.out.println(name+”is my name”);
看似已经很精��了，其实�q��如此。�ؓ了生成二�q�制的代码，要进行如下的步骤和操作�?
�Q?�Q?生成新的字符�?new String(STR_1);
�Q?�Q?复制该字�W�串�?
�Q?�Q?加蝲字符串常�?#8221;HuangWeiFeng”(STR_2);
�Q?�Q?调用字符串的构架器（Constructor�Q?
�Q?�Q?保存该字�W�串到数�l�中�Q�从位置0开始）
�Q?�Q?从java.io.PrintStream�c�M��得到静态的out变量
�Q?�Q?生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
�Q?�Q?复制该字�W�串�~�冲变量
�Q?�Q?调用字符串缓冲的构架器（Constructor�Q?
�Q?0�Q?保存该字�W�串�~�冲到数�l�中�Q�从位置1开始）
�Q?1�Q?以STR_1为参敎ͼ�调用字符串缓�?StringBuffer)�c�M��的append�Ҏ��?
�Q?2�Q?加蝲字符串常�?#8221;is my name”(STR_3);
�Q?3�Q?以STR_3为参敎ͼ�调用字符串缓�?StringBuffer)�c�M��的append�Ҏ��?
�Q?4�Q?对于STR_BUF_1执行toString命��o�?
�Q?5�Q?调用out变量中的println�Ҏ��Q�输出结果�?
由此可以看出�Q�这两行��单的代码�Q�就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的�cȝ��实例一般都存放在堆中。堆要对所有类的超�c�，�cȝ��实例�q�行初始化，同时�q�要调用�c�L��其每个超�cȝ��构架器。而这些操作都是非常消耗系�l�资源的。因此，对对象的生成�q�行限制�Q�是完全有必要的�?
�l�修改，上面的代码可以用如下的代码来替换�?
StringBuffer name=new StringBuffer(“HuangWeiFeng”);
System.out.println(name.append(“is my name.”).toString());
�pȝ��进行如下的操作�?
(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(2) 复制该字�W�串�~�冲变量
(3) 加蝲字符串常�?#8221;HuangWeiFeng”(STR_1);
(4) 调用字符串缓冲的构架器（Constructor�Q?
(5) 保存该字�W�串�~�冲到数�l�中�Q�从位置1开始）
(6) 从java.io.PrintStream�c�M��得到静态的out变量
(7) 加蝲STR_BUF_1;
(8) 加蝲字符串常�?#8221;is my name”(STR_2);
(9) 以STR_2为参敎ͼ�调用字符串缓�?StringBuffer)实例中的append�Ҏ��?
(10) 对于STR_BUF_1执行toString命��o�?STR_3)
(11)调用out变量中的println�Ҏ��Q�输出结果�?
由此可以看出�Q�经�q�改�q�后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对�E�序的性能有很大的提高。但下面的代码段2 的执行速度��是代码�D?�?倍。因��Z��码段1生成了八个对象，而代码段2只生成了四个对象�?
代码�D?�Q?
String name= new StringBuffer(“HuangWeiFeng”);
name+=”is my”;
name+=”name”;
代码�D?�Q?
StringBuffer name=new StringBuffer(“HuangWeiFeng”);
name.append(“is my”);
name.append(“name.”).toString();
因此�Q�充分的利用JAVA提供的库函数来优化程序，�Ҏ��高JAVA�E�序的性能旉��帔R��要的.其注意点主要有如下几斚w��Q?
�Q?�Q?��可能的使用静态变量（Static Class Variables�Q?
如果�c�M��的变量不会随他的实例而变化，��可以定义�ؓ静态变量，从而��他所有的实例都共享这个变量�?
例：
public class foo
{
SomeObject so=new SomeObject();
}
��可以定义�ؓ�Q?
public class foo
{
static SomeObject so=new SomeObject();
}
�Q?�Q?不要对已生成的对象作�q�多的改变�?
对于一些类(如：String�c?来讲�Q�宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例�?
例：
String name=”Huang”;
name=”Wei”;
name=”Feng”;
上述代码生成了三个String�c�d��的对象实例。而前两个马上��需要系�l�进行垃圑֛�收处理。如果要对字�W�串�q�行�q�接的操作，性能��得更差。因为系�l�将不得为此生成更多得��时变量。如上例1 所�C��?
�Q?�Q?生成对象�Ӟ��要分配给它合理的�I�间和大��?
JAVA中的很多�c�都有它的默认的�I�间分配大小。对于StringBuffer�c�L��Ԍ��默认的分配空间大��是16个字�W�。如果在�E�序中��用StringBu ffer的空间大��不�?6个字�W�，那么��必��进行正��的初始化�?
�Q?�Q?避免生成不太使用或生命周期短的对象或变量�?
对于�q�种情况�Q�因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销��的多�?
�Q?�Q?只在对象作用范围内进行初始化�?
JAVA允许在代码的��M��地方定义和初始化对象。这��P��可以只在对象作用的范围内进行初始化。从而节�U�系�l�的开销�?
例：
SomeObject so=new SomeObject();
If(x==1) then
{
Foo=so.getXX();
}
可以修改为：
if(x==1) then
{
SomeObject so=new SomeObject();
Foo=so.getXX();
}
2�Q�异�?Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常�Q�进行异常的处理。但是如果��用不当，也会�l�JAVA�E�序的性能带来影响。因此，要注意以下两炏V�?
(1) 避免对应用程序的逻辑使用try/catch
如果可以用if,while�{�逻辑语句来处理，那么��尽可能的不用try/catch语句
(2) 重用异常
在必��要�q�行异常的处理时�Q�要��可能的重用已经存在的异常对象。以为在异常的处理中�Q�生成一个异常对象要消耗掉大部分的旉��?
3. �U�程(Threading)
一个高性能的应用程序中一般都会用到线�E�。因为线�E�能充分利用�pȝ��的资源。在其他�U�程因�ؓ�{�待��盘或网�l�读写�?�Ӟ��E�序能��l�处理和�q�行。但是对�U�程�q�用不当�Q�也会媄响程序的性能�?
�?�Q�正��用Vector�c?
Vector主要用来保存各种�c�d��的对象（包括相同�c�d��和不同类型的对象�Q�。但是在一些情况下使用会给�E�序带来性能上的影响。这主要是由V ector�cȝ��两个特点所军_��的。第一�Q�Vector提供了线�E�的安全保护功能。即使Vector�c�M��的许多方法同步。但是如果你已经��认你的应用�E�序是单�U�程�Q�这些方法的同步��完全不必要了。第二，在V ector查找存储的各�U�对象时�Q�常常要花很多的旉��q�行�c�d��的匹配。而当�q�些对象都是同一�c�d��Ӟ��q�些匚w��完全不必要了。因此，有必要设计一个单�U�程的，保存特定�c�d��对象的类或集合来替代V ector�c?用来替换的程序如下（StringVector.java�Q�：
public class StringVector
{
private String [] data;
private int count;
public StringVector() { this(10); // default size is 10 }
public StringVector(int initialSize)
{
data = new String[initialSize];
}
public void add(String str)
{
// ignore null strings
if(str == null) { return; }
ensureCapacity(count + 1);
data[count++] = str;
}

private void ensureCapacity(int minCapacity)
{
int oldCapacity = data.length;
if (minCapacity > oldCapacity)
{
String oldData[] = data;
int newCapacity = oldCapacity * 2;
data = new String[newCapacity];
System.arraycopy(oldData, 0, data, 0, count);
}
}
public void remove(String str)
{
if(str == null) { return // ignore null str }
for(int i = 0; i < count; i++)
{
// check for a match
if(data[i].equals(str))
{
System.arraycopy(data,i+1,data,i,count-1); // copy data
// allow previously valid array element be gc'd
data[--count] = null;
return;
}
}
}
public final String getStringAt(int index) {
if(index < 0) { return null; }
else if(index > count)
{
return null; // index is > # strings
}
else { return data[index]; // index is good }
}
/* * * * * * * * * * * * * * * *StringVector.java * * * * * * * * * * * * * * * * */
因此�Q�代码：
Vector Strings=new Vector();
Strings.add(“One”);
Strings.add(“Two”);
String Second=(String)Strings.elementAt(1);
可以用如下的代码替换�Q?
StringVector Strings=new StringVector();
Strings.add(“One”);
Strings.add(“Two”);
String Second=Strings.getStringAt(1);
�q�样��可以通过优化�U�程来提高JAVA�E�序的性能。用于测试的�E�序如下�Q�TestCollection.java�Q?
import java.util.Vector;
public class TestCollection
{
public static void main(String args [])
{
TestCollection collect = new TestCollection();
if(args.length == 0)
{
System.out.println(
"Usage: java TestCollection [ vector | stringvector ]");
System.exit(1);
}
if(args[0].equals("vector"))
{
Vector store = new Vector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++)
{
store.addElement("string");
}
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++)
{
String result = (String)store.elementAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
else if(args[0].equals("stringvector"))
{
StringVector store = new StringVector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) { store.add("string"); }
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) {
String result = store.getStringAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
}
}
/* * * * * * * * * * * * * * * *TestCollection.java * * * * * * * * * * * * * * * * */
��试的结果如下（假设标准的时间�ؓ�Q�，��小性能��好�Q�：

关于�U�程的操作，要注意如下几个方面�?
(1) 防止�q�多的同�?
如上所�C�，不必要的同步常常会造成�E�序性能的下降。因此，如果�E�序是单�U�程�Q�则一定不要��用同步�?
(2) 同步�Ҏ��而不要同步整个代码段
　　　�Ҏ��个方法或函数�q�行同步比对整个代码�D�进行同步的性能要好�?
(3) �Ҏ��个对象��用多”�?#8221;的机制来增大�q�发�?
一般每个对象都只有一�?#8221;�?#8221;�Q�这��p��明如果两个线�E�执行一个对象的两个不同的同步方法时�Q�会发生”死锁”。即使这两个�Ҏ��q�不�׃�n��M��资源。�ؓ了避免这个问题，可以对一个对象实�?#8221;多锁”的机制。如下所�C�：
class foo
{
private static int var1;
private static Object lock1=new Object();
private static int var2;
private static Object lock2=new Object();
public static void increment1()
{
synchronized(lock1)
{
var1++;
}
}
public static void increment2()
{
synchronized(lock2)
{
var2++;
}
}
}
4�Q�输入和输出(I/O)
输入和输出包括很多方面，但涉及最多的是对��盘�Q�网�l�或数据库的��d��操作。对于读写操作，又分为有�~�存和没有缓存的�Q�对于数据库的操作，又可以有多种�c�d��的J DBC驱动器可以选择。但无论怎样�Q�都会给�E�序的性能带来影响。因此，需要注意如下几点：
(1) 使用输入输出�~�冲
　　　��可能的多��用缓存。但如果要经常对�~�存�q�行��h��Q�flush�Q?则徏议不要��用缓存�?
(2) 输出��?Output Stream)和Unicode字符�?
　　　当时用Output Stream和Unicode字符串时�Q�Write�cȝ��开销比较大。因为它要实现Unicode到字�?byte)的�{�?因此�Q�如果可能的�?在��用Write�c�M��前就实现转换或用O utputStream�c�M��替Writer�c�L��使用�?
(3) 当需序列化时使用transient
　　　当序列化一个类或对象时�Q�对于那些原子类型（atomic�Q�或可以重徏的原素要表识为transient�c�d��。这样就不用每一�ơ都�q�行序列化。如果这些序列化的对象要在网�l�上传输�Q�这一��小的改变对性能会有很大的提高。　　
(4) 使用高速缓存（Cache�Q?
　　　对于那些�l�常要��用而又不大变化的对象或数据�Q�可以把它存储在高速缓存中。这样就可以提高讉K��的速度。这一点对于从数据库中�q�回的结果集��其重要�?
(5) 使用速度快的JDBC驱动器（Driver�Q?
　　　JAVA对访问数据库提供了四�U�方法。这其中有两�U�是JDBC驱动器。一�U�是用JAVA外包的本地驱动器�Q�另一�U�是完全的JAVA驱动器。具体要使用哪一�U�得�Ҏ��J AVA布��v的环境和应用�E�序本��n来定�?
5.一些其他的�l�验和技�?
(1) 使用局部变�?
(2) 避免在同一个类中动�q�调用函数或�Ҏ��(get或set)来设�|�或调用变量�?
(3) 避免在��@环中生成同一个变量或调用同一个函敎ͼ�参数变量也一��P��
(4) ��可能的使用static,final,private�{�关键字
(5) 当复制大量数据时�Q��用System.arraycopy()命��o�?

暗夜�_�� 2007-03-02 21:46 发表评论

equals() �?hashCode()

暗夜�_�� — Fri, 02 Mar 2007 11:41:00 GMT

我们知道�Q�equals()函数是用来做比较的。java中的比较有两�U�：一�U�是内存地址的比较，一�U�是内容的比较。而比较个体也有两�U�：一�U�是��单类型（�q�类��单说来无所谓内存地址的比较或者内�Ҏ��较的区别�Q�；�q�有一�U�是对象的比较，本文中说的主要是后�?/p>
在java中，�Q�对象）内存地址的比较，是通过==完成的。比�?#160;

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

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

而equals()通常是比较内容的。这里说“通常” �Q�是因�ؓ在最�Ҏ��的Object�c�M��Q�equal()函数做的是地址的比较。而在其他几乎所有的�c�M��Q�equals()都经�q�重载，�q�行内容的比较�?/p>
而在说equals()的时候我们还涉及hashCode()是因为在有些应用中（比如�Q�HashMap的key是对象）�Q�必��d��重蝲equals()的同旉��载hashCode()�?strong>因�ؓjava中默�?Object)的hashCode是根据对象的地址计算得到的�?/strong>

我们通常不会注意到这个问题，因�ؓ我们通常所使用�?em>key都是��单类型，或者是String, Long�{�一些特�D�的对象�Q�其�Ҏ��性请参看�W�者在写java ��拷贝和深拷贝时的讨论）�Q�这时候，�q�个问题被我们无意间�l�过�?/p>
有�h已经概括了这�U�我们忽略了的情况：“如果你想��一个对象A攑օ�另一个收集（集合�Q�对象B里，或者��用这个对象A为查找一个元对象在收集对象B里位�|�的钥匙�Q�key�Q�，�q�支持是否容�U�I��isContains()�Q�，删除攉��对象B里的元对象（remove()?�Q�这��L��操作�Q�那么，equals()和hashCode()函数必须开发者自己定义�?#8221; �Q�括号�ؓ�W�者添加）

��Z��便于理解�Q��D一�D늨�序�ؓ例：

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);
 }
}

�q�段代码的结果是什么？�{�案是nullPointerExcetpion.

而把hashCode()的注释去除，�E�序��可以返回正��的�l�果了。�ؓ什么呢�Q�因为：

Map.put(key,value)时根据key.hashCode生成一个内部hash��|��Ҏ��q�个hash值将对象存放在一个table�?/p>
Map.get(key)会比较key.hashCode和equals�Ҏ��Q�当且仅当这两者相�{�时�Q�才能正��定位到table。而我们说�q�，默认的java是对地址�q�行比较的�?/p>

暗夜�_�� 2007-03-02 19:41 发表评论

JAVA正则表达�?-Pattern和Matcher

暗夜�_�� — Wed, 28 Feb 2007 05:47:00 GMT

现在JDK1.4里终于有了自��q��正则表达式API包，JAVA�E�序员可以免��L��W�三�Ҏ��供的正则表达式库的周折了�Q�我们现在就马上来了解一下这个SUN提供�?#173;�q�来恩物-
-�Ҏ��来说��实如此�?
1.��介：
java.util.regex是一�?b style="COLOR: black; BACKGROUND-COLOR: #99ff99">�?/b>正则表达式所订制的模式来对字�W�串�q�行匚w��工作的类库包�?

它包括两个类�Q�Pattern和Matcher Pattern
一个Pattern是一个正则表辑ּ��l�编译后的表现模式�?
Matcher
一个Matcher对象是一个状态机器，它依据Pattern对象做�ؓ匚w��模式对字�W�串展开匚w��查�?

首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经�~�译后的模式�Q�然后一个Matcher实例在这个给定的Pattern实例的模�?#173;控制下进行字�W�串的匹配工作�?

以下我们��分别来看看�q�两个类�Q?

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

String pattern()
�q�回该Patter对象所�~�译的正则表辑ּ��?
String[] split(CharSequence input)
��目标字�W�串按照Pattern里所包含的正则表辑ּ�为模�q�行分割�?

String[] split(CharSequence input, int limit)
作用同上�Q�增加参数limit目的在于要指定分割的�D�|��Q�如��limi设�ؓ2�Q�那么目标字�W�串��根据正则表辑ּ�分�ؓ割�ؓ两段�?

一个正则表辑ּ��Q�也��是一串有特定意义的字�W�，必须首先要编译成��Z��个Pattern�cȝ��实例�Q�这个Pattern对象��会使用matcher()�Ҏ��来生成一个Matcher实例�Q�接着便可以��用该
Matcher实例以编译的正则表达式�ؓ基础对目标字�W�串�q�行匚w��工作�Q�多个Matcher是可以共用一个Pattern对象的�?

现在我们先来看一个简单的例子�Q�再通过分析它来了解怎样生成一个Pattern对象�q�且�~�译一个正则表辑ּ��Q�最后根据这个正则表辑ּ��目标字�W�串�q�行分割�Q?

import java.util.regex.*;
public class Replacement{
public static void main(String[] args) throws Exception {
// 生成一个Pattern,同时�~�译一个正则表辑ּ�
Pattern p = Pattern.compile("[/]+");
//�?/b>Pattern的split()�Ҏ��把字�W�串�?/"分割
String[] result = p.split(
"Kevin has seen《LEON》seveal times,because it is a good film."
+"/
凯文已经看过《这个杀手不太冷》几�ơ了�Q�因为它是一�?
+"好电影�?名词:凯文�?);
for (int i=0; iSystem.out.println(result[i]);

}
}

输出�l�果为：
Kevin has seen《LEON》seveal times,because it is a good film.
凯文已经看过《这个杀手不太冷》几�ơ了�Q�因为它是一部好电媄�?
名词:凯文�?
很明显，该程序将字符串按"/"�q�行了分�D�，我们以下再��?
split(CharSequence input, int
limit)�Ҏ��来指定分�D늚��D�|��Q�程序改动�ؓ�Q?
tring[] result = p.split("Kevin has seen《LEON》seveal times,because
it is a good film./
凯文已经看过《这个杀手不太冷》几�ơ了�Q�因为它是一部好电媄�?名词:凯文�?�Q?);
�q�里面的参数"2"表明��目标语句分��Z��D�c�?
输出�l�果则�ؓ�Q?
Kevin has seen《LEON》seveal times,because it is a good film.
凯文已经看过《这个杀手不太冷》几�ơ了�Q�因为它是一部好电媄�?名词:凯文�?
�׃��面的例子�Q�我们可以比较出java.util.regex包在构造Pattern对象以及�~�译指定的正则表辑ּ�的实现手法与我们在上一��中所介绍的Jakarta-ORO
包在完成同样工作时的差别�Q?b style="COLOR: black; BACKGROUND-COLOR: #ffff66">Jakarta-ORO
包要先构造一个PatternCompiler�c�d��象接着生成一个Pattern对象�Q�再��正则表辑ּ��?/b>该PatternCompiler�cȝ��compile()�Ҏ��来将所需的正则表辑ּ��~�译赋予Pattern�c�：
PatternCompiler orocom=new Perl5Compiler();
Pattern pattern=orocom.compile("REGULAR EXPRESSIONS");
PatternMatcher matcher=new Perl5Matcher();
但是在java.util.regex包里�Q�我们仅需生成一个Pattern�c�，直接使用它的compile()�Ҏ��可以达到同��L��效果:
Pattern p = Pattern.compile("[/]+");
因此��g��java.util.regex的构造法�?b style="COLOR: black; BACKGROUND-COLOR: #ffff66">Jakarta-ORO更�ؓ��z��ƈ�Ҏ��理解�?
3.Matcher�c?
Matcher�Ҏ��如下�Q?Matcher appendReplacement(StringBuffer sb,
String replacement)
��当前匹配子串替换�ؓ指定字符�Ԍ��q�且��替换后的子串以及其之前��C��ơ匹配子串之后的字符串段��d��C��个StringBuffer对象里�?
StringBuffer appendTail(StringBuffer sb)
��最后一�ơ匹配工作后剩余的字�W�串��d��C��个StringBuffer对象里�?
int end()
�q�回当前匚w��的子串的最后一个字�W�在原目标字�W�串中的索引位置
�?
int end(int group)
�q�回与匹配模式里指定的组相匹配的子串最后一个字�W�的位置�?
boolean find()
��试在目标字�W�串里查找下一个匹配子丌Ӏ?
boolean find(int start)
重设Matcher对象�Q��ƈ且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串�?
String group()
�q�回当前查找而获得的与组匚w��的所有子串内�?
String group(int group)
�q�回当前查找而获得的与指定的�l�匹配的子串内容
int groupCount()
�q�回当前查找所获得的匹配组的数量�?
boolean lookingAt()
��目标字�W�串是否以匹配的子串起始�?
boolean matches()
��试�Ҏ��个目标字�W�展开匚w��，也就是只有整个目标字�W�串完全匚w��时才�q�回真倹{�?
Pattern pattern()
�q�回该Matcher对象的现有匹配模式，也就是对应的Pattern
对象�?
String replaceAll(String replacement)
��目标字�W�串里与既有模式相匹配的子串全部替换为指定的字符丌Ӏ?
String replaceFirst(String replacement)
��目标字�W�串里第一个与既有模式相匹配的子串替换为指定的字符丌Ӏ?
Matcher reset()
重设该Matcher对象�?
Matcher reset(CharSequence input)
重设该Matcher对象�q�且指定一个新的目标字�W�串�?
int start()
�q�回当前查找所获子串的开始字�W�在原目标字�W�串中的位置�?
int start(int group)
�q�回当前查找所获得的和指定�l�匹配的子串的第一个字�W�在原目标字�W�串中的位置�?
�Q�光看方法的解释是不是很不好理解�Q�不要急，待会�l�合例子��比较容易明白了�Q?
一个Matcher实例是被用来对目标字�W�串�q�行��Z��既有模式�Q�也��是一个给定的Pattern所�~�译的正则表辑ּ��Q�进行匹配查扄��Q�所有往Matcher的输入都是通过CharSequence接口提供的，�q�样做的目的在于可以支持对从多元化的数据源所提供的数据进行匹配工作�?
我们分别来看看各�Ҏ��的��用：
★matches()/lookingAt ()/find()�Q?
一个Matcher对象是由一个Pattern对象调用其matcher()�Ҏ��而生成的�Q�一旦该Matcher对象生成,它就可以�q�行三种不同的匹配查找操�?#173;�Q?
matches()�Ҏ��试�Ҏ��个目标字�W�展开匚w��，也就是只有整个目标字�W�串完全匚w��时才�q�回真倹{�?
lookingAt
()�Ҏ��检��目标字�W�串是否以匹配的子串起始�?
find()�Ҏ��试在目标字�W�串里查找下一个匹配子丌Ӏ?
以上三个�Ҏ��都将�q�回一个布��值来表明成功与否�?
★replaceAll ()/appendReplacement()/appendTail()�Q?
Matcher�c�d��时提供了四个��匹配子串替换成指定字符串的�Ҏ��Q?
replaceAll()
replaceFirst()
appendReplacement()
appendTail()
replaceAll()与replaceFirst()的用法都比较��单，��L��上面�Ҏ��的解释。我们主要重点了解一下appendReplacement()和appendTail()�Ҏ��?
appendReplacement(StringBuffer sb, String replacement)
��当前匹配子串替换�ؓ指定字符�Ԍ��q�且��替换后的子串以及其之前��C��ơ匹配子串之后的字符串段��d��C��个StringBuffer对象里，而appendTail(StringBuffer
sb)
�Ҏ��则将最后一�ơ匹配工作后剩余的字�W�串��d��C��个StringBuffer对象里�?
例如�Q�有字符串fatcatfatcatfat,假设既有正则表达式模式�ؓ"cat"�Q�第一�ơ匹配后调用appendReplacement(sb,"dog"),那么�q�时StringBuffer
sb的内容�ؓfatdog�Q�也��是fatcat中的cat被替换�ؓdog�q�且与匹配子串前的内容加到sb里，而第二次匚w��后调用appendReplacement(sb,"dog")�Q�那么sb的内容就变�ؓfatdogfatdog�Q�如果最后再调用一�ơappendTail�Q�sb�Q?那么sb最�l�的内容��是fatdogfatdogfat�?
�q�是有点模糊�Q�那么我们来看个��单的�E�序�Q?
//该例��把句子里的"Kelvin"改�ؓ"Kevin"
import java.util.regex.*;
public class MatcherTest{
public static void main(String[] args)
throws Exception {
//生成Pattern对象�q�且�~�译一个简单的正则表达�?Kelvin"
Pattern p = Pattern.compile("Kevin");
//�?/b>Pattern�cȝ��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()�Ҏ��查找�W�一个匹配的对象
boolean result = m.find();
//使用循环��句子里所有的kelvin扑և��q�替换再��内容加到sb�?
while(result) {
i++;
m.appendReplacement(sb, "Kevin");
System.out.println("�W?+i+"�ơ匹配后sb的内�Ҏ��Q?+sb);
//�l�箋查找下一个匹配对�?
result = m.find();
}

//最后调用appendTail()�Ҏ��最后一�ơ匹配后的剩余字�W�串加到sb里；
m.appendTail(sb);
System.out.println("调用m.appendTail(sb)后sb的最�l�内�Ҏ��:"+
sb.toString());
}
}

最�l�输出结果�ؓ�Q?
�W?�ơ匹配后sb的内�Ҏ��Q�Kevin
�W?�ơ匹配后sb的内�Ҏ��Q�Kevin Li and Kevin
�W?�ơ匹配后sb的内�Ҏ��Q�Kevin Li and Kevin Chan are both
working in Kevin
�W?�ơ匹配后sb的内�Ҏ��Q�Kevin Li and Kevin Chan are both
working in Kevin Chen's Kevin
调用m.appendTail(sb)后sb的最�l�内�Ҏ��Q�Kevin Li and Kevin Chan
are both working in Kevin Chen's KevinSoftShop company.
看了上面�q�个例程是否对appendReplacement()�Q�appendTail()两个�Ҏ��的��用更清楚呢，如果�q�是不太肯定最好自己动手写几行代码��?#173;试一下�?
★group()/group(int group)/groupCount()�Q?
该系列方法与我们在上��介�l�的Jakarta-ORO中的MatchResult
.group()�Ҏ��c�M��(有关Jakarta-ORO请参考上��的内容)�Q�都是要�q�回与组匚w��的子串内容，下面代码��很好解释其用法�Q?
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("该次查找获得匚w��l�的数量为："+m.groupCount());
for(int i=1;i<=m
}
}

输出为：
该次查找获得匚w��l�的数量为：2
�W?�l�的子串内容为：ca
�W?�l�的子串内容为：t
Matcher对象的其他方法因比较好理解且�׃��幅有限�Q�请读者自��q��E�验证�?
4�Q�一个检验Email地址的小�E�序�Q?
最后我们来看一个检验Email地址的例�E�，该程序是用来��验一个输入的EMAIL地址里所包含的字�W�是否合法，虽然�q�不是一个完整的EMAIL地址��验程序，它不能检验所有可能出现的情况�Q�但在必要时您可以在其基��上增加所需功能�?
import java.util.regex.*;
public class Email {
public static void main(String[] args) throws Exception {
String input = args[0];
//��输入的EMAIL地址是否�?
非法�W�号"."�?@"作�ؓ起始字符
Pattern p = Pattern.compile("^\.|^\@");
Matcher m = p.matcher(input);
if (m
//��是否以"www."��v�?
p = Pattern.compile("^www\.");
m = p.matcher(input);
if (m
//��是否包含非法字�W?
p = Pattern.compile("[^A-Za-z0-9\.\@_\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
while(result) {
//如果扑ֈ�了非法字�W�那么就设下标记
deletedIllegalChars = true;
//如果里面包含非法字符如冒号双引号�{�，那么��把他们消去�Q�加到SB里面
m.appendReplacement(sb, "");
result = m.find();
}

m.appendTail(sb);
input = sb.toString();
if (deletedIllegalChars) {
System.out.println("输入的EMAIL地址里包含有冒号、逗号�{�非法字�W�，请修�?);
System.out.println("您现在的输入�? "+args[0]);
System.out.println("修改后合法的地址应类�? "+input);
}
}
}

例如�Q�我们在命��o行输入：java Email www.ke...@163.net
那么输出�l�果��会是：EMAIL地址不能�?www.'起始
如果输入的EMAIL为@k...@163.net
则输��Zؓ�Q�EMAIL地址不能�?.'�?@'作�ؓ起始字符
当输入�ؓ�Q�cgjmail...@163.net
那么输出��是�Q?
输入的EMAIL地址里包含有冒号、逗号�{�非法字�W�，请修�?
您现在的输入�? cgjmail...@163.net
修改后合法的地址应类�? cgjm...@163.net
5�Q��ȝ��Q?
本文介绍了jdk1.4.0-beta3里正则表辑ּ��?-java.util.regex中的�c�M��及其�Ҏ��Q�如果结合与上一��中所介绍�?b style="COLOR: black; BACKGROUND-COLOR: #ffff66">Jakarta-ORO
API作比较，读者会更容易掌握该API的��用，当然该库的性能��在未来的日子里不断扩展�Q�希望获得最��C��息的读者最好到及时到SUN的网站去了解�?
6�Q�结束语�Q?
本来计划再多写一��介�l�一下需付费的正则表辑ּ�库中较具代表性的作品�Q�但觉得既然有了免费且优�U�的正则表辑ּ�库可以��用，何必�q�要��L��需付费的呢�Q�相信很多读�?#173;也是�q�么想的:�Q�所以有兴趣了解更多其他的第三方正则表达式库的朋友可以自己到�|�上查找或者到我在参考资料里提供的网址�ȝ��看�?
参考资�?
java.util.regex的帮助文�?
Dana Nourie 和Mike McCloskey所写的Regular Expressions and the
Java™ Programming Language
需要更多的�W�三�Ҏ��则表辑ּ�资源以及��Z��它们所开发的应用�E�序��L��http://www.meurrens.org/ip-Links/java/regex/index.html
关于作�?
陈广�?Kevin
Chen,汕头大学电子信息工程�p�d��U�学士，台湾大新出版�C��区开发部�Q�现正围�l�中日韩电子资料使用JAVA开发电子词典等相关��目。可通过E-mail:cgjm...@163.net于他联系�?/p>

暗夜�_�� 2007-02-28 13:47 发表评论

暗夜�_�� — Tue, 27 Feb 2007 01:43:00 GMT

本文以一条龙的�Ş式一�ơ性解决问题�?/font>

�c�L��q�泛的概念，表示一个有共同性质的群体。如�Q��h�c�R�?br />
代码�Q?br /> // 声明一个类“Human”
 class Human{
 private String name;
 public String getName(){
 return name;
 }
 public void setName(String value){
 this.name = value;
 }
 //......
 }

对象指的是具体的一个实实在在的东西。如、张三、李四�?br />
代码�Q?br /> Human zhangsan = new Human();

图：


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

Human human = new Human();

�E�序执行到这里之后，java虚拟机将会在内存中创��Z��?#160;Human 对象�Q��ƈ��这个对象的引用赋给 human 变量�?/font>

接着�Q?font color="#000000">human.setName("张三"); human.setName("李四");好了对象�Q�实例）创徏好了�Q�呵�?/font>�Q?br />
图：


“�?#8221;是一�?font color="#ff0000">基类�Q�则“男�h”�?#8220;�?#8221;的一�?font color="#ff0000">子类。如�?#8220;张三”是一�?#8220;男�h”�Q�也��是�?#8220;张三”�?#8220;男�h”的一个对象，那么昄��“张三”也是“�?#8221;�q�个基类的一个对象�?br /> class nanren extends human(String args[ ]){
 //.............
 }

�Ҏ��是类的行为，如�h会笑、会坐、会走�\ 一栗��?br />
图：


代码�Q?br /> zhangsan.go();zhangsan.xiao();zhangsan.shuijiao();zhangsan.qita();

接口只定义了一些方法，而没有实现这些方法，它规定了实现接口的类必须具备的方法（能力�Q�，它只是一个规�?/font>�?/font>

我们规定�Q�只要是人就可以走�\、笑、睡觉、做其他的事�Q�于是我们用代码实现�q�个规定
public interface you_are_human{
public void go();
public void xiao();
public void shuijiao();
public void qita();
}
�q�时�Q�张三想做�h�Q�但他只��x��有走路和�W�的能力。首先，他必��d��明自己是人，也就是前面对人的规定�Q?br />然后惛_��什么由他自己决定：

public class zhangsan extends Human implements you_are_human{
public void go(){
// ......
}
public void xiao(){
// ......
}
}
使用的时候：
you_are_human zhangsan = new you_are_human();

zhangsan.go();

zhangsan.xiao();

那有的�h��׃��问，�q�和前面我定义类有什么区别；

�q�是因�ؓ�Q�java的类的��承是从上��C��的，��L��1 》老爸1 》儿�?

 ��L��2 》老爸2 �?#160;儿子2
 而不能是�Q�爷�? �?#160;儿子1

�q�样��׃ؕ套了 �Q�是不，闹笑话；所以，�c�规定了不��承关�p�，防止乱套�Q��ɾl�构变得清晰�?br />
所以，当我们��用树型结构时�Q��用类�?br />

�׃��Q�在生活中还有许多这��L��情况�Q�如�Q�张三是中国人，那张三他也是��国人双重��n份�?br />
 再如�Q�李四是java工程�?也是厨师�?br />那怎么办？�Q?br />
我们可以�q�么做：
规定多个�w�䆾
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(){
// ......
}
}

当张三去��国�Ӟ��老美叫他拿个�l�证来看�Q?br />
zhangsan.USA_L();

呵呵�Q�再举个例子大家��清楚了�Q?br />
HP�?#8220;三星”�?#8220;IBM”两种�Q�我通常而言不可能一个HP是既�?#8220;三星”又是“IBM”的吧~~~~~~~~�c?br /> “家庭�?#8221;�?#8220;办公�?#8221;两种�Q�但往往我们能买到拥有两�U�款式相�l�合厂品是吧 ~~~~~~~~~~~接口

中国��h��Q?u>�c�L��?#8220;��徏世袭�?#8221;�Q�接口有�?#8220;�q�反常理�׃�u”�Q�呵�?img height="20" src="http://m.tkk7.com/Emoticons/QQ/lol.gif" width="20" border="0" />开个玩�W?/u>�?br />
�q�样说完大家再去看些相关文章��׃��觉得很容易了呵呵

剩下抽象�c�d��单了�Q�那是抽象类�Q?font color="#000000">abstract�Q?/font>他还是类�Q�class)�Q�只不过是抽象的�|�了�?br />
抽象�c?font color="#000000">�Ҏ��具体�c�d��的部分实�?-----抽象�c�L��对具体的抽象�Ҏ��特征包括�Q?font color="#ff0000">�Ҏ��的名字、参数的数目、参数的�c�d��?br />
不包括：�q�回�c�d��、参数名字、和抛出的异常�?br />
java接口�Q�抽象类�Q�用来声明一个新的类�?Java设计师应当主要��用接口和抽象�c�d��软�g单位与内部和外部耦合(软�g工程中内�?��h��?br />
在理想的情况下，一个具体类应当只实现接口和抽象�c�M��声明的方法，而不应当�l�出多余的方法！

抽象�c�M��提供一个类的部分实现。抽象类可以有实例变量、以及一个或多个构造函数�?br />
��个概念够抽象了吧�Q?br />public abstract class Human{...}

男�h也是
public abstract class man{...}

有一点必��讲清：接口不能�l�承抽象�c�，接口只能�l�承实实在在的类�Q?br />
如，我可以�ؓ某个HP厂品�Q�类�Q�规定一�U�规范（接口�Q�，但由于各个厂家推陈出斎ͼ�所以，我很隑֯�某一�c�d��厂品规定�Q?#8220;家庭型hp”��很难下个结论（接口�Q��?br />

从��Y件优化角度来考虑�c�d��接口问题。类class条理清楚内聚性好�Q�用于��Y件模块内部实玎ͼ�汽�R的内部机

梎ͼ��Q�接口interface很灵�z�耦合性好�Q�用于模块外部实玎ͼ�如，汽�R操作板的按钮�Q�。从而实现强内聚、松耦合

的��Y件设计思想�?/strong>

暗夜�_�� 2007-02-27 09:43 发表评论

include指��o和include动作的区别是什�?

暗夜�_�� — Mon, 13 Nov 2006 13:23:00 GMT

 include指��o和include动作都能实现��外部文档包含到JSP文档中的功能�Q�名�U�C��很相��|��非常�Ҏ��h��。include指��o和include动作到底有什么分别，哪一�U�方式会更好呢？
1.include指��o
 include可以在JSP��面转换成Servlet之前�Q�将JSP代码插入其中。它的主要优�Ҏ��功能强大�Q�所包含的代码可以含有��M��上媄响主��面的JSP构造，比如属性、方法的定义和文档类型的讑֮�。它的缺�Ҏ��难于�l�护只要被包含的��面发生更改�Q�就得更改主��面�Q�这是因��Z��面不会自动地查看被包含的页面是否发生更攏V�?br />include指��o的语法格式如�?br /> <%@ include file="Relative Url"%>

2.include动作
jsp:include动作是在主页面被��h��Ӟ��次�U�页面的输出包含�q�来。尽��被包含的页面的输出中不能含有JSP�Q�但�q�些��面可以是其他资源所产生的结果。服务器按照正常的方式对指向被包含资源的URL�q�行解释�Q�因而这个URL可以是Servlet或JSP��面。服务器以通常的方式运行被包含的页面，��生的输出攑ֈ�主页面中�Q�这�U�方式与RequestDispatcher�cȝ��include�Ҏ��一致。它的优�Ҏ��在被包含的页面发生更�Ҏ��Q�无��d��主页面做��Z��攏V��它的缺�Ҏ��所包含的是�ơ��面的输出，而非�ơ��面的实际代码，所以在被包含的��面中不能��用�Q何有可能在整体上影响主页面的JSP构造�?br /> jsp:include动作的完整语法如�?br />
其中jsp:include之间不能有空��|��page属性指定被包含的页面，�q�个属性是必需的，是指向某�U�资源的相对URL。如果这个相对URL不是�?开��_��则将其解释�ؓ相对于主��面的�\径；如果是以/开��_��是这个URL被解释�ؓ相对于当前WEB应用的根目录�Q�而不是服务器的根目录�Q�这是因��URL是由服务器来解释的，不是��q��L��览器来解释的。像下面�q�行代码�Q�是��q��L��览器进行解释的�Q�因此会按照相对于服务器的根目录�q�行解释�?br /> flush属性是一个可选的�ơ��属性，默认��gؓfalse�Q�它指定在将��面包含�q�来之前是否应该清空主页面的输出��?br /> 注意�Q�在JSP1.1中，flush是必需的属性，而且聚会只能是true�?br />3.两者的区别和比�?/strong>
 jsp:include动作和include指��o之间的根本性的不同在于它们被调用的旉��。jsp:include动作在请求期间被�Ȁ�z�，而include指��o在页面�{换期间被�Ȁ�z�R�?br /> 两者之间的差异军_��着它们在��用上的区别。��用include指��o的页面要比��用jsp:include动作的页面难于维护。前面已�l�说�q�，使用JSP指��o�Q�如果包含的JSP��面发生变化�Q�那么用到这个页面的所有页面都需要手动更新。在JSP服务器的相关规范中�ƈ没要求能够检��出包含的文件什么时候发生改变，实际上大多数服务器页都有��d��现这�U�机制。这样就会导致十分严重的�l�护问题�Q�需要记住所有包含某一个页面的其他��面�Q�或者重新编译所有的��面�Q�以使更改能够生效。在�q�点上，jsp:include��׃��现出了十分巨大的优势�Q�它在每�ơ请求时重新把资源包含进来。在实现文�g包含上，应该��可能地使用jsp:include动作�?br /> jsp:include动作直比于include指��o在维护上有着明显优势�Q�而include指��o仍然能够得以存在�Q�自然在其他斚w��有特�D�的优势。这个优势就是include指��o的功能更强大�Q�执行速度也稍快。include指��o允许所包含的文件中含有影响主页面的JSP代码�Q�比如响应报送的讄��和属性方法的定义。以下表格就是两�U�包含方式的�Ҏ��:

include指��o
jsp:include动作
语法格式
<%@ include file=”..”%>
发生作用的时�?/span>
��面转换期间
��h��期间
包含的内�?/span>
文�g的实际内�?/span>
��面的输�?/span>
转换成的Servlet
主页面和包含��面转换��Z��?/span>Servlet
主页面和包含��面转换为独立的Servlet
影响主页�?/span>
可以
不可�?/span>

include指��o
jsp:include动作
发生更改时是否需要显式更改主��面
需�?/span>
不需�?/span>
�~�译旉��
较慢�Q�资源必��被解析
较快
执行旉��
�E�快
较慢�Q�每�ơ资源必��被解析
灉|��?/span>
较差�Q�页面名�U�固�?/span>
更好�Q�页面可以动态指�?/span>

 了解到jsp:include动作和include指��o各自的功能和区别�Q�在使用�Ӟ��可以通过考虑各方面的因素�Q�来军_��使用哪一�U�方式。尽��各自都有一定的优缺点，在实际��用中�Q�还是应优先考虑使用jsp:include动作�Q�这是因为它在代码维护上的优势远胜过其在功能上的不��?

暗夜�_�� 2006-11-13 21:23 发表评论

暗夜�_�� — Mon, 09 Oct 2006 08:23:00 GMT

Servlet是在多线�E�环境下的。即可能有多个请求发�l�一个servelt实例�Q�每个请求是一个线�E��?
struts下的action也类��|��同样在多�U�程环境下。可以参考struts user guide: http://struts.apache.org/struts-action/userGuide/building_controller.html 中的Action Class Design Guidelines一�? Write code for a multi-threaded environment - Our controller servlet creates only one instance of your Action class, and uses this one instance to service all requests. Thus, you need to write thread-safe Action classes. Follow the same guidelines you would use to write thread-safe Servlets.
�?为多�U�程环境�~�写代码。我们的controller servlet指挥创徏你的Action �cȝ��一个实例，用此实例来服务所有的��h��。因此，你必��ȝ��写线�E�安全的Action�c�R��遵循与写线�E�安全的servlet同样的方针�?

1.什么是�U�程安全的代�?
在多�U�程环境下能正确执行的代码就是线�E�安全的�?
安全的意思是能正��执行，否则后果是程序执行错误，可能出现各种异常情况�?/p>
2.如何�~�写�U�程安全的代�?
很多书籍里都详细讲解了如何这斚w��的问题，他们主要讲解的是如何同步�U�程对共享资源的使用的问题。主要是对synchronized关键字的各种用法�Q�以及锁的概��c�?
Java1.5中也提供了如��d��锁这�cȝ��工具�c�R��这些都需要较高的技巧，而且相对难于调试�?

但是�Q�线�E�同步是不得以的�Ҏ��,是比较复杂的,而且会带来性能的损失。等效的代码中，不需要同步在�~�写�Ҏ��度和性能上会更好些�?
我这里强调的是什么代码是始终为线�E�安全的、是不需要同步的。如�?
1)帔R��始终是线�E�安全的�Q�因为只存在��L��作�?
2)�Ҏ��造器的访�?new 操作)是线�E�安全的�Q�因为每�ơ都新徏一个实例，不会讉K��׃�n的资源�?
3)最重要的是:局部变量是�U�程安全的。因为每执行一个方法，都会在独立的�I�间创徏局部变量，它不是共享的资源。局部变量包括方法的参数变量�?
struts user guide里有�Q?
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.
�?只��用用局部变量�?-�~�写�U�程安全的代码最重要的原则就是，在Action�c�M��只��用局部变量，不��用实例变量�?/p>

�ȝ��Q?
在Java的Web服务器环境下开发，要注意线�E�安全的问题。最��单的实现方式��是在Servlet和Struts Action里不要��用类变量、实例变量，但可以��用类帔R��和实例常量�?
如果有这些变量，可以��它们�{换�ؓ�Ҏ��的参��C��入，以消除它们�?
注意一个容易�؜淆的地方�Q�被Servlet或Action调用的类�?如值对象、领域模型类)中是否可以安全的使用实例变量�Q�如果你在每�ơ方法调用时
新徏一个对象，再调用它们的�Ҏ��Q�则不存在同步问�?--因�ؓ它们不是多个�U�程�׃�n的资源，只有�׃�n的资源才需要同�?--而Servlet和Action的实例对于多个线�E�是�׃�n的�?
换句话说�Q�Servlet和Action的实例会被多个线�E�同时调用，而过了这一�?如果在你自己的代码中没有另外启动�U�程�Q�且每次调用后箋业务对象旉��是先新徏一个实例再调用�Q�则都是�U�程安全的�?/p>

暗夜�_�� 2006-10-09 16:23 发表评论

java.util.ArrayList 详解

暗夜�_�� — Sat, 30 Sep 2006 00:14:00 GMT
 摘要: java.util.ArrayList 数组和数�l�列表之间有着重大的区别。数�l�是 Java 语言的一个特征，对于每个元素�c�d�� T �Q�都有数�l�类�? T[]; 然而， ... 阅读全文

暗夜�_�� 2006-09-30 08:14 发表评论

JSP生成静态页实践及其设计思想

暗夜�_�� — Fri, 29 Sep 2006 14:29:00 GMT
引子�Q?br />我们以两个大型网站�ؓ例作比较�Q?br />51job和智联招聘（先声明我不是��Z��们作�q�告�Q�仅以他们�ؓ例作技术上的比较）
51job采用的是比较“先进”的php技术，而智联用的是比较落后的asp.但我们可能会明显的感觉到51job的反应速度相比��招聘实在是太慢了�Q��ؓ什么会�q�样�Q�细心的人可能会察觉��C��。智联虽然用的是asp,但他采用了另一�U�更巧妙的技�?-asp生成静态页技术。所有的动态页基本上都转换成了html静态页�Q�不用访问数据库�Q�当然反应快了�?br />下面我们讨论一下jsp怎么转换成html??
首先要做一个模�ѝ��后�~�不限�Q�但一般都�?.template例子
<html>
<head>
<title>#title#title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<LINK href="../css.css" rel=stylesheet type=text/css>
head>
<body>

#title# 
作者：#author# 
 
#content# 
P>
body>
html>

做一个处理模板的�c�L��者jsp文�g�?��明问题我们从��单入手以一个jsp文�g��Z��)
filePath = request.getRealPath("/")+"WEB-INF/templates/template.htm";
out.print(filePath);
String templateContent="";
FileInputStream fileinputstream = new FileInputStream(filePath);//��d��模块文�g
int lenght = fileinputstream.available();
byte bytes[] = new byte[lenght];
fileinputstream.read(bytes);
fileinputstream.close();
templateContent = new String(bytes);
out.print("以下是模板内容：
"+templateContent+"
以下是置换以后的html内容
");
templateContent=templateContent.replaceAll("#title#",title);
templateContent=templateContent.replaceAll("#author#",editer);//替换掉模块中相应的地�?/span>
templateContent=templateContent.replaceAll("#content#",content);
// �Ҏ��旉��得文件名
Calendar calendar = Calendar.getInstance();
String fileame = String.valueOf(calendar.getTimeInMillis()) +".html";
fileame = request.getRealPath("/")+fileame;//生成的html文�g保存路径

out.print(templateContent);
FileOutputStream fileoutputstream = new FileOutputStream(fileame);//建立文�g输出��?/span>
byte tag_bytes[] = templateContent.getBytes();
fileoutputstream.write(tag_bytes);
fileoutputstream.close();
嗯，核心技术就是这样了�Q�如果大家要求的性能更高�Q�可以改用freemarker做模�ѝ��freemarker的��用方法可以参阅另一��文章�?a class="singleposttitle" id="viewpost1_TitleUrl" href="/zhanglijun33/archive/2006/07/20/freemarker.html">Freemarker 模板工具的作用及使用�?br />
引自�Q?a href="/zhanglijun33/archive/2006/07/28/60568.aspx">http://m.tkk7.com/zhanglijun33/archive/2006/07/28/60568.aspx

暗夜�_�� 2006-09-29 22:29 发表评论

	include指��o	jsp:include动作
语法格式	<%@ include file=”..”%>
发生作用的时�?/span>	��面转换期间	��h��期间
包含的内�?/span>	文�g的实际内�?/span>	��面的输�?/span>
转换成的Servlet	主页面和包含��面转换��Z��?/span>Servlet	主页面和包含��面转换为独立的Servlet
影响主页�?/span>	可以	不可�?/span>
	include指��o	jsp:include动作
发生更改时是否需要显式更改主��面	需�?/span>	不需�?/span>
�~�译旉��	较慢�Q�资源必��被解析	较快
执行旉��	�E�快	较慢�Q�每�ơ资源必��被解析
灉\|��?/span>	较差�Q�页面名�U�固�?/span>	更好�Q�页面可以动态指�?/span>

亚洲国产午夜电影在线入口,亚洲国产精品久久久久婷婷老年,91精品国产亚洲爽啪在线影院

全面文�g操作java代码

JAVA语言的反���和内省

1 术语定义

2 朴素匚w�����法

3 KMP���法

4 支持通配�W?�?的KMP���法

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

6 �l�语

NoClassDefDoundErr与ClassNotFoundException区别

java异常处理

Hibernate二��~�存

equals() �?hashCode()

JAVA正则表达�?-Pattern和Matcher

include指��o和include动作的区别是什�?

java.util.ArrayList 详解

JSP生成静态页实践及其设计思想

JAVA语言的反��和内省

2 朴素匚w��法

3 KMP��法

4 支持通配�W?�?的KMP��法