Welcome to JTL's Blog

[Java Ajax] GWT vs. Swing

这几天学了Google的GWT，即用Java来编写Ajax程序，写了下面这个演示程序。演示了GWT中大部分有用的组件，详细使用方法见源代码内注释。
下面还有一个演示程序是去年学Swing时做的，也是使用了Swing里主要有用的组件，详细说明见源代码内注释。

Image: attachments/gwt/gwt4.gif

关于Swing的各种布局见：http://www.hartech.cn/blog/blogview.asp?logID=79
关于Swing的各种窗口见：http://www.hartech.cn/blog/blogview.asp?logID=81

GWT

运行与源码:

进入演示页面

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

上方是事件显示版，用于显示下面各个组件发出的事件类型、发出者和其他信息
MenuBar、Button、CheckBox、ToggleBox、RadioButton、PopupPanel、DialogBox

Image: attachments/gwt/gwt1.gif

GWT中九种面板的演示，与Swing中一种面板多种布局控制器不同的是，GWT中无布局控制器，每一种面板本身就代表一种布局
TabPanel、VerticalPanel、HorizontalSplitPanel、 DockPanel ScrollPanel、 DisclosurePanel、 FlowPanel、 HorizontalPanel、 StackPanel、 Grid

Image: attachments/gwt/gwt2.gif

List类演示，这个SuggestBox最有意思
SuggestBox、ListBox、Tree

Image: attachments/gwt/gwt3.gif

Text类演示，GWT可实时捕捉文本框的各种键盘、鼠标事件（见上方的事件显示板），右边是GWT的富文本RichText编辑框，其下方用于实时显示该RichTextArea的HTML代码。
TextBox、PasswordTextBox、TextArea、RichTextArea、RichTextToolbar

Image: attachments/gwt/gwt4.gif

Swing

关于Swing的各种布局见：http://www.hartech.cn/blog/blogview.asp?logID=79
关于Swing的各种窗口见：http://www.hartech.cn/blog/blogview.asp?logID=81

运行与源码:

点击运行该程序(jar)

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

源代码下载：
File: Click to Download

菜单与Button类演示，与上面GWT类似，上面的DisplayZone也是用于显示各种事件的信息
JMenuBar、JMenu、JToolBar、JButton、JPopupMenu、JToggleButton、JCheckBox、JRadioButton、ButtonGroup

Image: attachments/gwt/swing1.gif

Bars类演示，图中图片可拖动
JProgressBar、JSlider、JSpinner、JTextArea、JScrollPane、ScrollablePicture

Image: attachments/gwt/swing2.gif

Texts类演示
JLabel、JTextField、JPasswordField

Image: attachments/gwt/swing3.gif

Choosers类演示，各种选择组件
JComboBox、JList、JFileChooser、JColorChooser

Image: attachments/gwt/swing4.gif

[感恩] 遇见

             1，遇见可信任的朋友時

                  要記得好好珍惜他

                  因為在一生中，能遇到这样的朋友并不容易



             2，遇见人生中的貴人時

                  要記得好好感激

                  因為他是你人生的轉折點



             3，遇见你真愛的人時

                  要努力爭取和她相伴一生的機會

                  因為當她離去時，一切都來不及了

             4，遇见曾經愛過的人時

                  記得微笑向她感激

                  因為她是讓你更懂得愛的人

             5，遇见曾經恨過的人時

                  要微笑向她打招呼

                  因為是她讓你更加堅強

             6，遇见曾經背叛你的人時

                  要跟他好好聊一聊

                  因為若不是他今天你不會懂得這世界

             7，遇见曾經偷偷喜歡的人時

                  要记得祝她幸福哦

                  因為你喜歡她時，不是希望她幸福快樂嗎？

             8，遇见匆匆離開你人生的人時

                  要謝謝她走過你的人生

                  因為她是你精采回憶的一部分

             9，遇见曾經和你有誤會的人時

                  要趁現在解清誤會

                  因為你可能只有這一次機會解釋清楚

            10，遇见相伴一生的人時

                  要心存感激的感謝她愛你

                  因為你們現在都得到幸福和真愛

[Java] JBallField

按照物理公式计算控制球体的运动与碰撞
可以用来模拟一些物理运动实验

Image: attachments/jballfield/1.gif

运行与下载:

进入演示页面(applet)

点击运行该程序(jar)

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

设计文档

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

