public void seek(long pos)可以将读写指针移到文件尾，参数Pos表示从文件开头以字节为单位测量的偏移位置，在该位置文件指针。

public void write(int pos)将数据写到读写指针后面，完成文件的追加。参数pos表示要写入的Byte

通过FileWrite打开文件输出流，构造FileWrite时指定写入模式，是一个布尔量，为真时表示写入的内容添加到已有文件的内容的后面，为假时表示重新写文件，以前的记录被清空，默认的值为假。

具体的例子可以参看以下的代码：

package Characters;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;

public class CharactersDemo_03 {
 // 使用RandomAccessFile实现文件的追加，其中：fileName表示文件名；content表示要追加的内容
 public static void appendMethod_one(String fileName, String content) {
  try {
   // 按读写方式创建一个随机访问文件流
   RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
   long fileLength = raf.length();// 获取文件的长度即字节数
   // 将写文件指针移到文件尾。
   raf.seek(fileLength);
   // 按字节的形式将内容写到随机访问文件流中
   raf.writeBytes(content);
   // 关闭流
   raf.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
 // 使用FileWriter实现文件的追加，其中：fileName表示文件名；content表示要追加的内容
 public static void appendMethod_two(String fileName, String content) {
  try {
   // 创建一个FileWriter对象，其中boolean型参数则表示是否以追加形式写文件
   FileWriter fw = new FileWriter(fileName, true);
   // 追加内容
   fw.write(content);
   // 关闭文件输出流
   fw.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
 public static void showFileContent(String fileName) {
  File file = new File(fileName);
  BufferedReader reader = null;
  try {
   System.out.println("以行为单位读取文件内容，一次读一整行：");
   reader = new BufferedReader(new FileReader(file));
   String tempString = null;
   int line = 1;
   // 一次读入一行，直到读入null为文件结束
   while ((tempString = reader.readLine()) != null) {
    // 显示行号
    System.out.println(line + ": " + tempString);
    line++;
   }
   reader.close();
  } catch (IOException e) {
   e.printStackTrace();
  } finally {
   if (reader != null) {
    try {
     reader.close();
    } catch (IOException e1) {
    }
   }
  }
 }
 public static void main(String[] args) {
  String fileName = "C:/temp/append.txt";
  String content = "Successful operation!";
  System.out.println(fileName + "文件的内容如下：");
  CharactersDemo_03.showFileContent(fileName); // 显示文件内容
  // 按RandomAccessFile的形式追加文件
  System.out.println("\n按RandomAccessFile的形式追加文件后的内容如下：");
  CharactersDemo_03.appendMethod_one(fileName, content);
  CharactersDemo_03.appendMethod_one(fileName, "\n Game is Over！ \n");
  CharactersDemo_03.showFileContent(fileName); // 显示文件内容
  // 按FileWriter的形式追加文件
  System.out.println("\n按FileWriter的形式追加文件后的内容如下：");
  CharactersDemo_03.appendMethod_two(fileName, content);
  CharactersDemo_03.appendMethod_two(fileName, "\n Game is Over！ \n");
  CharactersDemo_03.showFileContent(fileName); // 显示文件内容
 }
}

<pathelement path="${project.jar.path}> 里面path指向的不是一个预先定义的<path>,而是一个符合classpath规则的property.

1,正确的例子:

<property name="project.jar.path" value="D:/temp/temp.jar;D:/temp/temp1.jar" />

<classpath id="tcls">
       <pathelement path="${project.jar.path}" />
 </classpath>

2,如果误认为path应该指向一个预先定义的path是不正确的.

        <path id="testTask.classpath">
            <fileset dir="${project.lib.path}">
                <include name="**/*.jar" />
            </fileset>
        </path>

         <classpath id="tcls">
              <pathelement path="${testTask.classpath}" />
         </classpath>

如果想在<classpath>里引用预先定义好的path,应该如下:

         <classpath id="tcls">
             <path refid="testTask.classpath" />
         </classpath>

pathelement的path指定的是一个预先定义的property或者一个符合classpath规则的字符串,

location指定的是一个jar文件或者一个目录.

<property name="project.jar.path" value="D:/temp/temp.jar;D:/temp/temp1.jar" />
<classpath>
    <pathelement path="${project.jar.path}" />     
    <pathelement location="lib/helper.jar"/>
</classpath>

classpath内嵌的元素除了pathelement和path之外,还可以是fileset,dirset和filelist.

<path id="cls.path.ref">
    <fileset dir="lib" includes="*.jar" />
</path>
<filelist id="third-party_jars" dir="${jar.dir}"files="foo.jar, bar.jar"/>

<classpath>
    <pathelement path="d:/temp/temp.jar" />
    <path refid="cls.path.ref" />
   
    <fileset dir="lib">
        <include name="**/*.jar" />
    </fileset>
   
    <pathelement location="classes" />
   
    <dirset dir="${build.dir}">
        <include name="apps/**/classes" />
        <exclude name="apps/**/*Test*" />
    </dirset>
   
    <filelist refid="third-party_jars" />
</classpath>

转自：http://blog.csdn.net/kkdelta/article/details/5684228

当你想下载Linux、JDK、Tomcat、eclipse时，你是下载32位版本还是64位版本？64位版本有两种，应该选哪一个？当你看到这些内容：x86、x64、x86－32、x86－64、ia64、i80386、i80486、i80586、i80686，知道是干什么的吗？

这事儿要先从CPU说起：
——————————-

IA-32架构与IA-64架构
IA是Intel Architecture（英特尔体系结构）的英语缩写。
IA-32架构下有32位CPU，也64位CPU。（我们经常使用的CPU）
IA-64架构下有Intel64的位CPU （只有服务器使用的CPU）
——————————-

IA-32架构：
本架构的CPU都采用X86指令
Intel、AMD、Cyrix等厂家都生产使用X86指令集的CPU
 
其中32位（x86－32）的CPU有：i80386、i80486、i80586、i80686、统称i80x86、简称x86。
其中64位（x86－64，EM64T）的CPU有：2006年以后生产的PC机CPU都是64位的。简称x64
x86－64是AMD在其64位处理器系列中采用的技术
EM64T是Intel在其64位处理器系列中采用的技术
x86－64与EM64T都差不多，都是64位。最大的优点就是可以全面兼容以前的32位x86指令的应用程序，因为都是IA-32架构架构。
——————————-
IA-64架构：
IA－64架构是英特尔为了全面提高以前IA－32位处理器的运算性能，是Intel和Hp共同开发了6年的64位CPU架构，是专为服务器市场开发的一种全新的处理器架构，它放弃了以前的IA-32架构（x86系统CPU采用的架构），认为它严重阻碍了处理器的性能提高。它的最初应用是英特尔的Itanium（安腾）系列服务器处理器，现在最新的Itanium 2系列处理器也是采用这一架构的。由于它不能很好地解决与以前32位应用程序的兼容，所以应用受到较大的限制，尽管目前Intel采取了各种软、硬方法来弥补这一不足，但随着AMD Operon处理器的全面投入，Intel的IA－64架构的这两款处理器前景不容乐观。 
——————————-
RISC架构  
采用这一架构的仍是IBM、SUN和HP等。不过近几年由于这一处理器架构标准没有完全统一、处理器的发展和应用非常缓慢，使得原来本占有的绝大多数中高档服务器市场被IA架构瓜分了大部分江山，已是日趋衰落。目前连这几家服务器厂商也开始了自己放弃，转投IA旗下，推出越来越多的IA架构服务器，以保生存。

目前采用这一架构的主要服务器处理器有IBM的Power4、Compaq Alpha 21364、HP PA－8X00、Sun的UltraSPARC III、SGI的MIPS 64 20Kc等。
——————————-

说完了CPU，现在说一说软件，下载时如何选择,主看下面的示例：

SUN JDK:

jdk-6u25-windows-i586.exe  适用于x86－32（简称x86）的CPU，要586以上的CPU，因为x86－64的CPU能向下兼容32位，所以运行在x86－64CPU也是可以的，但是以32位运行的。
jdk-6u25-windows-x64.exe   适用于x86－64，EM64T 的64位CPU。
jdk-6u25-windows-ia64.exe  适用于IA－64Itanium（安腾）系列服务器CPU

Tomcat:
apache-tomcat-6.0.32-windows-x86.zip  适用于x86－32（简称x86）的32位CPU，因为x86－64的CPU能向下兼容32位，所以运行在x86－64CPU也是可以的，但是以32位运行的。
apache-tomcat-6.0.32-windows-x64.zip  适用于x86－64，EM64T 的64位CPU。（简称x64）
apache-tomcat-6.0.32-windows-i64.zip  适用于Itanium（安腾）系列服务器CPU,全称应该是ia64，这里简写了。

CentOS:

Linux操作系统的一个发行版本CentOS，下载时有
CentOS-5.6-i386-bin-DVD.iso        适用于x86－32（简称x86）的CPU，要386以上的CPU
CentOS-5.6-x86_64-bin-DVD-1of2.iso 适用于x86－64，EM64T 的64位CPU（简称x64）

eclipse:

eclipse-jee-helios-SR2-win32.zip         适用于x86－32（简称x86）的CPU
eclipse-jee-helios-SR2-win32-x86_64.zip  适用于x86－64，EM64T 的64位CPU（简称x64）

如何选择：如果你想使用32位程序，就下载32位的版本，如果你想使用64位的版本，请根据你的CPU来选择，但我想没人使用Itanium（安腾）的64位CPU来做开发吧（服务器除外），所以ia64不能选，只能选x86－64。总之就是根据你的实际情况选择。

最后说明一下，要所有的软件，硬件，全是64位的，你的应用才算成功的运行在64位上了。比如：

使用64位的CPU，现在（2006年以后生产）的CPU都是64位。
安装64位的操作系统，比如64位的windows 7
安装64位的JDK,比如jdk-6u25-windows-x64.exe
安装64位的Tomcat,比如apache-tomcat-6.0.32-windows-x64.zip

安装64位的eclipse，比如eclipse-jee-helios-SR2-win32-x86_64.zip

注：本文不讨论64位程序与32位程序的性能问题，只讨论如何选择相应的版本。

DefaultMutableTreeNode root = new DefaultMutableTreeNode("根节点");

DefaultMutableTreeNode leafNode1 = new DefaultMutableTreeNode("叶节点1");

DefaultMutableTreeNode leafNode2 = new DefaultMutableTreeNode("叶节点2");

root.add(leafNode1);

root.add(leafNode2);

2.设置树的显示风格

UIManager.getDefaults().put("Tree.lineTypeDashed", true);// 设置连接线为虚线

UIManager.getDefaults().put("Tree.lineTypeDashed",false); //设置连接线为直线

JTree tree = new JTree(root);//建树

tree.putClientProperty("JTree.lineStyle","None");//去掉连接线
tree.putClientProperty("JTree.lineStyle","Horizontal");//将树设为水平分隔风格
tree.putClientProperty("JTree.lineStyle","Angled");//默认

3.给树上节点添加图片

首先要获得树的DefaultTreeCellRenderer

DefaultTreeCellRenderer renderer = (DefaultTreeCellRenderer) tree.getCellRenderer();

Icon rootIcon = new ImageIcon("rootIcon路径");
Icon leafIcon = new ImageIcon("leafIcon路径");

添加图片

rend.setLeafIcon(leafIcon);//叶节点图片
rend.setOpenIcon(rootIcon);//树打开时显示的图片
rend.setClosedIcon(collIcon);//树关闭时显示的图片

若要隐藏根节点

tree.setRootVisible(false);

setBounds(int x, int y, int width, int height)方法的应用

很早以前就看到了这个方法，其说明：（x,y）为组件显示的坐标，（width,height）为组件的宽和高

但无论我怎么设置都没有用，知道前天看到了一个具体实例才豁然开朗,只需要加上一行代码：

this.setLayout(null);

转自：
http://hi.baidu.com/%C4%CF%BA%BD%CC%EC%CF%C2/blog/item/aa71f4c7287d93d5d000606d.html

jexegen /OUT:exe_file_name　
/MAIN:main_class_name main_class_file_name.class　
[and other classes]

这几步操作网上介绍的插件和方法很多，但有的好用有的不好用，而且有的还需要注册。经过尝试比较，在“千里冰封”的博客上得到了很大的帮助。整理一下。使用这几个工具，您也可以顺利的发布您的java程序！

1 打包成双击可执行的jar文件。
推荐插件：fatJar（Eclipse使用）
下载地址 http://sourceforge.net/project/showfiles.php?group_id=115990&package_id=125924

我用的是Eclipse，它自带的打包方法在打包一些图片等资源时不是很爽。可以使用这个插件。
安装方法解压后将plugins文件夹下的net.sf.fjep.fatjar_0.0.24文件夹拷到eclipse安装目录的plugins 下。
用此工具可以方便的将eclipse中的工程打包成jar文件。如果是要打成可执行的jar请注意选取主类。
你的项目=〉Export..=>向导里有fat jar =>...

2 将jar文件转换成exe文件。
推荐工具：exe4j

用exe4j把java打包成exe
http://www.blogjava.net/hadeslee/archive/2007/10/12/152228.html
在我们写程序的时候，有时会有一种需求，那就是希望我们的程序是一个可执行文件，而不是一个jar文件，其实大部份时候，可执行的jar文件都可以满足要求，但是如果我们的程序是需要保护的，那么打包成jar文件就不太安全了，因为jar文件就是一个解压缩文件，一解压就什么都能看到了，当然也可以选择混淆，但是混淆了以后排错就没那么容易了，因为混淆的时候，把一些类的信息都混淆了。如何既保证代码的安全又容易排错呢？那么打包成exe就是一种很好的办法了，其实我今天介绍这个方法并不是希望大家去打包成exe文件，因为exe文件毕竟不是跨平台的，用了exe的格式就失去了java的初衷了。

exe4j可以打包成各种格式的exe,可以把jar打包进exe,也可以引用一个外部的jar文件，还可以打包成windows服务的程序，并且可以设置最低jre的版本，还可以设定启动画面，虽然java6.0已经实现了这一点，但是还是没有exe4j生成的启动画面快。

3 将exe文件并jre打包成安装文件 可以在没有安装java虚拟机的电脑上运行
推荐工具：install4j

Install4j介绍
http://www.blogjava.net/hadeslee/archive/2007/10/15/152855.html
install4j是一个功能强大的,多平台Java安装文件生成工具，用于生成Java应用程序本地化的安装及应用程序发布。 install4j 的优异性在于它易于使用，紧密的集成到目标平台，以及灵活的JRE 管理与部署选项。

创建发布树
install4j的图形用户界面允许你:

    * 完全自定义发布树
      在发布树的每一个目录中，你能设置整个目录内容或是磁盘上任何目录的单个文件。定义的视图与结果视图让你能完全控制安装程序将发布的文件。
      　
    * 处理特定平台的差异
      install4j提供方便的“包含／排除”机制，使其适应平台方式来进行发布。
      　
    * 针对Unix, Linux 及Mac OS X所定义的文件权限
      对发布树的每一个元素，当其安装在类似于Unix这样的平台上时，你能自定义用户访问的权限。
      　
    * 定义优良的卸载策略
      对发布树的每一个元素，你能决定在卸载时是否删除它。
      　
    * 定义覆盖策略
      对发布树的每一个元素，你能配置不同的覆盖策略，当安装过程中需要覆盖文件时，这些覆盖策略会指示nstall4j进行相应的操作。
      　
    * 定义安装的组件
      你能定义文件及目录的分组，形成分离的安装组件，这样你就可提供给用户来选择只安装一定的组件。

其实一个好的应用如果不太好布署,那么别人也只能对它望而兴叹了,现在有了install4j,很多布署的问题几乎全部解决了.我们可以用exe4j打包java应用,然后用install4j发布java应用,以前java程序布署难的问题,现在几乎都解决了.install4j不但用于打包很合适,并且它还提供了一组很强大很实用的与平台相关的api.这些对于扩展我们的程序也是有很大的帮助的.

Xalan既可以作为一个XSLT工具以命令行的方式使用，也可以作为一个模块在其他应用程序中使用，我们可以在http://www.fayea.com/apache-mirror/xml/xalan-j/上下载最新版本的Xalan处理器，下载解压后的目录中有一个xalan.jar，，该xalan.jar就是Xalan解析器，也是实现XSLT和XPath规范的类库，如果我们想使用Xalan解析器的话，
需要应用xalan.jar和serializer.jar这两个jar包，如果只用用xalan.jar,就会报出：

D:\XML\test>java org.apache.xalan.xslt.Process -PARAM oddline-color #FFOOOO

-IN em.xml -XSL em.xsl -OUT em.out

(错误位置未知)XSLT 错误 (java.lang.NoClassDefFoundError): org/apache/xml/seriali

zer/ExtendedContentHandler

Exception in thread "main" java.lang.RuntimeException: org/apache/xml/serializer

/ExtendedContentHandler

        at org.apache.xalan.xslt.Process.doExit(Process.java:1155)

        at org.apache.xalan.xslt.Process.main(Process.java:1128)

D:\XML\test>

方法一：

将组件的jar包放到classpath环境变量中就行了，但是这里的classpath是用户变量中的，不是系统变量中的，你可以在命令行中使用set classpath来查看环境变量classpath的值（同样我们也可以使用这种方法测试我们设置的环境变量是否已经生效）。

注意：我们可以使用DOS窗口中用set classpath查看我们设置的CLASSPATH环境变量的值是否已经生效了。

方法二：

我们可以直接将组件的jar包放到jdk安装路径下的jre\jre\lib\ext下面，这种方法准行。

Path使得系统可以在任何路径下识别java命令，设为：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

CLASSPATH为java加载类(class or lib)路径，只有类在classpath中，java命令才能识别，设为：.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar (要加.表示当前路径)

特别注意：

◆环境变量值的结尾没有任何符号，不同值之间用；隔开（unix中用:）。

◆CLASSPATH变量值中的.表示当前目录。

四、JDK1.6安装的最后检验

呵呵，基本上就大功告成了，如果不放心，可以检验下。在命令行窗口下，键入java -version命令可以查看到安装的JDK版本信息；键入java命令，可以看到此命令的帮助信息；键入javac命令可以看到此命令的帮助信息。如果都如愿看到，呵呵，检验完毕！

最初的xml解析器是sun的Crimson和IBM的Xerces，这两个开源项目都捐给了apache组织，后来Xerces发展很快，Crimon基本没有人使用。
1.4 版本起，用于 XML 处理的 Java API 就已经加入了Java 2 平台中。 利用该 API，可通过一系列标准的 Java 平台 API 来处理 XML 文档。
 因此，也就无需另外添加 XML 处理包了。sun的JDK1.4使用Crimson，IBM的JDK使用Xerces。
如果打算把sun 的jdk程序移植到IBM的JDK下，注意解析器不同，XML处理会出问题。这就说明了java不是“一次编译，到处运行”，而是“一次编译，到处调试”。
如果你把IBM的JDK移植到SUN的JDK下，即使把Xerces包引入CLASSPATH，JDK还是使用Crimson，不信你运行java -verbose试一试。
解决的办法就是在在JRE\lib\目录下，建立一个jaxp.properties的文件，
内容如下：
    javax.xml.parsers.DocumentBuilderFactory=org.apache.xerces.jaxp.DocumentBuilderFactoryImpl
    javax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl
就可以使用Xerces。
或者使用命令行
# Add the XML parser jars and set the JAXP factory names
# Crimson parser JAXP setup(default)
CLASSPATH=$CLASSPATH:../lib/crimson.jar
JAXP=-Djavax.xml.parsers.DocumentBuilderFactory=org.apache.crimson.jaxp.DocumentBuilderFactoryImpl
JAXP="$JAXP -Djavax.xml.parsers.SAXParserFactory=org.apache.crimson.jaxp.SAXParserFactoryImpl"
或
# Add the XML parser jars and set the JAXP factory names
# Xerces parser JAXP setup
CLASSPATH=$CLASSPATH:../lib/xerces.jar
JAXP=-Djavax.xml.parsers.DocumentBuilderFactory=org.apache.xerces.jaxp.DocumentBuilderFactoryImpl
JAXP="$JAXP -Djavax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl"
最终sun还是指定JAXP规范，JSR 206 Java API for XML Processing(JAXP) 1.3，他已经由JDK1.5实现。
JAXP实现了XPath，但是xalan的org.apache.xpath.XPathAPI 类已经移植到了 JRE 1.5 中，重构为com.sun.org.apache.xpath.internal.XPathAPI。 
如果在以前的JDK中，使用含 XPathAPI 类的 jar，例如 xalan-2.4.1.jar。 将该 jar 加入到 CLASSPATH（类路径）。

W3C的DOM标准API非常难用，于是有人开发 Java专用的XML API，这就是jdom=java+DOM。其中一部分人，去开发dom4j，这个不是非常标准，但是速度很快。
使用JDOM隐含服务器风险，因为JBoss和Webphere都是基于JDOM开发的，在这两个服务器下使用JDOM，必须进行相应的设置，而且你的JDOM版本必须与服务器使用的相近，
因为JVM只加载一份相同的类，服务器优先加载自己使用的JDOM，你开发用的JDOM不会被加载，你的应用就会出错。
使用Dom4J隐含工程问题，主要是hibernate，如果你开发的项目和hibernate合并，Dom4J版本不兼容的话，寻找dom4j相同版本hibernate，或者你改程序适应hibernate的Dom4j。
java没有windows的DLL地狱，但是java的jar地狱有过而无不及啊。

  为了支持向后兼容以及可能的升级方案，JDBC Driver 2.0 在每个安装包中都包括 2 个 JAR 类库：sqljdbc.jar 和 sqljdbc4.jar。本文将介绍SQL Server JDBC驱动中sqljdbc和sqljdbc4的区别。

2、在弹出的窗口中选择 (x)=Arguments 选项卡，VM arguments 输入框中输入所需要的内存最大占用量，我这里输入的是800兆。最后点击Apply按钮即可。

【附】MyEclipse的设置地址在run--->Open Run Dialog--->Arguments

　　 将数据（如汉字）运算为另一固定长度值是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。

        本实例介绍用MD5进行加密和验证，将输入字符串通过MD5加密成另一个字符串，而且根据新的字符串无法获得原字符串，但可以在不知道原始密码的情况下进行密码验证。

关键技术：

*通过java.security.MessageDigest的静态方法getInstance创建具有指定算法名称的信息摘要，参数为算法名，传入“MD5”则表示将使用MD5算法。

*MessageDigest的digest实例方法使用指定的字节数组对摘要进行最后更新，然后完成摘要计算，返回存放哈希值结果的季节数组，这个数组就是MD5加密产品。

*将加密后的字节数组转换成十六进制的字符窜，形成最终的密码。

*当输入字符串经过MD5加密后，得到的字符串与密码一样，则认为密码验证通过。

实例演示：

 1import java.security.MessageDigest;  
 2
 3  
 4public class Password {  
 5    //16进制下数字到字符的映射数组   
 6    private static String[] hexDigits = new String[]{"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};  
 7  
 8    //将inputstr加密   
 9    public static String createPassword(String inputstr)  
10    {  
11        return encodeByMD5(inputstr);  
12    }  
13  
14    //验证密码是否正确   
15    public static boolean authenticatePassword(String pass , String inputstr)  
16    {  
17        if(pass.equals((encodeByMD5(inputstr))))  
18        {  
19            return true;  
20        }  
21         else  
22         {  
23             return false;  
24         }  
25     }  
26     //对字符串进行MD5编码   
27     private static String encodeByMD5(String originstr)  
28     {  
29         if(originstr !=null)  
30         {  
31             try{  
32                 //创建具有指定算法名称的信息摘要   
33                 MessageDigest md = MessageDigest.getInstance("MD5");  
34                 //使用指定的字节数组对摘要进行最后的更新，然后完成摘要计算   
35                 byte[] results = md.digest(originstr.getBytes());  
36                  //将得到的字节数组编程字符窜返回   
37                 String resultString = byteArrayToHexString(results);  
38                 return resultString.toUpperCase();  
39             }catch(Exception ex){  
40                 ex.printStackTrace();  
41             }  
42         }  
43        return null;  
44     }  
45     //转换字节数组为十六进制字符串   
46     private static String byteArrayToHexString(byte[] b)  
47    {  
48        StringBuffer resultsb = new StringBuffer();  
49        int i=0;  
50        for(i=0;i<b.length;i++)  
51        {  
52            resultsb.append(byteToHexString(b[i]));  
53        }  
54        return resultsb.toString();  
55    }  
56    //将字节转化成十六进制的字符串   
57    private static String byteToHexString(byte b)  
58    {  
59        
60       int n=b;  
61       if(n<0)  
62        {  
63            n = 256 + n;  
64        }  
65        int d1 = n / 16;  
66        int d2 = n /16;  
67        return hexDigits[d1]+hexDigits[d2];  
68    }  
69  
70    public static void main(String[] args)  
71    {  
72        String password = Password.createPassword("123456");  
73        System.out.println("对123456用MD5加密后："+password);  
74        String inputstr = "1234";  
75        System.out.println("1234与密码相同？"+Password.authenticatePassword(password, inputstr));  
76        inputstr = "123456";  
77        System.out.println("123456与密码相同？"+Password.authenticatePassword(password, inputstr));  
78    }  
79}  

转自：http://blog.csdn.net/jay314159/article/details/4918358

根据以上原理，我们就可以将byte[] 数组转换为16进制字符串了，当然也可以将16进制字符串转换为byte[]数组了。

/**

Java代码 
1. * Convert byte[] to hex string.这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。  
2. * @param src byte[] data  
3. * @return hex string  
4. */     
5.public static String bytesToHexString(byte[] src){  
6.    StringBuilder stringBuilder = new StringBuilder("");  
7.    if (src == null || src.length <= 0) {  
8.        return null;  
9.    }  
10.    for (int i = 0; i < src.length; i++) {  
11.        int v = src[i] & 0xFF;  
12.        String hv = Integer.toHexString(v);  
13.        if (hv.length() < 2) {  
14.            stringBuilder.append(0);  
15.        }  
16.        stringBuilder.append(hv);  
17.    }  
18.    return stringBuilder.toString();  
19.}  
20./** 
21. * Convert hex string to byte[] 
22. * @param hexString the hex string 
23. * @return byte[] 
24. */ 
25.public static byte[] hexStringToBytes(String hexString) {  
26.    if (hexString == null || hexString.equals("")) {  
27.        return null;  
28.    }  
29.    hexString = hexString.toUpperCase();  
30.    int length = hexString.length() / 2;  
31.    char[] hexChars = hexString.toCharArray();  
32.    byte[] d = new byte[length];  
33.    for (int i = 0; i < length; i++) {  
34.        int pos = i * 2;  
35.        d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));  
36.    }  
37.    return d;  
38.}  
39./** 
40. * Convert char to byte 
41. * @param c char 
42. * @return byte 
43. */ 
44. private byte charToByte(char c) {  
45.    return (byte) "0123456789ABCDEF".indexOf(c);  
46.} 
     * Convert byte[] to hex string.这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
     * @param src byte[] data
     * @return hex string
     */  
    public static String bytesToHexString(byte[] src){
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }
    /**
     * Convert hex string to byte[]
     * @param hexString the hex string
     * @return byte[]
     */
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }
    /**
     * Convert char to byte
     * @param c char
     * @return byte
     */
     private byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }


Java代码 
1.//将指定byte数组以16进制的形式打印到控制台  
2.public static void printHexString( byte[] b) {    
3.   for (int i = 0; i < b.length; i++) {   
4.     String hex = Integer.toHexString(b[i] & 0xFF);      //b[i] 和0xFF进行与运算（0xFF默认是int型，二进制位00000000 00000000 00000000 11111111）
5.     if (hex.length() == 1) {   
6.       hex = '0' + hex;    //高四位置为0
7.     }   
8.     System.out.print(hex.toUpperCase() );      //将十六进制个字符转换为大写输出到控制台
9.   }   
10. 
11.} 


//将指定byte数组以16进制的形式打印到控制台
public static void printHexString( byte[] b) { 
   for (int i = 0; i < b.length; i++) {
     String hex = Integer.toHexString(b[i] & 0xFF);
     if (hex.length() == 1) {
       hex = '0' + hex;
     }
     System.out.print(hex.toUpperCase() );
   }

}

java中byte转换int时为何与0xff进行与运算

在剖析该问题前请看如下代码

Java代码 
1.public static String bytes2HexString(byte[] b) {  
2.  String ret = "";  
3.  for (int i = 0; i < b.length; i++) {  
4.   String hex = Integer.toHexString(b[ i ] & 0xFF);  
5.   if (hex.length() == 1) {  
6.    hex = '0' + hex;  
7.   }  
8.   ret += hex.toUpperCase();  
9.  }  
10.  return ret;  
11.} 
上面是将byte[]转化十六进制的字符串,注意这里b[ i ] & 0xFF将一个byte和 0xFF进行了与运算,然后使用Integer.toHexString取得了十六进制字符串,可以看出
b[ i ] & 0xFF运算后得出的仍然是个int,那么为何要和 0xFF进行与运算呢?直接 Integer.toHexString(b[ i ]);,将byte强转为int不行吗?答案是不行的.

其原因在于:
1.byte的大小为8bits而int的大小为32bits
2.java的二进制采用的是补码形式

在这里先温习下计算机基础理论

byte是一个字节保存的，有8个位，即8个0、1。
8位的第一个位是符号位，
也就是说0000 0001代表的是数字1
1000 0000代表的就是-1
所以正数最大位0111 1111，也就是数字127
负数最大为1111 1111，也就是数字-128

上面说的是二进制原码，但是在java中采用的是补码的形式，下面介绍下什么是补码

1、反码：
        一个数如果是正，则它的反码与原码相同；
        一个数如果是负，则符号位为1，其余各位是对原码取反；

2、补码：利用溢出，我们可以将减法变成加法
       对于十进制数，从9得到5可用减法：
       9－4＝5    因为4+6＝10，我们可以将6作为4的补数
       改写为加法：
       9+6＝15（去掉高位1，也就是减10）得到5.

