BlogJava-花-随笔分类-Java

ANT 下载,ant的配法

Tue, 18 Sep 2007 01:44:00 GMT

下载http://www.apache.org/dist/ant/binaries下的apache-ant-1.6.1-bin.zip
接压安装。

ant的配法：
1。解压ant的包到本地目录。
2。在环境变量中设置ANT_HOME，值为你的安装目录。
3。在环境变量中设置JAVA_HOME，值为你的jdk安装目录。
4。把ANT_HOME/bin加到你系统的path目录中去。

SET ANT_HOME=D:\jakarta-ant-1.5.1 //注意是Ant的安装目录，不是bin子目录
SET PATH=%PATH%;%ANT_HOME%\bin;

在cmd模式下输入 ant -version回车，看到输出说明配置成功。

花 2007-09-18 09:44 发表评论

深入 JAVA对象的复制与比较

Wed, 10 Jan 2007 02:46:00 GMT

1.对象的复制

String str1 = "This is a string!" //这里是 "对象引用" 的复制
String str2 = new String(str1); //这里是 "对象实例" 的复制

浅复制: 只复制复合对象本身.
深复制: 除了复制复合对象本身, 还复制了复合对象的引用的对象实例.

例如:

class Pupil{
    public Pupil(String sno, String name, int age){
        this.sno = new String(sno);
        this.name = new String(name);
        this.age = age;
    }

    public String getSno() {
        return sno;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private String sno;
    private String name;
    private int age;
}

public class CopyDemo {
public static Pupil[] shallowCopy(Pupil[] aClass) {
Pupil[] newClass = new Pupil[aClass.length];

        //此时newClass 与aClass 指向同一块内存
        for(int i=0; i            newClass[i] = aClass[i];
        return newClass;
    }

    public static Pupil[] deepCopy(Pupil[] aClass) {
        Pupil[] newClass = new Pupil[aClass.length];

        //此时newClass 与aClass 的相应sno , name 指向同一块内存
        for(int i=0; i            String sno = aClass[i].getSno();
            String name = aClass[i].getName();
            int age = aClass[i].getAge();
            newClass[i] = new Pupil(sno, name, age);
        }

return newClass;
}

public static Pupil[] deeperCopy(Pupil[] aClass) {
Pupil[] newClass = new Pupil[aClass.length];

        //完全的复制
        for(int i=0; i            String sno = new String(aClass[i].getSno());
            String name = new String(aClass[i].getName());
            int age = aClass[i].getAge();
            newClass[i] = new Pupil(sno, name, age);
        }

return newClass;
}
}

2.clone()的使用

* Object.clone()
* Cloneable 接口
* CloneNotSupportedException

a. 使用Object.clone 进行复制
两个必须条件:
1.一定要将重定义后的clone() 方法定义为公有方法(在Object 类中, 它是受保护的成员, 不能直接使用)
2.该后代类声明实现接口 Cloneable 接口(当类实现该接口, 其任何子类也会继承该接口), 该接口实际上没有任何
内容, 只是一个标识, 标志实现该接口的类提供clone() 方法.(这是接口的一种非典型用法)

public class Fraction implements Cloneable {
    public Object clone() {
        try{
            return super.clone(); //call protected method
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }
    //other methods ...
}

b.重写Object.clone()
例如对   private char[] cb; character buffer 进行复制

// add in class Cirbuf
        public Object clone() {
        try{
            Cirbuf copy = (Cirbuf)super.clone();
            copy.cb = (char[])cb.clone();
            return copy;
        }catch (CloneNotSupportedException e){
            throw new InternalError(e.toString());
        }
    }

c.复制数组
数组是在方法调用重以引用的形式传递的对象. 下述情况下非常适合引用来传递数组:
*正在接收的方法不修改数组
*正在调用的方法不必关心是否修改数组
*正在调用的方法想要得到数组中的修改结果
否则, 就应该在方法调用中传递数组对象的副本. 只需调用 arrObj.clone() 方法即可完成数组arrObj 的复制操作. 随后将该数组副本强制转换为其正确类型:
      (type[])arrObj.clone();
   System.arraycopy 方法提供一种用于在数组间复制多个元素的有效方式.
        System.arraycopy(source, i, target, j, len)

3.对象实例的比较

例如:

Pupil p1 = new Pupil("99184001", "zhang3", 18);
Pupil p2 = new Pupil("99184001", "zhang3", 18);

a. "=="
if(p1 == p2)...
此次测试的是对象引用, 其结果肯定是false, 只要两个对象引用不是互为别名就不会相等.
b. 浅比较 false

if(p1.getSno() == p2.getSno() && p1.getName() == p2.getName()
&& p1.getAge() == p2.getAge()) ...;

c. 深比较   true[/code]
if(p1.getSno().equals(p2.getSno()) && p1.getName().equals(p2.getName())
     && p1.getAge() == p2.getAge()) ...;[/code]
    JAVA API 的跟类Object 也提供了equals() 方法, 但它只是比较两个对象引用, 而非比较两个对象实例.
    不管怎样, 如果需要比较Pupil 类的对象(例如要将它们放入对象容器), 应该为Pupil 类重定义equals() 方法:

