我的理智小窝~

与深蓝下棋

woods — Fri, 11 Jul 2008 11:13:57 +0800

作者: woods 链接：http://woods.javaeye.com/blog/213830 发表时间: 2008年07月11日

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

与深蓝下棋，卡斯帕罗夫这一刻灵魂附体- -#
天杀的os390...完全不是一路牌= =~
喝茶- -！

http://www.datatrain.nl/training_zos_mvs_console_simulators_.htm
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

FireFox3 是个好东西- -!

woods — Wed, 25 Jun 2008 12:52:27 +0800

作者: woods 链接：http://woods.javaeye.com/blog/207821 发表时间: 2008年06月25日

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

FireFox3 是个好东西- -!
附上我的插件列表~
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

自卑阿- -#

woods — Thu, 12 Jun 2008 13:19:54 +0800

作者: woods 链接：http://woods.javaeye.com/blog/202463 发表时间: 2008年06月12日

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

牛顿和爱因斯坦，都在他们20多岁的时候，就取得了他们一生最大的成就~
我们这时候却都在干嘛呢？

算了，关劳子鸟事，劳子出来打酱油的- -# （请用川音谢谢- - ）~
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

unicode, character, character set, encoding, utf-8

woods — Thu, 12 Jun 2008 10:51:35 +0800

作者: woods 链接：http://woods.javaeye.com/blog/202410 发表时间: 2008年06月12日

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

unicode, character, character set, encoding, utf-8

这些相关的东西并不复杂, 但非常容易混淆不清, 尤其是最近看了一些这方面的文章, 即使是被认为是权威的出处, 也经常出现冲突矛盾, 和用词不准确, 解释的概念不清楚的情况:

1. 字符集和编码方案混为一谈. http://www.utf.com.cn/article/s320 中说:

UTF_8字符集
UTF-8是UNICODE的一种变长字符编码
后一句话对, 但前一句话, UTF-8是对Unicode字符集的可能的编码方案中的一种, 它本身不是字符集.

2. 字符集只是字义了一个虚拟的, 与电脑无关的一个字符的集合, 规定了在这些集合里面就有哪些字符, 每个字符被赋予一个编号, 编号不是编码, 编号是Unicode术语中的code point的概念, 这些字符就外在的人眼所能看到的形状而言不必是唯一的.

3. Unicode给每个字符赋予的唯一的code point, 只是一个数学概念上的数字, 不要与计算机里对数值的某种表示法联系起来, 还没到那一步, 那是由编码方案决定的. 这个概念上的数, 在Joel on software里的那篇文章"
The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)"章中作者称它是"柏拉图"式的.

4. utf-8究竟最长是4字节还是6字节

The original specification allowed for sequences of up to six bytes covering numbers up to 31 bits (the original limit of the universal character set). However, UTF-8 was restricted by RFC 3629 to use only the area covered by the formal Unicode definition, U+0000 to U+10FFFF, in November 2003.
曾经是6字节, 现在是4字节, 两者都对, 但如果你看到介绍UTF-8的文章说是6字节, 基本可以判断这是比较早的文章. 这跟IPV6的情形不同, IPV6是最初4字节, 最终扩展得更长了, 16字节.

5. 判断ANSI/Unicode 文本的方法
http://www.cppblog.com/liangbo/archive/2006/04/23/6103.html :
如何判断一个文本文件是ANSI还是Unicode？
判断如果文本文件的开头两个字节是0xFF和0xFE，那幺就是Unicode，否则是ANSI

这样的说法你不忍心说它错, 但是, 也绝不能说它对, 非常容易误导人, 开头两个字节来表示的BOM只是一种约定, 你没有任何办法保证文件的后续内容到底是什么, 也许它既不是ASCII也不是Unicode, 它不能是GB2312编码的? 不能是二进制文件? BOM只是一种约定, 约定只有在两方都严格遵守时才有意义, 你当然可以利用这种约定进行欺骗. 而且. 这个说法还忽略了BOM对于UTF-16有little-endian和big-endian的区分, 这里只给一种情况. 其它的情况都落入了它的"否则". 对UTF-8没有大头小头的问题, 但也有一个三字节的特殊标记约定它是UTF-8编码, UTF-8编码当然也是Unicode编码的一种.

对这一问题真正的答案可能会让人失望: 没办法判断, 但是, 这是理论上的说法, 实际上没有那么无聊的人故意使坏, 做出非此非彼的文件来. 想象一下, HTTP头部没有送给IE Content-Type, 同时HTML代码中也没有时, IE怎么办? 它怎么知道你的网页编码是什么? 通过猜! 根据内容猜测, 所以有时候它会猜错, 所以你会需要选择不同的编码方案重新显示来避免乱码.

6. unicode就是UCS2, 就是16位的?
unicode是字符集, 跟具体的几位表示没有关系. 当然Unicode标准也规定了字符集的编码方案, 可以认为UTF-8等等都是Unicode标准的平分.

http://www.cppblog.com/liangbo/archive/2006/04/23/6103.html
14. Unicode和DBCS之间的区别
Unicode使用（特别在C程序设计语言环境里）“宽字符集”。「Unicode中的每个字符都是16位宽而不是8位宽。」在Unicode中，没有单单使用8位数值的意义存在。
上面的说法????

7. UTF-16 是16位的定长编码方案?
Nooooooooooooo!
http://www.answers.com/topic/utf-8-1
UTF-16 is often mistaken to be constant-length, leading to code that works for most text but suddenly fails for non-BMP characters

BMP中定义的字符可以被16位, 也就是仅仅一个字(WORD, 2字节)的UTF-16所编码.
Plane 0 (0000–FFFF): Basic Multilingual Plane (BMP)
所以, Windows API, WCHAR/w_char(w_char从语言的角度可以是4字节的), Java/C#中的char, 只支持BMP.

尽管UTF-16是变长编码, 它却不象UTF-8一样, 可以是1, 2, 3, 4字节, 它只能是2或4字节.

