最好的方式是将一件事做到极致

sources.list书写的方法

syhan — Wed, 25 Jul 2007 16:17:30 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/105412 发表时间: 2007年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

（1）地址：找到包含dists和pool这两个目录的地址，比如
http://mirrors.geekbone.org/debian/；
（2）目录名：打开dists，里面包含的目录名字，记下来。比如dists/包含sarge、etch、woody、sid。
（3）名字：打开以上目录，看看里面包含哪些组件名字，比如main、cont
rib、non-free；
（4）书写格式：deb <1记下来的地址> <2记下来的目录名> <3记下来的名字>，如：
deb ftp://ftp.linuxforum.net/debian/ sarge main contrib non-free
发现一个比较快的台湾地址： http://ftp.isu.edu.tw/pub/Linux/Debian/debian/
书写了一下：deb http://ftp.isu.edu.tw/pub/Linux/Debian/debian/ sarge main contrib non-free

版本说明：
一般有三个版本：stable,testing,unstable
当前的stable是sarge，unstable是sid，testing是etch。

stable
The “stable” distribution contains the latest officially released distribution of Debian.
This is the production release of Debian, the one which we primarily recommend using.
The current “stable” distribution of Debian GNU/Linux is version 3.1r0, codenamed sarge. It was released on June 6th, 2005.

testing
The “testing” distribution contains packages that haven't been accepted into a “stable” release yet, but they are in the queue for that. The main advantage of using this distribution is that it has more recent versions of software.
The current “testing” distribution is etch.

unstable
The “unstable” distribution is where active development of Debian occurs. Generally, this distribution is run by developers and those who like to live on the edge.
The “unstable” distribution is called sid.

stable — 最广泛的用于架设产品化服务器，因为它只包含安全更新。
testing — 推荐工作站用户使用的发行版，因为它包含有最近发布的桌面软件，这些软件已经接受了少量测试。
unstable — 处在悬崖边缘的版本，供 Debian 开发者选用。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

今天被群硕电面了

syhan — Thu, 05 Jul 2007 20:56:00 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/98227 发表时间: 2007年07月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

面了有28分多种，有点紧张，不过感觉还好吧，各种各样的问题都有，和之前网上搜的差不多，应该比前一阵电面IBM的时候要好一些了，但是又是最后面我的那位gg说过一会儿hr会给我打电话，然后我到现在还没有等到，不会又被bs了吧，我祈祷啊，群硕，你快给我通知吧，优质大学生真诚觅求实习岗位~~~
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

我的豆瓣收藏秀

syhan — Sun, 17 Jun 2007 02:31:19 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/91142 发表时间: 2007年06月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

还不错啊，呵呵~

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

向橘红色天空的叫喊

syhan — Sat, 16 Jun 2007 01:52:00 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/90883 发表时间: 2007年06月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

突然想到这首歌

永远的在这个时刻，永远的在这个时刻，一起歌唱，一起歌唱，我们永远年轻，我们永远倔强，我们永远纯洁，没有人能消灭我们，没有人能消灭我们，永远的在这个时刻，永远的在这个时刻，一起歌唱，永远歌唱

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

儿童节礼物

syhan — Sat, 02 Jun 2007 12:44:44 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/85903 发表时间: 2007年06月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

昨天下午我正昏昏沉沉的躺在床上睡觉，突然手机震动了，一看是021开头的，心里就很高兴，赶紧起来接，果然是ibm通知电面的通知，这个儿童节过得真好~
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

心情比较复杂

syhan — Wed, 30 May 2007 17:26:20 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/84774 发表时间: 2007年05月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天心情有点复杂，做事情也不专注，平均每个小时就要去检查一下邮箱，啊呀呀，这不是真正的我，什么都可以输，但是信心不能输.
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

IBM笔试归来

syhan — Sun, 27 May 2007 19:40:48 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/83598 发表时间: 2007年05月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

