java编码

Unicode字 符在某个平台上不存在，将会输出一个'?'。
GB2312编码中一个汉字是16位的，而UTF8中一个汉字却是24位的。
如果发出页面采用了UTF-8的编码，怎样实现转换到gb2312？

private String utf8Togb2312(String str){
      StringBuffer sb = new StringBuffer();
      for(int i=0; i<str.length(); i++) {
          char c = str.charAt(i);
          switch (c) {
             case '+':
                 sb.append(' ');
             break;
             case '%':
                 try {
                      sb.append((char)Integer.parseInt(
                      str.substring(i+1,i+3),16));
                 }
                 catch (NumberFormatException e) {
                     throw new IllegalArgumentException();
                }
                i += 2;
                break;
             default:
                sb.append(c);
                break;
           }
      }
      // Undo conversion to external encoding
      String result = sb.toString();
      String res=null;
      try{
          byte[] inputBytes = result.getBytes("8859_1");
          res= new String(inputBytes,"UTF-8");
      }
      catch(Exception e){}
      return res;
}


UTF8转换成GB2312 当我们在基于HTTP协议的JSP或Servlet的应用中获取数据或发送请求时，JVM会把输送的数据编码成UTF8格式。如果我们直接从HTTP流中 提取中文数据，提取的结果为“????”（可能更多问号），为转换成我们能够理解的中文字符，我们需要把UTF8转换成GB2312，借助ISO- 8859-1标准编码能够轻易的实现，下面的代码实现了这一功能：

byte [] b;
String utf8_value;
utf8_value = request.getParameter("NAME");//从HTTP流中取"NAME"的UTF8数据
b = utf8_value.getBytes("8859_1"); //中间用ISO-8859-1过渡
String name = new String(b, "GB2312"); //转换成GB2312字符

这是我做的一个项目程序的一段：
      byte[] b;
      String gbk_value;
      gbk_value=request.getParameter("address");//从HTTP流中取"name"的GBK数据（由于web.xml中过滤器设置默认编码为GBK，所以外网从UTF-8变为GBK）
      b=gbk_value.getBytes("GBK");//中间用GBK过渡，从GBK转换成GBK数组
      String address=new String(b,"utf-8");//转换成utf-8字符
      myform.setAddress(address);

在知道流长度的情况下将输入流转换成字节数组 Java中的输入流抽象类InputStream有int read(byte[] b, int off, int len)方法，参数中byte[] b是用来存放从InputStream中读取的数据,int off指定数组b的偏移地址，也就是数组b的起始下标，int len指定需要读取的长度，方法返回实际读取的字节数。

刚学Java 的朋友可能要说：先定义一个与流长度等长的字节数组，调用read方法，指定起始下标为0，指定读取长度与数组长度等长，不是一下子可以读出来了吗？说的 没错，笔者曾经也试着这样读取数据，但后来发现在读取网络数据时很不安全，我们想想在网络上获取数据可能并没那么流畅，数据流的传送可能会断断续续，所以 并不能保证一次就能读取全部数据，特别是在读取大容量数据时更是如此，所以我们必须在读取数据时检测实际读到的长度，如果没有读完已知长度的数据就应该再 次读取，以此循环检测，直到实际读取的长度累加与已知的长度相等，下面的代码实现了这一功能：

UTF8到GBK的相互转换          
<%
              String str="你好莱坞";
              out.print(enCode(str));
              out.print("<br/>"+deCode(enCode(str)));
           %>

<%!
String enCode(String str)                                   
      {                                                       
        if(str==null)return "";                               
        String hs="";                                         
                                                            
        try                                                   
        {                                                     
          byte b[]=str.getBytes("UTF-16");                    
          //System.out.println(byte2hex(b));                  
          for (int n=0;n<b.length;n++)                        
          {                                                   
              str=(java.lang.Integer.toHexString(b[n] & 0XFF));
              if (str.length()==1)                            
                hs=hs+"0"+str;                                
              else                                            
                hs=hs+str;                                    
              if (n!=b.length-1)hs=hs+"";                     
          }                                                   
                                                              
          str= hs.toUpperCase().substring(4);                 
          //System.out.println(str);                          
          char[] chs=str.toCharArray();                       
          str="";                                             
          for(int i=0;i<chs.length;i=i+4)                     
          {                                                   
            str+="&#x"+chs[i]+chs[i+1]+chs[i+2]+chs[i+3]+";"; 
          }                                                   
                                                              
        }                                                     
        catch(Exception e)                                    
        {                                                     
          System.out.print(e.getMessage());                   
        }                                                     
        return str;                                           
      }            


String deCode(String str)                                                
    {                                                                                                          
        if (str == null)                                               
        {                                                              
            return "";                                                   
        }                                                              
        String temp = "";                                              
        String return_temp = "";                                       
        try                                                            
        {                                                              
            int str_len = str.length() / 7;                              
            for (int i = 1; i <= str_len; i++)                           
            {                                                            
                temp += str.substring(3 * i + 5 * (i - 1), 7 * i + (i - 1));
            }                                                            
            temp = "FEFF" + temp;                                        
            temp = temp.toLowerCase();                                   
            int temp_len = temp.length() / 2;                            
            byte mm[] = new byte[temp_len];                              
            String ss[] = new String[temp_len];                          
            for (int i = 0; i < temp_len; i++)                           
            {                                                            
                String qq = temp.substring(i * 2, i * 2 + 1);              
                if (!qq.equals("0"))                                       
                {                                                          
                    ss[i] = temp.substring(i * 2, i * 2 + 2);                
                }                                                          
                else                                                       
                {                                                          
                    ss[i] = temp.substring(i * 2 + 1, i * 2 + 2);            
                }                                                          
                mm[i] = (byte) Integer.parseInt(ss[i], 16);                
                System.out.println(mm[i]);                                 
            }                                                            
            return_temp = new String(mm, "UTF-16");                      
        }                                                              
        catch (Exception e)                                            
        {                                                              
            System.out.print(e.getMessage());                            
        }                                                              
        return return_temp;                                            
    }                                       
   


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yown/archive/2007/05/15/1610010.aspx