2014年8月16日 星期六

JAVA Base64 Encode/Decode

JAVA Base64 Encode/Decode


 


找到JAVA Base64 Encode/Decode並在http://www.compileonline.com/compile_java_online.php線上驗證ok,趕緊備份。



 




 


/*
 * Base64.java
 *
 * Brazil project web application toolkit,
 * export version: 2.0 
 * Copyright (c) 2000-2002 Sun Microsystems, Inc.
 *
 * Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is included as
 * the file "license.terms", and also available at
 * http://www.sun.com/
 * 
 * The Original Code is from:
 *    Brazil project web application toolkit release 2.0.
 * The Initial Developer of the Original Code is: cstevens.
 * Portions created by cstevens are Copyright (C) Sun Microsystems,
 * Inc. All Rights Reserved.
 * 
 * Contributor(s): cstevens, suhler.
 *
 * Version:  1.9
 * Created by cstevens on 00/04/17
 * Last modified by suhler on 02/07/24 10:49:48
 */


//http://www.herongyang.com/encoding/Base64-Sun-Java-Implementation.html

/**
 * Utility to base64 encode and decode a string.
 * @author      Stephen Uhler
 * @version    1.9, 02/07/24
 */


public class Base64 {
    static byte[] encodeData;
    static String charSet = 
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    
    static {
        encodeData = new byte[64];
    for (int i = 0; i<64; i++) {
        byte c = (byte) charSet.charAt(i);
        encodeData[i] = c;
    }
    }

    private Base64() {}

    /**
     * base-64 encode a string
     * @param s        The ascii string to encode
     * @returns        The base64 encoded result
     */


    public static String
    encode(String s) {
        return encode(s.getBytes());
    }

    /**
     * base-64 encode a byte array
     * @param src    The byte array to encode
     * @returns        The base64 encoded result
     */


    public static String
    encode(byte[] src) {
    return encode(src, 0, src.length);
    }

    /**
     * base-64 encode a byte array
     * @param src    The byte array to encode
     * @param start    The starting index
     * @param len    The number of bytes
     * @returns        The base64 encoded result
     */


    public static String
    encode(byte[] src, int start, int length) {
        byte[] dst = new byte[(length+2)/3 * 4 + length/72];
        int x = 0;
        int dstIndex = 0;
        int state = 0;    // which char in pattern
        int old = 0;    // previous byte
        int len = 0;    // length decoded so far
    int max = length + start;
        for (int srcIndex = start; srcIndex<max; srcIndex++) {
        x = src[srcIndex];
        switch (++state) {
        case 1:
            dst[dstIndex++] = encodeData[(x>>2) & 0x3f];
        break;
        case 2:
            dst[dstIndex++] = encodeData[((old<<4)&0x30) 
                | ((x>>4)&0xf)];
        break;
        case 3:
            dst[dstIndex++] = encodeData[((old<<2)&0x3C) 
                | ((x>>6)&0x3)];
        dst[dstIndex++] = encodeData[x&0x3F];
        state = 0;
        break;
        }
        old = x;
        if (++len >= 72) {
            dst[dstIndex++] = (byte'\n';
            len = 0;
        }
    }

    /*
     * now clean up the end bytes
     */


    switch (state) {
    case 1: dst[dstIndex++] = encodeData[(old<<4) & 0x30];
       dst[dstIndex++] = (byte'=';
       dst[dstIndex++] = (byte'=';
       break;
    case 2: dst[dstIndex++] = encodeData[(old<<2) & 0x3c];
       dst[dstIndex++] = (byte'=';
       break;
    }
    return new String(dst);
    }

    /**
     * A Base64 decoder.  This implementation is slow, and 
     * doesn't handle wrapped lines.
     * The output is undefined if there are errors in the input.
     * @param s        a Base64 encoded string
     * @returns        The byte array eith the decoded result
     */


    public static byte[]
    decode(String s) {
      int end = 0;    // end state
      if (s.endsWith("=")) {
      end++;
      }
      if (s.endsWith("==")) {
      end++;
      }
      int len = (s.length() + 3)/4 * 3 - end;
      byte[] result = new byte[len];
      int dst = 0;
      try {
      for(int src = 0; src< s.length(); src++) {
          int code =  charSet.indexOf(s.charAt(src));
          if (code == -1) {
              break;
          }
          switch (src%4) {
          case 0:
              result[dst] = (byte) (code<<2);
              break;
          case 1: 
              result[dst++] |= (byte) ((code>>4) & 0x3);
              result[dst] = (byte) (code<<4);
              break;
          case 2:
              result[dst++] |= (byte) ((code>>2) & 0xf);
              result[dst] = (byte) (code<<6);
              break;
          case 3:
              result[dst++] |= (byte) (code & 0x3f);
              break;
          }
      }
      } catch (ArrayIndexOutOfBoundsException e) {}
      return result;
    }

    /**
     * Test the decoder and encoder.
     * Call as Base64 [string].
     */


    public static void
    main(String[] args) {
        System.out.println("encode: " + args[0]  + " -> (" 
            + encode(args[0]) + ")");
        System.out.println("decode: " + encode(args[0])  + " -> (" 
            + new String(decode(encode(args[0]))) + ")");
    }
}


沒有留言:

張貼留言