8. Unicode 能包含多少字符, 它就是双字节的吗?
Unicode was originally a “double-byte,” or 16-digit, binary number (see numeration) code that could represent up to 65,536 items. No longer limited to 16 bits, it can now represent about one million code positions using three encoding forms called Unicode Transformation Formats (UTF)

Unicode reserves 1,114,112 (= 220 + 216 or 17 × 216, hexadecimal 110000) code points.
As of Unicode 5.0.0, 101,063 (9.1%) of these codepoints are assigned, with another 137,468 (12.3%) reserved for private use, leaving 875,441 (78.6%) unassigned

UCS-2 — a 16-bit, fixed-width encoding that only supports the BMP, considered obsolete

BMP 是按使用频度分配的, 所以UCS-2/或微软的有限的Unicode支持在现实中可能已经是足够了

9. Windows 的内置Unicode到底是怎么回事?
UTF-16 is the standard format for the Windows API (though surrogate support is not enabled by default), 正因为surrogate support不支持, 所以windows API不能支持所有的Unicode字符.

UTF-16 is the native internal representation of text in the Microsoft Windows NT/2000/XP/CE, Qualcomm BREW operating systems; the Java and .NET bytecode environments; Mac OS X's Cocoa and Core Foundation frameworks; and the Qt cross-platform graphical widget toolkit.
UTF-16 作为程序的内部表示是最游行的, 正如UTF-8作为传输和存储是最流行的一样. 因为UTF-16带来了程序处理效率上的优势.

Older Windows NT systems (prior to Windows 2000) only support UCS-2
这就是说XP 能支持UTF-16? 那么它的.NET和WCHAR又怎么办? 定义_UCS4 的宏?

10. GB18030
GB18030 is another encoding form for Unicode, from the Standardization Administration of China. It is the official character set of the People's Republic of China (PRC)

11. 从概念上UCS(Universal Character Set)既然是一个字符集, 区别于编码方案, 为何又要带有-2, -4呢?
UCS是指字符集, 但UCS-2就是指编码方案了.
-2 和-4的确是表示字节(8位组), 但UCS-2 是在说一个编码方案, 是编码UCS的早期的一个版本, 早于UTF-16的出现, 我理解-2是说从理论上它可以被2个字节来表示. 而实际的编码方案, 如UTF-8来编码UCS-2字符集时, 由于UCS-2字符集容纳了所有的BMP, 因此可能UTF-8编码UCS-2需要3个字节. 但不会是4个字节.

这里面的确有一些混乱, 字符集后面跟的数字表示字节, 而编码方案后面跟的表示位数, 如UTF-16, 这个位数是一个字符被编码时使用的最少的位数, 而不是一个字符被编码后最终要占用的位数.

12. 大头小头
FE FF (in hexadecimal) for big-endian architectures, or FF FE for little-endian

Technically, with the UTF-16 scheme the BOM prefix is optional, but omitting it is not recommended as UTF-16LE or UTF-16BE should be used instead. If the BOM is missing, barring any indication of byte order from higher-level protocols, big endian is to be used or assumed. The BOM is not optional in the UCS-2 scheme.
技术上说, UTF-16编码中BOM是可选的, 但不推荐忽略, 而应该明确指定UTF-16LE还是UTF-16BE. 如果没指定BOM, 又没有其它的方式指定大头小头, 默认使用大头.
对UCS-2来说BOM不是可选的.

纯印:trackback=http://www.utf.com.cn/article/s1383
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

很好很强大- -!

woods — Wed, 11 Jun 2008 13:53:23 +0800

作者: woods 链接：http://woods.javaeye.com/blog/202117 发表时间: 2008年06月11日

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

我很好，他们很强大- -#

好吧~ 这是个奋青的黄金年代- -！

是你们逼我的- -#

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

JavaEye推荐

about工作

woods — Tue, 10 Jun 2008 10:30:28 +0800

作者: woods 链接：http://woods.javaeye.com/blog/201688 发表时间: 2008年06月10日

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

我向来不惮以最大的恶意来揣测这款软件的- -！（向鲁爷爷致敬！）~
...（metadata of my right brain）

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

JavaEye推荐

Step By Step TDD树的遍历算法：）

woods — Fri, 09 May 2008 17:11:16 +0800

作者: woods 链接：http://woods.javaeye.com/blog/191499 发表时间: 2008年05月09日

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

Tree Node的定义。普通的POJO类：

public class TreeNode {

	private TreeNode rightChild;
	private TreeNode leftChild;
	protected String treeNodeString;

	public TreeNode(String treeNodeString) {
		this.treeNodeString = treeNodeString;
	}
		
	public TreeNode getRightChild() {
		return rightChild;
	}

	public void setRightChild(TreeNode rightChild) {
		this.rightChild = rightChild;
	}

	public TreeNode getLeftChild() {
		return leftChild;
	}

	public void setLeftChild(TreeNode leftChild) {
		this.leftChild = leftChild;
	}

	public String getTreeNodeString() {
		return this.treeNodeString;
	}

}

第一个Test：

public class TreeTest extends TestCase {
	public void testTreePreTraverse() {
		TreeNode a= new TreeNode("a");
		assertEquals("a", preOrderTraverse(a));
	}

	private String preOrderTraverse(TreeNode root) {
		return null;//为了看得清楚直接写在test里了，应该提出成单独类
	}
}

...
	private String preOrderTraverse(TreeNode root) {
		return root.getTreeNodeString();//绿
	}

增加test，进一步描述需求

...
	public void testABCPreOrderTraverse(){
		TreeNode a= new TreeNode("a");
		TreeNode b= new TreeNode("b");
		TreeNode c= new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		assertEquals("abc", preOrderTraverse(a));//红expected:abc actual:a
	}

	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		}else{
			return "abc";
		}
	}

else里面的演化

return root.getTreeNodeString()+"bc";

return root.getTreeNodeString()+"b"+"c";

"b" == root.getLeftChild().getTreeNodeString()
"c" == root.getRightChild().getTreeNodeString()

	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += rightChild.getTreeNodeString();

			return result;
		}
	}

