Image: attachments/gwt/gwt4.gif

运行与源码:

进入演示页面


源代码下载（一Eclipse工程）：
File: Click to Download

Image: attachments/gwt/gwt1.gif

Image: attachments/gwt/gwt2.gif

Image: attachments/gwt/gwt3.gif

Image: attachments/gwt/gwt4.gif

运行与源码:

点击运行该程序(jar)

若不能正常运行请先安装 Java运行环境(JRE)


源代码下载：
File: Click to Download

Image: attachments/gwt/swing1.gif

Image: attachments/gwt/swing2.gif

Image: attachments/gwt/swing3.gif

Image: attachments/gwt/swing4.gif

Image: attachments/jballfield/1.gif

运行与下载:

进入演示页面(applet)

点击运行该程序(jar)

若不能正常运行请先安装 Java运行环境(JRE)

设计文档

文档、程序、源代码下载：
File: Click to Download

Image: attachments/jballfield/Communicate.gif

Image: attachments/jballfield/formulas.gif

Image: attachments/jballfield/collision_formulas.gif

Image: attachments/jballfield/collision.gif

Image: attachments/jballfield/collision_process.gif

package hibernate;

import java.util.*;

import org.hibernate.*;
import org.hibernate.cfg.*;


/**
* 一、配置
*
*
* MyEclipse中配置Hibernate： 右击工程-MyEclipse-Add Hibernate Capabitilies
*
* 若选择 use JDBC，则使用hibernate自带的数据池
* 若选择 use JDNI，则使用托管环境(Tomcat)数据池
*
*
* 配置对应数据库表的java类和*.hbm.xml文件
*     打开MyEclipse Database Explorer视图
*     右击目标数据表-Hibernate Reverse Engineering
*
*
*/


/**
* 二、Java中如何使用
*
*
* Hibernate禁止立即自动事务提交模式，即必须使用事务模式
*   （自动事务提交(auto-commit)模式本来是专门为SQL控制台操作设计的）
*
*
* 对于使用托管环境
*   （如使用Tomcat或J2EE的数据池），该托管环境会自己负责事务管理
*     所以不用声明事务，甚至session.fluse()也会自动完成。
  
     Session session = HibernateSessionFactory.getSession();
     // 处理数据
     session.flush();
     session.close();
    
*
*
* 对于使用非托管环境
*    (如直接连接即使用hibernate自身的数据池管理），要显式声明事务

    Session session = HibernateSessionFactory.getSession();
    Transaction  transaction = session.beginTransaction();
    // 处理数据
    transaction.commit();
    // 这里不需要再session.flush(); commit()已经flush()了
    session.close();

*
*
* 查询可以不用事务
*
*/


/**
* 三、关于新建对象时分配ID的方式：
*
*
*     increment  根据表中最大ID+1生成，表ID类型为Integer，不推荐使用，
*             当有多个线程同时写入时可能会生成同一ID
*     identity  让数据库本身生成ID，如数据库设置成"Auto increment"
*     uuid.hex  随机生成一 十六进制字符串(32位)
*     assigned  由所对应的类自己设定id为多少
*/


/**
* 四、session使用方式？
*
*
* 不使用session-per-operation模式
*     也就是说，在单个线程中， 不要因为一次简单的数据库调用， 就打开和关闭一次Session！
*     数据库事务也是如此。
*
*
* 最常用的模式是 每个请求一个会话(session-per-request)
*     在这种模式下，来自客户端的请求被发送到服务器端，一个新的Hibernate Session被打开，
*     并且执行这个操作单元中所有的数据库操作。 一旦操作完成（同时发送到客户端的响应也准备就绪）
*     session被同步，然后关闭。
*
*/


/**
* 五、笔记
*
*
* 持久化时Hibernate使用POJO的getXXX()方法获取数据并保存到数据库，不是直接访问变量成员
*
*
* 关于POJO如何与数据库中记录一一对应起来：
*
*   一，即时形式
*     即同一个session时（如调用flush()、delete()）
*     此时每一个POJO对象对应一条记录，内部对应方式，改不了
*     此时调用POJO.setId(4);会抛出异常
*
*   二，脱管形式
*     即不同session时（如调用update()、delete()）
*       session都变了，Hibernate是根据什么决定这个POJO对象对应于表中哪个记录呢？
*       答曰：根据这个POJO的ID域
*       如原test的Id为4，更改数据后调用test.setId(1);
*       则session.update(test);后更改的是1的数据而非4的
*
*/


public class Main {

  /**
   * 查询
   *
   *
   * 关于HQL查询语句
   *
   *
   * Query query = session.createQuery("from Test where age>21");
   * 以上""内的就是HQL语句
   *
   *
   * 当有select子句时
   *     如
   *     session.createQuery("select count(*) from Test");
   *     session.createQuery("select name,age from Test");
   *     则iterate.next()返回的不是POJO
   *     而是普通类型
   *       如第一条返回类型为一Integer
   *       第二条返回类型为一Object[]，object[0]类型为String，object[1]类型为Integer
   *
   *
   * 当无select子句时
   *     如
   *     session.createQuery("from Test where age>21");
   *     则返回的是POJO
   *     Test test = (Test) iterate.next();
   *
   *
   *
   * HQL中加入变量
   *
     Query query = session.createQuery("from Test where name = :name and age = :age");
    query.setString("name", "JTL");
    query.setInteger("age", 25);
   *
   *
   * Date: Dec 1, 2007
   *
   */
  public static void printAll() {

    Session session = HibernateSessionFactory.getSession();

    // Test 头字母要大写
    Query query = session.createQuery("from Test");

    Iterator iterate = query.iterate();
    while (iterate.hasNext()) {
      Test test = (Test) iterate.next();
      test.print();
    }
    session.close();

  }


  /**
   * 添加
   *
   * Date: Dec 1, 2007
   *
   */
  public static void addNew() {

    Session session = HibernateSessionFactory.getSession();
    Transaction transaction = session.beginTransaction();

    Test test = new Test("newOne", 21);
    session.save(test);

    transaction.commit();
    session.close();
  }


  /**
   * 修改
   *
   * 有两种更新方式：
   *     一、即时形式，session.flush();
   *     二、脱管形式，session.update(Object);
   *
   *
   * 一，即时形式：
   *     用于同一会话中
   *       从一会话中取出POJOs，修改这些POJOs，即时调用同一会话的
   *       session.fluse();
   *       把该会话取出的所有POJOs所做的更改保存起来
   *
   *
   * 二，脱管形式
   *     用于不同会话中
   *       如从一会话中取出POJOs，关闭该会话
   *       此时这些POJOs还存于内存中
   *       一个小时后用户更改这些POJOs，更改完后建立一新会话，调用
   *       sessino.update(要更新的POJO);
   *       把更新的POJO保存起来
   *       
   *
   *
   *
   * 关于POJO如何与数据库中记录一一对应起来：
   *
   *   一，即时形式
   *     即同一个session时（如调用flush()、delete()）
   *     此时每一个POJO对象对应一条记录，内部对应方式，改不了
   *     此时调用POJO.setId(4);会抛出异常
   *
   *   二，脱管形式
   *     即不同session时（如调用update()、delete()）
   *       session都变了，Hibernate是根据什么决定这个POJO对象对应于表中哪个记录呢？
   *       答曰：根据这个POJO的ID域
   *       如原test的Id为4，更改数据后调用test.setId(1);
   *       则session.update(test);后更改的是1的数据而非4的
   *     
   *
   * Date: Dec 1, 2007
   *
   */
  // 即时形式
  public static void edit_flush() {

    Session session = HibernateSessionFactory.getSession();
    Transaction transaction = session.beginTransaction();

    Query query = session.createQuery("from Test");
    Test test = null;
    Iterator iterate = query.iterate();
    // 所有age-1
    while (iterate.hasNext()) {
      test = (Test) iterate.next();
      test.setAge(test.getAge() - 1);
    }

    // 把该会话取出的所有POJOs所做的更改保存起来
    session.flush();


    transaction.commit();
    session.close();
  }