昨天我去南大参加了IBM的招聘暑期实习生的笔试，累死了（回来后又看到了前校长顾冠群院士去世的消息，默哀）。由于我应聘的是技术类的职位，整个考试分为IPAT和技术加试两个部分。感觉一般，哎
整个考场大概有100多人，大概有30+是自己学校的，可惜一个都不认识。
IPAT和google到的信息一致，矩阵变换，数列与应用题，考察的就如名字Information Processing Aptitude Test一样，主要考察的就是信息处理、逻辑判断以及快速阅读等等的能力，这个考试是和IBM签订了保密协议的，但是也可以google到一些真题，没什么好说的，时间是不够用的，答题卡有点混乱，也许也是考察范围吧，做下来很累感觉，哎，我已经没什么感觉了。
技术类加试分ABC三个部分，A是java的，B是C++的，C部分是综合测试。我选择的是A+C，java的整体难度类似SCJP，也包含一些J2EE（EJB啊XML啊什么的）的和有点偏的东西（例如package java.nio.*），还好吧。C部分就很广了，相对来说几天前Business Object的笔试就不算什么了，包括Design Pattern, UML, SQL, OO, C甚至还有一道关于raid卷的题目。总体来说还不算太差吧。
考完试后我就去山西路买书了，最后买了GoF的《Design Pattern》, MIT Press的《Introduction to Algorism》。然后混在人山人海的安铜线上回到了学校。

顺者，不妄喜，自知顺逆相随；
逆者，不惶馁，自知逆过即顺；
安者，不奢逸，自知奢逸丧志；
危者，不惊惧，自知惟静制危；
胸有激雷而面如平湖者，可拜上将军！

我师兄写的比我好多了，需要的可以参考
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

HashMap,Hashtable,HashSet等等Hash Collection之间的区别

syhan — Fri, 25 May 2007 13:00:24 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/82980 发表时间: 2007年05月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

昨天博奥杰面试的时候，pm问了我一个问题，HashMap与Hashtable之间有什么区别？我虽然以前看过java doc，里面的确提到过二者的区别，但是我当时实在想不起来了，只好老老实实和pm说我以前看过java api里面说二者的区别只有一点点，但是我记不得了，然后又balabala的说了一点以前看effective java的关于hash的，还有什么对象的hashcode云云。

回来后赶紧查java api：
HashMap:

public class HashMapextends AbstractMap
implements Map, Cloneable, Serializable

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

其实Hashtable的迭代是Enumberation，而HashMap则是Iterator

HashSet:

public class HashSet
extends AbstractSet
implements Set, Cloneable, Serializable

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证集合的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。……注意，此实现不是同步的。

此外，java.util包里还提供了其他有关Hash的Collection，但是不常用
IdentityHashMap:

public class IdentityHashMap
extends AbstractMap
implements Map, Serializable, Cloneable

此类利用哈希表实现 Map 接口，比较键（和值）时使用引用相等性代替对象相等性。换句话说，在 IdentityHashMap 中，当且仅当 (k1==k2) 时，才认为两个键 k1 和 k2 相等（在正常 Map 实现（如 HashMap）中，当且仅当满足下列条件时才认为两个键 k1 和 k2 相等：(k1==null ? k2==null : e1.equals(e2))）。

此类不是通用 Map 实现！此类实现 Map 接口时，它有意违反 Map 的常规协定，该协定在比较对象时强制使用 equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况。

此类的典型用法是拓扑保留对象图形转换，如序列化或深层复制。要执行这样的转换，程序必须维护用于跟踪所有已处理对象引用的“节点表”。节点表一定不等于不同对象，即使它们偶然相等也如此。此类的另一种典型用法是维护代理对象。例如，调试设施可能希望为正在调试程序中的每个对象维护代理对象。

LinkedHashMap:

public class LinkedHashMapextends HashMap
implements Map

Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（插入顺序）。注意，如果在映射中重新插入键，则插入顺序不受影响。（如果在调用 m.put(k, v) 前 m.containsKey(k) 返回了 true，则调用时会将键 k 重新插入到映射 m 中。）

LinkedHashSet:

public class LinkedHashSet
extends HashSet
implements Set, Cloneable, Serializable

具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到集合中的顺序（插入顺序）进行迭代。注意，插入顺序不受在集合中重新插入的元素的影响。（如果在 s.contains(e) 返回 true 后立即调用 s.add(e)，则元素 e 会被重新插入到集合 s 中。）

顺带再复习下Set、List、Map之间的区别：
Set集合是不包含重复元素的，List则可以包含重复元素，Map是键-值的映射关系
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

java到底是传值还是传引用

syhan — Wed, 23 May 2007 22:42:17 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/82309 发表时间: 2007年05月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

这个很基础很基础的问题今天才搞明白。
今天和同学讨论C++的一个函数的参数是指针的时候我无意说了一句，要是java的话就不用这么复杂了，一律传引用，于是就引起了java到底是传值还是传引用的讨论。
我之前的认识是这样的：在处理简单数据类型的时候毫无疑问是传值的，而当对象作为函数的参数的时候则是传的是引用。
但是事实证明我的认识还是错的，现在我当然明白了java的传参究竟是传什么，下面简单说一下：
可以说java不存在传递引用的情况，java只有一种传递方法就是传值，但是这个传值还是有一点小小的不同，例如在函数

java 代码

public void testRef(SomeClass sc) {
//stub
sc.someMethod();
// sc = new SomeClass();
}

中，其中当调用此函数时

java 代码

SomeClass someClass = new SomeClass();
testRef(someClass);

作为形参的sc会生成实参someClass的一个拷贝，但是这个拷贝是someClass在栈空间指向堆空间的地址的拷贝，我们知道，当使用诸如A a = new A();的时候，实际上A a是在栈空间中获得了一个A对象的“引用”，当使用new A();初始化这个对象是，则是在堆空间中申请了空间同时将a指向堆空间中的地址。有了这些知识就不难理解，在方法testRef中通过.的操作其实就是对传进来的实参someClass进行操作，因为此时sc是someClass地址，而若执行了sc = new SomeClass();sc的.的操作变不会再对someClass产生影响，究其原因，是因为此时sc已经指向了堆空间中另一块SomeClass类大小的地址。
简单一点就是说，java在传递参数过程中若参数是对象传递的是对象地址的拷贝，也就是说传递的是地址的值。

这个故事告诉我：凡事不可想当然

补充，今天看sun出的SCJP指南，上面的解释比较科学