进一步添加test

	public void testABCDEPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		assertEquals("abdec", preOrderTraverse(a));//红
	}

红expected:abdec actual:abc

最快使其通过，然后refactor消除重复

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += "d";
			result += "e";
			result += rightChild.getTreeNodeString();

testABCDEPreOrderTraverse()通过了:-)
但testABCPreOrderTraverse()会红，暂时先不管这个，我们refactor完这步再来看这个= =

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += leftChild.getLeftChild().getTreeNodeString();//"d"
			result += "e";
			result += rightChild.getTreeNodeString();

private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += leftChild.getLeftChild().getTreeNodeString();
			result += leftChild.getRightChild().getTreeNodeString();
			result += rightChild.getTreeNodeString();

			return result;
		}
	}

result += leftChild.getTreeNodeString();//visit leftChild
result += leftChild.getLeftChild().getTreeNodeString();//visit leftChild's leftChild
result += leftChild.getRightChild().getTreeNodeString();//visit leftChild's rightChild
root，left，right 恩恩这不就是在preOrderTraverse么？
等同于 preOrderTraverse(leftChild)可以试一下。（有test在咱不怕，不行就退回去= =）

private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += preOrderTraverse(leftChild);
			result += rightChild.getTreeNodeString();

			return result;
		}
	}

是个绿，通过 yeah~而且连testABCPreOrderTraverse()也通过了。
访问右孩子也没区别吧？那咱试试.(有test在，咱就可以随便试，方便= =~)

	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += preOrderTraverse(leftChild);
			result += preOrderTraverse(rightChild);

			return result;
		}
	}

目前为止都是完全树，那瘸腿的呢？写个test看下

public void testABCDEFPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);
		assertEquals("abdefc", preOrderTraverse(a));//完了 nullPointer了,惨
	}

因为e只有左孩子f，e的右孩子==null,走到e的右孩子时（执行preOrderTraverse(e的右孩子)）
if (root.getLeftChild() == null && root.getRightChild() == null)
时会错（其实在调用null.getLeftChild()，所以错了）

太技术化了= =
事实是：你要访问人家的右孩子，你不得问问人家有没有啊（if（e的右孩子有否？））
我改= =

			String result = root.getTreeNodeString();
			result += preOrderTraverse(leftChild);
			if (rightChild != null)
				result += preOrderTraverse(rightChild);

这次通过了，同理我把f放e右边呢？也得check吧？先写个test

	public void testABCDEF2PreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("abdefc", preOrderTraverse(a));//红 还没check左孩子
	}

	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			if (leftChild != null)
				result += preOrderTraverse(leftChild);
			if (rightChild != null)
				result += preOrderTraverse(rightChild);

			return result;
		}
	}

这下可以了：）仔细看看怎么有点别扭啊那么多check null啊？
嘿嘿其实这里面有重复情况。第一个if 其实已经被else中包含了。去了试试执行test，给我走= =

	private String preOrderTraverse(TreeNode root) {

		TreeNode leftChild = root.getLeftChild();
		TreeNode rightChild = root.getRightChild();

		String result = root.getTreeNodeString();
		if (leftChild != null)
			result += preOrderTraverse(leftChild);
		if (rightChild != null)
			result += preOrderTraverse(rightChild);

		return result;

	}

通过:-) 继续refactor，消除重复 extract method

	private String preOrderTraverse(TreeNode root) {

		TreeNode leftChild = root.getLeftChild();
		TreeNode rightChild = root.getRightChild();

		String result = root.getTreeNodeString();//root
		result = visitChild(leftChild, result);//left
		result = visitChild(rightChild, result);//right 真清爽:-)

		return result;

	}

	private String visitChild(TreeNode child, String result) {
		if (child != null)
			result += preOrderTraverse(child);
		return result;
	}

差不多了下面是结果:-) 最后的extract class没有做= = 不过不难:-)


import junit.framework.TestCase;

public class TreeTest extends TestCase {
	public void testTreePreTraverse() {
		TreeNode a = new TreeNode("a");
		assertEquals("a", preOrderTraverse(a));
	}

	public void testABCPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		assertEquals("abc", preOrderTraverse(a));
	}

	public void testABCDEPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		assertEquals("abdec", preOrderTraverse(a));
	}

	public void testABCDEFPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);
		assertEquals("abdefc", preOrderTraverse(a));
	}

	public void testABCDEF2PreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("abdefc", preOrderTraverse(a));
	}

	private String preOrderTraverse(TreeNode root) {
		
		String result = root.getTreeNodeString();
		result = visitChild(root.getLeftChild(), result);
		result = visitChild(root.getRightChild(), result);
		return result;

	}

	private String visitChild(TreeNode child, String result) {
		if (child != null)
			result += preOrderTraverse(child);
		return result;
	}
}

extract class
先序:

public class PreOrderTraverserOld implements ITraverser {
	private String result = new String();

	public String doTraverse(TreeNode root) {
		result += root.getTreeNodeString();
		result = visitChild(root.getLeftChild(), result);
		result = visitChild(root.getRightChild(), result);
		return result;
	}

	public String visitChild(TreeNode child, String result) {
		if (child != null)
			result = doTraverse(child);
		return result;
	}

}

中序，后序步骤没啥差别= =

中序

public class InOrderTraverserOld implements ITraverser {
	private String result = new String();

	public String doTraverse(TreeNode root) {
		result = visitChild(root.getLeftChild(), result);
		result += root.getTreeNodeString();
		result = visitChild(root.getRightChild(), result);
		return result;
	}

	public String visitChild(TreeNode child, String result) {
		if (child != null)
			result = doTraverse(child);
		return result;
	}

}

后序

public class PostOrderTraverserOld implements ITraverser {
	private String result = new String();

	public String doTraverse(TreeNode root) {
		result = visitChild(root.getLeftChild(), result);
		result = visitChild(root.getRightChild(), result);
		result += root.getTreeNodeString();
		return result;
	}

