Java I/O流总结

字节流

/*
名称：inputstream
说明：inputstream是字节流中的最基本的输入流，它是很多输入流的基本类，其不能直接实例化对象，因为它是个抽象类。但是可以将其子类的对赋给它（如本例中的system.in）,通过多态来实现输入流。不过一般不直接用inputstream而是用其子类的fileinputstream、bufferinputstream等来实现。

*/

package CharStream;

import java.io.IOException;
import java.io.InputStream;

public class J_inputstream
{
    public void TestInputstream(InputStream in)
    {
        try
        {
            int i;
            while(true)
            {
                i = in.read();
                if(i != -1)     //文件末尾返回-1                    
                    System.out.println((char)i);
                else
                    break;
            }

            in.close();
        } 
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

/*
名称：outputstream
说明：这个是字节输出流的父类，是最基本的抽象类。其基本特点和inputstream类似。在此例中，12输出后是乱码，It’s a test 。输出后可以正常显示，这还是字节和字符储存传输的区别问题。

*/

public class J_outputstream
{
    public void TestOutputstream(OutputStream out)
    {
        String string="It's a test!";
        try
        {
            out.write(12);
            out.write(string.getBytes());
            out.close();
        } catch (Exception e)
        {
            // TODO: handle exception
            System.out.println("输出流错误！");
        }
    }
}

/*
名称：fileinputstream
说明：fileinputstream为文件输出流，它是inputstream的子类，用于文件内容的输入。它所含有的方法基本为inputstream中的方法，read（），read（byte[]）等。在此例中文件的输出结果是不是和原来一样，因为fileinutstream是按字节读取，然后按字节输出而在文本文件中我们用的是字符，所以会有格式上的区别。这也正表示了字节类的方法一般用于处理二进制文件（字节存储与它们在内存中的形式完全一样），如图像、声音等，而下面要说到的字符输入输出流可以更好的处理显示的字符问题。
*/

public class J_fileinputstream
{
    public void TestFileInputstream()
    {
        try
        {
    FileInputStream in = new FileInputStream("test.txt");
                int i;
                int num = 0;
            while((i = in.read())!= -1)
            {
                System.out.print((char)i);
                ++num;
            }
            System.out.println("num0：" + num);
            in.close();
        } 
        catch (IOException e)
        {
            System.out.println("文件打开出错");
        }
    }
}

/*
名称：fileoutputstream
说明：此输出流和fileinputstream对应，不在此赘述。
*/

public class J_fileoutstream
{
    public void TestFileOutputstream()
    {
        try
        {
            FileOutputStream out= new FileOutputStream("test.txt");

            String string = "It's a test! hehe!";
            out.write(string.getBytes());

            out.close();
        } 
        catch (IOException e)
        {
            System.out.println("文件打开出错");
        }
    }
}

/*
名称：bufferedinputstream
说明：此输入流主要是为了提高效率准备的，就是在一般的输入流中加入了一个缓冲，当缓冲满了读入内存，这样在读取大文件时可以提高效率；其基本的读取方法和inputstream差不多；而且此方法多是和fileinputstream结合使用。
*/

public class J_bufferedinputstream
{
    public void TestBufferedInputstream()
    {
            int i = 0,ch;
            Date d1 = new Date();
            FileInputStream fileInputStream;
            try
            {
                fileInputStream = new FileInputStream("text.txt");
                while((ch = fileInputStream.read()) != -1)
                {
                    ++i;
                }
                Date d2 = new Date();

                long t = d2.getTime()-d1.getTime();
                System.out.println("不使用缓冲读取文件花了"+t+"ms");

                i = 0;
                BufferedInputStream  bufferedInputStream = new BufferedInputStream(fileInputStream);
                d1= new Date();
                while((ch = fileInputStream.read()) != -1)
                {
                    ++i;
                }
                d2 = new Date();
                t= d2.getTime()-d1.getTime();
                System.out.println("使用缓冲读取文件花了"+t+"ms");

            } 
            catch (IOException e)
            {
                e.printStackTrace();
            }   
    }
}

/*
名称：bufferedoutputstream
说明:此输出流和bufferedinputstream用法类似。不再论述。
*/

public class J_bufferedOutputstream
{
    public void TestBufferedOutputstream()
    {
        try
        {
            FileOutputStream fileOutputStream = new FileOutputStream("text.txt");
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            String string = "qwryuiopasdfgh";
            bufferedOutputStream.write(string.getBytes());

        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

/*
名称：DataInputstream
说明：此输入流主要用来读取基本类型的数据，主要是和文件结合，即从文件中读取相关数据，所以它的构造参数是一般文件的输入流，（算是一个高层流）。它可以读取文件中基本类型的数据主要是它提供了大量的的方法如readInt,readChar,readByte等。不过要注意，它相当于自动从
文件的输入的字节流中按格式提取相应的长度，这就和字符输入流有点像了。

*/

public class J_datainputstream
{
    public void TestDataInputstream() 
    {
        try
        {
            FileInputStream fileInputStream = new FileInputStream("test.txt");
            DataInputStream dataInputStream = new DataInputStream(fileInputStream);
            char i = dataInputStream.readChar();
            System.out.println(i);
        dataInputStream.close();
        } catch (IOException e)
        {
            e.printStackTrace();
        }

    }
}

/*
* 名称：dataoutputstream
* 说明：此输出流和datainputstream对应，特点基本相同，不在赘述。在这说明另外一个问题：数据在内存中和文件中的存储问题。我们以字节流的方式把数据输入到内存中，其存储方式就是普通的二进制（也可能是其ASCII之类，但总是二进制）当我们把数据以这种方式存储到文件中时，实际上在文件中也是以这种方式存储，但是当文件中的内容呈现给用户时，采用的是字符的形式，即系统要将在文件中（即磁盘）的存储的二进制字节文件转化为字符，然后显示给我们。 那为什么此例中的整形12在文本文件中显示的是乱码呢？那可能是和不同的编码长度有关在文本文件中，一个字符读取的可能是一个字节（具体的我也不太清楚），但是整形12存储是是按4个字节存储的，所以直接用文本文件打开，会出现错误。（也就是系统吧把整形数据当成字符来处理了）。如果直接用datainputstream中的readInt（）即可以读取正确的形式。
*
*/

public class J_dataoutputstream
{
    public void TestDataOutputstream() 
    {
        try
        {
            FileOutputStream fileOutputStream = new FileOutputStream("test.txt");
            DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
            int i = 12;
            char  c ='z';
            String  string = "It's a test! ";
            dataOutputStream.writeChar(c);
            dataOutputStream.writeUTF(string);
            dataOutputStream.write(string.getBytes());
        dataOutputStream.close();
        J_datainputstream iDatainputstream= new J_datainputstream();
        iDatainputstream.TestDataInputstream();

        } catch (IOException e)
        {
            e.printStackTrace();
        }

    }
}