hex解码然后写输出流

来源:http://www.iteye.com/


  
  1. /*  
  2.  * @(#)TestHex.java  
  3.  *  
  4.  * Summary: Demonstrate how to handle hex strings.  
  5.  *  
  6.  * Copyright: (c) 2009-2010 Roedy Green, Canadian Mind Products, http://mindprod.com  
  7.  *  
  8.  * Licence: This software may be copied and used freely for any purpose but military.  
  9.  *          http://mindprod.com/contact/nonmil.html  
  10.  *  
  11.  * Requires: JDK 1.6+  
  12.  *  
  13.  * Created with: IntelliJ IDEA IDE.  
  14.  *  
  15.  * Version History:  
  16.  *  1.0 2009-06-05 - initial version.  
  17.  */ 
  18. package com.mindprod.example;  
  19.  
  20.  
  21. import static java.lang.System.out;  
  22.  
  23. /**  
  24.  * Demonstrate how to handle hex strings.  
  25.  *  
  26.  * @author Roedy Green, Canadian Mind Products  
  27.  * @version 1.0 2009-06-05 - initial version.  
  28.  * @since 2009-06-05  
  29.  */ 
  30. public final class TestHex  
  31.     {  
  32.     /**  
  33.      * precomputed translate table for chars 0..'f'  
  34.      */ 
  35.     private static byte[] correspondingNibble = new byte['f' + 1];  
  36. // -------------------------- PUBLIC STATIC METHODS --------------------------  
  37.  
  38.     /**  
  39.      * Convert a hex string to an unsigned byte array.  
  40.      * Permits upper or lower case hex.  
  41.      *  
  42.      * @param s String must have even number of characters.  
  43.      *          and be formed only of digits 0-9 A-F or  
  44.      *          a-f. No spaces, minus or plus signs.  
  45.      *  
  46.      * @return corresponding unsigned byte array. see http://mindprod.com/jgloss/unsigned.html  
  47.      */ 
  48.     public static byte[] fromHexString( String s )  
  49.         {  
  50.         int stringLength = s.length();  
  51.         if ( ( stringLength & 0x1 ) != 0 )  
  52.             {  
  53.             throw new IllegalArgumentException( "fromHexString requires an even number of hex characters" );  
  54.             }  
  55.         byte[] bytes = new byte[stringLength / 2];  
  56.  
  57.         for ( int i = 0, j = 0; i < stringLength; i += 2, j++ )  
  58.             {  
  59.             int high = charToNibble( s.charAt( i ) );  
  60.             int low = charToNibble( s.charAt( i + 1 ) );  
  61.             // You can store either unsigned 0..255 or signed -128..127 bytes in a byte type.  
  62.             bytes[ j ] = ( byte ) ( ( high << 4 ) | low );  
  63.             }  
  64.         return bytes;  
  65.         }  
  66.  
  67. // -------------------------- STATIC METHODS --------------------------  
  68.  
  69.     static 
  70.         {  
  71.         // only 0..9 A..F a..f have meaning. rest are errors.  
  72.         for ( int i = 0; i <= 'f'; i++ )  
  73.             {  
  74.             correspondingNibble[ i ] = -1;  
  75.             }  
  76.         for ( int i = '0'; i <= '9'; i++ )  
  77.             {  
  78.             correspondingNibble[ i ] = ( byte ) ( i - '0' );  
  79.             }  
  80.         for ( int i = 'A'; i <= 'F'; i++ )  
  81.             {  
  82.             correspondingNibble[ i ] = ( byte ) ( i - 'A' + 10 );  
  83.             }  
  84.         for ( int i = 'a'; i <= 'f'; i++ )  
  85.             {  
  86.             correspondingNibble[ i ] = ( byte ) ( i - 'a' + 10 );  
  87.             }  
  88.         }  
  89.  
  90.     /**  
  91.      * convert  a single char to corresponding nibble using a precalculated array.  
  92.      * Based on code by:  
  93.      * Brian Marquis  
  94.      * Orion Group Software Engineers http://www.ogse.com  
  95.      *  
  96.      * @param c char to convert. must be 0-9 a-f A-F, no  
  97.      *          spaces, plus or minus signs.  
  98.      *  
  99.      * @return corresponding integer  0..15  
  100.      * @throws IllegalArgumentException on invalid c.  
  101.      */ 
  102.     private static int charToNibble( char c )  
  103.         {  
  104.         if ( c > 'f' )  
  105.             {  
  106.             throw new IllegalArgumentException( "Invalid hex character: " + c );  
  107.             }  
  108.         int nibble = correspondingNibble[ c ];  
  109.         if ( nibble < 0 )  
  110.             {  
  111.             throw new IllegalArgumentException( "Invalid hex character: " + c );  
  112.             }  
  113.         return nibble;  
  114.         }  
  115.  
  116.     /**  
  117.      * code not used, for explanation only.  
  118.      * convert a single char to corresponding nibble.  
  119.      * Slow version, easier to understand.  
  120.      *  
  121.      * @param c char to convert. must be 0-9 a-f A-F, no  
  122.      *          spaces, plus or minus signs.  
  123.      *  
  124.      * @return corresponding integer  
  125.      */ 
  126.     private static int slowCharToNibble( char c )  
  127.         {  
  128.         if ( '0' <= c && c <= '9' )  
  129.             {  
  130.             return c - '0';  
  131.             }  
  132.         else if ( 'a' <= c && c <= 'f' )  
  133.             {  
  134.             return c - 'a' + 0xa;  
  135.             }  
  136.         else if ( 'A' <= c && c <= 'F' )  
  137.                 {  
  138.                 return c - 'A' + 0xa;  
  139.                 }  
  140.             else 
  141.                 {  
  142.                 throw new IllegalArgumentException( "Invalid hex character: " + c );  
  143.                 }  
  144.         }  
  145.  
  146. // --------------------------- main() method ---------------------------  
  147.  
  148.     /**  
  149.      * Test harness  
  150.      *  
  151.      * @param args not used  
  152.      */ 
  153.     public static void main( String[] args )  
  154.         {  
  155.         String hexString = "FFD8FFE000104A46494600010100000100010000FFDB0043000503040404030504040405050506070C08070707070F";  
  156.         out.println( hexString );  
  157.         // convert hex string to an array of bytes  
  158.         byte[] bytes = fromHexString( hexString );  
  159.         out.println( bytes.length + " bytes long" );  
  160. try{  
  161.         OutputStream os=new FileOutputStream("d:\a.data");  
  162. os.write(bytes);  
  163. os.flush();  
  164. os.close();  
  165. }catch(Exception ex){  
  166. ex.printStackTrace();  
  167. }  
  168.         }  
  169.     }