	public String visitChild(TreeNode child, String result) {
		if (child != null)
			result = doTraverse(child);
		return result;
	}

}

Test

import junit.framework.TestCase;

public class TreeTest extends TestCase {
	ITraverser preOrderTraverserOld = new PreOrderTraverserOld();
	ITraverser inOrderTraverserOld = new InOrderTraverserOld();
	ITraverser postOrderTraverserOld = new PostOrderTraverserOld();

	public void testTreePreTraverse() {
		TreeNode a = new TreeNode("a");
		assertEquals("a", preOrderTraverserOld.doTraverse(a));
	}

	public void testABCPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		assertEquals("abc", preOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		assertEquals("abdec", preOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEFInOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);

		assertEquals("dbfeac", inOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEF2InOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("dbefac", inOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEFPostOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);
		assertEquals("dfebca", postOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEF2PostOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("dfebca", postOrderTraverserOld.doTraverse(a));
	}

}

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

JavaEye推荐

Composite+Visitor模式的树形结构实现

woods — Thu, 08 May 2008 17:46:12 +0800

作者: woods 链接：http://woods.javaeye.com/blog/191166 发表时间: 2008年05月08日

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

import junit.framework.TestCase;

public class TreeWalkerTest extends TestCase {

	// 对T进行前序遍历是先访问树根n,然后依次前序遍历T1,T2,..,Tk。
	// 对T进行中序遍历是先中序遍历T1，然后访问树根n，接着依次对T2,T2,..,Tk进行中序遍历。
	// 对T进行后序遍历是先依次对T1,T2,..,Tk进行后序遍历，最后访问树根n
	public void testSimpleTreeWalk() {

		IVisitor preOrderTraverser= new TreePreOrderTraverser();
		IVisitor inOrderTraverser= new TreeInOrderTraverser();
		IVisitor postOrderTraverser= new TreePostOrderTraverser();
		
		TreeNode a= new TreeNode("a");
		TreeNode b= new TreeNode("b");
		TreeNode c= new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		TreeNode d= new TreeNode("d");
		TreeNode e= new TreeNode("e");
		b.setLeftChild(d);
		b.setRightChild(e);
		
		a.accept(preOrderTraverser);
		assertEquals("abdec",preOrderTraverser.getOutString().toString());
		
		a.accept(inOrderTraverser);
		assertEquals("dbeac",inOrderTraverser.getOutString().toString());
		
		a.accept(postOrderTraverser);
		assertEquals("debca",postOrderTraverser.getOutString().toString());
	}

}

public interface ITreeNode {

	public abstract boolean isLeaf();

	public abstract TreeNode getRightChild();

	public abstract void setRightChild(TreeNode rightChild);

	public abstract TreeNode getLeftChild();

	public abstract void setLeftChild(TreeNode leftChild);

	public abstract String getTreeNodeString();

}

如下是节点的Visitable接口
这个地方有些困惑：为啥要 node.accept(visitor) ？
好像： visitor.visit(node)更直接些？呵呵哪位大哥给解释下:-)

public interface IVisitable {
	public abstract void accept(IVisitor v);
}

public interface IVisitor {
	public abstract void visit(TreeNode node);
	public abstract StringBuffer getOutString();
}

public class TreeInOrderTraverser implements IVisitor {
	// 对T进行前序遍历是先访问树根n,然后依次前序遍历T1,T2,..,Tk。
	// 对T进行中序遍历是先中序遍历T1，然后访问树根n，接着依次对T2,T2,..,Tk进行中序遍历。
	// 对T进行后序遍历是先依次对T1,T2,..,Tk进行后序遍历，最后访问树根n

	// 基本上有4种遍历方法，先、中、后根，逐层。当初我对这个很迷惑，搞这么多干什么？
	// 到了后面才明白，这是不同的应用需要的。
	// 例如，判断两个二叉树是否相等，只要子树根节点不同，那么就不等，显然这时要用先序遍历；
	// 而删除二叉树，必须先删除左右子树，然后才能删除根节点，这时就要用后序遍历。
	// 实际上，搞这么多遍历方法，根本原因是在内存中储存的树是非线性结构。
	// 对于用数组储存的二叉树，这些名目繁多的方法都是没有必要的。
	// 利用C++的封装和重载特性，这些遍历方法能很清晰的表达。
	private StringBuffer outString = new StringBuffer();;

	public void visit(TreeNode node) {

		visitChild(node.getLeftChild());
		getOutString().append(node.getTreeNodeString());//visit root
		visitChild(node.getRightChild());

	}
	
	private void visitChild(TreeNode childNode) {
		if ( childNode!= null) {
			childNode.accept(this);
		}
	}
	
	public StringBuffer getOutString() {
		return this.outString;
	}
}

public class TreeNode implements IVisitable, ITreeNode {

	private TreeNode rightChild;
	private TreeNode leftChild;
	protected String treeNodeString;

	public TreeNode() {
		super();
	}

	public TreeNode(String treeNodeString) {
		this.treeNodeString = treeNodeString;
	}

	public boolean equals(Object anotherTreeNode) {
		if (anotherTreeNode instanceof TreeNode) {
			return treeNodeString.equals(((TreeNode) anotherTreeNode)
					.getTreeNodeString());
		} else {
			return false;
		}
	}

	public boolean isLeaf() {
		return getLeftChild() == null && getRightChild() == null;
	}

	public TreeNode getRightChild() {
		return rightChild;
	}

	public void setRightChild(TreeNode rightChild) {
		this.rightChild = rightChild;
	}

	public TreeNode getLeftChild() {
		return leftChild;
	}

	public void setLeftChild(TreeNode leftChild) {
		this.leftChild = leftChild;
	}

	public String getTreeNodeString() {
		return this.treeNodeString;
	}

	public void accept(IVisitor v) {
			v.visit(this);
	}

}

public class TreePostOrderTraverser implements IVisitor {
	// 对T进行前序遍历是先访问树根n,然后依次前序遍历T1,T2,..,Tk。
	// 对T进行中序遍历是先中序遍历T1，然后访问树根n，接着依次对T2,T2,..,Tk进行中序遍历。
	// 对T进行后序遍历是先依次对T1,T2,..,Tk进行后序遍历，最后访问树根n

