化_列_序_反_和_化_列_序

1.序列化：把内存中正在运行的对象写到输出流中
  反序列化：从输入流中读取对象

2.需要被序列化操作的类必须实现：java.io.Serializable接口

3.通过transient关键字限制对属性的序列化
  private transient String passWord;

4.重写readObject()和writeObject()来控制序列化方式
  调用defaultReadObject()和defaultWriteObject()执行默认序列化操作
 
5.序列化前加密属性
  示例：
   //加密属性
   private byte[] change(byte[] buff){
      for(int i=0;i<buff.length;i++){
         int b = 0;
         for(int j=0;j<8;j++){
            int bit = (buff[i]>>j & 1)==0? 1 : 0;
            b+=(1<<j)*bit;
         }
         buff[i]=(byte)b;
      }
      return buff;
   }
   private void writeObject(ObjectOutputStream o)throw IOException{
      o.defaultWriteObject();//按默认方式序列化
      o.writeObject(change(passWord.getByte()));
   }
   private void readObject(ObjectOutputStream o)throw IOException{
      o.defaultReadObject();//按默认方式反序列化
       byte[] buff = (byte[])o.readObject();
       passWord = new String(change(buff));
   }
-------------------------------------------------------


public static void getSerializable() throws IOException,
ClassNotFoundException {
// 序列化
FileOutputStream fs = new FileOutputStream("D:\\a.serializable");
ObjectOutputStream ops = new ObjectOutputStream(fs);
String a = "Object-str";
Date date = new Date();
ops.writeObject(a);
ops.writeObject(date);
ops.close();

// 反序列化
FileInputStream fss = new FileInputStream("D:\\a.serializable");
ObjectInputStream is = new ObjectInputStream(fss);
String as = (String) is.readObject();
Date dates = (Date) is.readObject();
System.out.println(as);
System.out.println(dates);
}

public static void getInputStream() throws IOException {
// 输入流
InputStream is = new FileInputStream("D:\\in.txt");
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String data;
while ((data = br.readLine()) != null) {
System.out.println(data);
}
br.close();

// 输出流
OutputStream os = new FileOutputStream("D:\\out.txt");
OutputStreamWriter oss = new OutputStreamWriter(os);
PrintWriter pw = new PrintWriter(oss);
pw.println(data);
pw.close();
}
--------------------------------------------------------------
注册登录示例
public static boolean insertUser(UserInfo userInfo) throws IOException
    {
        boolean osBoolean = false;
        if (userInfo == null || userInfo.getUserName().isEmpty()
                || userInfo.getPassWord().isEmpty())
        {
            return osBoolean;
        }
        OutputStream os = new FileOutputStream("F:\\userInfo.xbliuc");
        ObjectOutputStream oos = new ObjectOutputStream(os);
       
        List<Map<String, String>> listUsers = new ArrayList<Map<String, String>>();
        Map<String, String> maps = new HashMap<String, String>();
        maps.put(userInfo.getUserName(), userInfo.getPassWord());
        listUsers.add(maps);
        if (listUsers.size() > 0)
        {
            oos.writeObject(listUsers);
            osBoolean = true;
        }
        oos.close();
        return osBoolean;
    }
    public static boolean enterUser(UserInfo userInfo) throws IOException,
            ClassNotFoundException
    {
        boolean isBoolean = false;
        if (userInfo == null || userInfo.getUserName().isEmpty()
                || userInfo.getPassWord().isEmpty())
        {
            return isBoolean;
        }
        InputStream is = new FileInputStream("F:\\userInfo.xbliuc");
        ObjectInputStream ois = new ObjectInputStream(is);
        List<Map<String, String>> lists = new ArrayList<Map<String, String>>();
        lists = (List<Map<String, String>>)ois.readObject();
        if (lists.size() > 0)
        {
            Map<String, String> maps = lists.get(0);
            if (userInfo.getPassWord().equals(maps.get(userInfo.getUserName())))
            {
                isBoolean = true;
            }
        }
        is.close();
        return isBoolean;
    }
    public static void Test() throws IOException, ClassNotFoundException
    {
        System.out.print("：");
        BufferedReader bra = new BufferedReader(
                new InputStreamReader(System.in));
        String a = bra.readLine();
        int b = Integer.parseInt(a);
        System.out.print(": ");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String userName = br.readLine();
        System.out.print("：");
        BufferedReader br2 = new BufferedReader(
                new InputStreamReader(System.in));
        String passWord = br2.readLine();
        UserInfo userInfo = new UserInfo(userName, passWord);
        insertUser(userInfo);
        enterUser(userInfo);
    }