可能会问你是否理解传递值到方法中时会发生什么结果。如果方法中的代码改变了变量,对外部的方法是否可见?直接引用 Peter van der Lindens 的 Java 程序员解答的一段话(在 http://www.afu.com)
//引用
所有的变量(基本类型值和对象的引用值)都是值传递。但是这不是全部情况,对象是经常通过 Java 的引用变量来操作的。所以也可以说对象是通过引用传递的(引用变量通过值传递) 。这是变量不使用对象的值而是像前一个问题那样描述的使用对象引用的值的结果。最后一行:调用者对基本类型参数(int,char 等)的拷贝在相应参数变化时不会改变。但是,在被调用方法改变相应作为参数传递的对象(引用)字段时,调用者的对象也改变其字段。
//引用结束
如果你来自 C++背景,你可能对值传递参数和用&符号传递引用参数熟悉。在 Java 中没有这样的选择,所有的都是值传递。但是看起来并不总是这样。如果你传递的对象是对象的引用,你不能直接对对象的引用进行操作。所以如果你操作一个传递到方法的对象的字段, 结果就好像你按引用传递(任何改变结果都会返回到调用函数) 将对象引用作为方法变量
请看下面的例子

java 代码

class ValHold{
public int i = 10;
}
public class ObParm{
public static void main(String argv[]){
ObParm o = new ObParm();
o.amethod();
}
public void amethod(){
ValHold v = new ValHold();
v.i=10;
System.out.println("Before another = "+ v.i);
another(v);
System.out.println("After another = "+ v.i);
}//End of amethod
public void another(ValHold v){
v.i = 20;
System.out.println("In another = "+ v.i);
}//End of another
}

程序的输出结果是
Before another = 10
In another = 20
After another = 20
看变量 i 是怎么被修改的。如果 Java 总是值传递(也就是对变量的拷贝) ,它是怎么被修改的呢?过程是这样的方法收到了句柄的拷贝或者对象的引用, 但是这个引用的作用类似于指向真实的指针。对这个字段的改变会反映到它所指的值。这有些像是在 C/C++中指针的自动间接应用的的作用。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

如何ie6下utf8的页面传递中文参数

syhan — Mon, 14 May 2007 22:51:48 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/79909 发表时间: 2007年05月14日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天遇到了一个问题，就是明明在ff和opera下都很正常的链接在ie6下就是不能工作，甚至ie7是可以的。google了一下，好像这是ie6的一个bug，我的页面是utf8的，页面链接是含有中文参数的，ie6传过来的参数通过转码后好像会被截去半个字节，而其他的浏览器却不会。例如 http://url?name=中文转码后 name 的值就会变成中和一个菱形乱码。现在的解决方法是将页面链接用jstl拼一下。
例如：原来是

xml 代码

<a href="url?name=中文">链接a>

现在使用jstl改写成

xml 代码

<c:url value="url" var="testurl">
<c:param name="name" value="中文">c:param>
c:url>
<a href="${testurl}">链接a>

jstl会将中文字符自动的转为ascii码的格式，类似%E4%B8%AD%E6%96%87，这样在ie6下就没问题了，乱码解决了，生活真美好！
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

子查询转连接的一点

syhan — Thu, 10 May 2007 15:00:00 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/78506 发表时间: 2007年05月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

因为万网使用的MySQL是4.0.24不支持子查询（MySQL从4.1开始支持），不得已要将现有的SQL语句涉及子查询的转化为连接：
以下是我google到的一些资料：
将 WHERE 子句中的子查询转换为连接
           Adaptive Server Anywhere 查询优化程序会对一些多层查询进行转换,以
           使用连接。执行这一转换不需要任何用户操作。本节将介绍哪些子查询
           可转换为连接,以便您可以了解数据库中的查询的性能。
           问题 [Clarke 女士和 Suresh 女士何时下的订单,并且是向哪些销售代表示例
           下的订单? ] 可表示为两层查询:

sql 代码

SELECT order_date, sales_rep
FROM sales_order
WHERE cust_id IN (
SELECT id
FROM customer
WHERE lname = 'Clarke' OR fname = 'Suresh')

或者,可以采用同样正确的方法来表示为使用连接的查询:

sql 代码

SELECT fname, lname, order_date, sales_rep
FROM sales_order, customer
WHERE cust_id=customer.id AND
(lname = 'Clarke' OR fname = 'Suresh')

           要将多层查询改写为连接必须满足一定的条件,运算符的类型不同,这
           些条件也将有所不同。请回忆一下子查询出现在查询的 WHERE 子句中
           的情况,其形式如下

sql 代码

SELECT select-list
FROM table
WHERE
[NOT] expression comparison-operator ( subquery )
| [NOT] expression comparison-operator { ANY | SOME } ( subquery )
| [NOT] expression comparison-operator ALL ( subquery )
| [NOT] expression IN ( subquery )
| [NOT] EXISTS ( subquery )
GROUP BY group-by-expression
HAVING search-condition

子查询是否可转换为连接取决于多种因素,例如运算符的类型、查询的
结构和子查询的结构等。

下面是我的通用的解决方案：

查询：

sql 代码

SELECT * FROM table1 WHERE id IN (SELECT id FROM table2);

可以被写成：

sql 代码

SELECT table1.* FROM table1,table2 WHERE table1.id=table2.id;

或者使用一个内连接：

sql 代码

SELECT table1.* FROM table2 INNER JOIN table1 ON table1.id=table2.id;

查询：

sql 代码

SELECT * FROM table1 WHERE id NOT IN (SELECT id FROM table2);
SELECT * FROM table1 WHERE NOT EXISTS (SELECT id FROM table2 WHERE table1.id=table2.id);

可以被写成：

sql 代码

SELECT table1.* FROM table1 LEFT JOIN table2 ON table1.id=table2.id WHERE table2.id IS NULL;

参考资料：
http://corp.avantgo.com/developer/product_manuals/sqlanywhere/0902/zh/html/dbfgzh9/00000172.htm
Adaptive Server® Anywhere
SQL 用户指南

http://topic.csdn.net/t/20020813/09/935770.html
将一个子查询转换成外部连接
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

破解了下ViPlugin

syhan — Sun, 06 May 2007 22:48:24 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/77408 发表时间: 2007年05月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

是eclipse的一个插件，等于在eclipse下模拟vi的操作，我本以为是免费的，没想到要n欧元，google了一下，发现这个文章geniil.spaces.live.com/blog/cns!81B15F02616BA25C!238.entry#comment
于是我就自己尝试破解了一下，的确很简单，只是将源码改成类似如下就可以了，很简单，整个文件就不发上来了，确实需要和我联系吧

java 代码

private static boolean checkLicenseFile(String fileName)
throws Exception
{
return true;
}

还发现jad很酷，速度也不错：）
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

最近在玩wordpress

syhan — Sun, 29 Apr 2007 02:44:00 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/55574 发表时间: 2007年04月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

这个东西很好玩，很自由，可定制性非常强，插件体系我很喜欢
www.prophp.org上的空间也很酷

我的wordpress地址是http://syhan.prophp.org
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

如何使用jstl只获取数组中的某些项

syhan — Sun, 29 Apr 2007 02:38:29 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/76015 发表时间: 2007年04月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

我原以为可以直接修改中的步长的，像这样

xml 代码

<c:set var="step" value="1"/>
<c:forEach items="${district}" var="d" begin="1" step="${step}">
……
<c:set var="step" value="${expression}">
c:forEach>

结果发现这一行根本不改变整个的循环，没办法只好想了个笨办法，就是增加零时变量来比较，像这样

xml 代码

<c:forEach items="${district}" var="d" begin="1">
<c:if test="${index == temp}">
……
<c:set var="temp" value="${temp+(d.right-d.left-1)/2 + 1}">
c:if>
c:forEach>

整个写法很繁琐，也许都怪我有对jsp页面中的java代码的偏执感，用java很容易就解决了，但是我就是不想让我的jsp页面出现java代码
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

有关读数据库的无刷新的三级联动以及层次数据(树形结构)在关系数据库的存储

syhan — Wed, 11 Apr 2007 11:26:55 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/70002 发表时间: 2007年04月11日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

我的标题真冗长：P

最近一直在考虑这个问题，如何在现在常用的关系型数据库（如mysql，mssql）中存储含有层次结构（例如xml或者树型结构）的数据，我最终要实现的结果是一个比较好的页面三级联动菜单。比较了一下现有的三级联动，无非有两种解决方案，1、将所有数据写成静态的，这样的缺点在于对更新封闭;2、每改变一次去数据库中获取数据，填充到下一级菜单，这个缺点是对数据库的开销比较大，查询一次数据要对数据库做三次操作，而且数据库设计的比较丑陋。上述两种方法都让我比较不能接受。

我想的是一种比较优雅的解决方案：在数据库中存储的数据不要冗余，便于查询，不要产生递归，对数据库的开销要尽可能的小，尽量做到一次将所有数据都读出来，用户也要有比较好的体验。我最初的解决方案就是用xml来存储联动的数据，但是对于数据库操作来说，最后还是要落实到对文件的I/O操作，从这方面来讲，使用xml和数据库并没有什么本质的不同。另外一种解决方案就是在关系数据库中存类xml的数据了。google了半天，最后发现了一片自己学院一位学长翻译的文章www.nirvanastudio.org/category/database，讲得就是如何在关系型数据库存储这种层次数据的。文中提出了两种解决方案，一是“邻接列表模型”或称为“递归方法”，这种存在着数据冗余，而且递归出于众所周知的原因，效率不高。第二种方法，也就是我现在采用的方法是"前序优先遍历"，表结构也很简单，没有冗余

name

left

right

我觉得应该属于一种深度优先。通过每个节点的左右两个属性获得其子女的属性，好处就在于获得一个或几个节点只需要一次查询，而在更新的时候速度会比较慢，因为要更新多个后继节点，不过话说回来，更新相对于获取来说次数要少的多，可以忽略。

下面是我的解决方案：

java 代码

import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import com.netkc.struts.datasource.DataSource;
import com.netkc.struts.mapping.District;
/**
* @author SONG Yihan
* @version 1.0
* @date: Monday, April 09 2007
*/
public class DistrictTree {
private ArrayList tree;
private Statement stmt1 = null;
private Statement stmt2 = null;
private Connection conn = null;
private ResultSet rs = null;
public DistrictTree() {
try {
conn = DataSource.getConnection();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public DistrictTree(Connection conn) {
this.conn = conn;
}
public boolean addNode(String parentId, String districtId, String districtName) {
try {
String sql = "SELECT * FROM district WHERE districtId='" + parentId + "';";
conn.setAutoCommit(false);
stmt1 = conn.createStatement();
rs = stmt1.executeQuery(sql);
if(rs.next()) {
int right = rs.getInt("rgt");
sql = "UPDATE district SET lft=lft+2 WHERE lft>=" + right;
stmt2.addBatch(sql);
sql = "UPDATE district SET rgt=rgt+2 WHERE rgt>=" + right;
stmt2.addBatch(sql);
sql = "INSERT INTO district (districtId, districtName, lft, rgt) VALUES ('"+districtId + "', '" + districtName + "', " +
(right) + ", " + (right+1) +");";
stmt2.addBatch(sql);
int[] flag = stmt2.executeBatch();
if(flag[flag.length - 1] == 1) {
conn.commit();
return true;
} else {
conn.rollback();
return false;
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
}
return false;
}
public boolean deleteNode(String districtId) {
String sql = "SELECT * FROM district WHERE districtId='" + districtId + "';";
try {
conn.setAutoCommit(false);
rs = stmt1.executeQuery(sql);
if(rs.next())
{
int left = rs.getInt("lft");
int right = rs.getInt("rgt");
int count = (right - left - 1) / 2 + 1;
int minus = count * 2;
sql = "DELETE FROM district WHERE lft BETWEEN " + left + " AND " + right + ";";
stmt2.addBatch(sql);
sql = "UPDATE district SET lft=lft-" + minus + " WHERE lft>"+right;
stmt2.addBatch(sql);
sql = "UPDATE district SET rgt=rgt-" + minus + " WHERE rgt>"+right;
stmt2.addBatch(sql);
int flag = stmt2.executeBatch()[0];
if(flag == 1) {
conn.commit();
return true;
} else {
conn.rollback();
return false;
}
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return false;
}
public void displayTree(String parentId) {
}
public ArrayList getTree(String parentId) {
String sql = "SELECT * FROM district WHERE districtId='" + parentId + "';";
try {
stmt1 = conn.createStatement();
rs = stmt1.executeQuery(sql);
if(rs.next()) {
int left = rs.getInt("lft");
int right = rs.getInt("rgt");
stmt2 = conn.createStatement();
sql = "SELECT * FROM district WHERE lft BETWEEN " + left + " AND " + right + " ORDER BY lft ASC";
rs = stmt2.executeQuery(sql);
tree = new ArrayList();
District district = null;
while(rs.next()) {
district = new District();
district.setDistrictId(rs.getString("districtId"));
district.setDistrictName(rs.getString("districtName"));
district.setLeft(rs.getInt("lft"));
district.setRight(rs.getInt("rgt"));
tree.add(district);
}
return tree;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (rs != null) {
rs.close();
}
stmt1.close();
stmt2.close();
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
public ArrayList getChildren(String parentId) {
if(tree == null) {
tree = getTree(parentId);
}
ArrayList children = new ArrayList();
int index = this.indexof(parentId);
if(index != -1) {
District d = tree.get(index);
final int count = (d.getRight() - d.getLeft() - 1) / 2;
for(int i = index + 1; i <= index + count; i++) {
d = tree.get(i);
children.add(d);
i += (d.getRight() - d.getLeft() - 1) / 2;
}
}
return children;
}
private int indexof(String districtId) {
for(int index = 0; index < tree.size(); index++) {
if(districtId.equals(tree.get(index).getDistrictId())) {
return index;
}
}
return -1;
}
public boolean updateNode(String districtId, String districtName) {
String sql = "UPDATE district SET districtName='" + districtName + "' WHERE districtId='" + districtId + "';";
try {
conn.setAutoCommit(false);
stmt1 = conn.createStatement();
int flag = stmt1.executeUpdate(sql);
if(flag == 1) {
conn.commit();
return true;
}
else {
conn.rollback();
return false;
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
}
return false;
}
}

这个最遗憾的地方就是在其中混杂了java代码，这让我及其不爽，但是我没有找到向js传值的好办法：（

js 代码

function District(id, name, left, right) {
this.id=id;
this.name=name;
this.left=left;
this.right=right;
};
var tree = new Array();
<%
for(District d : tree) {
%> tree.push(new District('<%=d.getDistrictId()%>', '<%=d.getDistrictName()%>', '<%=d.getLeft()%>', '<%=d.getRight()%>'));
<%}%>
Array.prototype.indexof = function(id) {
for(var index = 0; index < tree.length; index++) {
if(id == tree[index].id) {
return index;
}
}
return -1;
};
function citychanged(id){
document.getElementById('district').length = 0;
document.getElementById('area').length = 0;
var districts = getChildren(id);
for(var i = 0; i < districts.length; i++){
document.getElementById('district').options[i] = new Option(districts[i].name, districts[i].id);
}
};
function districtchanged(id) {
document.getElementById('area').length = 0;
var area = getChildren(id);
for(var i = 0; i < area.length; i++){
document.getElementById('area').options[i] = new Option(area[i].name, area[i].id);
}
};
function getChildren(id) {
if(tree.length == 0) {
}
var children = new Array();
var index = tree.indexof(id);
if(index != -1) {
var d = tree[index];
var count = (d.right - d.left - 1) / 2;
for(var i = index + 1; i <= index + count; i++) {
d = tree[i];
children.push(d);
i += (d.right - d.left - 1) / 2;
}
}
return children;
};

jsp 页面代码

"/fastfoodAct?method=query" styleId="queryFoodForm">
searchType :
city :
district :
area :
restaurantName :
searchType :
foodName :

以上就是我解决三级联动和层次结构的一点想法：）

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

有一天有许多话要说出的人

syhan — Mon, 26 Mar 2007 18:48:19 +0800

作者: syhan 链接：http://syhan.javaeye.com/blog/65616 发表时间: 2007年03月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

有一天有许多话要说出的人，
常默然把许多话藏在内心：
有一天要点燃闪电火花的人，
必须长时期做天上的云。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