  // 脱管形式
  public static void edit_update() {

    Session session = HibernateSessionFactory.getSession();

    // 找不到时返回null
    Test test = (Test) session.get(Test.class, 4);
    session.close();


    // 已经关闭session，但test对象仍在内存中供用户操作
    test.setName("任盈盈");
    test.setAge(20);
    // 改来改去
    test.setName("令狐冲");
    test.setAge(24);


    // 一个小时后用户决定要保存这个对象

    // 建立一新session
    session = HibernateSessionFactory.getSession();
    Transaction transaction = session.beginTransaction();

    // 保存这个POJO，根据Id修改数据库中对应记录
    session.update(test);

    transaction.commit();
    session.close();
  }


  /**
   * 删除
   *
   *
   *
   * 关于POJO如何与数据库中记录一一对应起来：
   *
   *   一，即时形式
   *     即同一个session时（如调用flush()、delete()）
   *     此时每一个POJO对象对应一条记录，内部对应方式，改不了
   *     此时调用POJO.setId(4);会抛出异常
   *
   *   二，脱管形式
   *     即不同session时（如调用update()、delete()）
   *       session都变了，Hibernate是根据什么决定这个POJO对象对应于表中哪个记录呢？
   *       答曰：根据这个POJO的ID域
   *       如原test的Id为4，更改数据后调用test.setId(1);
   *       则session.update(test);后更改的是1的数据而非4的
   *
   * Date: Dec 1, 2007
   *
   */
  // 即时形式
  public static void delete() {

    Session session = HibernateSessionFactory.getSession();
    Transaction transaction = session.beginTransaction();

    Test test = (Test) session.get(Test.class, 7);

    // setId会抛出异常
    //    test.setId(17);

    session.delete(test);

    transaction.commit();
    session.close();
  }


  // 脱管形式
  public static void delete2() {

    Session session = HibernateSessionFactory.getSession();

    Test test = (Test) session.get(Test.class, 10);
    session.close();

    // 更改Id域
    test.setId(12);


    // 一个小时后，一个新的session
    session = HibernateSessionFactory.getSession();
    Transaction transaction = session.beginTransaction();

    // 根据Id域去删除，这里删的是12而非10
    session.delete(test);

    transaction.commit();
    session.close();
  }


  public static void main(String... arg) {


  }
}

package hartech;

import org.jdom.*;

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

/**
  * <p>Title: JDOM examples </p>
  *
  * <p>Description:
  *
  * JDOM安装：
  *
  *   开发端（JBuilder2006）：
  *
  *        从jdom.org下载最新的jdom.zip
  *        把jdom.jar复制到JBuilder2006/lib
  *        把jdom.zip复制到JBuilder2006/extras
  *        在JBuilder内tools-configure-libraries左边找到JDOM
  *        在右边修改其Source、Document路径为新加入的jdom.zip内的src、doc路径
  *
  *        启用JDOM：右击工程属性-Paths-Required Libraries-Add 加入JDOM
  *
  *   客户端（两种方法）：
  *
  *        1，修改JRE：把jdom.jar复制到用户JRE/lib/ext
  *        2，绑定JDOM：在建立jar文件时，Dependencies选择"Dependencies & Resources"
  *
  *
  * </p>
  *
  * <p>Website: www.hartech.cn </p>
  * <p>Page: http://www.hartech.cn/blog/blogview.asp?logID=94 </p>
  *
  * <p>Date: 2007-02-25 </p>
  */

public class JDom {