模拟的物理特征：

      1，球的属性：质量、直径、受力情况、加速度、速度、平面位置

      2，球的受力：重力、空气阻力、球之间的万有引力、用户控制的力

      3，球碰撞所遵守的公式：能量守恒、动量守恒

      这里蓝色的球是用户可以通过键盘上下左右键控制的
      采用施力的方式，如按向右5秒，表示给蓝色球施加一个向右100N的力，维持时间为5秒，力度在界面可以调节

一些实验：

      由于碰撞采用能量、动量守恒进行计算，可以看到经过一段时间的碰撞后界面下方显示的总能量、X动量、Y动量仍保持不变
      （但这些数字在球数量一多，碰撞一多时还是会有上下轻微波动）

      打开重力效果可以看到不同质量的球从同一高度上做自由落体运动的时间是相同的
      而且每次都能反弹到同一个高度

      打开球间万有引力，如果控制得好可以模拟行星绕太阳的向心力运动
      （把关键球质量设为50kg并停住，球数量为2~4，打开空气阻力的话更容易看到效果）
      两个同质量的球可以做双子星运动

      打开空气阻力和重力模式，让球从高处落下，可以看到球在向下加速一段时间后停止加速，保持匀速下落
      因为空气阻力随速度而成平方比增长，最后抵消了重力

完整的设计说明请下载设计文档，这里列出一些主要的

关于游戏中各种单位：

      本游戏严格按照物理公式计算结果运行，单位都采用标准单位。
      质量单位为千克kg
      距离单位为米，表现为界面上的十个像素距离
      这里场地大小为（70米X 50米），球的直径为2米（像素到米的转换比例由Main.scale_Field_TO_Calculate 控制）
      力单位为牛N
      加速度单位为 m*m/s
      时间单位为秒，这里周期间的时间差采用系统的时间差，而非设定的周期长度。

每个球、场地独自一线程，完全自主

      做到新建一个球时仅需往场地一扔，该球即开始负责其本身的运动，而场地要做的仅是定期把所有球画出来而已。
      由此可降低整个游戏的复杂性，例如在为球增加新的物理特性时，仅需修改球对象即可。

      这里球采用的线程是Thread，无需使用SwingWorker，因其不主动更新UI，sleep时间为1ms

      Field动画效果采用重写JPanel.paintComponent(Graphics g)
      并使用一swing.Timer定期更新画面（field.repaint()），该Timer测试过最小周期为15ms
      所以画面fps大约为65
      这里也可以采用Thread+sleep或java.util.Timer更新画面，但要注意在EDT里更新UI

各类简要说明：

      Ball：
          球对象，负责模拟该球所应该具有的所有物理特征（运动、碰撞、受力等）

      Field：
          场地，只有一个场地，负责定时依据各个球体位置绘制出球体

      KeyBall：
          关键球，继承自Ball，仅是重写了受用户力处理方法和获取球质量方法

      Collision_Monitor：
          用于碰撞检测和处理的线程，为何使用独立线程处理所有碰撞请见文档

      Events：
          处理所有界面事件

      UI：
          主界面

      Main：
          Swing app入口

      Applet：
          Applet入口

Ball与Field的沟通：

      通过全局变量Main.ball_X[]与Main.ball_Y[]
      即本球在其运行周期结束后确定该时刻的实时位置，并把坐标写入这两个变量中
      Field定时从这两个变量数组中读取全部球的坐标，并绘图。

Image: attachments/jballfield/Communicate.gif

球的一个计算周期：

Image: attachments/jballfield/formulas.gif

碰撞的计算：

把坐标转成两球碰撞点切线法线的坐标会更好计算，因为这样两球受到的力仅是在法线上，切线上无受力.
所以计算动量动能守恒可以仅计算法线上的，把二维转成一维碰撞问题。

Image: attachments/jballfield/collision_formulas.gif

Image: attachments/jballfield/collision.gif

      所以处理碰撞总过程就是：

          1，把坐标系转换成切线法线坐标系，计算出新坐标系上两球的x、y方向速度
          2，y方向速度保留
          3，x方向速度使用上面推导出的公式计算碰撞后的新速度
          4，把坐标系转换回原来正常的坐标系，计算出正常坐标系下两球x、y方向碰撞后的新速度

      转换坐标公式：

Image: attachments/jballfield/collision_process.gif

完整的说明请下载设计文档

[ 笔记 ] Hibernate & JDOM & JDBC & Tomcat6 数据池配置

Hibernate：

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) {

  }
}

JDOM：

package hartech;

import org.jdom.*;

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