	// 基本上有4种遍历方法，先、中、后根，逐层。当初我对这个很迷惑，搞这么多干什么？
	// 到了后面才明白，这是不同的应用需要的。
	// 例如，判断两个二叉树是否相等，只要子树根节点不同，那么就不等，显然这时要用先序遍历；
	// 而删除二叉树，必须先删除左右子树，然后才能删除根节点，这时就要用后序遍历。
	// 实际上，搞这么多遍历方法，根本原因是在内存中储存的树是非线性结构。
	// 对于用数组储存的二叉树，这些名目繁多的方法都是没有必要的。
	// 利用C++的封装和重载特性，这些遍历方法能很清晰的表达。
	private StringBuffer outString= new StringBuffer();
	
	public void visit(TreeNode node) {

		visitChild(node.getLeftChild());
		visitChild(node.getRightChild());
		getOutString().append(node.getTreeNodeString());
	}
	private void visitChild(TreeNode childNode) {
		if ( childNode!= null) {
			childNode.accept(this);
		}
	}
	public StringBuffer getOutString() {
		return outString;
	}

}

public class TreePreOrderTraverser implements IVisitor {
	// 对T进行前序遍历是先访问树根n,然后依次前序遍历T1,T2,..,Tk。
	// 对T进行中序遍历是先中序遍历T1，然后访问树根n，接着依次对T2,T2,..,Tk进行中序遍历。
	// 对T进行后序遍历是先依次对T1,T2,..,Tk进行后序遍历，最后访问树根n

	// 基本上有4种遍历方法，先、中、后根，逐层。当初我对这个很迷惑，搞这么多干什么？
	// 到了后面才明白，这是不同的应用需要的。
	// 例如，判断两个二叉树是否相等，只要子树根节点不同，那么就不等，显然这时要用先序遍历；
	// 而删除二叉树，必须先删除左右子树，然后才能删除根节点，这时就要用后序遍历。
	// 实际上，搞这么多遍历方法，根本原因是在内存中储存的树是非线性结构。
	// 对于用数组储存的二叉树，这些名目繁多的方法都是没有必要的。
	// 利用C++的封装和重载特性，这些遍历方法能很清晰的表达。
	private StringBuffer outString = new StringBuffer();;

	public void visit(TreeNode node) {
		getOutString().append(node.getTreeNodeString());
		visitChild(node.getLeftChild());
		visitChild(node.getRightChild());
	}

	private void visitChild(TreeNode childNode) {
		if ( childNode!= null) {
			childNode.accept(this);
		}
	}

	public StringBuffer getOutString() {
		return outString;
	}

}

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

JavaEye推荐

翻转句子的TDD讨论：）

woods — Wed, 07 May 2008 14:07:44 +0800

作者: woods 链接：http://woods.javaeye.com/blog/190581 发表时间: 2008年05月07日

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

http://www.javaeye.com/topic/122472?page=1
需求:把字符串"Tdd is a software devolopment technology" 按照单词反转为
"technology devolopment software a is Tdd"
是看了这个帖子后一直有困惑。直接促成了我找了Kent Beck大的Test-Driven Development
By Example来看。自此进入TDD的世界。其实这题目和书后面的那个fibonacci的解法一样。
关键在于：“分解多项式” 且听我忽悠..

import junit.framework.TestCase;
public class NewStringReverserTest extends TestCase{
	//"a b" - "b a"
	public void testSimpleReverse(){
		assertEquals("b a", reverse("a b"));//从最简单的情况开始
	}

 	private String reverse(String string) {		
		return "b a";//最“直接”的实现，绿了吧- -！
	}
}

public class NewStringReverserTest extends TestCase{
	...
	private String reverse(String string) {		 	
		return "b"+" "+"a";//拆，为什么这么拆？ 往下看
	}
}

public class NewStringReverserTest extends TestCase{
	...
	private String reverse(String string) {	
                //要拆得有意义，注意描述= =
                //其实是一个一个拆的，每步都执行test，边绿边拆...小步快跑	 	
		String splitToken = " ";
		String preWord = "a";
		String postWord = "b";
                //下面其实是业务逻辑了，看后面的postWord被放在了前面——所谓的交换
		return postWord + splitToken + preWord;
	}
}

public class NewStringReverserTest extends TestCase{
	...
	private String reverse(String inputString) {	               
		String splitToken = " ";
                //实现切词逻辑
		String preWord =    inputString.substring(0,inputString.indexOf(splitToken));
		String postWord = inputString.substring(inputString.indexOf(splitToken)+1);               
		return postWord + splitedToken + preWord;
	}
}

ok 目前为止似乎无法继续了。那么继续添加test描述需求："a b c"-"c b a"

public class NewStringReverserTest extends TestCase{
	//"a b" - "b a"
	public void testSimpleReverse(){
		assertEquals("b a", reverse("a b"));
                assertEquals("c b a", reverse("a b c"));//红了吧？- -
	}
        ...
}

Expected：c b a Actual:b c a
好吧分析下：bc 反了，bc看做一个整体，再“交换”一次就ok了,即: reverse("b c")+"a"

        private String reverse(String inputString) {	               
		...          
		return reverse(postWord) + splitToken + preWord;
	}

还是会红，debug发现“切到剩一个词”了就不能切了嘛= =

        private String reverse(String inputString) {	
                int tokenIndex = inputString.indexOf(splitToken);
		if (tokenIndex == -1)
			return inputString;
		String prePart = inputString.substring(0, tokenIndex);
		String postPart = inputString.substring(tokenIndex + 1);               
		//描述为prePart，postPart 更符合语义，也是一步重构吧        
		return reverse(postPart)+ splitToken + prePart
	}

这下绿了，想想其实prePart其实是reverse(prePart)
另外把那个需求的test加上看看符合需求否？

