IO流-数据流、对象流(序列化与反序列化)、打印流

数据流:DataOutputStream

public class TestDataStream
{
    public void writeData()
    {
        double[] arrays = new double[1000];
        Arrays.fill(arrays, Math.PI);

        String fileName = "F:/java/test2.txt";
        FileOutputStream out;
        DataOutputStream dos = null;
        try
        {
            out = new FileOutputStream(fileName);
            dos = new DataOutputStream(out);
            for (int i = 0; i < arrays.length; i++)
            {
                dos.writeDouble(arrays[i]);
            }
//            dos.write(123);
//            dos.writeBoolean(true);
//            dos.writeChar('Z');
//            dos.writeDouble(Math.PI);
            dos.flush();
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (dos != null)
            {
                try
                {
                    dos.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args)
    {
        TestDataStream tds = new TestDataStream();
        tds.writeData();
    }

}

 

数据流:DataInputStream

public class TestDataInputStream
{
    public static void main(String[] args)
    {
        String fileName = "F:/java/test2.txt";
        FileInputStream in = null;
        DataInputStream dis = null;
        try
        {
            in = new FileInputStream(fileName);
            dis = new DataInputStream(in);
            for (int i = 0; i < 1000; i++)
            {
                System.out.println(dis.readDouble() + "i: " + i);
            }
//            System.out.println(dis.read());
//            System.out.println(dis.readBoolean());
//            System.out.println(dis.readChar());
//            System.out.println(dis.readDouble());
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (dis != null)
            {
                try
                {
                    dis.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

对象流：ObjectOutputStream（unserializable）、ObjectInputStream（serializable）

public class TestSerializable
{
    public static void main(String[] args)
    {
        TestSerializable ts = new TestSerializable();
        ts.serializable();
        ts.unserializable();
    }
    public void serializable()//序列化，写入
    {
        String filename = "F:/java/stu.txt";
        Student s1 = new Student("haoyouduo",1987);

        FileOutputStream fis =null;
        ObjectOutputStream ois = null;
        try
        {
            fis = new FileOutputStream(filename);
            ois = new ObjectOutputStream(fis);
            ois.writeObject(s1);
            ois.flush();
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null != ois)
            {
                try
                {
                    ois.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }

    }
    public void unserializable()//反序列化，读取
    {
        String filename = "F:/java/stu.txt";
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try
        {
            fis = new FileInputStream(filename);
            ois = new ObjectInputStream(fis);
            Student s = (Student)ois.readObject();
            System.out.println(s);

        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(ois != null)
            {
                try
                {
                    ois.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }

    }
}

class Student implements Serializable//对象类必须实现可序列化的
{
    String name;
    int age;
    public Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString()
    {
        return "Student [name=" + name + ", age=" + age + "]";
    }


}

 

打印流:PrintStream

public class Test
{
    public static void main(String[] args)
    {
        boolean flag = 2 > 1;
        if (flag)
        {
            System.out.println("sss");
        }
        else
        {
            System.out.println("aaa");
        }

        System.out.println("使用printStream之前");

        /**
         * 上面部分的内容将打印在控制台里
         * 下面部分的内容不会打印在控制台里，而是文件里
         */

        String filename = "f:/java/log.txt";
        FileOutputStream fos;
        PrintStream ps = null;
        try
        {
            fos = new FileOutputStream(filename);
            ps = new PrintStream(fos);
            System.setOut(ps);
            System.out.println("这将打印在文件里");
            System.out.println("使用printStream之后");
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (ps != null)
            {
                ps.close();
            }
        }
    }
}

 

本文出自 “天空没有痕迹但我飞过” 博客，转载请与作者联系！