/**
 * Title: JDOM examples 
 *
 * 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"
 *
 *
 * 
 *
 * Website: www.hartech.cn 
 * Page: http://www.hartech.cn/blog/blogview.asp?logID=94 
 *
 * Date: 2007-02-25 
 */

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

JDBC

package hartech;

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

import java.io.*;

/**
 * Title: JDBC examples 
 *
 * 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);

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

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文件

<?xml version='1.0' encoding='utf-8'?>

<slideshow title="Sample Slide Show" date="Date of publication" author="Yours Truly">
 

<?my.presentation.Program QUERY="exec, tech, all"?>
 
 <slide type="all">
 <title>Wake up to WonderWidgets!</title>
 </slide>
 
 <slide type="all">
 <title>Overview</title>
 <item> Why
 WonderWidgets
 are great
 </item>
 <item/>
 <item> Who
 buys
 WonderWidgets
 </item>
 </slide>
 <slide type="exec">
 <title>Financial Forecast</title>
 <item> Market Size
 <
 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数据池的配置

/**
*
* 配置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
*/

[Flash] 多路口交通灯演示系统

用于演示简单的交通运行情况

Image: attachments/TrafficDemo/image/tip.gif

演示与下载:

进入演示界面

源文件下载：
File: Click to Download

界面说明：

红灯停车，绿灯通行，全绿的红绿灯台为全通行，即该红绿灯失效，下面的车可以自由行驶

蓝色的车为正常状态，红色为故障状态

每条路的入口处都有一拥塞指示器，指明该条路上的拥塞情况（蓝色为轻微，黄色中等，红色严重），右上角的指示器显示全地图的拥塞情况

操作说明：

Image: attachments/TrafficDemo/image/readme.gif

四种交通灯变换类型：

Image: attachments/TrafficDemo/image/type.gif

实现的规则：

一，每一辆车：

1，车任意时刻的速度取最大速度和最小速度之间的随机数

2，车的最大速度为其所在车道设定的速度，每条车道可以不同

3，最小速度为最大速度的1/3

4，始终保持与其之前一辆车的车距，当车速过快时，允许小几率出现超红灯、追尾，不允许越过前面的车

5，当与前面的车的车距为设定车距的4倍以内时，该车换成以最小车速行驶，当车距为设定车距以内时，该车停止行驶

6，当行驶到红灯区前一定距离并且红灯亮时，该车停止行驶

7，本车以设定的概率出现故障

8，车正常时，当用户点击该车辆时，该车辆出现故障，故障时点击该车恢复正常

9，出现故障时，该车停止行驶，车颜色由蓝色变为红色，恢复正常时变回蓝色

10，当出现故障后经过设定的时间，该车恢复正常

二，每一个红绿灯

1，当为全绿色时为全通型，即该红绿灯失效，下面的车可以自由行驶

2，自备独立的一个定时器

3，当定时器到达设定时间时，切换红绿灯方向

4，当用户点击该红绿灯时，切换红绿灯方向

5，当"总红灯方案控制器"通知该红灯时，切换红绿灯方向

6，当切换红绿灯方向时，通知其下面的四条道路的车辆当前的红绿灯状态，并且定时器置零

三，其它：

1，拥塞定义：所停下来的车辆总数除以总车数

2，"总红灯方案控制器"控制所有的红绿灯，再由红绿灯控制其下方汽车

3，各道路上各自的发车率、车速，控制面板上的总发车率、总车速都可调节，实现各个道路的发车率和车速度可以各不相同，同时又能受全局控制

4，可以尝试不同的红灯切换组合和切换速度对交通所带来的影响

5，改变各个道路的发车率和车速可模拟一些高速公路（车速相对快）与一般公路的相互影响，闹市区街道（发车率高）与一般街道的相互影响

6，点击车辆使其出现故障可观察出现故障后带来的连锁反应

部分代码：

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

[Java DES SHA] JSecureKit

可对单个文件或整个文件夹进行加密或解密，使用DES算法
可计算单个文件或整个文件夹的消息摘要，使用SHA算法

Image: attachments/jSecureKit/0.gif

运行与下载:

点击运行该程序(jar)

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

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

功能：

加密解密部分：
DES算法

1.  可对单个文件进行加/解密操作
2.  可对整个目录（包括子目录）下所有文件进行加/解密操作，输出结果为一个与源目录文件结构完全相同的新建目录（子目录，文件名都相同，只是文件内容为加/解密后结果）
3.  要求输入的密钥为7个字符（56-bit），程序内自动加校验码增加到64-bit做为DES密钥
4.  可显示加/解密处理总时间

