<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>ChenTaoqian&#039;s Blog &#187; java</title>
	<atom:link href="http://www.chentaoqian.com/archives/tag/java/feed" rel="self" type="application/rss+xml" />
	<link>http://www.chentaoqian.com</link>
	<description>主机,企业邮箱,域名,空间,服务器,Java,Oracle,PHP,Linux,JS,MySQL,Apache</description>
	<lastBuildDate>Wed, 30 Nov 2011 14:35:01 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.9.2</generator>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
			<item>
		<title>Java语音引擎-实现人声说话</title>
		<link>http://www.chentaoqian.com/archives/763</link>
		<comments>http://www.chentaoqian.com/archives/763#comments</comments>
		<pubDate>Sat, 17 Jul 2010 15:23:06 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[引擎]]></category>
		<category><![CDATA[语音]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=763</guid>
		<description><![CDATA[为应用程序加上语音能力有什么好处呢？粗略地讲，是为了趣味，它适合所有注重趣味的
应用，比如游戏。当然，从更严肃的角度来讲，它还涉及到应用的可用性问题。注意，这
里我考虑的不仅是可视化界面固有的不足，而且还有这样一些情形：一些时候，让双眼离
开当前的工作很不方便，甚至是不合法的。比如，假设有一个带语音功能的浏览器，你就
可以在外出散步或开车上班的同时，用听的方式浏览自己喜爱的网站。
从目前来看，邮件阅读器或许是语音技术更实际的应用，在JavaMail API的帮助下，
这一切已经可能。邮件阅读器可以定期地检查收件箱，然后用语音“You have new mail,
would you like me to read it to you?”引起你的注意。按照类似的思路，我们还可以
考虑一个带语音功能的提醒器，把它连接到一个日历应用：它会及时地提醒你“Don&#8217;t
forget your meeting with the boss in 10 minutes!”。
也许你已经被这些主意吸引，或者有了自己更好的主意，现在让我们继续。首先我将
介绍如何启用本文提供的语音引擎，这样，如果你认为语音引擎的实现细节过于复杂，就
可以直接使用它而忽略其实现细节。
一、试用语音引擎
要使用这个语音引擎，你必须在CLASSPATH中加入本文提供的javatalk.jar文件，然后从
命令行运行（或者从Java程序调用）com.lotontech.speech.Talker类。如果从命令行运
行，则命令为：
java com.lotontech.speech.Talker &#8220;h&#124;e&#124;l&#124;oo&#8221;
如果从Java程序调用，则代码为：
com.lotontech.speech.Talker talker=new com.lotontech.speech.Talker();
talker.sayPhoneWord(&#8220;h&#124;e&#124;l&#124;oo&#8221;);
现在，对于在命令行上（或者调用sayPhoneWord()方法时）提供的“h&#124;e&#124;l&#124;oo”字符串，你
或许有所不解。下面我就来解释一下。
语音引擎的工作原理是把细小的声音样本连接起来，每一个样本都是人的语言发音（英
语）的一个最小单位。这些声音样本称为音素（allophone）。每一个因素对应一个、二
个或者三个字母。从前面“hello”的语音表示可以看出，一些字母组合的发音显而易见，
还有一些却不是很明显：
h &#8212; 读音显而易见
e &#8212; 读音显而易见
l &#8212; 读音显而易见，但注意两个“l”被简缩成了一个“l”。
OO &#8212; 应该读作“hello”中的读音，不应读作“bot”、“too”中的读音。
下面是一个有效音素的清单：
a ： 如cat
b ： 如cab
c ： 如cat
d ： 如dot
e ： 如bet
f ： 如frog
g ： 如frog
h ： 如hog
i ： 如pig
j ： 如jig
k ： 如keg
l [...]]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/763/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Java编码转换-内存中字符串编码转换实例</title>
		<link>http://www.chentaoqian.com/archives/749</link>
		<comments>http://www.chentaoqian.com/archives/749#comments</comments>
		<pubDate>Sun, 11 Jul 2010 02:13:45 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[decode]]></category>
		<category><![CDATA[encode]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[编码]]></category>
		<category><![CDATA[编码转换]]></category>
		<category><![CDATA[解码]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=749</guid>
		<description><![CDATA[Java编程时会遇到很多字符集编码转换的问题，当读取的字符在内存中如何执行编码转换？下面给出一个实例


import java.nio.ByteBuffer;
import java.nio.charset.Charset;

public class MainClass {
 public static void main(String[] argv) throws Exception {
 String input = &#8221;\u00bfMa\u00f1ana?&#8221;;

 // The list of charsets to encode with
 String[] charsetNames = { &#8221;US-ASCII&#8221;, &#8221;ISO-8859-1&#8243;, &#8221;UTF-8&#8243;, &#8221;UTF-16BE&#8221;, &#8221;UTF-16LE&#8221;, &#8221;UTF-16&#8243;,
 // &#8221;X-ROT13&#8243; // This requires META-INF/services
 };
 for (int i = 0; i &#60; charsetNames.length; i++) {
 doEncode(Charset.forName(charsetNames[i]), input);
 }
 }
 private static void doEncode(Charset cs, String input) {
 ByteBuffer bb = cs.encode(input);
 System.out.println(&#8220;Charset: &#8221; + cs.name());
 System.out.println(&#8220;  Input: &#8221; + input);
 System.out.println(&#8220;Encoded: &#8221;);

 for (int i = 0; bb.hasRemaining(); i++) {
 int b = bb.get();
 int ival = ((int) b) &#38; 0xff;
 char c = (char) ival;
 // print index number
 System.out.print(&#8220;  &#8221; + i + &#8221;: &#8221;);
 // print the hex value of the byte
 System.out.print(Integer.toHexString(ival));
 System.out.println(&#8220; (&#8220; + c + &#8221;)&#8221;);
 }
 }
}


java
]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/749/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>4大类Java应用编码转换的详细过程</title>
		<link>http://www.chentaoqian.com/archives/747</link>
		<comments>http://www.chentaoqian.com/archives/747#comments</comments>
		<pubDate>Wed, 07 Jul 2010 13:03:09 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[编码]]></category>
		<category><![CDATA[编码转换]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=747</guid>
		<description><![CDATA[常见的JAVA程序包括以下类别：
*直接在console上运行的类(包括可视化界面的类)
*JSP代码类（注：JSP是Servlets类的变型）
*Servelets类
*EJB类
*其它不可以直接运行的支持类
这些类文件中，都有可能含有中文字符串，并且常用前三类JAVA程序和用户直接交互，用于输出和输入字符，如：在JSP和Servlet中得到客户端送来的字符，这些字符也包括中文字符。无论这些JAVA类的作用如何，这些JAVA程序的生命周期都是这样的：
*编程人员在一定的操作系统上选择一个合适的编辑软件来实现源程序代码并以.java扩展名保存在操作系统中，例如我们在中文win2k中用记事本编辑一个java源程序；
*编程人员用JDK中的javac.exe来编译这些源代码，形成.class类(JSP文件是由容器调用JDK来编译的)；
*直接运行这些类或将这些类布署到WEB容器中去运行，并输出结果。
那么，在这些过程中，JDK和JVM是如何将这些文件如何编码和解码并运行的呢？
这里，以中文win2k操作系统为例说明JAVA类是如何来编码和被解码的。
第 一步，我们在中文win2k中用编辑软件如记事本编写一个Java源程序文件(包括以 上五类JAVA程序)，程序文件在保存时默认采用了操作系统默认支持GBK编码格式(操作系统默认支持的格式为file.encoding格式)形成了一 个.java文件，也即，java程序在被编译前，我们的JAVA源程序文件是采用操作系统默认支持的file.encoding编码格式保存的， java源程序中含有中文信息字符和英文程序代码；要查看系统的file.encoding参数，可以用以下代码：
public class ShowSystemDefaultEncoding {
public static void main(String[] args) {
String encoding = System.getProperty(&#8220;file.encoding&#8221;);
System.out.println(encoding);
}}
第 二步，我们用JDK的javac.exe文件编译我们的Java源程序，由于JDK是 国际版的，在编译的时候，如果我们没有用-encoding参数指定我们的JAVA源程序的编码格式，则javac.exe首先获得我们操作系统默认采用 的编码格式，也即在编译java程序时，若我们不指定源程序文件的编码格式，JDK首先获得操作系统的file.encoding参数(它保存的就是操作 系统默认的编码格式，如WIN2k，它的值为GBK)，然后JDK就把我们的java源程序从file.encoding编码格式转化为JAVA内部默认 的UNICODE格式放入内存中。然后，javac把转换后的unicode格式的文件进行编译成.class类文件，此时.class文件是 UNICODE编码的，它暂放在内存中，紧接着，JDK将此以UNICODE编码的编译后的class文件保存到我们的操作系统中形成我们见到的. class文件。对我们来说，我们最终获得的.class文件是内容以UNICODE编码格式保存的类文件，它内部包含我们源程序中的中文字符串，只不过 此时它己经由file.encoding格式转化为UNICODE格式了。
这 一步中，对于JSP源程序文件是不同的，对于JSP，这个过程是这样的：即WEB容器 调用JSP编译器，JSP编译器先查看JSP文件中是否设置有文件编码格式，如果JSP文件中没有设置JSP文件的编码格式，则JSP编译器调用JDK先 把JSP文件用JVM默认的字符编码格式(也即WEB容器所在的操作系统的默认的file.encoding)转化为临时的Servlet类，然后再把它 编译成UNICODE格式的class类，并保存在临时文件夹中。如：在中文win2k上，WEB容器就把JSP文件从GBK编码格式转化为 UNICODE格式，然后编译成临时保存的Servlet类，以响应用户的请求。
第三步，运行第二步编译出来的类，分为三种情况：
A、 直接在console上运行的类
B、 EJB类和不可以直接运行的支持类(如JavaBean类)
C、 JSP代码和Servlet类
D、 JAVA程序和数据库之间
下面分这四种情况来看。
A、直接在console上运行的类
这 种情况，运行该类首先需要JVM支持，即操作系统中必须安装有JRE。运行过程是这样 的：首先java启动JVM，此时JVM读出操作系统中保存的class文件并把内容读入内存中，此时内存中为UNICODE格式的class类，然后 JVM运行它，如果此时此类需要接收用户输入，则类会默认用file.encoding编码格式对用户输入的串进行编码并转化为unicode保存入内存 （用户可以设置输入流的编码格式）。程序运行后，产生的字符串（UNICODE编码的）再回交给JVM，最后JRE把此字符串再转化为 file.encoding格式(用户可以设置输出流的编码格式)传递给操作系统显示接口并输出到界面上。
以上每一步的转化都需要正确的编码格式转化，才能最终不出现乱码现象。
B、EJB类和不可以直接运行的支持类(如JavaBean类)
由 于EJB类和不可以直接运行的支持类，它们一般不与用户直接交互输入和输出，它们常常 与其它的类进行交互输入和输出，所以它们在第二步被编译后，就形成了内容是UNICODE编码的类保存在操作系统中了，以后只要它与其它的类之间的交互在 参数传递过程中没有丢失，则它就会正确的运行。
C、JSP代码和Servlet类
经过第二步后，JSP文件也被转化为Servlets类文件，只不过它不像标准的Servlets一校存在于classes目录中，它存在于WEB容器的临时目录中，故这一步中我们也把它做为Servlets来看。
对 于Servlets，客户端请求它时，WEB容器调用它的JVM来运行 Servlet，首先，JVM把Servlet的class类从系统中读出并装入内存中，内存中是以UNICODE编码的Servlet类的代码，然后 JVM在内存中运行该Servlet类，如果Servlet在运行的过程中，需要接受从客户端传来的字符如：表单输入的值和URL中传入的值，此时如果程 序中没有设定接受参数时采用的编码格式，则WEB容器会默认采用ISO-8859-1编码格式来接受传入的值并在JVM中转化为UNICODE格式的保存 在WEB容器的内存中。Servlet运行后生成输出，输出的字符串是UNICODE格式的，紧接着，容器将Servlet运行产生的UNICODE格式 的串（如html语法，用户输出的串等）直接发送到客户端浏览器上并输出给用户，如果此时指定了发送时输出的编码格式，则按指定的编码格式输出到浏览器 上，如果没有指定，则默认按ISO-8859-1编码发送到客户的浏览器上。
D、Java程序和数据库之间
对 于几乎所有数据库的JDBC驱动程序，默认的在JAVA程序和数据库之间传递数据都是 以ISO-8859-1为默认编码格式的，所以，我们的程序在向数据库内存储包含中文的数据时，JDBC首先是把程序内部的UNICODE编码格式的数据 转化为ISO-8859-1的格式，然后传递到数据库中，在数据库保存数据时，它默认即以ISO-8859-1保存，所以，这是为什么我们常常在数据库中 读出的中文数据是乱码。
3、分析常见的JAVA中文问题几个必须清楚的原则
首先，经过上面的详细分析，我们可以清晰地看到，任何JAVA程序的生命期中，其编码转换的关键过程是在于：最初编译成class文件的转码和最终向用户输出的转码过程。
其次，我们必须了解JAVA在编译时支持的、常用的编码格式有以下几种：
*ISO-8859-1，8-bit, 同8859_1,ISO-8859-1,ISO_8859_1等编码
*Cp1252，美国英语编码，同ANSI标准编码
*UTF-8，同unicode编码
*GB2312，同gb2312-80,gb2312-1980等编码
*GBK , 同MS936，它是gb2312的扩充
及其它的编码，如韩文、日文、繁体中文等。同时，我们要注意这些编码间的兼容关体系如下：
unicode和UTF-8编码是一一对应的关系。GB2312可以认为是GBK的子集，即GBK编码是在gb2312上扩展来的。同时，GBK编码包含了20902个汉字，编码范围为：0&#215;8140-0xfefe，所有的字符可以一一对应到UNICODE2.0中来。
再 [...]]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/747/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>6大要点轻松了解Java字符编码规则</title>
		<link>http://www.chentaoqian.com/archives/744</link>
		<comments>http://www.chentaoqian.com/archives/744#comments</comments>
		<pubDate>Mon, 05 Jul 2010 15:27:32 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[字符编码]]></category>
		<category><![CDATA[编码]]></category>
		<category><![CDATA[规则]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=744</guid>
		<description><![CDATA[1. 概述
本文主要包括以下几个方面：编码基本知识，java，系统软件，url，工具软件等。
在下面的描述中，将以&#8221;中文&#8221;两个字为例，经查表可以知道其GB2312编码是&#8221;d6d0 cec4&#8220;，Unicode编码为&#8221;4e2d 6587&#8220;，UTF编码就是&#8221;e4b8ad e69687&#8220;。注意，这两个字没有iso8859-1编码，但可以用iso8859-1编码来&#8221;表示&#8221;。
2. 编码基本知识
最早的编码是iso8859-1，和ascii编码相似。但为了方便表示各种各样的语言，逐渐出现了很多标准编码，重要的有如下几个。
2.1. iso8859-1
属于单字节编码，最多能表示的字符范围是0-255，应用于英文系列。比如，字母&#8217;a'的编码为0&#215;61=97。
很明显，iso8859-1编码表示的字符范围很窄，无法表示中文字符。但是，由于是单字节编码，和计算机最基础的表示单位一致，所以很多时候，仍旧使用iso8859-1编码来表示。而且在很多协议上，默认使用该编码。比如，虽然&#8221;中文&#8221;两个字不存在iso8859-1编码，以gb2312编码为例，应该是&#8221;d6d0 cec4&#8220;两个字符，使用iso8859-1编码的时候则将它拆开为4个字节来表示：&#8221;d6 d0 ce c4&#8220;（事实上，在进行存储的时候，也是以字节为单位处理的）。而如果是UTF编码，则是6个字节&#8221;e4 b8 ad e6 96 87&#8220;。很明显，这种表示方法还需要以另一种编码为基础。
2.2. GB2312/GBK
这就是汉子的国标码，专门用来表示汉字，是双字节编码，而英文字母和iso8859-1一致（兼容iso8859-1编码）。其中gbk编码能够用来同时表示繁体字和简体字，而gb2312只能表示简体字，gbk是兼容gb2312编码的。
2.3. unicode
这是最统一的编码，可以用来表示所有语言的字符，而且是定长双字节（也有四字节的）编码，包括英文字母在内。所以可以说它是不兼容iso8859-1编码的，也不兼容任何编码。不过，相对于iso8859-1编码来说，uniocode编码只是在前面增加了一个0字节，比如字母&#8217;a'为&#8221;00 61&#8220;。
需要说明的是，定长编码便于计算机处理（注意GB2312/GBK不是定长编码），而unicode又可以用来表示所有字符，所以在很多软件内部是使用unicode编码来处理的，比如java。
2.4. UTF
考虑到unicode编码不兼容iso8859-1编码，而且容易占用更多的空间：因为对于英文字母，unicode也需要两个字节来表示。所以unicode不便于传输和存储。因此而产生了utf编码，utf编码兼容iso8859-1编码，同时也可以用来表示所有语言的字符，不过，utf编码是不定长编码，每一个字符的长度从1-6个字节不等。另外，utf编码自带简单的校验功能。一般来讲，英文字母都是用一个字节表示，而汉字使用三个字节。
注意，虽然说utf是为了使用更少的空间而使用的，但那只是相对于unicode编码来说，如果已经知道是汉字，则使用GB2312/GBK无疑是最节省的。不过另一方面，值得说明的是，虽然utf编码对汉字使用3个字节，但即使对于汉字网页，utf编码也会比unicode编码节省，因为网页中包含了很多的英文字符。
3. java对字符的处理
在java应用软件中，会有多处涉及到字符集编码，有些地方需要进行正确的设置，有些地方需要进行一定程度的处理。
3.1. getBytes(charset)
这是java字符串处理的一个标准函数，其作用是将字符串所表示的字符按照charset编码，并以字节方式表示。注意字符串在java内存中总是按unicode编码存储的。比如&#8221;中文&#8221;，正常情况下（即没有错误的时候）存储为&#8221;4e2d 6587&#8220;，如果charset为&#8221;gbk&#8221;，则被编码为&#8221;d6d0 cec4&#8220;，然后返回字节&#8221;d6 d0 ce c4&#8220;。如果charset为&#8221;utf8&#8243;则最后是&#8221;e4 b8 ad e6 96 87&#8220;。如果是&#8221;iso8859-1&#8243;，则由于无法编码，最后返回 &#8220;3f 3f&#8220;（两个问号）。
3.2. new String(charset)
这是java字符串处理的另一个标准函数，和上一个函数的作用相反，将字节数组按照charset编码进行组合识别，最后转换为unicode存储。参考上述getBytes的例子，&#8221;gbk&#8221; 和&#8221;utf8&#8243;都可以得出正确的结果&#8221;4e2d 6587&#8220;，但iso8859-1最后变成了&#8221;003f 003f&#8220;（两个问号）。
因为utf8可以用来表示/编码所有字符，所以new String( str.getBytes( &#8220;utf8&#8243; ), &#8220;utf8&#8243; ) === str，即完全可逆。
3.3. setCharacterEncoding()
该函数用来设置http请求或者相应的编码。
对于request，是指提交内容的编码，指定后可以通过getParameter()则直接获得正确的字符串，如果不指定，则默认使用iso8859-1编码，需要进一步处理。参见下述&#8221;表单输入&#8221;。值得注意的是在执行setCharacterEncoding()之前，不能执行任何getParameter()。java doc上说明：This method must be called prior to [...]]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/744/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Java编码转换-TXT文件编码转换实例</title>
		<link>http://www.chentaoqian.com/archives/740</link>
		<comments>http://www.chentaoqian.com/archives/740#comments</comments>
		<pubDate>Mon, 05 Jul 2010 15:13:32 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[decode]]></category>
		<category><![CDATA[encode]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[编码]]></category>
		<category><![CDATA[编码转换]]></category>
		<category><![CDATA[解码]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=740</guid>
		<description><![CDATA[Java中编码转换用到的类主要为Charset，CharsetDecoder，CharsetEncoder类，下面举例展示一下如何使用这些类处理TXT文件的编码转换。


import java.io.File;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public class TranslateCharset {
 static public void main(String args[]) throws Exception {
 String inFilename = &#8221;inputFileName.txt&#8221;;
 String inFileCharsetName = &#8221;InputFileCharSetName&#8221;;
 String outFilename = &#8221;outputFileName.txt&#8221;;
 String outFileCharsetName = &#8221;OutputFileCharSetName&#8221;;

 File infile = new File(inFilename);
 File outfile = new File(outFilename);

 RandomAccessFile inraf = new RandomAccessFile(infile, &#8221;r&#8221;);
 RandomAccessFile outraf = new RandomAccessFile(outfile, &#8221;rw&#8221;);

 FileChannel finc = inraf.getChannel();
 FileChannel foutc = outraf.getChannel();

 MappedByteBuffer inmbb =
 finc.map(FileChannel.MapMode.READ_ONLY, 0, (int) infile.length());

 Charset inCharset = Charset.forName(inFileCharsetName);
 Charset outCharset = Charset.forName(outFileCharsetName);

 CharsetDecoder inDecoder = inCharset.newDecoder();
 CharsetEncoder outEncoder = outCharset.newEncoder();

 CharBuffer cb = inDecoder.decode(inmbb);
 ByteBuffer outbb = outEncoder.encode(cb);

 foutc.write(outbb);

 inraf.close();
 outraf.close();
 }
}


文本文件的编码转换是很常用的功能
]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/740/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>java程序做成exe文件的几种做法</title>
		<link>http://www.chentaoqian.com/archives/489</link>
		<comments>http://www.chentaoqian.com/archives/489#comments</comments>
		<pubDate>Wed, 19 Aug 2009 05:59:40 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[exe]]></category>
		<category><![CDATA[jar]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[可执行文件]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=489</guid>
		<description><![CDATA[虽然Java拥有跨平台的优势，但是现在绝大部分程序还是以exe可执行程序为主。所以为了能将Java写的程序编译成可执行程序，我去网上搜了一些方法，在这里做个总结。
关于将java程序做成exe文件的几种做法：
可以把普通的Java程序做成真正的exe,也就是单一个exe就可以在没有安装JVM的机器上运行。这样的工具常见的有JET和gcj.前者是收费的，而且做出来的exe还是需要一堆dll。推荐使用gcj.他有windows和Linux版，直接下载zip包，不需要安装，里面有不少例子，一些build的批处理文件。从原理来说gcj自己实现了JVM规范，也就是你编写一个HelloWorld.java,其中的main方法为System.out.println(&#8220;foo&#8221;);
当使用gcj把它做成exe(大约2M)，运行这个exe时，会启动里面的一个小型jvm,在这上面跑HelloWorld。
其实，把Java做成纯exe实在是吃力不讨好，有很多限制，文件又大。
我比较倾向另几种做法：
. 使用InstallAnywhere等工具，制作一个exe的安装包用户可以选择使用他机器上的JRE或是这个安装包内的JRE来运行程序
这是很常见的一种做法，如JBuilder就是这么做的。
这样的好处是不要求对方机器上装有JRE，而且你原来的程序不需要任何改动。
InstallAnywhere中一个压缩的JRE大概是8M。
. 制作成可执行的jar,也就是在META-INF的MANIFEST文件制定Main-Class可以通过命令行java -jar jarfile.jar来执行，windows默认的把*.jar使用javaw -jar打开，所以有些机器上可以直接双击jar运行。
. 制作伪exe,其实和上一种做法是一样的，只不过做成exe,调用系统的java.exe来运行它，这样的工具有nativeJ,exe4j等
其实Java不像VB,Delphi只是一个语言，而是一个平台。
jar是最常用的部署单元，做成exe没什么意思。
一、exe4j。
说明：exe4j可以将Jar文件制作成exe文件，但需jre支持，也可将Jar文件放在外面。
软件性质：共享软件
下载地址：http://www.ej-technologies.com/products/exe4j/overview.html
二、JBuilder。
说明：新版本的JBuilder可以直接把工程制作成各系统的可执行文件，包括Windows系统。
软件性质：商业软件
下载地址：略。我是从eMule下载的。
三、NativeJ。
说明：与exe4j功能类似。
软件性质：共享软件
下载地址：http://www.dobysoft.com/products/nativej/download.html
四、Excelsior JET。
说明：可以直接将Java类文件制作成exe文件，除AWT和Swing及第三方图形接口外可不需jre支持（Java5.0不行）。
软件性质：共享软件
下载地址：http://excelsior-usa.com/home.html
五、jshrink。
说明：可将Jar文件打包进exe文件。同时具有混淆功能（这才是它的主要功能）。
软件性质：共享软件
下载地址：http://www.e-t.com/jshrink.html
六、InstallAnywhere。
说明：打包工具，对Java打包最好用。可打包成各操作系统运行包。包括Windows系统。
软件性质：商业软件。
下载地址：http://www.zerog.com/
七、InstallShieldX。
说明：与InstallAnywhere类似，但比InstallAnywhere功能强大。相对的，比较复杂，不易上手，我现在还没学会。
软件性质：商业软件。
下载地址：http://www.installshield.com/
]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/489/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Eclipse的几种安装插件的方法</title>
		<link>http://www.chentaoqian.com/archives/483</link>
		<comments>http://www.chentaoqian.com/archives/483#comments</comments>
		<pubDate>Sun, 16 Aug 2009 07:51:36 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[计算机]]></category>
		<category><![CDATA[eclipse]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[插件]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=483</guid>
		<description><![CDATA[Eclipse是目前应用非常广的Java 集成开发工具，而它的强大之处就在于通过安装，它能实现无限的扩展！这太令人振奋了！插件怎么装，下面就讲安装插件的三种方法。
一、覆盖安装。
将插件解压缩后，覆盖Eclipse下的相应文件夹，但是这种安装方式不利于卸除，以后不易维护，所以不太可取。
二、link安装。
以下是一个简单例子用以演示安装：
1.将插件解压到指定目录下，例如：D：\plugs
2.在eclipse 的主目录下，例如：C:\eclipse，新建一个名为 links的文件夹
3.在文件夹下新建文件*.link
内容：path=D:\\plugs
4.删除eclipse目录下C:\eclipse\configuration中除config.ini以外的所有文件重新启动 eclipse.
5.Ok
这种安装方式稍稍麻烦一点，但是有利于以后维护，以后可以方便删除，在这种安装方式中需要注意的是:path路径中的斜杠要写\\,文件名以.link做后缀名字。
三、引导安装。
不知道这是否算一个安装方式，但这样做很方便
安装过程：打开Eclipse菜单，在Help菜单下有一项是Software Update选项，单击
在弹出的对话框左侧的树突根部，右键，单击ADD，然后选择插件所在的路径，之后安装提示重启即可。
]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/483/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>在Windows上搭建Java开发环境</title>
		<link>http://www.chentaoqian.com/archives/475</link>
		<comments>http://www.chentaoqian.com/archives/475#comments</comments>
		<pubDate>Mon, 03 Aug 2009 04:49:12 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[Windows]]></category>
		<category><![CDATA[环境]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=475</guid>
		<description><![CDATA[Windows下JAVA用到的环境变量主要有3个，JAVA_HOME、CLASSPATH、PATH。下面逐个分析。JAVA_HOME指向的是JDK的安装路径，如x:\JDK_1.4.2，在这路径下你应该能够找到bin、lib等目录。值得一提的是，JDK的安装路径可以选择任意磁盘目录，不过建议你放的目录层次浅一点，如果你放的目录很深，比如x:\XXXXXX\xxxxx\XXXX\xxxx\XXXX\xxxx\XXXX\xxx&#8230;&#8230;
那么，下面的步骤和以后的应用你都要受累了，呵呵。设置方法：
JAVA_HOME=x:\JDK_1.4.2
PATH环境变量原来Windows里面就有，你只需修改一下，使他指向JDK的bin目录，这样你在控制台下面编译、执行程序时就不需要再键入一大串路径了。设置方法是保留原来的PATH的内容，并在其中加上%JAVA_HOME%\bin (注，如果你对DOS批处理不了解，你可能不明白%%引起来的内容是什么意思；其实这里是引用上一步设定好的环境变量JAVA_HOME，你写成x:\JDK_1.4.2也是可以的；你可以打开一个控制台窗口，输入echo %JAVA_HOME%来看一下你的设置结果) ：
PATH=%JAVA_HOME%\bin;%PATH%
同样，%PATH%是引用以前你设置的PATH环境变量，你照抄以前的值就行了。
CLASSPATH环境变量我放在最后面，是因为以后你出现的莫名其妙的怪问题80%以上都可能是由于CLASSPATH设置不对引起的，所以要加倍小心才行。
CLASSPATH=.;%JAVA_HOME%\lib\tools.jar
首先要注意的是最前面的&#8221;.;&#8221;，如果你看不清，我给你念念&#8211;句点分号。这个是告诉JDK，搜索CLASS时先查找当前目录的CLASS文件&#8211;为什么这样搞，这是由于LINUX的安全机制引起的，LINUX用户很明白，WINDOWS用户就很难理解(因为WINDOWS默认的搜索顺序是先搜索当前目录的，再搜索系统目录的，再搜索PATH环境变量设定的) ，所以如果喜欢盘根究底的朋友不妨研究一下LINUX。
为什么CLASSPATH后面指定了tools.jar这个具体文件？不指定行不行？显然不行，行的话我还能这么罗索嘛！:) 这个是由java语言的import机制和jar机制决定的，你可以查资料解决。
呵呵，具体的设定方法: win2k\xp用户右键点击我的电脑-&#62;属性-&#62;高级-&#62;环境变量，修改下面系统变量那个框里的值就行了。
win9x用户修改autoexec.bat文件，在其末尾加入:
set JAVA_HOME=x:\JDK_1.4.2
set PATH=%JAVA_HOME%\bin;%PATH%
set CLASSPATH=.;%JAVA_HOME%\lib\tools.jar
就可以了。
]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/475/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>用java调用3种类型oracle存储过程总结</title>
		<link>http://www.chentaoqian.com/archives/450</link>
		<comments>http://www.chentaoqian.com/archives/450#comments</comments>
		<pubDate>Sun, 12 Jul 2009 10:21:25 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[Oracle]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[oracle]]></category>
		<category><![CDATA[存储过程]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=450</guid>
		<description><![CDATA[因工作需要，开始学习Oracle的存储过程。本来以为很简单的，因为存储过程可以理解为对SQL语句的一个包装，但几经挫折，查遍互联网络，总算搞通了，为了以后重温方便，在这里记录一下。这里记录了调用三种存储过程的方法：1.无返回值的存储过程；2.返回标量的存储过程；3.返回列表的存储过程。
一：无返回值的存储过程
存储过程为：
CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2,PARA2 IN VARCHAR2)  AS
BEGIN
   INSERT INTO HYQ.B_ID (I_ID,I_NAME) VALUES (PARA1, PARA2);
END TESTA;
然后呢，在java里调用时就用下面的代码：
package com.hyq.src; 
import java.sql.*;
import java.sql.ResultSet;
 
public class TestProcedureOne {
  public TestProcedureOne() {
  }
  public static void main(String[] args ){
    String driver = &#8220;oracle.jdbc.driver.OracleDriver&#8221;;
    String strUrl = &#8220;jdbc:oracle:thin:@127.0.0.1:1521: hyq &#8220;;
    Statement stmt = null;
    ResultSet rs = null;
    Connection conn = [...]]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/450/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Java浅复制和深度复制 clone()</title>
		<link>http://www.chentaoqian.com/archives/349</link>
		<comments>http://www.chentaoqian.com/archives/349#comments</comments>
		<pubDate>Fri, 19 Jun 2009 13:13:13 +0000</pubDate>
		<dc:creator>admin</dc:creator>
				<category><![CDATA[Java]]></category>
		<category><![CDATA[clone]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[浅复制]]></category>
		<category><![CDATA[深复制]]></category>

		<guid isPermaLink="false">http://www.chentaoqian.com/?p=349</guid>
		<description><![CDATA[Java语言的一个优点就是取消了指针的概念，但也导致了许多程序员在编程中常常忽略了对象与引用的区别，本文会试图澄清这一概念。并且由于Java不能通过简单的赋值来解决对象复制的问题，在开发过程中，也常常要要应用clone（）方法来复制对象。本文会让你了解什么是影子clone与深度clone，认识它们的区别、优点及缺点。
看到这个标题，是不是有点困惑：Java语言明确说明取消了指针，因为指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常复杂难以理解，滥用指针写成的代码不亚于使用早已臭名昭著的&#8221;GOTO&#8221;语句。Java放弃指针的概念绝对是极其明智的。但这只是在Java语言中没有明确的指针定义，实质上每一个new语句返回的都是一个指针的引用，只不过在大多时候Java中不用关心如何操作这个&#8221;指针&#8221;，更不用象在操作C＋＋的指针那样胆战心惊。唯一要多多关心的是在给函数传递对象的时候。如下例程： 
package reference;
class Obj{
String str = &#8220;init value&#8221;;
public String toString(){
return str;
}
}
public class ObjRef{
Obj aObj = new Obj();
int aInt = 11;
public void changeObj(Obj inObj){
inObj.str = &#8220;changed value&#8221;;
}
public void changePri(int inInt){
inInt = 22;
}
public static void main(String[] args)
{
ObjRef oRef = new ObjRef();
System.out.println(&#8220;Before call changeObj() method: &#8221; + oRef.aObj);
oRef.changeObj(oRef.aObj);
System.out.println(&#8220;After call changeObj() method: &#8221; + oRef.aObj);
System.out.println(&#8220;==================Print Primtive=================&#8221;);
System.out.println(&#8220;Before call changePri() method: [...]]]></description>
		<wfw:commentRss>http://www.chentaoqian.com/archives/349/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

