序列化和反序列化工具类

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 序列化和反序列化工具类
 */
public class SerializeUtil
{
    /**
     * 统一编码，字符串获取byte数组

     * 编码格式：UTF-8
     */
    public static byte[] String2Byte(String s)
    {
        if (s == null)
        {
            return null;
        }
        
        try
        {
            return s.getBytes("UTF-8");
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 统一编码，byte数组转字符串

     * 编码格式：UTF-8
     */
    public static String Byte2String(byte[] bytes)
    {
        if (bytes == null)
        {
            return null;
        }
        
        try
        {
            return new String(bytes, "UTF-8");
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 序列化
     * 
     * @param object
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static byte[] serializeObj(Object object)
    {
        if (object == null)
        {
            return null;
        }
        
        ByteArrayOutputStream byteOutStream = null;
        
        ObjectOutputStream outputStream = null;
        
        try
        {
            byteOutStream = new ByteArrayOutputStream();
            
            outputStream = new ObjectOutputStream(byteOutStream);
            
            outputStream.writeObject(object);
            
            byte[] bytes = byteOutStream.toByteArray();
            
            return bytes;
        }
        catch (IOException e)
        {
            e.printStackTrace();
            
            return null;
        }
        finally
        {
            if (null != outputStream)
            {
                try
                {
                    outputStream.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                    return null;
                }
            }
            
            if (null != byteOutStream)
            {
                try
                {
                    byteOutStream.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                    return null;
                }
            }
        }
    }
    
    /**
     * 反序列化
     * 
     * @param bytes
     * @return
     * @see [类、类#方法、类#成员]
     */
    public static Object unserializeObj(byte[] bytes)
    {
        ByteArrayInputStream byteInputStream = null;
        
        ObjectInputStream inputStream = null;
        
        try
        {
            byteInputStream = new ByteArrayInputStream(bytes);
            
            inputStream = new ObjectInputStream(byteInputStream);
            
            return inputStream.readObject();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
        finally
        {
            if (null != byteInputStream)
            {
                try
                {
                    byteInputStream.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                    return null;
                }
            }
            
            if (null != inputStream)
            {
                try
                {
                    inputStream.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                    return null;
                }
            }
        }
    }
}