计算消息摘要（散列值）部分：
SHA算法

1，  可计算单个文件的消息摘要
2，  可计算整个目录（包括子目录）下所有文件的消息摘要
3，  计算结果（160-bit）以十六进制字符串方式显示在界面上，计算结束后会提示是否把结果保存到文件上（二进制）
4，  计算整个目录（甚至整个硬盘）消息摘要的作用：可用于检测指定目录或磁盘下某一文件某一字节是否被修改过，是否有增加或删除过文件或目录，某一文件/目录是否被重命名过
5，  可显示计算总时间

使用说明：

输入框：
Source File/Dir：    点击选择要进行加/解密操作或消息摘要计算的源文件或源目录
Save To：            点击选择保存加/解密操作结果的文件或目录
Key：                    输入加/解密的密钥，至少为7字符（少则有出错提示，多则只取前7个）
Digest(Hex)：        以十六进制字符串方式显示Hash计算结果（64-bit）

按钮：
Encrypt：      单击进行加密操作
Decrypt：      单击进行解密操作
Get Digest：  单击计算消息摘要

Image: attachments/jSecureKit/1.gif

Image: attachments/jSecureKit/2.gif

主要类功能说明

本软件中主要类都在包hartech.kids.jSecureKit内（目录hartech/kids/jSecureKit）
源程序中其它包的类为本软件要用到的，因为其它软件也共用这些类，所以没放在jSecureKit包内

类hartech.kids.jSecureKit.Main
本类里包含了加/解密函数，计算消息摘要（散列值）等，在各个按钮事件处理中被调用

    该类主要接口：
    public static String getHexString(byte[] bytes)
    把散列计算结果生成的字节数组转换为十六进制字符串，用于显示在界面上

    public static byte[] getMessageDigest(File file)
    计算指定文件的散列值

    public static boolean enDeCrypt(String keyStr, File fin, File fout,
                                  boolean isEncrypt)
    根据输入密钥字符串（56-bit），源文件，目标文件进行加密或解密操作

    public static byte[] addParity(byte[] in)
    把7字节（56-bit）密钥加入校验值转换为64-bit密钥，被调用于enDeCrypt内


类hartech.kids.jDesKit.Actions
处理Encrypt，Decrypt，Get Digest按钮所激发的事件
包含各种输入错误提示框，处理结果提示框，文件选择框


类hartech.kids.jDesKit.UI
处理本软件界面


其它包中两个主要类简介（具体使用说明见源程序中注释，其它类说明见其源程序中注释）：

类hartech. JDirectory
实现遍历指定文件夹下所有文件，包括所有子目录，可加过滤器
使用nextFile()每次返回其中一个文件
应用于对整个目录进行Hash计算中读取各个文件

类hartech.JDirectorySaveAs
继承自hartech. JDirectory类
每次返回一个FileBag对象，里面包含一个源文件和一个根据目标目录构造好路径的目标文件
用于对整个目录进行加/解密操作中读取源文件并把结果保存到相应目标文件中

简单测试：

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的消息摘要相同，说明源目录与加密解密后的目录内容完全相同

[数据结构 Java] AVL tree 平衡二叉树

AVLtree类接口：
使用方法见注释

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

AVLtree类：

package hartech.ds;

/**
 * Title: AVL tree 
 *
 * 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
 *
 * 
 *
 * Website: www.hartech.cn 
 * Page: http://www.hartech.cn/blog/blogview.asp?logID=91 
 *
 * Date: 2006-12-06 
 */

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

[数据结构 Java] 图的算法演示

演示了四种图的算法：深度优先遍历、广度优先遍历、最小生成树、图的最短路径
界面上的节点可以任意拖动，节点间距离为两点间实测直线距离，单位为象素

Image: attachments/grapher/ooop.gif

运行与下载:

进入演示页面(applet)

点击运行该程序(jar)

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

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

图的结构有两种可选：

一，完全无向图：任意两个节点间都有一无向路径，距离为两节点间实际距离
二，无向图：任意一节点仅和其相邻的最近两个节点有连通，该路径用灰色虚线表示（下图）
（点击"设置"－"使用路线图"来切换以上两种模式）


Image: attachments/grapher/route.gif






深度优先遍历：