    public boolean equals(Object otherobj) {
        //检查otherobj 是否为空
        if(otherobj == null) return false;

//检查otherobj 是否就是当前对象
if(otherobj == this) return true;

//检查otherobj 是否具有正确的类型, 即检查是否可与当前对象比较
if(!(otherobj instanceof Pupil)) return false;

        //将otherobj 转换为Pupil 类的对象引用
        Pupil tmpObj = (Pupil)otherobj;
        //关于学生是否相等的逻辑检查
        if(sno.equals(tmpObj.sno) && name.equals(tmpObj.name)
             && age == tmpObj.age) return true;

        return false;
    }

JAVA API 所提供的每个类几乎都提供了采用深比较策略的equals() 方法, 例如String 类equals() 方法. 一般来说, 用户自己定义的类也应当提供合适的equals() 方法, 特别是当程序要将其对象放入JAVA API 所提供的对象容器类的时候.
按照约定, 任何类所提供的equals() 方法所实现的相等比较应该是等价关系, 即满足自反性, 对称性和传递性. 另外一个类重定义了equals() 方法, 也应该重定义相应hashCode() 方法, 否则将这个类的对象放入映射对象容器时也会发生以外.

花 2007-01-10 10:46 发表评论

Java源码分析：深入探讨Iterator模式

Sat, 30 Dec 2006 01:43:00 GMT

java.util包中包含了一系列重要的集合类。本文将从分析源码入手，深入研究一个集合类的内部结构，以及遍历集合的迭代模式的源码实现内幕。

　　下面我们先简单讨论一个根接口Collection，然后分析一个抽象类AbstractList和它的对应Iterator接口，并仔细研究迭代子模式的实现原理。

　　本文讨论的源代码版本是JDK 1.4.2，因为JDK 1.5在java.util中使用了很多泛型代码，为了简化问题，所以我们还是讨论1.4版本的代码。

　　集合类的根接口Collection

　　Collection接口是所有集合类的根类型。它的一个主要的接口方法是：

boolean add(Object c)

　　add()方法将添加一个新元素。注意这个方法会返回一个boolean，但是返回值不是表示添加成功与否。仔细阅读doc可以看到，Collection规定：如果一个集合拒绝添加这个元素，无论任何原因，都必须抛出异常。这个返回值表示的意义是add()方法执行后，集合的内容是否改变了（就是元素有无数量，位置等变化），这是由具体类实现的。即：如果方法出错，总会抛出异常；返回值仅仅表示该方法执行后这个Collection的内容有无变化。

　　类似的还有：

boolean addAll(Collection c);
boolean remove(Object o);
boolean removeAll(Collection c);
boolean remainAll(Collection c);

　　Object[] toArray()方法很简单，把集合转换成数组返回。Object[] toArray(Object[] a)方法就有点复杂了，首先，返回的Object[]仍然是把集合的所有元素变成的数组，但是类型和参数a的类型是相同的，比如执行：

String[] o = (String[])c.toArray(new String[0]);

　　得到的o实际类型是String[]。

　　其次，如果参数a的大小装不下集合的所有元素，返回的将是一个新的数组。如果参数a的大小能装下集合的所有元素，则返回的还是a，但a的内容用集合的元素来填充。尤其要注意的是，如果a的大小比集合元素的个数还多，a后面的部分全部被置为null。

　　最后一个最重要的方法是iterator()，返回一个Iterator（迭代子），用于遍历集合的所有元素。

　　用Iterator模式实现遍历集合
　
　　Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

　　例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

for(int i=0; i

　　而访问一个链表（LinkedList）又必须使用while循环：

while((e=e.next())!=null) { ... e.data() ... }

　　以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

　　更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。

　　为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

for(Iterator it = c.iterater(); it.hasNext(); ) { ... }

　　奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。

　　客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

　　首先看看java.util.Iterator接口的定义：

public interface Iterator {
　boolean hasNext();
　Object next();
　void remove();
}

　　依赖前两个方法就能完成遍历，典型的代码如下：

for(Iterator it = c.iterator(); it.hasNext(); ) {
　Object o = it.next();
　// 对o的操作...
}

　　在JDK1.5中，还对上面的代码在语法上作了简化：

// Type是具体的类型，如String。
for(Type t : c) {
// 对t的操作...
}

　　每一种集合类返回的Iterator具体类型可能不同，Array可能返回ArrayIterator，Set可能返回SetIterator，Tree可能返回TreeIterator，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种Iterator，它只需要获得这个Iterator接口即可，这就是面向对象的威力。

　Iterator源码剖析

　　让我们来看看AbstracyList如何创建Iterator。首先AbstractList定义了一个内部类（inner class）：

private class Itr implements Iterator {
...
}

　　而iterator()方法的定义是：

public Iterator iterator() {
　return new Itr();
}

　　因此客户端不知道它通过Iterator it = a.iterator();所获得的Iterator的真正类型。

　　现在我们关心的是这个申明为private的Itr类是如何实现遍历AbstractList的：

private class Itr implements Iterator {
　int cursor = 0;
　int lastRet = -1;
　int expectedModCount = modCount;
}

　　Itr类依靠3个int变量（还有一个隐含的AbstractList的引用）来实现遍历，cursor是下一次next()调用时元素的位置，第一次调用next()将返回索引为0的元素。lastRet记录上一次游标所在位置，因此它总是比cursor少1。

　　变量cursor和集合的元素个数决定hasNext()：

public boolean hasNext() {
　return cursor != size();
}

　　方法next()返回的是索引为cursor的元素，然后修改cursor和lastRet的值：

public Object next() {
　checkForComodification();
　try {
　　Object next = get(cursor);
　　lastRet = cursor++;
　　return next;
　} catch(IndexOutOfBoundsException e) {
　　checkForComodification();
　　throw new NoSuchElementException();
　}
}

　　expectedModCount表示期待的modCount值，用来判断在遍历过程中集合是否被修改过。AbstractList包含一个modCount变量，它的初始值是0，当集合每被修改一次时（调用add，remove等方法），modCount加1。因此，modCount如果不变，表示集合内容未被修改。

　　Itr初始化时用expectedModCount记录集合的modCount变量，此后在必要的地方它会检测modCount的值：

final void checkForComodification() {
　if (modCount != expectedModCount)
　　throw new ConcurrentModificationException();
}

　　如果modCount与一开始记录在expectedModeCount中的值不等，说明集合内容被修改过，此时会抛出ConcurrentModificationException。

　　这个ConcurrentModificationException是RuntimeException，不要在客户端捕获它。如果发生此异常，说明程序代码的编写有问题，应该仔细检查代码而不是在catch中忽略它。

　　但是调用Iterator自身的remove()方法删除当前元素是完全没有问题的，因为在这个方法中会自动同步expectedModCount和modCount的值：

public void remove() {
...
AbstractList.this.remove(lastRet);
...
// 在调用了集合的remove()方法之后重新设置了expectedModCount：
expectedModCount = modCount;
...
}

　　要确保遍历过程顺利完成，必须保证遍历过程中不更改集合的内容（Iterator的remove()方法除外），因此，确保遍历可靠的原则是只在一个线程中使用这个集合，或者在多线程中对遍历代码进行同步。

　　最后给个完整的示例：

Collection c = new ArrayList();
c.add("abc");
c.add("xyz");
for(Iterator it = c.iterator(); it.hasNext(); ) {
　String s = (String)it.next();
　System.out.println(s);
}

　　如果你把第一行代码的ArrayList换成LinkedList或Vector，剩下的代码不用改动一行就能编译，而且功能不变，这就是针对抽象编程的原则：对具体类的依赖性最小

花 2006-12-30 09:43 发表评论

JS的正则表达式

Fri, 22 Dec 2006 05:51:00 GMT

摘要: //校验是否全由数字组成代码 function isDigit(s) ... 阅读全文

花 2006-12-22 13:51 发表评论

深入Java中文问题及最优解决方法

Tue, 26 Sep 2006 08:54:00 GMT

深入Java中文问题及最优解决方法

　Abstract：本文深入分析了Java程序设计中Java编译器对java源文件和JVM对class类文件的编码/解码过程，通过此过程的解析透视出了Java编程中中文问题产生的根本原因，最后给出了建议的最优化的解决Java中文问题的方法。

　　1、中文问题的来源

计算机最初的操作系统支持的编码是单字节的字符编码，于是，在计算机中一切处理程序最初都是以单字节编码的英文为准进行处理。随着计算机的发展，为了适应世界其它民族的语言（当然包括我们的汉字），人们提出了UNICODE编码，它采用双字节编码，兼容英文字符和其它民族的双字节字符编码，所以，目前，大多数国际***的软件内部均采用UNICODE编码，在软件运行时，它获得本地支持系统（多数时间是操作系统）默认支持的编码格式，然后再将软件内部的UNICODE转化为本地系统默认支持的格式显示出来。Java的JDK和JVM即是如此，我这里说的JDK是指国际版的JDK，我们大多数程序员使用的是国际化的JDK版本，以下所有的JDK均指国际化的JDK版本。我们的汉字是双字节编码语言，为了能让计算机处理中文，我们自己制定的gb2312、GBK、GBK2K等标准以适应计算机处理的需求。所以，大部分的操作系统为了适应我们处理中文的需求，均定制有中文操作系统，它们采用的是GBK,GB2312编码格式以正确显示我们的汉字。如：中文Win2K默认采用的是GBK编码显示，在中文WIN2k中保存文件时默认采用的保存文件的编码格式也是GBK的，即，所有在中文WIN2K中保存的文件它的内部编码默认均采用GBK编码，注意：GBK是在GB2312基础上扩充来的。

由于Java语言内部采用UNICODE编码，所以在JAVA程序运行时，就存在着一个从UNICODE编码和对应的操作系统及浏览器支持的编码格式转换输入、输出的问题，这个转换过程有着一系列的步骤，如果其中任何一步出错，则显示出来的汉字就会出是乱码，这就是我们常见的JAVA中文问题。

同时，Java是一个跨平台的编程语言，也即我们编写的程序不仅能在中文windows上运行，也能在中文Linux等系统上运行，同时也要求能在英文等系统上运行（我们经常看到有人把在中文win2k上编写的JAVA程序，移植到英文Linux上运行）。这种移植操作也会带来中文问题。

还有，有人使用英文的操作系统和英文的IE等浏览器，来运行带中文字符的程序和浏览中文网页，它们本身就不支持中文，也会带来中文问题。

几乎所有的浏览器默认在传递参数时都是以UTF-8编码格式来传递，而不是按中文编码传递，所以，传递中文参数时也会有问题，从而带来乱码现象。

总之，以上几个方面是JAVA中的中文问题的主要来源，我们把以上原因造成的程序不能正确运行而产生的问题称作：JAVA中文问题。

　　2、JAVA编码转换的详细过程

    我们常见的JAVA程序包括以下类别：
     *直接在console上运行的类(包括可视化界面的类)
     *JSP代码类（注：JSP是Servlets类的变型）
     *Servelets类
     *EJB类
     *其它不可以直接运行的支持类

这些类文件中，都有可能含有中文字符串，并且我们常用前三类JAVA程序和用户直接交互，用于输出和输入字符，如：我们在JSP和Servlet中得到客户端送来的字符，这些字符也包括中文字符。无论这些JAVA类的作用如何，这些JAVA程序的生命周期都是这样的：

    *编程人员在一定的操作系统上选择一个合适的编辑软件来实现源程序代码并以.java扩展名保存在操作系统中，例如我们在中文win2k中用记事本编辑一个java源程序；
     *编程人员用JDK中的javac.exe来编译这些源代码，形成.class类(JSP文件是由容器调用JDK来编译的)；
     *直接运行这些类或将这些类布署到WEB容器中去运行，并输出结果。
    那么，在这些过程中，JDK和JVM是如何将这些文件如何编码和解码并运行的呢？

这里，我们以中文win2k操作系统为例说明JAVA类是如何来编码和被解码的。

第一步，我们在中文win2k中用编辑软件如记事本编写一个Java源程序文件(包括以上五类JAVA程序)，程序文件在保存时默认采用了操作系统默认支持GBK编码格式(操作系统默认支持的格式为file.encoding格式)形成了一个.java文件，也即，java程序在被编译前，我们的JAVA源程序文件是采用操作系统默认支持的file.encoding编码格式保存的，java源程序中含有中文信息字符和英文程序代码；要查看系统的file.encoding参数，可以用以下代码：
　　public class ShowSystemDefaultEncoding {
　　public static void main(String[] args) {
　　String encoding = System.getProperty("file.encoding");
　　System.out.println(encoding);
　　}}

第二步，我们用JDK的javac.exe文件编译我们的Java源程序，由于JDK是国际版的，在编译的时候，如果我们没有用-encoding参数指定我们的JAVA源程序的编码格式，则javac.exe首先获得我们操作系统默认采用的编码格式，也即在编译java程序时，若我们不指定源程序文件的编码格式，JDK首先获得操作系统的file.encoding参数(它保存的就是操作系统默认的编码格式，如WIN2k，它的值为GBK)，然后JDK就把我们的java源程序从file.encoding编码格式转化为JAVA内部默认的UNICODE格式放入内存中。然后，javac把转换后的unicode格式的文件进行编译成.class类文件，此时.class文件是UNICODE编码的，它暂放在内存中，紧接着，JDK将此以UNICODE编码的编译后的class文件保存到我们的操作系统中形成我们见到的.class文件。对我们来说，我们最终获得的.class文件是内容以UNICODE编码格式保存的类文件，它内部包含我们源程序中的中文字符串，只不过此时它己经由file.encoding格式转化为UNICODE格式了。

这一步中，对于JSP源程序文件是不同的，对于JSP，这个过程是这样的：即WEB容器调用JSP编译器，JSP编译器先查看JSP文件中是否设置有文件编码格式，如果JSP文件中没有设置JSP文件的编码格式，则JSP编译器调用JDK先把JSP文件用JVM默认的字符编码格式(也即WEB容器所在的操作系统的默认的file.encoding)转化为临时的Servlet类，然后再把它编译成UNICODE格式的class类，并保存在临时文件夹中。如：在中文win2k上，WEB容器就把JSP文件从GBK编码格式转化为UNICODE格式，然后编译成临时保存的Servlet类，以响应用户的请求。

第三步，运行第二步编译出来的类，分为三种情况：

    A、直接在console上运行的类
    B、 EJB类和不可以直接运行的支持类(如JavaBean类)
    C、 JSP代码和Servlet类
    D、 JAVA程序和数据库之间
    下面我们分这四种情况来看。
    A、直接在console上运行的类

这种情况，运行该类首先需要JVM支持，即操作系统中必须安装有JRE。运行过程是这样的：首先java启动JVM，此时JVM读出操作系统中保存的class文件并把内容读入内存中，此时内存中为UNICODE格式的class类，然后JVM运行它，如果此时此类需要接收用户输入，则类会默认用file.encoding编码格式对用户输入的串进行编码并转化为unicode保存入内存（用户可以设置输入流的编码格式）。程序运行后，产生的字符串（UNICODE编码的）再回交给JVM，最后JRE把此字符串再转化为file.encoding格式(用户可以设置输出流的编码格式)传递给操作系统显示接口并输出到界面上。

对于这种直接在console上运行的类，它的转化过程可用图1更加明确的表示出来：

图1

以上每一步的转化都需要正确的编码格式转化，才能最终不出现乱码现象。

B、EJB类和不可以直接运行的支持类(如JavaBean类)

由于EJB类和不可以直接运行的支持类，它们一般不与用户直接交互输入和输出，它们常常与其它的类进行交互输入和输出，所以它们在第二步被编译后，就形成了内容是UNICODE编码的类保存在操作系统中了，以后只要它与其它的类之间的交互在参数传递过程中没有丢失，则它就会正确的运行。
这种EJB类和不可以直接运行的支持类, 它的转化过程可用图2更加明确的表示出来：

图2

C、JSP代码和Servlet类

经过第二步后，JSP文件也被转化为Servlets类文件，只不过它不像标准的Servlets一校存在于classes目录中，它存在于WEB容器的临时目录中，故这一步中我们也把它做为Servlets来看。

对于Servlets，客户端请求它时，WEB容器调用它的JVM来运行Servlet，首先，JVM把Servlet的class类从系统中读出并装入内存中，内存中是以UNICODE编码的Servlet类的代码，然后JVM在内存中运行该Servlet类，如果Servlet在运行的过程中，需要接受从客户端传来的字符如：表单输入的值和URL中传入的值，此时如果程序中没有设定接受参数时采用的编码格式，则WEB容器会默认采用ISO-8859-1编码格式来接受传入的值并在JVM中转化为UNICODE格式的保存在WEB容器的内存中。Servlet运行后生成输出，输出的字符串是UNICODE格式的，紧接着，容器将Servlet运行产生的UNICODE格式的串（如html语法，用户输出的串等）直接发送到客户端浏览器上并输出给用户，如果此时指定了发送时输出的编码格式，则按指定的编码格式输出到浏览器上，如果没有指定，则默认按ISO-8859-1编码发送到客户的浏览器上。这种JSP代码和Servlet类，它的转化过程可用图3更加明确地表示出来：

图3

D、Java程序和数据库之间

对于几乎所有数据库的JDBC驱动程序，默认的在JAVA程序和数据库之间传递数据都是以ISO-8859-1为默认编码格式的，所以，我们的程序在向数据库内存储包含中文的数据时，JDBC首先是把程序内部的UNICODE编码格式的数据转化为ISO-8859-1的格式，然后传递到数据库中，在数据库保存数据时，它默认即以ISO-8859-1保存，所以，这是为什么我们常常在数据库中读出的中文数据是乱码。
对于JAVA程序和数据库之间的数据传递，我们可以用图4清晰地表示出来

图4

    3、分析常见的JAVA中文问题几个必须清楚的原则

    首先，经过上面的详细分析，我们可以清晰地看到，任何JAVA程序的生命期中，其编码转换的关键过程是在于：最初编译成class文件的转码和最终向用户输出的转码过程。
    其次，我们必须了解JAVA在编译时支持的、常用的编码格式有以下几种：
    *ISO-8859-1，8-bit, 同8859_1,ISO-8859-1,ISO_8859_1等编码
    *Cp1252，美国英语编码，同ANSI标准编码
    *UTF-8，同unicode编码
    *GB2312，同gb2312-80,gb2312-1980等编码
    *GBK , 同MS936，它是gb2312的扩充
    及其它的编码，如韩文、日文、繁体中文等。同时，我们要注意这些编码间的兼容关体系如下：
    unicode和UTF-8编码是一一对应的关系。GB2312可以认为是GBK的子集，即GBK编码是在gb2312上扩展来的。同时，GBK编码包含了20902个汉字，编码范围为：0x8140-0xfefe，所有的字符可以一一对应到UNICODE2.0中来。

    再次，对于放在操作系统中的.java源程序文件，在编译时，我们可以指定它内容的编码格式，具体来说用-encoding来指定。注意：如果源程序中含有中文字符，而你用-encoding指定为其它的编码字符，显然是要出错的。用-encoding指定源文件的编码方式为GBK或gb2312，无论我们在什么系统上编译含有中文字符的JAVA源程序都不会有问题，它都会正确地将中文转化为UNICODE存储在class文件中。

    然后，我们必须清楚，几乎所有的WEB容器在其内部默认的字符编码格式都是以ISO-8859-1为默认值的，同时，几乎所有的浏览器在传递参数时都是默认以UTF-8的方式来传递参数的。所以，虽然我们的Java源文件在出入口的地方指定了正确的编码方式，但其在容器内部运行时还是以ISO-8859-1来处理的。

花 2006-09-26 16:54 发表评论

javamail总结经验

Thu, 31 Aug 2006 09:39:00 GMT

javamail总结经验（一）

环境配置。为了运行javamail。我们需要在classpath里导入两个包：mail.jar和activation.jar，这是在纯DOS里或者其它简单工具使用时才需要这个classpath。如果使用像eclipes这样的工具就不需要配置。因为myeclipes已经帮你做好了。
为了要发送邮件和接收邮件，我们必须要遵守smtp和pop3协议，不过还有其它协议也可执行(如IMAP)。如果把本机当作服务器来发送邮件请在http://jakrata.apache.org网站里下载james邮件服务器，然后解压在本机上。运行james/bin里的run.bat就可以启动了服务器。
运行后在DOS里登录邮件服务器。具体命令如下：
系统管理员：root
密码：root
telnet localhost 4555
然后就可以增加邮箱用户名了。命令如下：
adduser 用户名密码
例：adduser test test
这样就建立了这样一个邮箱test@localhost 密码为：test
如果想要更多功能用help命令
注意：如果在本机装了邮件服务器的话，只能在本机局域网里申请邮箱，发送和接收。不能发送到外部的邮箱里去。如果用外部的邮件服务器像比如163和126的服务器等就可以随心所欲的发邮件了。哈哈是不是很爽呢？
先看看用james邮件服务器在本机上发邮件吧。先简单看一个例子。
import javax.mail.*;
import java.util.*;
import javax.mail.internet.*;
public class MyFirstMail
{
    protected Session mailSession;
    public MyFirstMail()throws Exception
    {
        init();
    }
    public static void main(String[] args)
    {
        try
        {
            new MyFirstMail().sendMail();
            System.out.print("邮件已发");
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
//初始化服务器环境
    public void init()throws Exception
    {
        Properties props=new Properties();
        props.put("mail.transport.protocol","smtp");
        props.put("mail.smtp.host","localhost");
        props.put("mail.smtp.port","25");
        mailSession=Session.getDefaultInstance(props, null);;
    }
    public void sendMail()throws Exception
    {
        try
        {

//从哪里发的邮件
msg.setFrom(new InternetAddress("test@localhost"));
    //发送到目标邮件        msg.setRecipients(Message.RecipientType.TO,InternetAddress.parse("wang@localhost"));
    //抄送的接收者        msg.setRecipients(Message.RecipientType.CC,InternetAddress.parse("wang@localhost"));
//暗送的接收者
msg.setRecipients(Message.RecipientType.BCC,InternetAddress.parse("wang@localhost"));
//设置发送时间
msg.setSentDate(new java.util.Date());
//设置邮件标题
msg.setSubject("a test mail");
//设置邮件内容
msg.setText("this is the email content");
//指定协议发送消息的对像
Transport transport=mailSession.getTransport("smtp");
//发送消息
Transport.send(msg);
}
catch(Exception e)
{
throw e;
}
}
发送完后想要看邮件就要到james->apps->james->var->mail->inboxes就可以看见每个邮箱里的邮件数了。由于发过来的是字节流，邮件包括一个邮件属性和消息，所以每一封邮件是由二个文件组成的。

也许没有学过的javamail的人看上去会一头雾水。不要紧，现在一一详解。先说初始化的内容的吧！
1、    mail.transport.protocol=smtp 这里主要说明的是邮件传输协议。
2、    mail.smtp.host=localhost 发送邮件的主机如果用外部邮件服务器的话，可以这样写
mail.smtp.host=smtp.163.com这样就以163.为服务器了。
3、mail.smtp.prot=25    smtp端口可以省略，缺省为25

javax.mail.session
session类定义了与远程邮件系统通信的邮件会话。需要注意的是这个session不同servlet中的会话。Servlet中的会话需要共享一些信息，而mail里的session里没有这个功能，它只是用于存储与服务器建立连接会话相关信息和逻辑。Session类是javamail api最高层入口类，所有其它类都必须经由session对象生效。Session对象它管理配置选项和用于与邮件系统交互的用认证信息息。它通过使用java.util.properties对象配置邮件会话的属性如邮件服务器，用户名，密码，及整个应用程序中共享的其它信息。
Session并不处现任何授权操作，它只是存储这些授权信息。Session类的构造器是私有的，它不能被继承，也不能用new语名创建实例。但它提供了两个静态方法getInstance 和getDefaultInstance来获取session实例，在创建session实例时需要提供一些属性。具体实现如下：
    Properties props=new Properties()
    Props.put(“mail.transport.protocol”,”smtp”)
    Props.put(“mail.smtp.host”,”localhost”);
  Props.put(“mail.smtp.prot”,”25”)
//不加以认证也可以这样写
//Session session=Session.getDefaultInstance(props,null)
//如果认证传入null那么它和不使用认证调用方式一样
Session session=Session.getDefaultInstance(props)
Javax.mail. Message
经过session配置后就可以进行发送消息任务了。这由Message类来完成。Message实现了Part接口，它表示一个邮件消息，包含一系列的属性和一个消息内容。消息属性包括了消息址址消息，定义了消息内容的结构（包括内容类型），消息内容使用DataHandler对象包装实际数据。当邮件消息位于目录(folder)中时，系统还使用了一个标志位集合来描述它的状态。
Message是抽象类，实际使用时必须用一个子类代替以表示具体的邮件格式。比如说javamail api提供了MimeMessage类，该类扩展了Message，实现了RFC822和MIME标准。有两个构造方法：
//一般使用第一种
    Message msg=new MimeMessage(Session session)
Message msg=new MimeMessage(MimeMessage msg)
获得消息后，就可以设置消息各个部份了。在设置之前因为要涉及地址。所以讲一下地址类
javax.mail.Address
Address类表示电子邮件类，它是一个抽象类，它的子类InternetAddress提供具体实现且通常可串行化。若创建的地址只包含电子邮件，只要传递电子邮件到构造器即可如
InternetAddress addr=new InternetAddress();
addr.setAddress(“wang@126.com”)
或者是：InterntAddress addr=new InternetAddress(“wang@126.com”)
另外，InternetAddress类还提供了地址解析方法如
Address[] addrs=InternetAddress.parse(“wang@163.com,f@126.com,zuo@126.com”);
地址之后就可以发送消息了。
//设置发送者
Msg.setFrom(new InternetAddress(“test@126.com”));
//设置接收者,并还具有解析功能
Msg.setRecipients(Message.RecipientType.To,InternetAddress.parse(“zuolin0806@163.com”));
//抄送的接收者
Msg.setRecipients(Message.RecipientType.CC,InternetAddress.parse(“zuolin0806@163.com”));
//暗送的接收者
Msg.setRecipients(Message.RecipientType.CC,InternetAddress.parse(“zuolin0806@163.com”));
//设置消息主题
msg.setSubject(“我的爱”)
//设置内容的基本机制，其参数Mime类型
msg.setContent(“这是我的内容”,”text/html;charset=gb2312”)
其中的text/html表示消息内容采用的是HTML格式。如果消息格式是(text/plain)，而且使用的是MimeMessage,那么setText()方法设置邮件内容的参数（Mime类型默认为text/plain）
//设置邮件内容
msg.setText();
//设置发送时间
msg.setSentDate(new java.util.Date());
最后一步是就是发送了
javax.mail.Transport
该类也是抽象类，它可通过静态方法和实便方法发送消息。Transport断承service类。所以它提供了通用方法，如命名传输，连接服务器和监听传输事件等。
//默认
Transport.send(msg);

最后看一下使用外部邮件服务器的使用方法。先看程序再讲解，注意在使用外部邮件服务器时一定要有一个类来认证。到时在讲。
public class MySecondMail
{
protected Session session = null;
//邮件用户名
    String mailUser = "zuolin0806";
    String host = "smtp.163.com";
    String pwd = "用户名的密码";
    public MySecondMail()
    {
        init();
    }

    public void init()
    {
        Properties props = new Properties();
        props.put("mail.transpost.protocol", "smtp");
        props.put("mail.smtp.host", "smtp.163.com");
        //必须要有一个类来认证
props.put("mail.smtp.auth", "true");
props.put("mail.smpt.port", "25")
Email_Autherticatorbean auth =  new Email_Autherticatorbean(mailUser,pwd);
        //session认证
session = Session.getInstance(props,auth);
        //这个是跟踪后台消息。打印在控制台
session.setDebug(true);
   }
    public static void main(String[] args)
    {
        new MySecondMail().sendMails();
        System.out.println("send mail success!");
    }
    public void sendMails()
    {
        try
        {
            Message msg = new MimeMessage(session);
         msg.setFrom(new InternetAddress("zuolin0806@163.com"));
        msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("javaboy@126.com"));
       msg.setRecipients(Message.RecipientType.BCC, InternetAddress.parse("javaboy@126.com"));
      msg.setSentDate(new Date());
      msg.setSubject("this is my Threee mail");
      msg.setContent("this is my mail","text/html");
      msg.setText("我成功了。哈哈");

     Transport transport = session.getTransport("smtp");
      与发送者的邮箱相连
transport.connect(host,mailUser,pwd);
      transport.send(msg);
        }
        catch (SendFailedException e)
        {
            e.printStackTrace();
        }
        catch (Exception ee)
        {
            ee.printStackTrace();
        }

    }
}

认证类必须继承Authenticator  例子如下:
import javax.mail.*;
public class Email_Autherticatorbean extends Authenticator
{
    private String m_username = null;
    private String m_userpass = null;
    public void setUsername(String username)
    {
        m_username = username;
    }
    public void setUserpass(String userpass)
    {
        m_userpass = userpass;
    }
    public Email_Autherticatorbean(String username, String userpass)
    {
        super();
        setUsername(username);
        setUserpass(userpass);
    }
    public PasswordAuthentication getPasswordAuthentication()
    {
        return new PasswordAuthentication(m_username,m_userpass);
    }
}
经过成功发送邮件后是不是有点成就感呢！但还有很多疑问比如怎么读邮件呢？看了下面章节你就会知道了

花 2006-08-31 17:39 发表评论

正则表达式regular expression详述

Wed, 30 Aug 2006 15:16:00 GMT

正则表达式是regular expression，看来英文比中文要好理解多了，就是检查表达式符
不符合规定！！正则表达式有一个功能十分强大而又十分复杂的对象RegExp，在Javascript1.2 版本以
上提供。
下面我们看看有关正则表达式的介绍：
正则表达式对象用来规范一个规范的表达式(也就是表达式符不符合特定的要求，比如是不是Email
地址格式等)，它具有用来检查给出的字符串是否符合规则的属性和方法。
除此之外，你用RegExp构造器建立的个别正则表达式对象的属性，就已经预先定义好了正则表达式
对象的静态属性，你可以随时使用它们。
核心对象：
在Javascript 1.2, NES 3.0以上版本提供。
在Javascript 1.3以后版本增加了toSource方法。
建立方法：
文字格式或RegExp构造器函数。
文字建立格式使用以下格式：
/pattern/flags即/模式/标记

构造器函数方法使用方法如下：
new RegExp("pattern"[, "flags"])即new RegExp("模式"[,"标记"])

参数：
pattern(模式)
表示正则表达式的文本

flags(标记)
如果指定此项，flags可以是下面值之一：
g: global match(全定匹配)
i: ignore case(忽略大小写)
gi: both global match and ignore case(匹配所有可能的值，也忽略大小写)

注意：文本格式中的参数不要使用引号标记，而构造器函数的参数则要使用引号标记。所以下面的
表达式建立同样的正则表达式：
/ab+c/i
　　new RegExp("ab+c", "i")

描述：
当使用构造函数的时候，必须使用正常的字符串避开规则(在字符串中加入前导字符 )是必须的。
例如，下面的两条语句是等价的：
re = new RegExp("\w+")
re = /w+/

下面的提供了在正则表达式中能够使用的完整对特殊字符的一个完整的列表和描述。

表1.3：正则表达式中的特殊字符：

字符
意义：对于字符，通常表示按字面意义，指出接着的字符为特殊字符，不作解释。
例如：/b/匹配字符'b',通过在b 前面加一个反斜杠，也就是/b/，则该字符变成特殊字符，表示
匹配一个单词的分界线。
或者：
对于几个字符，通常说明是特殊的，指出紧接着的字符不是特殊的，而应该按字面解释。
例如：*是一个特殊字符，匹配任意个字符(包括0个字符)；例如：/a*/意味匹配0个或多个a。
为了匹配字面上的*，在a前面加一个反斜杠；例如：/a*/匹配'a*'。

字符^
意义：表示匹配的字符必须在最前边。
例如：/^A/不匹配"an A,"中的'A'，但匹配"An A."中最前面的'A'。

字符$
意义：与^类似，匹配最末的字符。
例如：/t$/不匹配"eater"中的't'，但匹配"eat"中的't'。

字符*
意义：匹配*前面的字符0次或n次。
例如:/bo*/匹配"A ghost booooed"中的'boooo'或"A bird warbled"中的'b'，但不匹配"A goat g
runted"中的任何字符。

字符+
意义：匹配+号前面的字符1次或n次。等价于。
例如：/a+/匹配"candy"中的'a'和"caaaaaaandy."中的所有'a'。

字符?
意义：匹配?前面的字符0次或1次。
例如：/e?le?/匹配"angel"中的'el'和"angle."中的'le'。

字符.
意义：(小数点)匹配除换行符外的所有单个的字符。
例如：/.n/匹配"nay, an apple is on the tree"中的'an'和'on'，但不匹配'nay'。

字符(x)
意义：匹配'x'并记录匹配的值。
例如：/(foo)/匹配和记录"foo bar."中的'foo'。匹配子串能被结果数组中的素[1], ..., [n] 返
回，或被RegExp对象的属性$1, ..., $9返回。

字符x|y
意义：匹配'x'或者'y'。
例如：/green|red/匹配"green apple"中的'green'和"red apple."中的'red'。

字符
意义：这里的n是一个正整数。匹配前面的n个字符。
例如：/a/不匹配"candy,"中的'a'，但匹配"caandy," 中的所有'a'和"caaandy."中前面的两个
'a'。

字符
意义：这里的n是一个正整数。匹配至少n个前面的字符。
例如：/a不匹配"candy"中的'a'，但匹配"caandy"中的所有'a'和"caaaaaaandy."中的所有'a'

字符
意义：这里的n和m都是正整数。匹配至少n个最多m个前面的字符。
例如：/a/不匹配"cndy"中的任何字符，但匹配 "candy,"中的'a'，"caandy," 中的前面两个
'a'和"caaaaaaandy"中前面的三个'a'，注意：即使"caaaaaaandy" 中有很多个'a'，但只匹配前面的三
个'a'即"aaa"。

字符[xyz]
意义：一字符列表，匹配列出中的任一字符。你可以通过连字符-指出一个字符范围。
例如：[abcd]跟[a-c]一样。它们匹配"brisket"中的'b'和"ache"中的'c'。

字符[^xyz]
意义：一字符补集，也就是说，它匹配除了列出的字符外的所有东西。你可以使用连字符-指出一
字符范围。
例如：[^abc]和[^a-c]等价，它们最早匹配"brisket"中的'r'和"chop."中的'h'。

字符[b]
意义：匹配一个空格(不要与b混淆)

字符b
意义：匹配一个单词的分界线，比如一个空格(不要与[b]混淆)
例如：/bnw/匹配"noonday"中的'no'，/wyb/匹配"possibly yesterday."中的'ly'。

字符B
意义：匹配一个单词的非分界线
例如：/wBn/匹配"noonday"中的'on'，/yBw/匹配"possibly yesterday."中的'ye'。

字符cX
意义：这里的X是一个控制字符。匹配一个字符串的控制字符。
例如：/cM/匹配一个字符串中的control-M。

字符d
意义：匹配一个数字，等价于[0-9]。
例如：/d/或/[0-9]/匹配"B2 is the suite number."中的'2'。

字符D
意义：匹配任何的非数字，等价于[^0-9]。
例如：/D/或/[^0-9]/匹配"B2 is the suite number."中的'B'。

字符f
意义：匹配一个表单符

字符n
意义：匹配一个换行符

字符r
意义：匹配一个回车符

字符s
意义：匹配一个单个white空格符，包括空格，tab，form feed，换行符，等价于[ fnrtv]。
例如：/sw*/匹配"foo bar."中的' bar'。

字符S
意义：匹配除white空格符以外的一个单个的字符，等价于[^ fnrtv]。
例如：/S/w*匹配"foo bar."中的'foo'。

字符t
意义：匹配一个制表符

字符v
意义：匹配一个顶头制表符

字符w
意义：匹配所有的数字和字母以及下划线，等价于[A-Za-z0-9_]。
例如：/w/匹配"apple,"中的'a'，"$5.28,"中的'5'和"3D."中的'3'。

字符W
意义：匹配除数字、字母外及下划线外的其它字符，等价于[^A-Za-z0-9_]。
例如：/W/或者/[^$A-Za-z0-9_]/匹配"50%."中的'%'。

字符n
意义：这里的n是一个正整数。匹配一个正则表达式的最后一个子串的n的值(计数左圆括号)。

例如：/apple(,)sorange1/匹配"apple, orange, cherry, peach."中的'apple, orange'，下面
有一个更加完整的例子。
注意：如果左圆括号中的数字比n指定的数字还小，则n取下一行的八进制escape作为描述。

字符ooctal和xhex
意义：这里的ooctal是一个八进制的escape值，而xhex是一个十六进制的escape值，允许在一个
正则表达式中嵌入ASCII码。

当表达式被检查的时候，文字符号提供了编辑正则表达式的方法。利用文字符号可以使到正则表达
式保持为常数。例如，如果你在一个循环中使用文字符号来构造一个正则表达式，正则表达式不需进行
反复编译。
正则表达式对象构造器，例如，new RegExp("ab+c")，提供正则表达式的运行时编译。当你知道正
则表达式的模式会变化的时候，应该使用构造函数，或者你不知道正则表达式的模式，而它们是从另外
的源获得的时候，比如由用户输入时。一旦你定义好了正则表达式，该正则表达式可在任何地方使用，
并且可以改变，你可以使用编译方法来编译一个新的正则表达式以便重新使用。
一个分离预先定义的RegExp对象可以在每个窗口中使用；也就是说，每个分离的Javascript线程运
行以获得自己的RegExp对象。因为每个脚本在一个线程中是不可中断的，这就确保了不同的脚本不会覆
盖RegExp对象的值。
预定义的RegExp对象包含的静态属性：input, multiline, lastMatch,lastParen, leftContext,
rightContext, 以及从$1到$9。input和multiline属性能被预设。其它静态属性的值是在执行个别正则
表达式对象的exec和test方法后，且在执行字符串的match和replace方法后设置的。

属性
注意RegExp对象的几个属性既有长名字又有短名字(象Perl)。这些名字都是指向相同的值。Perl是
一种编程语言，而Javascript模仿了它的正则表达式。

属性$1, ..., $9
取得匹配的子串，如果有的话

属性$_
参考input

属性$*
参考multiline

属性$&
参考lastMatch

属性$+
参考lastParen

属性$`
参考leftContext

属性$'
参考rightContext

属性constructor
指定用来建立对象原型函

属性global
决定是否测试正则表达式是否不能匹配所有的字符串，或者只是与最先的冲突。

属性ignoreCase
决定试图匹配字符串的时候是否忽略大小写

属性input
当正则表达式被匹配的时候，为相反的字符串。

属性lastIndex
决定下一次匹配从那里开始

属性lastMatch
最后一个匹配的字符

属性lastParen
子串匹配的时候，最后一个parenthesized，如果有的话。

属性leftContext
最近一次匹配前的子串。

属性multiline
是否在串的多行中搜索。

属性prototype
允许附加属性到所有的对象

属性rightContext
最近一次匹配后的的子串。

属性source
模式文本

方法
compile方法
编译一个正则表达式对象

exec方法
运行正则表达式匹配

test方法
测试正则达式匹配

toSource方法
返回一个对象的文字描述指定的对象；你可以使用这个值来建立一个新的对象。不考虑Object.toS
ource方法。

toString方法
返回一个字符串描述指定的对象，不考虑Object.toString对象。

valueOf方法
返回指定对角的原始值。不考虑Object.valueOf方法。

　另外，这个对象继承了对象的watch和unwatch方法

　　例子：
　　例１、下述示例脚本使用replace方法来转换串中的单词。在替换的文本中，脚本使用全局 RegExp
对象的$1和$2属性的值。注意，在作为第二个参数传递给replace方法的时候，RegExp对象的$属性的名
称。

显示结果："Smith, John".

　　例２、下述示例脚本中，RegExp.input由Change事件处理句柄设置。在getInfo函数中，exec 方法
使用RegExp.input的值作为它的参数，注意RegExp预置了$属性。

　　请输入你的姓和年龄，输入完后按回车键。
　　

$1, ..., $9属性
用圆括号括着的匹配子串，如果有的话。
是RegExp的属性
静态，只读

在Javascript 1.2, NES 3.0以上版本提供
描述：因为input是静态属性，不是个别正则表达式对象的属性。你可以使用RegExp.input 访问该
属性。

能加上圆括号的子串的数量不受限制，但正则表达式对象只能保留最后9 条。如果你要访问所有的
圆括号内的匹配字串，你可以使用返回的数组。

这些属性能用在RegExp.replace方法替换后的字符串(输出结果)。当使用这种方式的时候，不用预
先考虑RegExp对象。下面给出例子。当正则表达式中没有包含圆括号的时候，该脚本解释成$n的字面意
义。(这里的n是一个正整数)。

例如：
下例脚本使用replace 方法来交换串中单词的位置。在替换后的文本字串中，脚本使用正则表达式
RegExp对象的$1和$2属性的值。注意：当它们向replace方法传递参数的时候，这里没有考虑 $ 属性的
RegExp对象的名称。

显示的输出结果为：Smith, John。

正则表达式详述（二）

以下这些不是正则表达式的新增对象请参阅对应的Javascript对象的属性 $_属性参考input $*属性
参考multiline $&属性参考lastMatch $+属性参考lastParen $`属性
参考leftContext $'属性参考rightContext compile方法在脚本运行期间编译正则表达式对象
属于RegExp的方法在Javascript 1.2, NES 3.0以上版本提供语法：
regexp.compile(pattern[, flags]) 以数： regexp 正则表达式的名称，可以是变量名或文字串。
pattern 正则表达式的定义文本。 flags 如果指定的话，可以是下面其中的一个： "g": 匹配所有可能的字串
"i": 忽略大小写 "gi": 匹配所有可能的字串及忽略大小写描述：
使用compile方法来编译一个正则表达式 created with the RegExp constructor function。这样
就强制正则表达式只编译一次，而不是每次遇到正则表达式的时候都编译一次。当你确认正则表达式能
保持不变的时候可使用compile 方法来编译它(在获得它的匹配模式后)，这样就可以在脚本中重复多次使用它。
你亦可以使用compile 方法来改变在运行期间改变正则表达式。例如，假如正则表达式发生变化，
你可以使用compile方法来重新编译该对象来提高使用效率。
使用该方法将改变正则表达式的source, global和ignoreCasesource属性的值。 constructor
指出建立对象原型的function。注意这个属性的值由函数本身提供，而不是一个字串包含RegExp的name.Property提供。
在Javascript 1.1, NES 2.0以上版本提供 ECMA版本ECMA-262 描述：参考Object.constructor.
exec方法在指定的字符串运行匹配搜索。返回一个结果数组。是RegExp的方法
在Javascript 1.2, NES 3.0以上版本提供语法： regexp.exec([str])regexp([str])
参数： regexp，正则表达式的名称，可以是一个变量名或文字定义串。
str，要匹配正则表达式的字符串，如果省略，将使用RegExp.input的值。
描述：就如在语法描述中的一样，正则表达工的exec方法能够被直接调用(使用regexp.exec(str))或者间接调用(使用regexp(str))。
假如你只是运行以找出是否匹配，可以使用String搜索方法。
假如匹配成功，exec方法返回一个数组并且更新正则表达式对象属性的值和预先定义的正则表达式对象、RegExp。如果匹配失败，exec方法返回null。
请看下例：下面是该脚本的返回值：对象属性/Index 描述例子
myArray

myArray的内容 ["dbBd", "bB", "d"]
index
基于0的匹配index 1
input
原始字符串 cdbBdbsbz
[0]
最后匹配的字符 dbBd
[1], ...[n]
用圆括号括住的匹配字符串，如果有的话。不限制括号的个数。 [1] = bB
[2] = d
myRe
lastIndex
开始下次匹配操作的index值 5
ignoreCase
指出"i"是否使用以忽略大小写 true
global
指出是否使用"g"标记来进行匹配所有可能的字串 true
source
定义模式的文本字符串 d(b+)(d)
RegExp
lastMatch$&
最后匹配的字符 dbBd
leftContext$Q
最新匹配前面的子串 c
rightContext$'
最新匹配后面的子串 bsbz
$1, ...$9
圆括号内的匹配子串，如果有的话。圆括号的个数不受限制，但RegExp只能保留最后9个 $1 = bB
$2 = d
lastParen $+
最后一个加上圆括号的匹配子串，如果有的话 d

假如你的正则表达式使用了"g"标记，你可以多次使用exec 方法来连续匹配相同的串。当你这样做
的时候，新的匹配将从由正则表达式的lastIndex 属性值确定的子串中开始。例如，假定你使用下面的脚本：
这个脚本显示如下结果： Found abb. Next match starts at 3
Found ab. Next match starts at 9 例子：
在下面的例子中，用户输入一个名字，脚本根据输入执行匹配操作。接着检查数组看是否和其它用户的名字匹配。
本脚本假定已注册的用户的姓已经存进了数组A中，或许从一个数据库中取得。