import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class InsertSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }       
    }

}
冒泡排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class BubbleSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=0;i<data.length;i++){
            for(int j=data.length-1;j>i;j--){
                if(data[j]<data[j-1]){
                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }

}

选择排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SelectionSort implements SortUtil.Sort {

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for (int i = 0; i < data.length; i++) {
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[lowIndex]) {
                    lowIndex = j;
                }
            }
            SortUtil.swap(data,i,lowIndex);
        }
    }

}

Shell排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ShellSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        for(int i=data.length/2;i>2;i/=2){
            for(int j=0;j<i;j++){
                insertSort(data,j,i);
            }
        }
        insertSort(data,0,1);
    }

    /**
     * @param data
     * @param j
     * @param i
     */
    private void insertSort(int[] data, int start, int inc) {
        int temp;
        for(int i=start+inc;i<data.length;i+=inc){
            for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
                SortUtil.swap(data,j,j-inc);
            }
        }
    }

}

快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class QuickSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        quickSort(data,0,data.length-1);       
    }
    private void quickSort(int[] data,int i,int j){
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);
       
        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);
       
    }
    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) {
        do{
           while(data[++l]<pivot);
           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l<r);
        SortUtil.swap(data,l,r);       
        return l;
    }

}
改进后的快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedQuickSort implements SortUtil.Sort {

    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] stack=new int[MAX_STACK_SIZE];
       
        int top=-1;
        int pivot;
        int pivotIndex,l,r;
       
        stack[++top]=0;
        stack[++top]=data.length-1;
       
        while(top>0){
            int j=stack[top--];
            int i=stack[top--];
           
            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];
           
            SortUtil.swap(data,pivotIndex,j);
           
            //partition
            l=i-1;
            r=j;
            do{
                while(data[++l]<pivot);
                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l<r);
            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);
           
            if((l-i)>THRESHOLD){
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD){
                stack[++top]=l+1;
                stack[++top]=j;
            }
           
        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /**
     * @param data
     */
    private void insertSort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }      
    }

}

归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class MergeSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }
   
    private void mergeSort(int[] data,int[] temp,int l,int r){
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++){
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++){
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]<temp[i2])
                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];           
        }
    }

}