       对于十六进制数，从c到5可用减法：
       c－7＝5    因为7+9＝16 将9作为7的补数
       改写为加法：
       c+9＝15（去掉高位1，也就是减16）得到5.

    在计算机中，如果我们用1个字节表示一个数，一个字节有8位，超过8位就进1，在内存中情况为（100000000），进位1被丢弃。

    ⑴一个数为正，则它的原码、反码、补码相同
    ⑵一个数为负，刚符号位为1，其余各位是对原码取反，然后整个数加1
   
- 1的原码为                10000001
- 1的反码为                11111110
                                                   + 1
- 1的补码为                11111111

0的原码为                 00000000
0的反码为                 11111111（正零和负零的反码相同）
                                          +1
0的补码为               100000000（舍掉打头的1，正零和负零的补码相同）

Integer.toHexString的参数是int，如果不进行&0xff，那么当一个byte会转换成int时，由于int是32位，而byte只有8位这时会进行补位，
例如补码11111111的十进制数为-1转换为int时变为11111111111111111111111111111111好多1啊，呵呵！即0xffffffff但是这个数是不对的，这种补位就会造成误差。
和0xff相与后，高24比特就会被清0了，结果就对了。

----
Java中的一个byte，其范围是-128~127的，而Integer.toHexString的参数本来是int，如果不进行&0xff，那么当一个byte会转换成int时，对于负数，会做位扩展，举例来说，一个byte的-1（即0xff），会被转换成int的-1（即0xffffffff），那么转化出的结果就不是我们想要的了。

而0xff默认是整形，所以，一个byte跟0xff相与会先将那个byte转化成整形运算，这样，结果中的高的24个比特就总会被清0，于是结果总是我们想要的。

转自：http://franksinger.iteye.com/blog/614540