java图片，视频与Base64格式互转

package test.utils;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;

import sun.misc.BASE64Encoder;
import sun.misc.BASE64Decoder;
import javax.imageio.ImageIO;

import org.apache.commons.codec.binary.Base64;

import com.fintech.third.model.ThirdProperties;

public class Base64Util {

    private static final char[] intToBase64 = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
            'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
            'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
            '4', '5', '6', '7', '8', '9', '+', '/' };

    private static final char[] intToAltBase64 = { '!', '"', '#', '$', '%', '&', '\'', '(', ')', ',', '-', '.', ':',
            ';', '<', '>', '@', '[', ']', '^', '`', '_', '{', '|', '}', '~', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
            'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
            '3', '4', '5', '6', '7', '8', '9', '+', '?' };

    private static final byte[] base64ToInt = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1,
            -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,
            9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
            30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };

    private static final byte[] altBase64ToInt = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -1, 62, 9, 10,
            11, -1, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 12, 13, 14, -1, 15, 63, 16, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 17, -1, 18, 19, 21, 20, 26, 27, 28,
            29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 22, 23, 24,
            25 };


    // 将 s 进行 BASE64 编码
    public static String getBASE64(String s) throws UnsupportedEncodingException {
        if (s == null)
            return null;
        return new BASE64Encoder().encode(s.getBytes("UTF-8"));
    }

    // 将 字符串进行 BASE64 编码
    public static String getBASE64ByCodec(String s) {
        Base64 b64 = new Base64();
        return b64.encodeToString(s.getBytes());
    }

    public static String getBASE64ByByte(byte[] by) {
        Base64 b64 = new Base64();
        return b64.encodeToString(by);
    }

    public static byte[] getFromBASE64(String s) {
        if (s == null)
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        byte[] b = null;
        try {
            b = decoder.decodeBuffer(s);

        } catch (Exception e) {
            return null;
        }
        return b;
    }

    // 将 BASE64 编码的字符串 s 进行解码
    public static String getFromBASE64Str(String s) throws IOException {
        return new String(new BASE64Decoder().decodeBuffer(s), "UTF-8");
    }

    // 图片转化成base64字符串
    public static String getImageStr(String imgFile) {// 将图片文件转化为字节数组字符串，并对其进行Base64编码处理
        InputStream in = null;
        byte[] data = null;
        // 读取图片字节数组
        try {
            in = new FileInputStream(imgFile);
            data = new byte[in.available()];
            in.read(data);
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 对字节数组Base64编码
        BASE64Encoder encoder = new BASE64Encoder();
        return new String(encoder.encode(data));// 返回Base64编码过的字节数组字符串
    }

    // base64字符串转化成图片
    public static String generateImage(String imgStr, String fileName, String filePath) { // 对字节数组字符串进行Base64解码并生成图片
        if (imgStr == null) // 图像数据为空
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        try {
            // Base64解码
            byte[] b = decoder.decodeBuffer(imgStr);
            for (int i = 0; i < b.length; ++i) {
                if (b[i] < 0) {// 调整异常数据
                    b[i] += 256;
                }
            }
            // 生成jpeg图片
            String imgFilePath = filePath + fileName + ".jpg";// 新生成的图片
            OutputStream out = new FileOutputStream(imgFilePath);
            out.write(b);
            out.flush();
            out.close();
        //    resizeImage(imgFilePath, 300, 300);
            return imgFilePath;
        } catch (Exception e) {
            return null;
        }
    }

    // 图片转化成base64字符串
    public static String getImageStrByCodec(String imgFile) throws IOException {// 将图片文件转化为字节数组字符串，并对其进行Base64编码处理
        Base64 b64 = new Base64();
        File file = new File(imgFile);
        FileInputStream fis = new FileInputStream(file);
        byte[] buffer = new byte[(int) file.length()];
        fis.read(buffer);
        fis.close();
        return b64.encodeToString(buffer);
    }

    // base64字符串转化成图片
    public static String generateImageByCodec(String imgStr, String fileName) throws IOException { // 对字节数组字符串进行Base64解码并生成图片
        ThirdProperties thirdProperties = ThirdPropertiesInitUtil.getThirdProperties();
        Base64 b64 = new Base64();
        byte[] buffer = b64.decode(imgStr);

        // 生成jpeg图片
        String imgFilePath = SystemUtil.class.getResource(thirdProperties.getImage_path()).getPath() + fileName;// 新生成的图片
        OutputStream out = new FileOutputStream(imgFilePath);
        out.write(buffer);
        out.flush();
        out.close();
        resizeImage(imgFilePath, 300, 300);
        return imgFilePath;

    }

    // base64字符串转化成图片
    public static void generateImageByCodec2(String imgStr, String file) throws IOException { // 对字节数组字符串进行Base64解码并生成图片
        Base64 b64 = new Base64();
        byte[] buffer = b64.decode(imgStr);
        OutputStream out = new FileOutputStream(file);
        out.write(buffer);
        out.flush();
        out.close();
        return;
    }
        
    /**
     * 压缩图片
     *
     * @param srcImgPath
     * @param width
     * @param height
     * @throws IOException
     */
    public static void resizeImage(String srcImgPath, int width, int height) throws IOException {

        String subfix = "jpg";

        subfix = srcImgPath.substring(srcImgPath.lastIndexOf(".") + 1, srcImgPath.length());

        File srcFile = new File(srcImgPath);

        Image srcImg = ImageIO.read(srcFile);

        BufferedImage buffImg = null;

        if (subfix.equals("png")) {

            buffImg = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

        } else {

            buffImg = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        }

        Graphics2D graphics = buffImg.createGraphics();

        graphics.setBackground(Color.WHITE);

        graphics.setColor(Color.WHITE);

        graphics.fillRect(0, 0, width, height);

        graphics.drawImage(srcImg.getScaledInstance(width, height, Image.SCALE_SMOOTH), 0, 0, null);

        ImageIO.write(buffImg, subfix, new File(srcImgPath));

    }

    public static String ioToBase64(InputStream in) throws IOException {
        String strBase64 = null;
        try {

            // in.available()返回文件的字节长度
            byte[] bytes = new byte[in.available()];
            // 将文件中的内容读入到数组中
            in.read(bytes);
            strBase64 = new BASE64Encoder().encode(bytes); // 将字节流数组转换为字符串
            in.close();
        } catch (FileNotFoundException fe) {
            fe.printStackTrace();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return strBase64;
    }

    static String getPDFBinary(InputStream fin) {
        BufferedInputStream bin = null;
        ByteArrayOutputStream baos = null;
        BufferedOutputStream bout = null;
        BASE64Encoder encoder = new sun.misc.BASE64Encoder();
        try {

            // 在文件输出流上安装节点流（更大效率读取）
            bin = new BufferedInputStream(fin);
            // 创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量
            baos = new ByteArrayOutputStream();
            // 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
            bout = new BufferedOutputStream(baos);
            byte[] buffer = new byte[1024];
            int len = bin.read(buffer);
            while (len != -1) {
                bout.write(buffer, 0, len);
                len = bin.read(buffer);
            }
            bout.flush();
            byte[] bytes = baos.toByteArray();
            // sun公司的API
            return encoder.encodeBuffer(bytes).trim();
            // apache公司的API
            // return Base64.encodeBase64String(bytes);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fin.close();
                bin.close();
                bout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    static void base64StringToPDF(String base64sString) {
        BufferedInputStream bin = null;
        FileOutputStream fout = null;
        BufferedOutputStream bout = null;
        BASE64Decoder decoder = new sun.misc.BASE64Decoder();
        try {
            byte[] bytes = decoder.decodeBuffer(base64sString);

            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            // 创建从底层输入流中读取数据的缓冲输入流对象
            bin = new BufferedInputStream(bais);
            File file = new File("E://test.pdf");
            // 创建到指定文件的输出流
            fout = new FileOutputStream(file);
            // 为文件输出流对接缓冲输出流对象
            bout = new BufferedOutputStream(fout);
            byte[] buffers = new byte[1024];
            int len = bin.read(buffers);
            while (len != -1) {
                bout.write(buffers, 0, len);
                len = bin.read(buffers);
            }
            // 刷新此输出流并强制写出所有缓冲的输出字节，必须这行代码，否则有可能有问题
            bout.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bin.close();
                fout.close();
                bout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    public static String byteArrayToBase64(byte[] a)
      {
        return byteArrayToBase64(a, false);
      }

      public static String byteArrayToAltBase64(byte[] a)
      {
        return byteArrayToBase64(a, true);
      }

      private static String byteArrayToBase64(byte[] a, boolean alternate) {
        int aLen = a.length;
        int numFullGroups = aLen / 3;
        int numBytesInPartialGroup = aLen - 3 * numFullGroups;
        int resultLen = 4 * ((aLen + 2) / 3);
        StringBuffer result = new StringBuffer(resultLen);
        char[] intToAlpha = alternate ? intToAltBase64 : intToBase64;

        int inCursor = 0;
        for (int i = 0; i < numFullGroups; i++) {
          int byte0 = a[(inCursor++)] & 0xFF;
          int byte1 = a[(inCursor++)] & 0xFF;
          int byte2 = a[(inCursor++)] & 0xFF;
          result.append(intToAlpha[(byte0 >> 2)]);
          result.append(intToAlpha[(byte0 << 4 & 0x3F | byte1 >> 4)]);
          result.append(intToAlpha[(byte1 << 2 & 0x3F | byte2 >> 6)]);
          result.append(intToAlpha[(byte2 & 0x3F)]);
        }

        if (numBytesInPartialGroup != 0) {
          int byte0 = a[(inCursor++)] & 0xFF;
          result.append(intToAlpha[(byte0 >> 2)]);
          if (numBytesInPartialGroup == 1) {
            result.append(intToAlpha[(byte0 << 4 & 0x3F)]);
            result.append("==");
          }
          else {
            int byte1 = a[(inCursor++)] & 0xFF;
            result.append(intToAlpha[(byte0 << 4 & 0x3F | byte1 >> 4)]);
            result.append(intToAlpha[(byte1 << 2 & 0x3F)]);
            result.append('=');
          }

        }

        return result.toString();
      }

      public static byte[] base64ToByteArray(String s)
      {
        return base64ToByteArray(s, false);
      }

      public static byte[] altBase64ToByteArray(String s)
      {
        return base64ToByteArray(s, true);
      }

      private static byte[] base64ToByteArray(String s, boolean alternate) {
        byte[] alphaToInt = alternate ? altBase64ToInt : base64ToInt;
        int sLen = s.length();
        int numGroups = sLen / 4;
        if (4 * numGroups != sLen) {
          throw new IllegalArgumentException("String length must be a multiple of four.");
        }
        int missingBytesInLastGroup = 0;
        int numFullGroups = numGroups;
        if (sLen != 0) {
          if (s.charAt(sLen - 1) == '=') {
            missingBytesInLastGroup++;
            numFullGroups--;
          }
          if (s.charAt(sLen - 2) == '=') {
            missingBytesInLastGroup++;
          }
        }
        byte[] result = new byte[3 * numGroups - missingBytesInLastGroup];

        int inCursor = 0; int outCursor = 0;
        for (int i = 0; i < numFullGroups; i++) {
          int ch0 = base64toInt(s.charAt(inCursor++), alphaToInt);
          int ch1 = base64toInt(s.charAt(inCursor++), alphaToInt);
          int ch2 = base64toInt(s.charAt(inCursor++), alphaToInt);
          int ch3 = base64toInt(s.charAt(inCursor++), alphaToInt);
          result[(outCursor++)] = (byte)(ch0 << 2 | ch1 >> 4);
          result[(outCursor++)] = (byte)(ch1 << 4 | ch2 >> 2);
          result[(outCursor++)] = (byte)(ch2 << 6 | ch3);
        }

        if (missingBytesInLastGroup != 0) {
          int ch0 = base64toInt(s.charAt(inCursor++), alphaToInt);
          int ch1 = base64toInt(s.charAt(inCursor++), alphaToInt);
          result[(outCursor++)] = (byte)(ch0 << 2 | ch1 >> 4);

          if (missingBytesInLastGroup == 1) {
            int ch2 = base64toInt(s.charAt(inCursor++), alphaToInt);
            result[(outCursor++)] = (byte)(ch1 << 4 | ch2 >> 2);
          }

        }

        return result;
      }

      private static int base64toInt(char c, byte[] alphaToInt)
      {
        int result = alphaToInt[c];
        if (result < 0) {
          throw new IllegalArgumentException("Illegal character " + c);
        }
        return result;
      }
      
      
      
      public static void main(String[] args){
          String str="";
          try {
              String imgFile = "C:/Users/zengxs/Desktop/sfzbm.jpg";
             String imgstr =  getImageStrByCodec(imgFile);
            System.out.println(imgstr);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
          System.out.println(str);
      }
      
      
}