    public static Document readFile() {
        SAXBuilder builder = new SAXBuilder();
        Document doc = null;
        try {
            // 可从任一InputStream、Reader、File、URL流中读取
            //doc = builder.build(new URL("http://hartech.cn/blog/feedrss2.asp"));
            doc = builder.build(new FileReader("Data/xmlsrc.xml"));
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
        catch (JDOMException ex) {
            ex.printStackTrace();
        }
        return doc;
    }

    public static void printXML(Document doc) {

        if (doc == null) {
            doc = readFile();
        }
        XMLOutputter outputter = new XMLOutputter();

        // format 也可自定义缩进字符，是否另起一行，采用的编码
        Format format = Format.getPrettyFormat();
        outputter.setFormat(format);

        try {
            outputter.output(doc, System.out);
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static void saveToFile() {

        Document doc = readFile();
        // 设置DOCTYPEs
        DocType dtd = new DocType("docTYPE", "docTYPE.dtd");
        doc.setDocType(dtd);
        XMLOutputter outputter = new XMLOutputter();
        outputter.setFormat(Format.getPrettyFormat());

        FileOutputStream out = null;
        try {
            out = new FileOutputStream("Data/newXML.xml");
            // 可输入到任一OutputStream流内
            outputter.output(doc, out);
            out.flush();
            out.close();
        }
        catch (FileNotFoundException ex) {
            ex.printStackTrace();
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static void browseXML() {
        Document doc = readFile();
        Element el = doc.getRootElement();

        // 以root这个标签为例，其他标签也是同样用法
        J.p(el.getName());
        J.p(el.getTextTrim());
        J.p(el.getAttributeValue("title"));
        J.p(el.getChild("slide").getChild("title").getText());

        // 浏览其所有子属性
        List ls = el.getAttributes();
        Iterator il = ls.iterator();
        Attribute e;
        while (il.hasNext()) {
            e = (Attribute) il.next();
            // e.getIntValue,getDoubleValue...
            J.p("Name: " + e.getName() + "\tValue: " + e.getValue());
        }

        // 浏览其所有子内容（Content：标签、注释、PI等）
        ls = el.getContent();
        il = ls.iterator();
        Content o;
        while (il.hasNext()) {
            o = (Content) il.next();
            if (o instanceof Comment) {
                J.p("Comment: " + ( (Comment) o).getText());
            }
            else if (o instanceof ProcessingInstruction) {
                J.p("PI: " + ( (ProcessingInstruction) o).getValue());
            }
            else if (o instanceof Element) {
                J.p("Element: " + ( (Element) o).getName());
            }
        }
    }

    public static void editXML() {
        Document doc = readFile();
        Element el = doc.getRootElement();

        el.setName("newName");

        // setText会把所有的Content（子标签、注释等）替换掉
        //el.setText("new Text");

        // append text(使用CDATA)
        el.addContent(new CDATA("append Text"));

        // 加入标签、注释(都是加到最后)(可直接加入 Name Spaces)
        el.addContent(new Element("newElement", "prefix", "URL...."));
        el.addContent(new Comment("new Comment"));
        // 加入到指定位置(从1开始计数)
        el.addContent(1, new Element("indexedElement"));

        // 加入属性（已存在同名的则替换）（加入到最后）
        el.setAttribute(new Attribute("name1", "1111"));
        el.setAttribute("title", "222");

        // 删除
        // 删除第一个"slide"的标签
        el.removeChild("slide");
        // 删除所有叫"slide"的标签
        el.removeChildren("slide");
        // 删除属性(String)(Attribute)
        el.removeAttribute("title");
        // 删除指定Content
        el.addContent(3, new Element("toRemove"));
        Element e = (Element) el.getContent(3);
        el.removeContent(e);
        // 删除所有Content
        el.removeContent();

        printXML(doc);
    }

    // 验证XML文件语法是否正确，是否符合对应的DTD声明
    public static boolean validateXML(File src) {
        // JDOM本身不提供验证DTD功能，会自动忽略DTD声明，使用其他parser来验证
        // true 打开验证功能
        SAXBuilder builder = new SAXBuilder(true);
        try {
            builder.build(src);
        }
        catch (JDOMException ex) {
            ex.printStackTrace();
            return false;
        }
        catch (IOException ex) {
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    // 验证内存中的Document是否符合对应的DTD声明
    public static boolean validateXML(Document doc) {
        SAXBuilder builder = new SAXBuilder(true);
        String str = new XMLOutputter().outputString(doc);
        // 把字符串变成字符流
        StringReader stream = new StringReader(str);
        try {
            builder.build(stream);
        }
        catch (IOException ex) {
            ex.printStackTrace();
            return false;
        }
        catch (JDOMException ex) {
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    public static void main(String ...args) {
    }
}

package hartech;

import java.sql.*;
import javax.sql.*;

import java.io.*;

/**
  * <p>Title: JDBC examples </p>
  *
  * <p>Description:
  *
  * JDBC中：
  *
  * 要查询：
  * 使用Statement执行SQL查询语句，使用返回的ResultSet对象处理得到的数据
  * （下面 printInfos()）
  *
  * 要更新：（修改，插入，删除，建表）
  * 1，使用Statement执行SQL查询语句，再使用返回的ResultSet对象对数据进行更新操作
  * （下面 edit()、insert()、delete()）
  * 2，使用PreparedStatement预编译要执行更新的SQL语句，使用setXXX()方法设变量值
  * （下面 usePreparedStatementTransaction()）
  *
  *
  *
  * 对于数据冲突（数据同步）的解决方法：
  * 1，使用数据库锁
  * 2，使用会话（下面 usePreparedStatementTransaction()）
  *
  *
  *
  * PreparedStatement 与 会话：
  *
  * *** 使用 PreparedStatement 对象 ***
  *
  * 当同一个SQL语句要执行多次时，这个效率更高
  * 因为它对字符串的SQL语句只编译一次（在创建该对象时），而之前的方法每次都要编译一次
  *
  *
  * *** 使用会话 ***
  *
  * 用于要更新一系列数据时，对于查询数据无用
  *
  * 一般情况是每执行一次更新就对数据库修改一次，这些操作是间断，所以有可能被其他操作插入
  * 比如你在更新一个学生的所有信息，有可能修改到一半时有人来查该学生所有信息
  * 这是他得到的是前一半是刚更新的，后一半则是还未更新的信息
  *
  * 解决方法有两个：
  * 1，使用数据锁对整条记录上锁，这样别的操作（如查询）在当前操作未完成前是被阻塞的
  * 2，使用会话，即把不要一个信息项一个信息项的修改数据库，而是把所有要修改的项准备好
  * 最后打包一次性发送给DBMS修改整一条信息
  *
  * 使用方法：
  *
  * 首先设置 con.setAutoCommit(false);
  * 因为默认的连接为每次执行完 update 语句后都自动更新到数据库
  *
  * /...... 这里执行一系列数据库更新操作....../
  *
  * 最后把所有操作打包一次性发送到DBMS：
  * con.commit();
  * con.setAutoCommit(true);

  *
  * </p>
  *
  * <p>Website: www.hartech.cn </p>
  * <p>Page: http://www.hartech.cn/blog/blogview.asp?logID=94 </p>
  *
  * <p>Date: 2007-02-09 </p>
  */

public class JDBC {

    /**
      * 建立连接，返回con
      * using JDBC-ODBC driver
      *
      * @param dbPath String 目标数据库相对于 启动本程序的地方 的路径
      * @return Connection
      */
    public static synchronized Connection getConnection(String dbPath) {

        // 指定驱动程序，使用JDBC－ODBC桥
        String dirverName = "sun.jdbc.odbc.JdbcOdbcDriver";

        // 连接到DBMS时使用的路径
        // 也可： DriverManager.getConnection("jdbc:odbc:myDB_Name","","");
        // 这样要在控制面板数据源里制定该数据库位置并把其命名为 myDB_Name
        String url = "jdbc:odbc:driver={Microsoft Access Driver (*.mdb)};DBQ=" +
                dbPath;

        try {
            // 加载驱动程序
            Class.forName(dirverName);
        }
        catch (ClassNotFoundException ex) {
            // 找不到该驱动程序
            ex.printStackTrace();
        }

        Connection con = null;
        try {
            // 连接到DBMS,(url, user, password)
            con = DriverManager.getConnection(url, "", "");
        }
        catch (SQLException ex1) {
            // 连接失败，可能找不到数据库、数据库密码错误、数据库禁止访问
            ex1.printStackTrace();
        }

        return con;
    }

    /**
      * 打印列表
      */
    public static void printInfo() {
        J.p("\n-------------Print Infos---------------");
        Connection con = getConnection("Data/coffee.mdb");
        try {
            // 获得用于执行sql语句的Statement对象
            // 指针移动类型： ResultSet.TYPE_FORWARD_ONLY,
            // TYPE_SCROLL_INSENSITIVE, TYPE_SCROLL_SENSITIVE
            // 操作类型： ResultSet.CONCUR_READ_ONLY , CONCUR_UPDATABLE
            // 一般使用 ResultSet.TYPE_SCROLL_SENSITIVE
            Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                    ResultSet.CONCUR_READ_ONLY);
            // 执行sql语句
            ResultSet srs = stmt.executeQuery(
                    "select COF_NAME,price from COFFEES order by cof_name");

            while (srs.next()) {
                // 可以指定字符名称（大小写忽略），也可指定获取哪一列数据
                J.p(srs.getRow() + ":\t" + srs.getString("cof_name") + "\t\t" +
                        srs.getDouble(2));
            }

            stmt.close();
            con.close();
        }
        catch (SQLException ex) {
            ex.printStackTrace();
        }
    }

    /**
      * 更新数据内容
      */
    public static void edit() {

        J.p("\n----------- Edit ----------------");
        printInfo();

        Connection con = getConnection("Data/coffee.mdb");
        try {

            // 获得用于执行sql语句的Statement对象
            // 指针移动类型： ResultSet.TYPE_FORWARD_ONLY,
            // TYPE_SCROLL_INSENSITIVE, TYPE_SCROLL_SENSITIVE
            // 操作类型： ResultSet.CONCUR_READ_ONLY , CONCUR_UPDATABLE
            // 一般使用 ResultSet.TYPE_SCROLL_SENSITIVE
            Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                    ResultSet.CONCUR_UPDATABLE);
            ResultSet srs = stmt.executeQuery(
                    "select cof_name,price from coffees order by cof_name");

            // 首先指向要更新的那一行
            srs.next();

            // 可用名称字符串或序号(从1开始)指定要更改的项
            srs.updateString("cof_Name", "aa111");
            // 取消所做更新
            srs.cancelRowupdates();

            srs.updateDouble(2, 777117);
            // **** 在移动指针到别的地方之前要调用 updateRow() 保存更改 ****
            srs.updateRow();

            srs.next();
            srs.updateString(1, "13ctt1");
            srs.updateDouble(2, 8888);

            // 要更新生效，srs.updateRow() 和 con.close() 缺一不可
            // updateRow()用于把更新提交到ResultSet对象内，con.close()把更新保存到数据库内
            srs.updateRow();

            stmt.close();
            con.close();
        }
        catch (SQLException ex) {
            ex.printStackTrace();
        }

        printInfo();
    }

    /**
      * 删除指定行
      */
    public static void delete() {
        printInfo();
        Connection con = getConnection("Data/coffee.mdb");
        try {
            Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                    ResultSet.CONCUR_UPDATABLE);
            ResultSet srs = stmt.executeQuery("select cof_name,price from coffees");

            // 把指针定位到要删除的那行
            srs.absolute(2);
            srs.deleteRow();

            stmt.close();
            // 必须执行 con.close() 否则不删除
            con.close();
        }
        catch (SQLException ex) {
            ex.printStackTrace();
        }
        printInfo();

    }

    /**
      * 插入新记录
      */
    public static void insert() {
        printInfo();
        Connection con = getConnection("Data/coffee.mdb");
        try {
            Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                                                    ResultSet.CONCUR_UPDATABLE);
            ResultSet srs = stmt.executeQuery("select cof_name,price from coffees");

            srs.absolute(2);

            // 把指针移动到插入缓冲区（一个ResultSet对象有一个，行号为0）
            srs.moveToinsertRow();
            // 写入各项数据
            srs.updateString(1, "x665588884x");
            srs.updateDouble("price", 8888);
            // 把所有数据一次性插入ResultSet表内，但在调用con.close()前还没入数据库表内
            srs.insertRow();

            // 把指针移回原来的位置
            srs.moveToCurrentRow();

            stmt.close();
            // 必须执行 con.close() 否则无效
            con.close();
        }
        catch (SQLException ex) {
            ex.printStackTrace();
        }
        printInfo();
    }

    /**
      * *** 使用 PreparedStatement 对象 ***
      *
      * 当同一个SQL语句要执行多次时，这个效率更高
      * 因为它对字符串的SQL语句只编译一次（在创建该对象时），而之前的方法每次都要编译一次
      *
      *
      * *** 使用会话 ***
      *
      * 用于要更新一系列数据时，对于查询数据无用
      *
      * 一般情况是每执行一次更新就对数据库修改一次，这些操作是间断，所以有可能被其他操作插入
      * 比如你在更新一个学生的所有信息，有可能修改到一半时有人来查该学生所有信息
      * 这是他得到的是前一半是刚更新的，后一半则是还未更新的信息
      *
      * 解决方法有两个：
      * 1，使用数据锁对整条记录上锁，这样别的操作（如查询）在当前操作未完成前是被阻塞的
      * 2，使用会话，即把不要一个信息项一个信息项的修改数据库，而是把所有要修改的项准备好
      * 最后打包一次性发送给DBMS修改整一条信息
      *
      * 使用方法：
      *
      * 首先设置 con.setAutoCommit(false);
      * 因为默认的连接为每次执行完 update 语句后都自动更新到数据库
      *
      * /...... 这里执行一系列数据库更新操作....../
      *
      * 最后把所有操作打包一次性发送到DBMS：
      * con.commit();
      * con.setAutoCommit(true);
      */
    public static void usePreparedStatementTransaction() {
        printInfo();
        Connection con = getConnection("Data/coffee.mdb");

        try {
            // 使用'?'做为变量，第一个'?'序号为1
            PreparedStatement updateSales = con.prepareStatement(
                    "update coffees set price= ? where cof_name like ? ");

            // 使用会话
            con.setAutoCommit(false);

            // 一次更新
            updateSales.setInt(1, 7115588);
            updateSales.setString(2, "colombian");
            updateSales.executeupdate();

            // 二次更新
            updateSales.setString(2, "espr%");
            // 此时price仍保留上次7888的值，直到被重设或执行 clearParameters()
            updateSales.executeupdate();

            // 把上面一系列更新打包一次性发送给DBMS
            con.commit();
            updateSales.close();
            con.close();
        }
        catch (SQLException ex) {
            ex.printStackTrace();
        }

        printInfo();
    }

    public static void main(String ...args) {
        J.p( (char) 47);
    }
}

<?xml version='1.0' encoding='utf-8'?>
<!-- A SAMPLE set of slides -->
<slideshow title="Sample Slide Show" date="Date of publication" author="Yours Truly">
    <!-- PROCESSING INSTRUCTION -->

<?my.presentation.Program QUERY="exec, tech, all"?>
    <!-- TITLE SLIDE -->
    <slide type="all">
        <title>Wake up to WonderWidgets!</title>
    </slide>
    <!-- OVERVIEW -->
    <slide type="all">
        <title>Overview</title>
        <item> Why
            <em>WonderWidgets</em>
            are great
        </item>
        <item/>
        <item> Who
            <em>buys</em>
            WonderWidgets
        </item>
    </slide>
    <slide type="exec">
        <title>Financial Forecast</title>
        <item> Market Size
            &lt;
            predicted!
        </item>
        <item>Anticipated Penetration</item>
        <item>Expected Revenues</item>
        <item>Profit Margin</item>
    </slide>
    <slide type="tech">
        <title>How it Works</title>
        <item>First we fozzle the frobmorten</item>
        <item>Then we framboze the staten</item>
        <item>Finally, we frenzle the fuznaten</item>
        <item>
            <![CDATA[Diagram:

                      frobmorten <------------ fuznaten
                              | <3> ^
                              | <1> | <1> = fozzle
                              V | <2> = framboze
                          staten--------------------+ <3> = frenzle
                                                        <2> ]]>
                </item>
    </slide>
</slideshow>

/**
*
* 配置Tomcat6的数据池：
*
*
* 一，配置tomcat下的conf下的context.xml文件,在之间添加连接池如下
*
<Resource name="jdbc/mysql/party"
auth="Container"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/party"
username="root"
password=""
maxActive="50"
maxIdle="10"
maxWait="5000" />
*
*
* 二，配置你的应用下的web.xml中加入（作为第一个子标签）
*
*   
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/mysql/party</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
*
*
* 三，Java中获取连接
*
InitialContext context = new InitialContext();
DataSource dataSource = (DataSource)context.lookup("java:comp/env/jdbc/mysql/party");
Connection conn = dataSource.getConnection();
*
*
* 四，如何使用本类
*

Connection conn = MySQLConnectionPool.getConnection();

Statement stmt = conn.createStatement();

String strSql = " select * from test";

ResultSet rs = stmt.executeQuery(strSql);

// 使用完后记得用下面语句把连接交还给Tomcat，否则Tomcat中连接数会一直增加
conn.close();

*
*
* Date: 2007-11-1
*/

Image: attachments/TrafficDemo/image/tip.gif

演示与下载:

进入演示界面

源文件下载：
File: Click to Download

Image: attachments/TrafficDemo/image/readme.gif

Image: attachments/TrafficDemo/image/type.gif

1，  控制车的距离，红灯处理和故障处理

// 当前第i辆车的运行情况
    //
    // 判断是否红灯
    stopCar = 0;
    for (j=1; j<=3; j++) {
      if (eval("car"+i)._x>(eval("redLine"+j)._x-stop_interval) && eval("car"+i)._x<(eval("redLine"+j)._x) && eval("redLine"+j).redOn == 1) {
        stopCar = 1;
      }
    }
    if (_root.car_autoBroken_on == 1) {
      // 车子出现故障的概率为1秒内(1/_root.car_broken_rate)次
      if (random(_root.car_broken_rate*100) == 1 && eval("car"+i)._x>car_width && eval("car"+i)._x<(load_length-car_width)) {
        eval("car"+i).stopCar = 1;
        eval("car"+i).gotoAndStop(2);
      }
    }
    // 车故障自动恢复
    if (eval("car"+i).stopCar == 1) {
      eval("car"+i).count++;
      if (eval("car"+i).count>_root.car_recover_time) {
        eval("car"+i).count = 0;
        eval("car"+i).stopCar = 0;
        eval("car"+i).gotoAndStop(1);
      }
    }
    // 当非红灯且车子不出故障时可行
    if (stopCar == 0 && eval("car"+i).stopCar == 0) {
      moveCar();
    }
    // 当驶出地图时
    if (eval("car"+i)._x>(load_length+car_width*5)) {
      eval("car"+i)._visible = false;
      removeMovieClip(eval("car"+i));
      car_out++;
    }


2，  控制车速度

function moveCar() {
  // 保持车距，当小于四倍车距时以最低速行驶，小于一倍车距时停下
  if ((eval("car"+(i-1))._x-eval("car"+i)._x)>(_root.car_interval*4+car_width) || i == (car_out+1)) {
    eval("car"+i)._x += random(car_maxSpeed-car_maxSpeed*car_minK)+car_maxSpeed*car_minK;
  } else {
    if ((eval("car"+(i-1))._x-eval("car"+i)._x)>(_root.car_interval+car_width)) {
      eval("car"+i)._x += car_maxSpeed*car_minK;
    }
  }
}


3，  红灯的事件定义

onClipEvent (load) {
  count = 0;
  cancel_redLight();
  pass_WE = 1;
  // 通知使得该红灯下的南北走向畅通
  function getPass_NS() {
    pass_WE = 0;
    gotoAndStop(2);
    _parent.load_W_1.redLine3.redOn = 1;
    _parent.load_E_1.redLine1.redOn = 1;
    _parent.load_S_1.redLine1.redOn = 0;
    _parent.load_N_1.redLine3.redOn = 0;
  }
  // 通知使得该红灯下的东西走向畅通
  function getPass_WE() {
    pass_WE = 1;
    gotoAndStop(1);
    _parent.load_W_1.redLine3.redOn = 0;
    _parent.load_E_1.redLine1.redOn = 0;
    _parent.load_S_1.redLine1.redOn = 1;
    _parent.load_N_1.redLine3.redOn = 1;
  }
  // 改变方向
  function change_direction() {
    if (pass_WE == 1) {
      getPass_NS();
    } else {
      getPass_WE();
    }
  }
  // 使红绿灯失效
  function cancel_redLight() {
    gotoAndStop(3);
    _parent.load_W_1.redLine3.redOn = 0;
    _parent.load_E_1.redLine1.redOn = 0;
    _parent.load_S_1.redLine1.redOn = 0;
    _parent.load_N_1.redLine3.redOn = 0;
  }
}
on (release) {
  count = 0;
  change_direction();
}


4,红灯总控制器的代码

// 控制全部交通灯的变换，每个交通灯都有自己的独立的计时器，每隔lightChangeSpeed时间自动切换
onEnterFrame = function () {
  if (_root.cancelAllLights == 0) {
    // 遍历所有九个交通灯
    for (i=1; i<=3; i++) {
      for (j=1; j<=3; j++) {
        eval("Light_"+i+j).count++;
        if (eval("Light_"+i+j).count>_root.lightChangeSpeed) {
          eval("Light_"+i+j).count = 0;
          eval("Light_"+i+j).change_direction();
        }
      }
    }
  }
};


5,方案之一莲花型的事件处理

on (click) {
  _root.cancelAllLights = 0;
  // 全部计时器置零
  _parent.Light_11.count = 0;
  _parent.Light_12.count = 0;
  _parent.Light_13.count = 0;
  _parent.Light_21.count = 0;
  _parent.Light_22.count = 0;
  _parent.Light_23.count = 0;
  _parent.Light_31.count = 0;
  _parent.Light_32.count = 0;
  _parent.Light_33.count = 0;
  // Group 1
  _parent.Light_12.getPass_WE();
  _parent.Light_21.getPass_WE();
  _parent.Light_23.getPass_WE();
  _parent.Light_32.getPass_WE();
  // Group 2
  _parent.Light_11.getPass_NS();
  _parent.Light_13.getPass_NS();
  _parent.Light_22.getPass_NS();
  _parent.Light_31.getPass_NS();
  _parent.Light_33.getPass_NS();
}


6,所创建的滑杆组件的代码

on (press) {
  onEnterFrame = function () {
    this._x = _parent._xmouse;
    if (this._x<0) {
      this._x = 0;
    } else if (this._x>100) {
      this._x = 100;
    }
    _parent.mark._x = this._x-112.0;
  };
}
on (release, releaseOutside) {
  delete onEnterFrame;
  _parent.mark._x = this._x-112.0;
  if (this._x<0) {
    this._x = 0;
  } else if (this._x>100) {
    this._x = 100;
  }
}

onClipEvent (load) {
  // *** 设定从哪个数值到哪个数值 ***
  from = 400;
  to = 5;
  // *** 初始值(0到100) ***
  default_value = 85;
  //
  //
  line._x = default_value;
  mark._x = line._x-112.0;
}
onClipEvent (enterFrame) {
  // *** 要控制的变量 ***
  _root.lightChangeSpeed = from+((to-from)*line._x/100);
}

Image: attachments/jSecureKit/0.gif

运行与下载:

点击运行该程序(jar)

若不能正常运行请先安装 Java运行环境(JRE)


可执行文件、文档、源代码下载：
File: Click to Download

Image: attachments/jSecureKit/1.gif

Image: attachments/jSecureKit/2.gif

1，测试消息摘要（散列值）部分：

计算整个目录的消息摘要：
以一个具有87个文件，17个文件夹，总大小为400KB的目录SCR为例

一开始整个目录的消息摘要为：
41 e9 00 77 a9 26 41 ab 4f 3c b4 5c 1e 49 08 79 08 b2 b3 bd

对目录内一个文本文件加一个空格后，该目录的消息摘要为：
9f 23 28 7e 10 19 59 50 9e 8b 22 c8 47 1b bc 8b 2b 95 02 c1

删除其中一文件后，该目录的消息摘要为：
a8 ec 74 8c 85 04 68 a5 93 2b 4b 26 64 ed 6e ff e8 b3 45 df

增加一文件后，该目录的消息摘要为：
f7 5b 61 40 a8 d6 c5 1b 09 98 7f cc 84 2b a5 05 d7 ef 33 67


2，测试加/解密整个目录部分：

测试方法:
先对源目录计算其消息摘要，再对该目录进行加密，然后对生成的目录进行解密，计算解密后目录的消息摘要，若两消息摘要相同，则说明源目录与加密解密后的目录内容完全相同

以一个具有87个文件，17个文件夹，总大小为400KB的目录SCR为例

SCR目录的消息摘要为：
41 e9 00 77 a9 26 41 ab 4f 3c b4 5c 1e 49 08 79 08 b2 b3 bd

对其加密，密钥1234567，结果另存为SCR_encrypt目录
再对SCR_encrypt进行解密，结果另存为SCR_decrypt目录

再计算SCR_decrypt目录的消息摘要：
41 e9 00 77 a9 26 41 ab 4f 3c b4 5c 1e 49 08 79 08 b2 b3 bd

该的消息摘要与源目录SCR的消息摘要相同，说明源目录与加密解密后的目录内容完全相同

interface AVLtree_Interface {

    // return the number of nodes in the tree
    public int getSize();

    // insert element
    // the element's key and its reference
    // if the key already existed,return false
    public boolean insert(int key, Object reference);

    // whether the tree is empty
    public boolean isEmpty();

    // print the this AVL binary tree
    // using preorder traversal to print all the nodes and its left/right childs
    // print out format:
    // Node [node's key]: Left child:[lchlid's key] Right child:[rchild's key]
    public void printTree();

    // search by key, return its reference
    // if not find,return null
    public Object search(int key);
}

package hartech.ds;

/**
  * <p>Title: AVL tree </p>
  *
  * <p>Description:
  * Balanced Binary Tree
  *
  * according to the DS book's algorithm P236
  * but it's written in C++ which has reference variable which java don't have
  * so transform some codes of it
  * see the NoteBook Java(2) about how to transform
  *
  * </p>
  *
  * <p>Website: www.hartech.cn </p>
  * <p>Page: http://www.hartech.cn/blog/blogview.asp?logID=91 </p>
  *
  * <p>Date: 2006-12-06 </p>
  */

public class AVLtree
        implements AVLtree_Interface {

    // AVL tree node
    class Node {

        // the node's key
        int key;

        // content binding to the key
        Object reference;

        // the node's balance factor(平衡因子)
        int bf;

        Node lchild;
        Node rchild;
        Node(int key, Object reference) {
            this.bf = EH;
            this.key = key;
            this.reference = reference;
        }
    }

    // root node
    // if tree is empty, root==null
    private Node root;

    // the number of nodes in the tree
    private int size;

    // whether the tree getter taller after insert
    private boolean taller;

    // whether insert successfully,if the key already existed,return false
    private boolean insert_return;

    // balance factor's value
    private final int LH = +1; // left taller
    private final int EH = 0; // balanced
    private final int RH = -1; // right taller

    // initializtion
    public AVLtree() {
        root = null;
        size = 0;
        taller = false;
        insert_return = false;
    }

    public boolean isEmpty() {
        return root == null;
    }

    public int getSize() {
        return size;
    }

    // print the binary tree
    // using preorder traversal to print all the nodes and its left/right childs
    // print format:
    // [node's key]: Left child: [lchlid's key] Right child [rchild's key]
    public void printTree() {
        if (isEmpty()) {
            System.out.println("This AVL tree is Empty!");
        }
        else {
            System.out.println("Number of nodes: " + getSize());
            printTree(root);
        }
    }

    private void printTree(Node node) {
        if (node == null) {
            return;
        }
        System.out.print("Node [" + node.key + "]" + ":\t\tLeft child: ");
        if (node.lchild != null) {
            System.out.print(node.lchild.key + "\t\tRight child: ");
        }
        else {
            System.out.print("null\tRight child: ");
        }
        if (node.rchild != null) {
            System.out.print(node.rchild.key);
        }
        else {
            System.out.print("null");
        }
        System.out.println();
        printTree(node.lchild);
        printTree(node.rchild);
    }

    // search by key, return its reference
    public Object search(int key) {
        return search(root, key);
    }

    private Object search(Node node, int key) {
        // can't find it
        if (node == null) {
            System.out.println("Can't find key:" + key + " in the tree!");
            return null;
        }
        if (key == node.key) {
            return node.reference;
        }
        if (key < node.key) {
            return search(node.lchild, key);
        }
        else {
            return search(node.rchild, key);
        }
    }

    // insert element
    // the element's key and its reference
    // if the key already existed,return false
    public boolean insert(int key, Object reference) {
        root = insert(root, key, reference);
        return insert_return;
    }

    // called in insert()
    private Node insert(Node node, int key, Object reference) {

        // insert new node
        if (node == null) {
            node = new Node(key, reference);
            taller = true;
            insert_return = true;
            size++;
            return node;
        }

        // key already existed,don't do anything
        if (key == node.key) {
            taller = false;
            insert_return = false;
            return node;
        }

        // the key smaller than the node's key
        if (key < node.key) {

            // insert into node's left tree
            node.lchild = insert(node.lchild, key, reference);

            // left tree has taller, adjust it
            if (taller) {
                switch (node.bf) {
                    case LH:
                        node = leftBalance(node);
                        taller = false;
                        break;
                    case EH:
                        node.bf = LH;
                        taller = true;
                        break;
                    case RH:
                        node.bf = EH;
                        taller = false;
                        break;
                }
            }
        }

        // the key bigger than the node's key
        else {

            // insert into node's right tree
            node.rchild = insert(node.rchild, key, reference);

            // right tree has taller,adjust it
            if (taller) {
                switch (node.bf) {
                    case LH:
                        node.bf = EH;
                        taller = false;
                        break;
                    case EH:
                        node.bf = RH;
                        taller = true;
                        break;
                    case RH:
                        node = rightBalance(node);
                        taller = false;
                        break;
                }
            }
        }
        insert_return = true;
        return node;
    }

    // left balance
    // called in insert(Node,int,Object)
    private Node leftBalance(Node node) {
        Node lc = node.lchild;
        switch (lc.bf) {

            case LH:

                // right single rotate
                node.bf = EH;
                lc.bf = EH;
                node = right_rotate(node);
                break;

            case RH:

                // left-right double rotate
                Node rd = lc.rchild;
                switch (rd.bf) {
                    case LH:
                        node.bf = RH;
                        lc.bf = EH;
                        break;
                    case EH:
                        node.bf = EH;
                        lc.bf = EH;
                        break;
                    case RH:
                        node.bf = EH;
                        lc.bf = LH;
                        break;
                }
                rd.bf = EH;
                node.lchild = left_rotate(node.lchild);
                node = right_rotate(node);
        }
        return node;
    }

    // right balance
    // called in insert(Node,int,Object)
    private Node rightBalance(Node node) {
        Node rc = node.rchild;
        switch (rc.bf) {

            case RH:

                // left single rotate
                node.bf = EH;
                rc.bf = EH;
                node = left_rotate(node);
                break;

            case LH:

                // right-left double rotate
                Node ld = rc.lchild;
                switch (ld.bf) {
                    case RH:
                        node.bf = LH;
                        rc.bf = EH;
                        break;
                    case EH:
                        node.bf = EH;
                        rc.bf = EH;
                        break;
                    case LH:
                        node.bf = EH;
                        rc.bf = RH;
                        break;
                }
                ld.bf = EH;
                node.rchild = right_rotate(node.rchild);
                node = left_rotate(node);
        }
        return node;
    }

    // single right rotate
    private Node right_rotate(Node node) {
        Node lc = node.lchild;
        node.lchild = lc.rchild;
        lc.rchild = node;
        node = lc;
        return node;
    }

    // single left rotate
    private Node left_rotate(Node node) {
        Node rc = node.rchild;
        node.rchild = rc.lchild;
        rc.lchild = node;
        node = rc;
        return node;
    }
}

    // test
    public static void main(String args[]) {

        AVLtree avl = new AVLtree();

        avl.insert(4, "NO.4 info Jack");
        avl.insert(6, null);
        avl.insert(8, "NO.8 info harTech");
        avl.insert(3, null);
        avl.insert(2, null);
        avl.insert(5, "NO.5 info JTL");
        avl.insert(1, null);
        avl.insert(10, null);
        avl.insert(9, null);
        avl.insert(7, null);

        avl.printTree();

        // test search() method
        System.out.println(avl.search(8));
        System.out.println(avl.search(88));
    }

          Number of nodes: 10
          Node [4]:    Left child: 2    Right child: 8
          Node [2]:    Left child: 1    Right child: 3
          Node [1]:    Left child: null  Right child: null
          Node [3]:    Left child: null  Right child: null
          Node [8]:    Left child: 6    Right child: 9
          Node [6]:    Left child: 5    Right child: 7
          Node [5]:    Left child: null  Right child: null
          Node [7]:    Left child: null  Right child: null
          Node [9]:    Left child: null  Right child: 10
          Node [10]:    Left child: null  Right child: null
          

          NO.8 info harTech
          Can't find key:88 in the tree!

Image: attachments/month_200612/09_085532_jg9nAVL.gif

Image: attachments/grapher/ooop.gif

运行与下载:

进入演示页面(applet)

点击运行该程序(jar)

若不能正常运行请先安装 Java运行环境(JRE)


可执行文件、文档、源代码下载：
File: Click to Download

Image: attachments/grapher/route.gif

Image: attachments/grapher/dfs.gif

Image: attachments/grapher/bfs.gif

Image: attachments/grapher/tree.gif

Image: attachments/grapher/shortest.gif

package hartech.kids.grapher;

import hartech.ds.Queue;
import java.awt.Dimension;

/**
  * <p>Title: 图的遍历、最小生成树、最短路径</p>
  *
  *
  * <p>Description:
  *
  * 采用邻接矩阵做为图存储结构，有权无向图，不相连的值为 -1
  *
  * 图的遍历中深度遍历采用递归方法，广度遍历使用辅助队列
  *
  * 最小生成树采用克鲁斯卡尔（Kruskal）算法，使用一数组记录节点的连通情况
  *
  * 图的最短路径采用迪杰斯特拉（Dijkstra）算法，使用队列记录依次途经的路径
  *
  * 修改：
  * 深度、广度遍历中 在列出第n节点相邻的节点并一一入栈/队时，相邻最近的优先入栈/队
  *
  * </p>
  *
  * <p>Website: www.hartech.cn </p>
  * <p>Page: http://www.hartech.cn/blog/blogview.asp?logID=88 </p>
  *
  * <p>Date: 2006-09-08 </p>
  */
public class Graph {

    // 图邻接矩阵
    private static int[][] arcs;
    // 节点数
    private static int num;
    // 记录是否访问过
    private static boolean[] hasVisit;

    // 记录访问过的前一个节点，用于统计线路总长度
    static int pre;

    // 深度优先遍历，给出图邻接矩阵和开始遍历的节点
    public static void traverse_DFS(int[][] arcs_in, int begin) {
        pre = begin;
        if (arcs_in == null || arcs_in.length == 0 ||
                arcs_in.length != arcs_in[0].length || begin < 0) {
            System.err.println("wrong arcs[][] or begin!");
            return;
        }
        arcs = arcs_in;
        num = arcs.length;
        hasVisit = new boolean[num];

        DFS(begin);
    }

    private static void DFS(int begin) {
        hasVisit[begin] = true;
        Main.Q_DFS.enQueue(begin);
        Main.length_DFS += Main.arcs[pre][begin];
        pre = begin;

        int min, n = 0;
        for (int i = 1; i < num; i++) {
            // 距离最短的优先入栈
            min = Integer.MAX_VALUE;
            for (int j = 0; j < num; j++) {
                if (!hasVisit[j] && arcs[begin][j] != -1 && arcs[begin][j] < min) {
                    min = arcs[begin][j];
                    n = j;
                }
            }
            if (min == Integer.MAX_VALUE) {
                break;
            }
            else {
                DFS(n);
            }
        }
    }

    // 广度优先遍历，给出图邻接矩阵和开始遍历的节点
    public static void traverse_BFS(int[][] arcs_in, int begin) {
        pre = begin;
        if (arcs_in == null || arcs_in.length == 0 ||
                arcs_in.length != arcs_in[0].length || begin < 0) {
            System.err.println("wrong arcs[][] or begin!");
            return;
        }
        arcs = arcs_in;
        num = arcs.length;
        hasVisit = new boolean[num];
        Queue queue = new Queue();

        hasVisit[begin] = true;
        queue.enQueue(begin);
        int temp, min, n = 0;
        while (!queue.isEmpty()) {
            temp = ( (Integer) queue.deQueue()).intValue();
            for (int i = 1; i < num; i++) {
                // 距离最短的优先入队
                min = Integer.MAX_VALUE;
                for (int j = 0; j < num; j++) {
                    if (!hasVisit[j] && arcs[temp][j] != -1 && arcs[temp][j] < min) {
                        min = arcs[temp][j];
                        n = j;
                    }
                }
                if (min == Integer.MAX_VALUE) {
                    break;
                }
                else {
                    hasVisit[n] = true;
                    queue.enQueue(n);
                    Main.Q_BFS.enQueue(n);
                    Main.length_BFS += Main.arcs[pre][n];
                    pre = n;
                }
            }
        }
    }

    // 构造最小生成树，采用克鲁斯卡尔（Kruskal）算法
    // 使用一数组记录节点的连通情况
    public static void miniSpanTree(int[][] arcs_in) {
        if (arcs_in == null || arcs_in.length == 0 ||
                arcs_in.length != arcs_in[0].length) {
            System.err.println("wrong arcs[][]!");
            return;
        }
        arcs = arcs_in;
        num = arcs.length;

        // 使用一数组记录节点的连通情况
        // 如 group[0]＝0 表示节点未和任何节点连通
        // group[0]=group[3]=group[5]=2 表示节点0、3、5为同一连通图内，该连通图的标识为 2
        int[] group = new int[num];
        boolean finish = false;

        int temp = 0, min, n1 = 0, n2 = 0, groupNum = 0;
        // 到全部group[n]等于同一数值，也就是处于同一连通图才结束
        while (!finish) {

            // 遍历所有路径，无向图，仅遍历矩阵上三角
            // 找出最短的且不在同一连通图的（group[n1]!=group[n2]），或两节点都未加入连通图的
            min = Integer.MAX_VALUE;
            for (int i = 0; i < num; i++) {
                for (int j = i + 1; j < num; j++) {
                    if (arcs[i][j] < min && arcs[i][j] != -1) {
                        if (group[i] != group[j] || (group[i] == 0 && group[j] == 0)) {
                            min = arcs[i][j];
                            n1 = i;
                            n2 = j;
                        }
                    }
                }
            }
            // 无路了
            if (min == Integer.MAX_VALUE) {
                break;
            }

            Main.Q_tree.enQueue(new Dimension(n1, n2));
            Main.length_tree += Main.arcs[n1][n2];

            // 加入连通图组
            if (group[n1] == 0 && group[n2] == 0) {
                groupNum++;
                group[n1] = groupNum;
                group[n2] = groupNum;
            }
            else if (group[n1] != 0 && group[n2] != 0) {
                temp = group[n2];
                for (int i = 0; i < num; i++) {
                    if (group[i] == temp) {
                        group[i] = group[n1];
                    }
                }
            }
            else {
                if (group[n1] == 0) {
                    group[n1] = group[n2];
                }
                else {
                    group[n2] = group[n1];
                }
            }

            // 到全部group[n]等于同一数值且不为0，也就是处于同一连通图才结束
            temp = 1;
            while (temp < num && group[temp] == group[0]) {
                temp++;
            }
            if (group[0] != 0 && temp == num) {
                finish = true;
            }
        }
        if (!finish) {
            System.out.println("图为非强连通图");
        }
    }

    // 图的最短路径，给出图邻接矩阵，起点，终点，打印出途经的节点
    // 采用迪杰斯特拉（Dijkstra）算法
    public static void shortestPath_DIJ(int[][] arcs_in, int begin, int end) {
        if (arcs_in == null || arcs_in.length == 0 ||
                arcs_in.length != arcs_in[0].length) {
            System.err.println("wrong arcs[][]!");
            return;
        }
        arcs = arcs_in;
        num = arcs.length;
        // 标识节点是否已找到最短路径，从begin到n 为finish[n]=true;
        boolean[] finish = new boolean[num];
        // 记录从 begin 到 n 的最短路径为 min[n]
        int[] D = new int[num];
        // 使用队列记录路径途经节点
        Queue[] queue = new Queue[num];

        // 初始化
        for (int i = 0; i < num; i++) {
            D[i] = arcs[begin][i];
            finish[i] = false;
            queue[i] = new Queue();
        }
        finish[begin] = true;
        D[begin] = -1;

        int v = 0, min = 0;
        // 一个一个循环找出最短距离（共num－1个）
        for (int i = 1; i < num; i++) {
            min = Integer.MAX_VALUE;
            // 扫描找出非final集中最小的D[]
            for (int w = 0; w < num; w++) {
                if (!finish[w] && D[w] < min && D[w] != -1) {
                    v = w;
                    min = D[w];
                }
            }

            finish[v] = true;
            // 已找到目标，退出循环
            if (v == end) {
                queue[v].enQueue(v);
                Main.Q_shortest = queue[v].clone();
                Main.length_short = D[v];
                break;
            }

            // 更新各D[]数据
            for (int w = 0; w < num; w++) {
                if (!finish[w] && arcs[v][w] != -1) {
                    if ( (arcs[v][w] + min) < D[w] || D[w] == -1) {
                        D[w] = arcs[v][w] + min;
                        queue[w] = queue[v].clone();
                        queue[w].enQueue(v);
                    }
                }
            }
            queue[v].enQueue(v);
        }
    }
}

Image: attachments/huffman/1.gif

运行与下载:

进入演示页面(applet)

点击运行该程序(jar)

若不能正常运行请先安装 Java运行环境(JRE)


可执行文件、文档、源代码下载：
File: Click to Download

Image: attachments/huffman/2.gif



Image: attachments/huffman/3.gif



Image: attachments/huffman/4.gif

package hartech.kids.huffman;

/**
  * <p>Title: 哈夫曼编/译码器</p>
  *
  * <p>Description:
  * 利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。
  * 但是，这要求在发送端通过一个编码系统对待传数据预先编码，
  * 在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），
  * 每端都需要一个完整的编／译码系统。试为这样的信息收发站写一个哈夫曼码的编／译码系统。
  * </p>
  *
  * <p>Website: www.hartech.cn </p>
  * <p>Page: http://www.hartech.cn/blog/blogview.asp?logID=87 </p>
  * <p>Date: 2006-09-05 </p>
  */
public class Huffman {

    class Elem {
        char chara;
        int weight;
        int parent;
        int lchild;
        int rchild;
        public Elem(char c, int w, int p, int l, int r) {
            chara = c;
            weight = w;
            parent = p;
            lchild = l;
            rchild = r;
        }
    }

    // 哈夫曼树
    private Elem[] huffmanTree;
    // 哈夫曼编码表
    private String[] huffmanCode;
    // 字符个数
    int charNum;

    // 给出 in 构造哈夫曼树 huffmanTree、哈夫曼编码表huffmanCode
    // in 格式为{'字符1',对应权值,'字符2',对应权值, ...}
    public Huffman(char[] in) {
        if (in == null || in.length == 0 || in.length % 2 != 0) {
            System.err.println("dd");
            return;
        }
        charNum = in.length / 2;
        // 0 单元不用，要用到 0 来标记是否有孩子、父亲
        huffmanTree = new Elem[charNum * 2];
// 初始化
        for (int i = 1; i < charNum + 1; i++) {
            huffmanTree[i] = new Elem(in[ (i - 1) * 2], in[i * 2 - 1], 0, 0, 0);
        }
        for (int i = charNum + 1; i < charNum * 2; i++) {
            huffmanTree[i] = new Elem( (char) 0, 0, 0, 0, 0);
        }

// 构造哈夫曼树
        huffmanTree[0] = new Elem( (char) 0, Integer.MAX_VALUE, 0, 0, 0);
        int minNo1, minNo2;
        for (int i = charNum + 1; i < charNum * 2; i++) {
            // 找出weight最小且无父节点的两个
            minNo1 = 0;
            minNo2 = 0;
            for (int j = 1; j < i; j++) {
                if (huffmanTree[j].parent == 0) {
                    if (huffmanTree[j].weight < huffmanTree[minNo1].weight ||
                            huffmanTree[j].weight < huffmanTree[minNo2].weight) {
                        if (huffmanTree[minNo1].weight < huffmanTree[minNo2].weight) {
                            minNo2 = j;
                        }
                        else {
                            minNo1 = j;
                        }
                    }
                }
            }

            huffmanTree[minNo1].parent = i;
            huffmanTree[minNo2].parent = i;
            // 保持叶子节点为父节点的左孩，如书上图6.26
            if (minNo1 <= charNum) {
                huffmanTree[i].lchild = minNo1;
                huffmanTree[i].rchild = minNo2;
            }
            else {
                huffmanTree[i].lchild = minNo2;
                huffmanTree[i].rchild = minNo1;
            }
            huffmanTree[i].weight = huffmanTree[minNo1].weight +
                    huffmanTree[minNo2].weight;
        }

// 求出每个字符编码，从叶子到根，保存至 huffmanCode
        huffmanCode = new String[charNum + 1];
        char[] temp = new char[charNum + 1];
        int start, pa, ch;
        for (int i = 1; i <= charNum; i++) {
            start = charNum;
            ch = i;
            pa = huffmanTree[i].parent;
            while (pa != 0) {
                if (huffmanTree[pa].lchild == ch) {
                    temp[start] = '0';
                }
                else {
                    temp[start] = '1';
                }
                start--;
                ch = pa;
                pa = huffmanTree[pa].parent;
            }
            huffmanCode[i] = String.valueOf(temp, start + 1, charNum - start);
        }
    }

    // 返回给定字符串的哈夫曼代码，对于本树中无记录的字符则直接插入到原对应位置
    String toCodes(String in) {
        StringBuffer out = new StringBuffer();
        char c;
        int j;
        for (int i = 0; i < in.length(); i++) {
            c = in.charAt(i);
            j = 1;
            while (huffmanTree[j].chara != c && j <= charNum) {
                j++;
            }
            if (j <= charNum) {
                out.append(huffmanCode[j]);
            }
            else {
                out.append(c);
            }
        }
        return out.toString();
    }

    // 对给定哈夫曼码译码，对于非 1、0 的字符直接插入到原对应位置
    String toChars(String in) {
        StringBuffer out = new StringBuffer();
        // 指向树根
        int point = charNum * 2 - 1;
        char c;
        for (int i = 0; i < in.length(); i++) {
            c = in.charAt(i);
            if (c == '0') {
                point = huffmanTree[point].lchild;
            }
            else if (c == '1') {
                point = huffmanTree[point].rchild;
            }
            else {
                out.append(c);
                continue;
            }
            // 为叶子
            if (point <= charNum) {
                out.append(huffmanTree[point].chara);
                point = charNum * 2 - 1;
            }
        }
        return out.toString();
    }

    // 打印哈夫曼树
    public String printTree() {
        StringBuffer out = new StringBuffer();
        out.append("No.\t" + "Char\t" + "Weight\t" + "Parent\t" + "Lchild\t" +
                              "Rchild" + "\r\n\r\n");
        for (int i = 1; i < charNum * 2; i++) {
            out.append("[" + i + "]\t" + huffmanTree[i].chara + "\t" +
                                  huffmanTree[i].weight + "\t" +
                                  huffmanTree[i].parent + "\t" + huffmanTree[i].lchild + "\t" +
                                  huffmanTree[i].rchild + "\r\n");
        }
        return out.toString();
    }

    // 打印出所有编码
    public String printCodes() {
        StringBuffer out = new StringBuffer();
        int value = 0;
        out.append("No.\t" + "Char\t" + "Code" + "\r\n\r\n");
        for (int i = 1; i < charNum + 1; i++) {
            out.append("[" + i + "]\t" + huffmanTree[i].chara + "\t" + huffmanCode[i] +
                                  "\r\n");
            value += huffmanCode[i].length() * huffmanTree[i].weight;
        }
        out.append("\r\n总带权路径长度为：\t" + value + "\r\n");
        return out.toString();
    }

    public static void main(String[] args) {
        // test：

        // 词频表
        char[] in = {
                ' ', 186, 'a', 64, 'b', 13, 'c', 22, 'd', 32, 'e', 103, 'f', 21, 'g',
                15, 'h', 47, 'i', 57, 'j', 1, 'k', 5, 'l', 32, 'm', 20, 'n', 57, 'o',
                63, 'p', 15, 'q', 1, 'r', 48, 's', 51, 't', 80, 'u', 23, 'v', 8, 'w',
                18, 'x', 1, 'y', 16, 'z', 1};

        Huffman huffman = new Huffman(in);
        huffman.printTree();
        huffman.printCodes();

        // 编码：
        // 输出：0010111010101101000010101110001000101111100011000111000010101101
        // 000001110010100000001111011000110100100110010100010100
        String code = huffman.toCodes("this program is my favorite");

        // 译码：
        // 输出：this program is my favorite
        huffman.toChars(code);
    }
}

Image: attachments/filekits/FileKits.gif

运行与下载:

点击运行该程序(jar)

可执行程序与源代码下载：

File: Click to Download

Image: attachments/filekits/FileKits_2.gif