JAVA IO 学习

Java流的分类

1.输入/输出流

输入流：只能向其读数据，不能写。

输出流：只能向其写数据，不能读。

所谓的输入输出都是相对应用程序而言的。

2.字节流/字符流

单位不同，字节流操作8位，字符流操作16位，2倍关系。

3.节点流/处理流

按照流的角色来分的。

节点流：从/向特定的IO设备读/写的流，也称低级流。

处理流：对于一个已经存在的流进行连接或包装，通过包装后的流来实现读写功能，也称高级流。

Java流概念模型

Java.io包里面有40多个类，看上去很凌乱负责，但实际有规律。所有类都继承自4个类，

InputStream

OutputStream

Reader

Writer

所有类的结构图如下：

其实是按字节流/字符流来分的。

上述4个类是抽象类的主要方法。

读，InputStream/Reader

有几个主要的方法：

Int read()读取单个字节/字符。

Int read(byte[] b/char[] c)，读取给定数组的字节/字符。

Int read(byte[] b/char[] c, int off, int len)从字节/字符组中的off位置，读取len长度。

代码：

以FileInputStream和FileReader为例子：

public static void main(String[] args) throws Exception{

        // TODO Auto-generated method stub

        FileInputStream fis = new FileInputStream("TestFile1.java");

        byte[] bbuf = new byte[1024];

        int hasRead = 0;

        while((hasRead = fis.read(bbuf))>0){

            System.out.print(new String(bbuf,0,hasRead));

        }

        fis.close();

    }

这里byte数组的大小是1024，如果很小，或者为奇数的话，可能会出现读出来的是乱码。

public static void main(String[] args) throws IOException {

        // TODO Auto-generated method stub

        try {

            fr = new FileReader("TestFile1.java");

            char[] cbuf = new char[32];

            int hasRead = 0;

            while ((hasRead = fr.read(cbuf)) > 0) {

                System.out.print(new String(cbuf, 0, hasRead));

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        finally{

            fr.close();

        }

    }

写，OutputStream/Writer

主要的方法：

Void write(c)写入指定的c个字节/字符。

Void write(byte[] b/char[] c)写入字节/字符数组中的数据。

Void write(byte[]/char[] buf, int off, int len)从字节/字符数组中的off位置写入len长度到输出流。

由于字符流以字符为单位，Writer可以用字符串来代替字符数组，于是有了2个新的方法：

Void write(string s)写入字符串s到流。

Void write(string s, int off, int len)从字符串s的off位置处写入len长度到流。

以FileOutputStream和FileWriter为例子：

public static void main(String[] args) throws IOException {

        // TODO Auto-generated method stub

        FileInputStream fis = null;

        FileOutputStream fos = null;

        try {

            fis = new FileInputStream(

                    " TestFile1.java");

            fos = new FileOutputStream(

                    " NewFile.txt");

            byte[] bbuf = new byte[1024];

            int hasRead = 0;

            while ((hasRead = fis.read(bbuf)) > 0) {

                fos.write(bbuf, 0, hasRead);

            }

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            fis.close();

            fos.close();

        }

    }

FileWriter:

public static void main(String[] args) throws IOException {

        // TODO Auto-generated method stub

        FileWriter fw = null;

        try {

            fw = new FileWriter("newFile2.txt");

            fw.write("静夜思\r\n");

            fw.write("床前明月光，\r\n");

            fw.write("疑是地上霜,\r\n");

            fw.write("举头望明月，\r\n");

            fw.write("低头思故乡。\r\n");

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }finally{

            fw.close();

        }

    }

Java序列化和反序列化

序列化即将对象转换成数据(二进制或xml文本)，反序列化则相反。

Java序列化/反序列化用到的类：ObjectOutputStream/ObjectInputStream，它们都是处理流对象，接受节点流FileOutputStream/FileInputStream.

序列化/反序列化要求被处理的类继承Serializable接口。

例子：

//Person 类

public class Person implements java.io.Serializable {

    public String Name;

    public int Age;

    public Person(String name,int age){

        this.Name=name;

        this.Age=age;

    }

}

public class TestSerialization {

    /**

     * @param args

     * @throws ClassNotFoundException

     */

    public static void main(String[] args) throws ClassNotFoundException {

        // TODO Auto-generated method stub

        /**

         * Serialize

         */

        try {

            ObjectOutputStream op = new ObjectOutputStream(

                    new FileOutputStream(

                            "Person.txt"));

            Person p = new Person("Jackson", 24);

            Person p2 = new Person("Anne", 23);

            op.writeObject(p);

            op.writeObject(p2);

            System.out.println("person info: name is " + p.Name + " ;age is: "

                    + p.Age);

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        /**

         * DeSerialize

         */

        try {

            ObjectInputStream ip = new ObjectInputStream(new FileInputStream(

                    "Person.txt"));

            Person p = (Person) ip.readObject();

            Object o;

            while ((o = ip.readObject()) != null) {

                Person pp = (Person) o;

                System.out.println("name: " + pp.Name + ",Age:" + pp.Age);

            }

        } catch (FileNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

巴特西

JAVA IO 学习

最新文章

热门文章