改进后的归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedMergeSort implements SortUtil.Sort {

    private static final int THRESHOLD = 10;

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);

        for (i = l; i <= mid; i++) {
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) {
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) {
            if (a < b) {
                data[k] = temp[i++];
                a = temp[i];
            } else {
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }

    /**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) {
        for(int i=start+1;i<start+len;i++){
            for(int j=i;(j>start) && data[j]<data[j-1];j--){
                SortUtil.swap(data,j,j-1);
            }
        }
    }

}
堆排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class HeapSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        MaxHeap h=new MaxHeap();
        h.init(data);
        for(int i=0;i<data.length;i++)
            h.remove();
        System.arraycopy(h.queue,1,data,0,data.length);
    }

     private static class MaxHeap{
        
       
        void init(int[] data){
            this.queue=new int[data.length+1];
            for(int i=0;i<data.length;i++){
                queue[++size]=data[i];
                fixUp(size);
            }
        }
        
        private int size=0;

        private int[] queue;
               
        public int get() {
            return queue[1];
        }

        public void remove() {
            SortUtil.swap(queue,1,size--);
            fixDown(1);
        }
        //fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j]<queue[j+1])
                    j++;
                if (queue[k]>queue[j]) //不用交换
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j]>queue[k])
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }

    }

}

SortUtil:

package org.rut.util.algorithm;

import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SortUtil {
    public final static int INSERT = 1;

    public final static int BUBBLE = 2;

    public final static int SELECTION = 3;

    public final static int SHELL = 4;

    public final static int QUICK = 5;

    public final static int IMPROVED_QUICK = 6;

    public final static int MERGE = 7;

    public final static int IMPROVED_MERGE = 8;

    public final static int HEAP = 9;

    public static void sort(int[] data) {
        sort(data, IMPROVED_QUICK);
    }
    private static String[] name={
            "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
    };
   
    private static Sort[] impl=new Sort[]{
            new InsertSort(),
            new BubbleSort(),
            new SelectionSort(),
            new ShellSort(),
            new QuickSort(),
            new ImprovedQuickSort(),
            new MergeSort(),
            new ImprovedMergeSort(),
            new HeapSort()
    };

    public static String toString(int algorithm){
        return name[algorithm-1];
    }
   
    public static void sort(int[] data, int algorithm) {
        impl[algorithm-1].sort(data);
    }

    public static interface Sort {
        public void sort(int[] data);
    }

    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

====================http://www.glgg.net/blog===================zsjnju@hotmail.com================ 开发java应用出现乱码是很常见的，毕竟现在unicode的使用还不是很广泛，在使用gb2312（包含了gbk简体，big5繁体）的系统中要正确实现 中文的display和数据库的存储是最基本的要求。 ========================http://www.glgg.net/blog======================================= 1，首先developer要明确自己为什么会遇到乱码，遇到什么样的乱码（无意义的符号还是一串问号或者其它什么东西）。新手遇到一堆很乱的字符时通常不知所措，最直接的反映就是打开google搜索”java中文”（这个字符串在搜索引擎上的查询频率非常高）， 然后一个一个的去看别人的解决方法。这样做没有错，但是很难达到目的，原因下面会提到。总之，出现乱码的原因是非常多的，解决的方法也完全不一样，要解决

====================http://www.babatu.com===================babatu@gmail.com================
开发java应用出现乱码是很常见的，毕竟现在unicode的使用还不是很广泛，在使用gb2312（包含了gbk简体，big5繁体）的系统中要正确实现

中文的display和数据库的存储是最基本的要求。

========================http://www.babatu.com=======================================
1，首先developer要明确自己为什么会遇到乱码，遇到什么样的乱码（无意义的符号还是一串问号或者其它什么东西）。
新手遇到一堆很乱的字符时通常不知所措，最直接的反映就是打开google搜索”java中文”（这个字符串在搜索引擎上的查询频率非常高），

然后一个一个的去看别人的解决方法。这样做没有错，但是很难达到目的，原因下面会提到。
总之，出现乱码的原因是非常多的，解决的方法也完全不一样，要解决问题必须先分析自己的”上下文环境”。

========================http://www.babatu.com=====================================
2，具体说来，需要哪些信息才能确定项目中的乱码的根源。
a，开发者所用的操作系统
b，j2ee容器的名称，版本
c，数据库的名称，版本（精确版本）以及jdbc驱动的版本
d，出现乱码的source code（比如是system out 出来的，还是jsp页面中的，如果是jsp中的，那么头部声明的情况也很重要）

=========================http://www.glgg.net/blog========================================
3，如何初步分析乱码出现的原因。
有了上述的信息，基本上就可以发帖求助了，相信放到javaworld等论坛上，很快就会有高手给你提出有效的解决方案的。
当然不能总靠发帖求助，也要试试自行解决问题。如何下手呢？
a，分析一下你的”乱码”到底是什么编码。这个其实不难，比如
System.out.println(testString);
这一段出现了乱码，那么不妨用穷举法猜测一下它的实际编码格式。
System.out.println(new String(testString.getBytes(”ISO-8859-1″),”gb2312″));
System.out.println(new String(testString.getBytes(”UTF8″),”gb2312″));
System.out.println(new String(testString.getBytes(”GB2312″),”gb2312″));
System.out.println(new String(testString.getBytes(”GBK”),”gb2312″));
System.out.println(new String(testString.getBytes(”BIG5″),”gb2312″));
等等，上述代码的意思是用制定的编码格式去读取testString这个”乱码”，并转换成gb2312（此处仅以中文为例）
然后你看哪一个转换出来的结果是ok的，那就。。。

b，如果用上面的步骤能得到正确的中文，说明你的数据肯定是在的，只不过是界面中没有正确显示而已。那么第二步就该纠正你的view部分了

，通常需要检查的是jsp中是否选择了正确的页面编码。

在此要声明被很多人误解的一点，那就是<%@ page contentType=”text/html; charset=GB2312″ %>指令和<META http-equiv=Content-Type

content=”text/html; charset=gb2312″>两者的不同。通常网上的很多文章在提到中文问题时都是说数据库中选择unicode或者gb2312存储，同

时在jsp中用page指令声明编码就可以解决。但是我觉得这种说法很不负责任，害的我费了N多时间为本来并不存在的乱码而郁闷。实际上page

的作用是在jsp被编译成为html的过程中提供编码方式让java来”读取”表达式当中的String（有点类似于上面的第三个语句的作用），而meta

的作用是众所周知的为IE浏览器提供编码选择，是用来”显示”最后的数据的。但是没有看到有人提醒这一点，我一直把page当成meta在用，

导致本来是iso-8859的数据，被page指令读成gb2312，于是乱码，所以又加了编码转化的函数把所有的string数据都从iso8859转到gb2312（为

什么这么转，当时也没考虑这么多，因为这么做可以正常显示了，所以就这么改了，呵呵当时实在没有时间慢慢排查问题了）。

===========================http://www.glgg.net/blog==========================================
4，数据库选择什么样的编码比较好。
目前流行的DB主要有sql server，mysql，oracle，DB2等，其中mysql作为免费DB中的老大，性能和功能是得到公认的，安装配置比较方便，相

应的driver也比较完善，性价比是绝对的OK。所以就以mysql为例。

我个人建议采用mysql的默认编码来存储，也就是iso-8859-1（在mysql的选项中对应于latin-1）。理由主要有这么几个，一是iso-8859-1对中

文的支持不错；二是跟java中的默认编码一致，至少在很多地方免除了转换编码的麻烦；三是默认的比较稳定，兼容性也更好，因为多编码的

支持是由具体的DB产品提供的，别说跟其它的DB会不兼容，即使自身的不同版本也可能出现兼容性的问题。

例如mysql 4.0以前的产品中，很多中文的解决方案是利用connection中的characterEncoding字段来制定编码，比如gb2312什么的，这样是ok

的，因为原数据都是ISO8859_1编码，jdbc驱动会采用url里面指定的character set来进行编码，resultSet.getString(*)取出的就是编码后的

字符串。这样就直接拿到gb2312的数据了。

但是mysql 4.1的推出给很多dbadmin带来了不小的麻烦，因为mysql4.1支持column level的character set，每个table,column都可以指定编码

，不指定就是ISO8895_1，因此jdbc取出数据后会根据column的character set来进行编码，而不再是用一个全局的参数来取所有的数据了。

这从另一个方面也说明了乱码问题的产生实在是很复杂的事情，原因太多了。我也只是针对自己遇到的实际情况提供一些解决思路，有什么错

误的地方请email至zsjnju@hotmail.com.希望能更多的看到达人自己的文章，而不是一堆以讹传讹的拷贝。
Internel Use Only.
Any Question,please reffer to zsjnju@hotmail.com
================================http://www.glgg.net/blog======================================

终于找到最完美的解决中文问题的方案了。。。谢谢网上的这个文章的作者。。。
我的原文是根据自己的经验总结出来的。虽然没什么错误，但是始终没有找到最终的病根。看了这个文章之后，开始恍然大悟，哈哈，
———————————————————————————————————————————————————————————-

由于Java编程中的中文问题是一个老生常谈的问题，在阅读了许多关于Java中文问题解决方法之后，结合作者的编程实践，我发现过去谈的许多方法都不能清晰地说明问题及解决问题，尤其是跨平台时的中文问题。
于是我给出此篇文章，内容包括对控制台运行的class、Servelets、JSP及EJB类中的中文问题我剖析和建议解决办法。希望大家指教。

Abstract：本文深入分析了Java程序设计中Java编译器对Java源文件和JVM对class类文件的编码/解码过程，通过此过程的解析透视出了Java编程中中文问题产生的根本原因，最后给出了建议的最优化的解决Java中文问题的方法。

1、中文问题的来源

计算机最初的操作系统支持的编码是单字节的字符编码，于是，在计算机中一切处理程序最初都是以单字节编码的英文为准进行处理。

随着计算机的发展，为了适应世界其它民族的语言（当然包括我们的汉字），人们提出了UNICODE编码，它采用双字节编码，兼容英文字符和其它民族的双字节字符编码，所以，目前，大多数国际性的软件内部均采用UNICODE编码，在软件运行时，它获得本地支持系统（多数时间是操作系统）默认支持的编码格式，然后再将软件内部的UNICODE转化为本地系统默认支持的格式显示出来。

Java的JDK和JVM即是如此，我这里说的JDK是指国际版的JDK，我们大多数程序员使用的是国际化的JDK版本，以下所有的JDK均指国际化的JDK版本。我们的汉字是双字节编码语言，为了能让计算机处理中文，我们自己制定的gb2312、GBK、GBK2K等标准以适应计算机处理的需求。

所以，大部分的操作系统为了适应我们处理中文的需求，均定制有中文操作系统，它们采用的是GBK,GB2312编码格式以正确显示我们的汉字。如：中文Windows默认采用的是GBK编码显示，在中文Windows2000中保存文件时默认采用的保存文件的编码格式也是GBK的，即所有在中文Windows2000中保存的文件它的内部编码默认均采用GBK编码，注意：GBK是在GB2312基础上扩充来的。

由于Java语言内部采用UNICODE编码，所以在Java程序运行时，就存在着一个从UNICODE编码和对应的操作系统及浏览器支持的编码格式转换输入、输出的问题，这个转换过程有着一系列的步骤，如果其中任何一步出错，则显示出来的汉字就会出是乱码，这就是我们常见的Java中文问题。

同时，Java是一个跨平台的编程语言，也即我们编写的程序不仅能在中文windows上运行，也能在中文Linux等系统上运行，同时也要求能在英文等系统上运行（我们经常看到有人把在中文Windows2000上编写的Java程序，移植到英文Linux上运行）。这种移植操作也会带来中文问题。

还有，有人使用英文的操作系统和英文的IE等浏览器，来运行带中文字符的程序和浏览中文网页，它们本身就不支持中文，也会带来中文问题。

几乎所有的浏览器默认在传递参数时都是以UTF-8编码格式来传递，而不是按中文编码传递，所以，传递中文参数时也会有问题，从而带来乱码现象。

总之，以上几个方面是Java中的中文问题的主要来源，我们把以上原因造成的程序不能正确运行而产生的问题称作：Java中文问题。

2、Java编码转换的详细过程

我们常见的Java程序包括以下类别：

*直接在console上运行的类(包括可视化界面的类)

*JSP代码类（注：JSP是Servlets类的变型）

*Servelets类

*EJB类

*其它不可以直接运行的支持类

这些类文件中，都有可能含有中文字符串，并且我们常用前三类Java程序和用户直接交互，用于输出和输入字符，如：我们在JSP和Servlet中得到客户端送来的字符，这些字符也包括中文字符。无论这些Java类的作用如何，这些Java程序的生命周期都是这样的：

*编程人员在一定的操作系统上选择一个合适的编辑软件来实现源程序代码并以.Java扩展名保存在操作系统中，例如我们在中文Windows2000中用记事本编辑一个Java源程序。

*编程人员用JDK中的Javac.exe来编译这些源代码，形成.class类(JSP文件是由容器调用JDK来编译的)。

*直接运行这些类或将这些类布署到WEB容器中去运行，并输出结果。

那么，在这些过程中，JDK和JVM是如何将这些文件如何编码和解码并运行的呢？

这里，我们以中文Windows2000操作系统为例说明Java类是如何来编码和被解码的。

第一步，我们在中文Windows2000中用编辑软件如记事本编写一个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(”file.encoding”);
　　System.out.println(encoding);
　　}
}

　　第二步，我们用JDK的Javac.exe文件编译我们的Java源程序，由于JDK是国际版的，在编译的时候，如果我们没有用-encoding参数指定我们的Java源程序的编码格式，则Javac.exe首先获得我们操作系统默认采用的编码格式，也即在编译Java程序时，若我们不指定源程序文件的编码格式，JDK首先获得操作系统的file.encoding参数(它保存的就是操作系统默认的编码格式，如Windows2000，它的值为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类，并保存在临时文件夹中。

如：在中文Windows2000上，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×8140-0xfefe，所有的字符可以一一对应到UNICODE2.0中来。

再次，对于放在操作系统中的.Java源程序文件，在编译时，我们可以指定它内容的编码格式，具体来说用-encoding来指定。注意：如果源程序中含有中文字符，而你用-encoding指定为其它的编码字符，显然是要出错的。

用-encoding指定源文件的编码方式为GBK或gb2312，无论我们在什么系统上编译含有中文字符的Java源程序都不会有问题，它都会正确地将中文转化为UNICODE存储在class文件中。

然后，我们必须清楚，几乎所有的WEB容器在其内部默认的字符编码格式都是以ISO-8859-1为默认值的，同时，几乎所有的浏览器在传递参数时都是默认以UTF-8的方式来传递参数的。

所以，虽然我们的Java源文件在出入口的地方指定了正确的编码方式，但其在容器内部运行时还是以ISO-8859-1来处理的。

4、中文问题的分类及其建议最优解决办法

了解以上Java处理文件的原理之后，我们就可以提出了一套建议最优的解决汉字问题的办法。我们的目标是：我们在中文系统中编辑的含有中文字符串或进行中文处理的Java源程序经编译后可以移值到任何其它的操作系统中正确运行，或拿到其它操作系统中编译后能正确运行，能正确地传递中文和英文参数，能正确地和数据库交流中英文字符串。我们的具体思路是：在Java程序转码的入口和出口及Java程序同用户有输入输出转换的地方限制编码方法使之正确即可。

具体解决办法如下：

1、 针对直接在console上运行的类

对于这种情况，我们建议在程序编写时，如果需要从用户端接收用户的可能含有中文的输入或含有中文的输出，程序中应该采用字符流来处理输入和输出，具体来说，应用以下面向字符型节点流类型：

对文件：FileReader，FileWrieter

其字节型节点流类型为：FileInputStream，FileOutputStream

对内存（数组）：CharArrayReader，CharArrayWriter

其字节型节点流类型为：ByteArrayInputStream，ByteArrayOutputStream

对内存（字符串）：StringReader，StringWriter

对管道：PipedReader，PipedWriter

其字节型节点流类型为：PipedInputStream，PipedOutputStream

同时，应该用以下面向字符型处理流来处理输入和输出：

BufferedWriter，BufferedReader

其字节型的处理流为：BufferedInputeStream，BufferedOutputStream

InputStreamReader，OutputStreamWriter

其字节型的处理流为：DataInputStream，DataOutputStream

其中InputStreamReader和InputStreamWriter用于将字节流按照指定的字符编码集转换到字符流，如：

InputStreamReader in = new InputStreamReader(System.in，”GB2312″)； OutputStreamWriter out = new OutputStreamWriter (System.out，”GB2312″)；例如：采用如下的示例Java编码就达到了要求：

//Read.Java
import Java.io.*;
public class Read
{
public static void main(String[] args)
throws IOException
{
String str =
“\n中文测试，这是内部硬编码的串
“+”\ntest english character”;
String strin= “”;
BufferedReader stdin =
new BufferedReader(new
InputStreamReader(System.in,”gb2312″));
//设置输入接口按中文编码
BufferedWriter stdout =
new BufferedWriter(new
OutputStreamWriter(System.out,”gb2312″));
//设置输出接口按中文编码
stdout.write(”请输入:”);
stdout.flush();
strin = stdin.readLine();
stdout.write(”这是从用户输入的串：”+strin);
stdout.write(str);
stdout.flush();
}}

同时，在编译程序时，我们用以下方式来进行：

Javac -encoding gb2312 Read.Java

　 2、针对EJB类和不可以直接运行的支持类(如JavaBean类)

由于这种类它们本身被其它的类调用，不直接与用户交互，故对这种类来说，我们的建议的处理方式是内部程序中应该采用字符流来处理程序内部的中文字符串（具体如上面一节中一样），同时，在编译类时用-encoding gb2312参数指示源文件是中文格式编码的即可。

3、针对Servlet类

针对Servlet，我们建议用以下方法：

在编译Servlet类的源程序时，用-encoding指定编码为GBK或GB2312，且在向用户输出时的编码部分用response对象的setContentType(”text/html;charset=GBK”);或gb2312来设置输出编码格式，同样在接收用户输入时，我们用request.setCharacterEncoding(”GB2312″)；这样无论我们的servlet类移植到什么操作系统中，只有客户端的浏览器支持中文显示，就可以正确显示。如下是一个正确的示例：

//HelloWorld.Java
package hello;
import Java.io.*;
import Javax.servlet.*;
import Javax.servlet.http.*;
public class HelloWorld
extends HttpServlet
{
public void init()
throws ServletException
{
}
public void doGet
(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException
{
request.setCharacterEncoding(”GB2312″);
//设置输入编码格式
response.setContentType
(”text/html;charset=GB2312″);
//设置输出编码格式
PrintWriter out = response.getWriter();
//建议使用PrintWriter输出
out.println(”<hr>”);
out.println(”Hello World!
This is created by Servlet!测试中文!”);
out.println(”<hr>”);
}
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException
{
request.setCharacterEncoding(”GB2312″);
//设置输入编码格式
response.setContentType
(”text/html;charset=GB2312″);
//设置输出编码格式
String name = request.getParameter(”name”);
String id = request.getParameter(”id”);
if(name==null) name=”";
if(id==null) id=”";
PrintWriter out = response.getWriter();
//建议使用PrintWriter输出
out.println(”<hr>”);
out.println(”你传入的中文字串是：” + name);
out.println(”<hr>你输入的id是：” + id);
out.println(”<hr>”);
}
public void destroy()
{
}
}


请用Javac -encoding gb2312 HelloWorld.Java来编译此程序。

测试此Servlet的程序如下所示：

<%@page contentType=”text/html;
charset=gb2312″%>
<%request.setCharacterEncoding(”GB2312″);%>
<html><head><title></title>
<Script language=”JavaScript”>
function Submit()
{
//通过URL传递中文字符串值给Servlet
document.base.action =
“./HelloWorld?name=中文”;
document.base.method = “POST”;
document.base.submit();
}
</Script>
</head>

<body bgcolor=”#FFFFFF”
text=”#000000″ topmargin=”5″>
<form name=”base” method =
“POST” target=”_self”>
<input name=”id” type=”text”
value=”" size=”30″>
<a href = “JavaScript:Submit()”>
传给Servlet</a>
</form></body></html>


　　4、Java程序和数据库之间

为避免Java程序和数据库之间数据传递出现乱码现象，我们建议采用以下最优方法来处理：

1、对于Java程序的处理方法按我们指定的方法处理。

2、把数据库默认支持的编码格式改为GBK或GB2312的。

如：在mysql中，我们可以在配置文件my.ini中加入以下语句实现：

在[mysqld]区增加：

default-character-set=gbk

并增加：

[client]
default-character-set=gbk

在SQL Server2K中，我们可以将数据库默认的语言设置为Simplified Chinese来达到目的。

5、针对JSP代码

由于JSP是在运行时，由WEB容器进行动态编译的，如果我们没有指定JSP源文件的编码格式，则JSP编译器会获得服务器操作系统的file.encoding值来对JSP文件编译的，它在移植时最容易出问题，如在中文Windows2000中可以很好运行的jsp文件拿到英文linux中就不行，尽管客户端都是一样的，那是因为容器在编译JSP文件时获取的操作系统的编码不同造成的（在中文wink中的file.encoding和在英文Linux中file.encoding是不同的，且英文Linux的file.encoding对中文不支持，所以编译出来的JSP类就会有问题）。

网络上讨论的大多数是此类问题，多是因为JSP文件移植平台时不能正确显示的问题，对于这类问题，我们了解了Java中程序编码转换的原理，解决起来就容易多了。我们建议的解决办法如下：

1、我们要保证JSP向客户端输出时是采用中文编码方式输出的，即无论如何我们首先在我们的JSP源代编中加入以下一行：

<%@page contentType=”text/html;
charset=gb2312″%>

2、为了让JSP能正确获得传入的参数，我们在JSP源文件头加入下面一句：

<%request.setCharacterEncoding(”GB2312″);
%>

　 3、为了让JSP编译器能正确地解码我们的含有中文字符的JSP文件，我们需要在JSP源文件中指定我们的JSP源文件的编码格式，具体来说，我们在JSP源文件头上加入下面的一句即可：

<%@page pageEncoding=”GB2312″%>
或<%@page pageEncoding=”GBK”%>

　这是JSP规范2.0新增加的指令。

我们建议使用此方法来解JSP文件中的中文问题，下面的代码是一个正确做法的JSP文件的测试程序：

//testchinese.jsp
<%@page pageEncoding=”GB2312″%>
<%@page contentType=”text/html;
charset=gb2312″%>
<%request.setCharacterEncoding(”GB2312″);
%>
<%
String action = request.getParameter(”ACTION”);
String name = “”;
String str = “”;
if(action!=null && action.equals(”SENT”))
{
name = request.getParameter(”name”);
str = request.getParameter(”str”);
}
%>
<html>
<head>
<title></title>
<Script language=”JavaScript”>
function Submit()
{
document.base.action =
“?ACTION=SENT&str=传入的中文”;
document.base.method = “POST”;
document.base.submit();
}
</Script>
</head>
<body bgcolor=”#FFFFFF”
text=”#000000″ topmargin=”5″>
<form name=”base” method =
“POST” target=”_self”>
<input type=”text” name=”name”
value=”" size=”30″>
<a href = “JavaScript:Submit()”>提交</a>
</form>
<%
if(action!=null && action.equals(”SENT”))
{
out.println(”<br>你输入的字符为：”+name);
out.println(”<br>你通过URL传入的字符为：”+str);
}
%>
</body>
</html>

jsp的中文乱码问题的解决

<%@page contentType="text/html; charset=gb2312"%>

<%request.setCharacterEncoding("GB2312");%>

<%@page pageEncoding="GB2312"%>
或
<%@page pageEncoding="GBK"%>

//testchinese.jsp
<%@page pageEncoding="GB2312"%>
<%@page contentType="text/html; charset=gb2312"%>
<%request.setCharacterEncoding("GB2312");%>
<%
String action = request.getParameter("ACTION");
String name = "";
String str = "";
if(action!=null && action.equals("SENT"))
{
name = request.getParameter("name");
str = request.getParameter("str");
}
%>
<html>
<head>

<Script language="JavaScript">
function Submit()
{
document.base.action = "?ACTION=SENT&str=传入的中文";
document.base.method = "POST";
document.base.submit();
}
</Script>
</head>
<body bgcolor="#FFFFFF" text="#000000" topmargin="5">
提交
<%
if(action!=null && action.equals("SENT"))
{
out.println("你输入的字符为："+name);
out.println("你通过URL传入的字符为："+str);
}
%>
</body>
</html>