-----------------------------


/*******************************************************************************
* Copyright(c) 2005-2009 Huawei Tech. Co., Ltd.
* All rights reserved.
*
* Author: xbliuc
* Date  : 2010-12-19
*******************************************************************************/
package com.rt.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Date;

/**
* File InputStream
*/
public class InputStreamTest
{
   
    /**
     * TODO 添加方法注释
     * @param args
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void main(String[] args) throws IOException,
            ClassNotFoundException
    {
        //getFileText();//字节输入流
        //getStringBufferStream();//字符输入流
        //copyFile();
        //copy();
        getSerializable();
    }
   
    /**
     * 对象序列化和反序列化
     * @throws IOException
     * @throws ClassNotFoundException
     * @throws FileNotFoundException
     * @throws ClassNotFoundException
     */
    public static void getSerializable() throws IOException,
            ClassNotFoundException
    {
        //创建保存序列化对象的文件
        ObjectOutputStream oOutput = new ObjectOutputStream(
                new FileOutputStream("D:\\ObjectFile.obj"));
        String oStr = "Object";
        Date odata = new Date();
        oOutput.writeObject(oStr);
        oOutput.writeObject(odata);
        oOutput.close();
       
        //反序列对象
        ObjectInputStream oInput = new ObjectInputStream(new FileInputStream(
                "D:\\ObjectFile.obj"));
        String str = (String)oInput.readObject();
        System.out.println("String : " + str);
        Date date = (Date)oInput.readObject();
        System.out.println("Date :　" + date);
    }
   
    //把键盘输入的数据输出到控制台
    public static void copy() throws IOException
    {
        InputStreamReader a = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(a);
        String data;
        while ((data = br.readLine()) != null && data.length() != 0)
        {
            System.out.println(data);
            System.err.println(data);
        }
    }
   
    /**
     * 输入流种类
     * InputStream ：字节输入流
     * OutputStream ： 字节输出流
     * ByteArrayInputStream:字节数组输入流
     * FileInputStream ： 文件输入流
     * StringBufferInputStream ： 字符串输入流(StringReader)
     * SequenceInputStream : 顺序输入流
     * FilterInputStream ： 过滤输入流
     * @throws IOException
     */
    public static void getFileText() throws IOException
    {
        final int SIZE = 1024;
        FileInputStream fs = null;
        FileOutputStream os = null;
        try
        {
            fs = new FileInputStream("D:\\a.txt");//输出字节流
            os = new FileOutputStream("D:\\b.txt");//输入字节流
           
            byte[] bytes = new byte[SIZE];//创建字节缓冲区
           
            int len = fs.read(bytes);//把a.txt文件中的数据读到bytes中
            while (len != -1)
            {
                os.write(bytes, 0, len);//把bytes中的数据写到b.txt中
                len = fs.read(bytes);//此时缓冲区bytes数组为空
            }
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        finally
        {
            fs.close();
            os.close();
        }
    }
   
    /**
     * 字符串输入流示例
     * TODO 添加方法注释
     * @throws IOException
     */
    public static void getStringBufferStream() throws IOException
    {
        final String FORMAT = "GBK";
        InputStream input = new FileInputStream("D:\\aa.txt");
        InputStreamReader reader = new InputStreamReader(input);
        BufferedReader br = new BufferedReader(reader, 1024);
        String data = "";
        while ((data = br.readLine()) != null)
        {
            System.out.println(data);
        }
        br.close();
    }
   
    public static void copyFile() throws IOException
    {
        //编码格式,不添加此参数则按照本地平台的编码读取输入流中的字符
        final String FORMAT = "GBK";//UTF-8,
       
        //文件输入流
        InputStream in = new FileInputStream("D:\\aa.txt");
        //字符输入流
        InputStreamReader reader = new InputStreamReader(in, FORMAT);
        //带有缓冲区的字符输入流，提高文件读的效率
        BufferedReader br = new BufferedReader(reader);
       
        //文件输出流
        OutputStream output = new FileOutputStream("D:\\bb.txt");
        //字符输出流
        OutputStreamWriter write = new OutputStreamWriter(output, FORMAT);
        BufferedWriter bw = new BufferedWriter(write);
        //输入格式化数据
        PrintWriter pw = new PrintWriter(bw, true);
       
        String data;
        while ((data = br.readLine()) != null)
        {
            pw.println(data);//向目标逐行写数据
        }
        br.close();
        pw.close();
    }
}