       public class NewStringReverserTest extends TestCase {
	// "a b" - "b a"
	public void testSimpleReverse() {
		assertEquals("b a", reverse("a b"));
		assertEquals("c b a", reverse("a b c"));
                assertEquals("Tdd is a software devolopment technology",  reverse("technology devolopment software a is Tdd"));

	}

	private String reverse(String inputString) {
		String splitToken = " ";
		int tokenIndex = inputString.indexOf(splitToken);
		if (tokenIndex == -1)
			return inputString;
		String prePart = inputString.substring(0, tokenIndex);
		String postPart = inputString.substring(tokenIndex + 1);
		return reverse(postPart) + splitToken + reverse(prePart);
	}

	public void testReverseWithSingleWords() {
		assertEquals("a", reverse("a"));
	}

	public void testReverseWithSplitTokenIn() {
		assertEquals(" ", reverse(" "));
		assertEquals("   ", reverse("   "));
		assertEquals("   a", reverse("a   "));
		assertEquals("b a", reverse("a b"));
		assertEquals("c b a ", reverse(" a b c"));
		assertEquals("c b a", reverse("a b c"));
	}

}

最后总结："a b c"到"c b a"
原来是a b c->[b c] a->[c b] a
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

拥抱ruby~

woods — Fri, 25 Apr 2008 14:43:31 +0800

作者: woods 链接：http://woods.javaeye.com/blog/186776 发表时间: 2008年04月25日

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

终于决定开始拥抱ruby了。

说实话我是JAVA古典派:P. 一直对ruby持怀疑态度，这个新近冒出的小玩意儿到底有啥意思，不屑不屑。不过看着robbin的网站就是ruby实现的，这么快速稳定，慢慢有了点兴趣。再后来看到ruby on rails的快速实现意图的能力（透明gigix的技能云 shock！Just 2 weeks）（这是我最最想要的），突然间惊讶了，“恩恩这小玩意儿还挺不简单”。

所以亡羊补牢还不晚~ 我准备来淌水啦:-)

还是有些疑惑？

是直接投入ruby?
还是ruby的其他实现比较好呢？比如JRuby ，Grails

还要多尝试尝试 (*^__^*) 嘻嘻……哪位大大给支支招:P
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

树的遍历（A TDD Question - -~）

woods — Mon, 21 Apr 2008 15:35:23 +0800

作者: woods 链接：http://woods.javaeye.com/blog/184990 发表时间: 2008年04月21日

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

最近在学习TDD。看了那个fibonacci 的TDD过程。我就想：咋能TDD出树的遍历算法呢？我来试一下。当作练习了~ （树的知识有些忘了，先贴些基础- -#做准备）

数据结构知识——树的三种不同遍历算法解析- -- -

树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的系统的访问，即依次对树中每个结点访问一次且仅访问一次。树的3种最重要的遍历方式分别称为前序遍历、中序遍历和后序遍历。以这3种方式遍历一棵树时，若按访问结点的先后次序将结点排列起来，就可分别得到树中所有结点的前序列表，中序列表和后序列表。相应的结点次序分别称为结点的前序、中序和后序。

树的这3种遍历方式可递归地定义如下：

如果T是一棵空树，那么对T进行前序遍历、中序遍历和后序遍历都是空操作，得到的列表为空表。

如果T是一棵单结点树，那么对T进行前序遍历、中序遍历和后序遍历都只访问这个结点。这个结点本身就是要得到的相应列表。

否则，设T如图6所示，它以n为树根，树根的子树从左到右依次为T1,T2,..,Tk，那么有：

对T进行前序遍历是先访问树根n,然后依次前序遍历T1,T2,..,Tk。

对T进行中序遍历是先中序遍历T1，然后访问树根n，接着依次对T2,T2,..,Tk进行中序遍历。

对T进行后序遍历是先依次对T1,T2,..,Tk进行后序遍历，最后访问树根n。

图6 树T

前序遍历和中序遍历可形式地依次描述如下

三种遍历可以形式地描述如下，其中用到了树的ADT操作：

Procedure Preorder_Traversal(v:NodeType); {前序遍历算法}

begin

Visite(v); {访问节点v}

i:=Leftmost_Child(v);

while i<>∧ do

begin

Preorder_Traversal(i);{从左到右依次访问v的每一个儿子节点i}

i:=Right_Sibling(i);

end;

end;

Procedure Inorder_Traversal(v:NodeType); {中序遍历算法}

begin

if Leftmost_Child(v)=∧ {判断v是否是叶节点}

then Visite(v)

else

begin

Inorder_Traversal(Leftmost_Child(v)); {中序遍历v的左边第一个儿子节点}

Visite(v); {访问节点v}

i:=Right_Sibling(Leftmost_Child(v)); {i=v的左边第二个儿子}

while i<>∧ do

begin

Inorder_Traversal(i);

{从左边第二个开始到最右边一个为止依次访问v的每一个儿子节点i}

i:=Right_Sibling(i);

end;

end;

end;

Procedure Postorder_Traversal(v:NodeType); {后序遍历算法}

begin

i:=Leftmost_Child(v);

while i<>∧ do

begin

Preorder_Traversal(i);{从左到右依次访问v的每一个儿子节点i}

i:=Right_Sibling(i);

end;

Visite(v); {访问节点v}

end;

为了将一棵树中所有结点按某种次序列表，只须对树根调用相应过程。例如对图7中的树进行前序遍历、中序遍历和后序遍历将分别得到前序列表：A B E F I J C D G H；中序列表：E B I F J A C G D H；后序列表：E I J F B C G H D A。

图7 一棵树

下面介绍一种方法可以产生上述3种遍历方式的结点列表。设想我们从树根出发，依逆时针方向沿树的外缘绕行(例如围绕图7中的树绕行的路线如图8所示)。绕行途中可能多次经过同一结点。如果我们按第一次经过的时间次序将各个结点列表，就可以得到前序列表；如果按最后一次经过的时间次序列表，也就是在即将离开某一结点走向其父亲时将该结点列出，就得到后序列表。为了产生中序列表，要将叶结点与内部结点加以区别。叶结点在第一次经过时列出，而内部结点在第二次经过时列出。