蓝色
采用递归的方法，使用邻接矩阵
在列出第n节点相邻的节点并一一入栈时，相邻最近的优先入栈
可以看出深度优先遍历的顺序是一直深入探索下去
可选起点，可选显示序号，右下角为其总路程长度

Image: attachments/grapher/dfs.gif







广度优先遍历：

绿色
使用辅助队列、邻接矩阵
在列出第n节点相邻的节点并一一入队时，相邻最近的优先入队
可以看出广度优先遍历的顺序是按距离一层层探索出去
可选起点，可选显示序号，右下角为其总路程长度

Image: attachments/grapher/bfs.gif







最小生成树：

红色
最小生成树：使用线把所有节点连接起来，且要求线段的总长度最短
采用克鲁斯卡尔（Kruskal）算法，邻接矩阵
使用一辅助数组记录节点的连通情况（记录连通图组，具体见源码中注释）
可选显示序号，右下角为其总路程长度

Image: attachments/grapher/tree.gif







图的最短路径：

紫色
采用迪杰斯特拉（Dijkstra）算法，邻接矩阵
使用队列记录依次途经的路径
在这里要打开"使用路线图"，因若不打开，则为完全图，两点间直线距离最短，没意思
可选起点、终点，可选显示序号，右下角为其总路程长度

Image: attachments/grapher/shortest.gif





相关：
C++的图的最短路径应用
http://www.hartech.cn/blog/blogview.asp?logID=52
最短路径理解
http://www.hartech.cn/blog/blogview.asp?logID=54




主要类：Graph.java

package hartech.kids.grapher;

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

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

[数据结构 Java] 哈夫曼编码/译码器

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

主要类：Huffman.java

package hartech.kids.huffman;

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

[数据结构 Java] 文件统计器

可以统计指定目录下（包括子目录）所有指定类型文件中出现的所有单词的频率并排序
同时统计以上所有文件的文件数、目录数、总单词数、总行数、注释行数、代码行数

Image: attachments/filekits/FileKits.gif

界面中：

Files 为所统计的总文件数，Directorys 为总目录数
Words 为所有文件中的单词数
Lines 为总行数、Comment Lines 为注释行数、Codes Lines 为程序行数

接下的为 [单词出现频率] -> 该单词
频率高的在前面，同频率的单词在同一行
可见在这里 Java 中使用频率最高的为关键字 new，超过第二 jpanle 三分一以上，接下为 public、string

操作：

第一个输入框输入所要统计的目录或特定文件，也可点击右边 "Pick" 按钮使用对话框选择目录或文件
第二个输入框输入所要统计文件类型的后缀，可多选，如 "java,cpp,txt"
界面右边为两条竖的按钮
左按钮点击开始统计
右按钮把所选定文件内容读取到剪贴板（仅是一附加功能，与上面的统计无关）

这里的单词界定为：纯字母连接组成，大小写视为同一单词
注释行：以 // 或 /* 或 * 或 ' 开头的行
程序行：总行数－注释行数

运行与下载:

点击运行该程序(jar)

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

File: Click to Download

统计过程大致为：

取出所有文件中的每个单词：

JDirectory 类实现遍历指定目录下所有文件（包括子目录），同时过滤文件（如只统计 java、cpp、txt 文件），每次返回其中一文件
JLineReader 类实现遍历上面所得的所有文件中的每一行，每次返回其中一行
再使用 pickWords() 方法读取出该行中各个单词（由纯字母组成，忽略大小写）

统计单词频率：

把取出的每个单词加入哈希表，该单词为 key、其出现频率为值
同一单词每加一次其对应值（频率）＋1
同时记录频率最高的频率值 maxFre

对频率排序：

全部加完后建一个字符串数组，数组中元素个数为 maxFre+1
把所有哈希表中的单词和其频率写入该字符串数组：
string[单词频率] + = " -> " + 该单词字符串;
由此实现排序（如 string[maxFre]单词频率最高）

下面是分析网页文件（htm、html）的截图，分析对象是 JDK 5.0 Documentation

a 为最多，它可能为网页中的链接符号，也可能是语言上的 a

在网页代码中用得最多的是空格符 nbsp、粗体符号 b、code、html、href、td、font、tr
－－td 大概为 tr 的两倍，也就是说一般表格中平均行列比为 1：2
而关于 Java 的用到最多的为：class、java、javax、lang、swing、awt、object、interface、string、int、method
也可看出在语言上用得最多的为：the、of、to、is、this、and、that、by、an、or、with、be、from、as

Image: attachments/filekits/FileKits_2.gif