图8 树的遍历

在上述3种不同次序的列表方式中，各树叶之间的相对次序是相同的，它们都按树叶之间从左到右的次序排列。3种列表方式的差别仅在于内部结点之间以及内部结点与树叶之间的次序有所不同。

一棵树进行前序列表或后序列表有助于查询结点间的祖先子孙关系。假设结点v在后序列表中的序号(整数)为postorder(v)，我们称这个整数为结点v的后序编号。例如在图7中，结点E，I和J的后序编号分别为1，2和3。

结点的后序编号具有这样的特点：设结点v的真子孙个数为desc(v)，那么在以v为根的子树中的所有结点的后序编号恰好落在postorder(v)- desc(v)与postorder(v)之间。因此为了检验结点x是否为结点y的子孙，我们只要判断它们的后序编号是否满足：

postorder(y)-desc(y)≤postorder(x)≤postorder(y)

前序编号也具有类似的性质。

Trackback=http://publishblog.blogchina.com/blog/tb.b?diaryID=1833654
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

linux相关的网络配置文件

woods — Mon, 21 Apr 2008 15:28:41 +0800

作者: woods 链接：http://woods.javaeye.com/blog/184983 发表时间: 2008年04月21日

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

在linux系统中，TCP/IP网络是通过若干个文本文件进行配置的，需要编辑这些文件来完成联网工作。系统中重要的有关网络配置文件为：

◆ /etc/sysconfig/network
◆ /etc/HOSTNAME
◆ /etc/hosts
◆ /etc/services
◆ /etc/host.conf
◆ /etc/nsswitch.conf
◆ /etc/resolv.conf
◆ /etc/rc.d/init.d/network

接下来我们将对这些文件逐一讲述，这些文件都可以在系统运行时进行修改，不用启动或者停止任何守护程序，更改会立刻生效(除了 /etc/sysconfig/network)。另外，这些文件都支持由"#"开头的注释，每一个文件都有在UNIX手册页中的第5部分中有一项，可以用man命令来获取它们。

◆ /etc/sysconfig/network 网络设置
该文件用来指定服务器上的网络配置信息，包含了控制和网络有关的文件和守护程序的行为的参数。下面是一个例子文件：

NETWORKING=yes
HOSTNAME=machine1
GATEWAY=210.34.6.2
FORWARD_IPV4=yes
GATEWAYDEV=

其中，NETWORK=yes/no 表示网络是否被配置；
HOSTNAME=hostname hostname 表示服务器的主机名；
GATEWAY=gw-ip gw-ip 表示网络网关的IP地址；
FORWARD_IPV4=yes/no 是否开启IP转发功能；
GAREWAYDEV=gw-dev gw-dw 表示网关的设备名，如：eth0等；
为了和老的一些软件相兼容，"/etc/HOSTNAME"文件应该用和HOSTNAME=hostname相同的主机名。

[NextPage]
◆ /etc/HOSTNAME 主机名

该文件包含了系统的主机名称，包括完全的域名，如：

192.168.0.1 machine1.domain machine1

这个文件是在启动时从文件/etc/sysconfig/network中的HOSTNAME行中得到的，用于在启动时设置系统的主机名。

◆ /etc/hosts IP地址和主机名的映射

/etc/hosts中包含了IP地址和主机名之间的映射，还包括主机名的别名，IP地址的设计使计算机容易识别，但对于人却很难记住它们，为了解决这个问题，创建了/etc/hosts这个文件。下面是一个例子文件：

127.0.0.1 machine1 localhost.localdomain localhost
192.168.1.100 machine7
192.168.1.101 otherpc otheralias

在这个例子中，本机名是machine1，otherpc还有别名otheralias，它可以指向otheralias。。一旦配置完机器的网络配置文件，应该重新启动网络以使修改生效，使用下面的命令来重新启动网络：

/etc/rc.d/init.d/network restart

/etc/hosts文件通常含有主机名、localhost和系统管理员经常使用的系统别名，有时候telnet到linux机器要等待很长时间，可以通过在"/etc/hosts"加入客户的机器的IP地址和主机名的匹配项，就可以减少登录等待时间。在没有域名服务器情况下，系统上的所有网络程序都通过查询该文件来解析对应于某个主机名的IP地址，否则，其他的主机名通常使用DNS来解决，DNS客户部分的配置在文件 /etc/resolv.conf中。

◆ /etc/services

/etc/services中包含了服务名和端口号之间的映射，不少的系统程序要使用这个文件，下面是RedHat 安装时缺省的/etc/services中的前几行：

tcpmux 1/tcp # TCP port service multiplexer
echo 7/tcp
echo 7/udp
discard 9/tcp sink null
discard 9/udp sink null
systat 11/tcp users

最左边一列是主机服务名，中间一列是端口号，”/“ 后面是端口类型，可以是TCP也可以是UDP。任何后面的列都是前面服务的别名。在这个文件中也存在着别名，它们出现在端口号后面，在上述例子中sink和null 都是discard服务的别名。
[NextPage]

◆ /etc/host.conf 配置名字解析器

有两个文件声明系统到哪里寻找名字信息来配置UNIX名字解析器的库。文件/etc/host.conf由版本5的libc库所使用，而/etc/nsswitch.conf由版本6使用(glibc )。问题在于一些程序使用其中一个，而一些使用另一个，所以将两个文件都配置正确是必要的。

/etc/host.conf文件指定如何解析主机名，linux通过解析器库来获得主机名对应的IP地址。下面是RedHat安装后缺省的"/etc/host.conf"内容：

order hosts，bind
multi on

※"order " 指定主机名查询顺序，其参数为用逗号隔开的查找方法，支持的查找方法为bind、hosts和nis，分别代表DNS、/etc/hosts和NIS，这里规定先查询"/etc/hosts"文件然后再使用DNS来解析域名。
※"trim" 表明当通过DNS进行地址到主机名的转换时，域名将从主机名中被裁剪掉，trim可以被多个域包含多次，对/etc/hosts和NIS查询方法不起作用，注意在/etc/hosts和NIS表中主机名是被适当地(有或没有全域名)列出的。
※"multi" 指定是否"/etc/hosts"文件中指定的主机可以有多个地址，值为on表示允许，拥有多个IP地址的主机一般称为具有多个网络界面。
※"nospoof " 指是否允许对该服务器进行IP地址欺骗，值为on表示不允许，IP欺骗是一种攻击系统安全的手段，通过把IP地址伪装成别的计算机，来取得其它计算机的信任。
※"alert" 当nospoof指令为on时，alert控制欺骗的企图是否用syslog工具进行记录，值为on表示使用，缺省值为off。
※"rccorder" 如果被设置为on，所有的查询将被重新排序，所以在同一子网中的主机将首选被返回，缺省值为off。
[NextPage]

◆ /etc/nsswitch.conf 配置名字解析器

/etc/nsswitch.conf文件是由S u n公司开发并用于管理系统中多个配置文件查找的顺序，它比/etc/host.conf文件提供了更多的功能。/etc/nsswitch.conf中的每一行或者是注释(以#号开头)或者是一个关键字后跟冒号和一系列要试用的有顺序的方法。每一个关键字是在/etc/目录可以被 /etc/nsswitch.conf控制的/etc文件的名字。下面是可以被包含的关键字：

※aliases 邮件别名；
※passwd 系统用户；
※group 用户组；
※shadow 隐蔽口令；
※hosts 主机名和I P地址；
※networks 网络名和号；
※protocols 网络协议；
※services 端口号和服务名称；
※ethers 以太网号；
※rpc 远程进程调用的名称和号
※netgroup 网内组

下面也是可以包含的关键字：

※files 除了netgroup，对其他关键字都有效。在相应的/etc文件中寻找记录
※db 除了netgroup，对其他关键字都有效。在相应的/var/db数据库中寻找记录。对长文件很有效，如passwd文件已经超过500项。要从标准/etc文件中产生这些文件，应改变目录到/var/db并运行run命令
※compat 兼容性模式，对passwd、group和shadow文件有效。在本模式中，将先在对应的/etc文件中查找。如果想进行NIS查找，需要第一个值(用户名或组名)为加号( + )，后面跟对应数量的冒号( : ) ( /etc/passwd为6个， /etc/group为3个， /etc/shadow为8个)。如在/etc/passwd文件中，下面一行应被包含在文件尾： + : * : : : : :
※dns 只对hosts有意义。像在/etc/resolvconf配置的，在DNS中进行查找
※nis 对所有的关键字都有意义。如NIS是可以用的，在NIS服务器中查找
※[ STATUS = action ] 控制名字服务的行为。STATUS是SUCCESS(操作被成功执行)、NOTFOUND (记录没找到)、UNAVAIL (所选择的服务不可用)和TRYAGAIN (服务暂时不可用，请重试)中的一个。action是return (终止查找并返回当前状态)或continue (继续这一行的其他项)中的一个。如hosts: dns nis [NOTFOUND=return] files将会首先在DNS中，然后在NIS中查找主机名。只有当前两项都不可用时才使用文件/etc/hosts

◆ /etc/resolv.conf 配置DNS客户

文件/etc/resolv.conf配置DNS客户，它包含了主机的域名搜索顺序和DNS服务器的地址，每一行应包含一个关键字和一个或多个的由空格隔开的参数。下面是一个例子文件：

search mydom.edu.cn
nameserver 210.34.0.14
nameserver 210.34.0.2

合法的参数及其意义如下：
[NextPage]
※nameserver 表明DNS服务器的IP地址。可以有很多行的nameserver，每一个带一个I P地址。在查询时就按nameserver在本文件中的顺序进行，且只有当第一个nameserver没有反应时才查询下面的nameserver.
※domain 声明主机的域名。很多程序用到它，如邮件系统；当为没有域名的主机进行DNS查询时，也要用到。如果没有域名，主机名将被使用，删除所有在第一个点( . )前面的内容。
※search 它的多个参数指明域名查询顺序。当要查询没有域名的主机，主机将在由search声明的域中分别查找。domain和search不能共存；如果同时存在，后面出现的将会被使用。
※sortlist 允许将得到域名结果进行特定的排序。它的参数为网络/掩码对，允许任意的排列顺序。Red Hat中没有提供缺省的/ e t c / r e s o l v. c o n f文件，它的内容是根据在安装时给出的选项动态创建的。

◆ /etc/init.d/network 主机地址、子网掩码和网关

不像很多其他的UNIX和linux操作系统， Red Hat当前并不能自动地通过/etc/hostname和/etc/hosts文件来配置网络。为了改变主机缺省的IP地址，必须直接编辑 /etc/init.d/network脚本使其反映正确的网络配置。这个文件包括了声明IP地址、掩码、网络、广播地址和缺省路由器的变量。下面是这个文件中相应的部分：

IPADDR=192.168.1.100
NETMASK=255.255.255.0
BROADCAST=192.168.1.255
GATEWAY=192.168.1.1
Trackback=http://www.chinaemail.com.cn/wlzsjy/zujian/200508/2049.html
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

重新配置Domino服务器的步骤

woods — Mon, 21 Apr 2008 11:54:10 +0800

作者: woods 链接：http://woods.javaeye.com/blog/184863 发表时间: 2008年04月21日

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

重新配置Domino服务器的步骤：

在执行下列步骤前，请先将有用的ID文件和nsf文件备份好。1. 删除Domino目录下notes.ini文件中内容，保留前四行，如下：[Notes]

NotesProgram=C:Program FilesIBMLotusdomino

Directory=C:Program FilesIBMLotusdominodata

KitType=2

InstallType=4

2. 删除DominoData目录下所有.nsf文件（不要删除homepage.nsf,此数据库不会重建）3. 删除DominoData目录下所有.id文件4. 删除DominoDatamail目录下所有.nsf文件5. 重启server开始配置。配置时可以选择已有的ID。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1564657
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