java基础（12）- java的输入/输出(IO)包（2）

ImportNewXXT0101

已于 2023-09-08 00:09:28 修改

阅读量278

点赞数

分类专栏：【基础要牢靠】Java核心基础文章标签： java

于 2017-12-05 11:22:58 首次发布

本文链接：https://blog.csdn.net/m0_37955444/article/details/78717728

版权

【基础要牢靠】Java核心基础专栏收录该内容

28 篇文章 2 订阅

订阅专栏

本文详细介绍了Java中的IO流概念及应用，包括带缓冲的字符流和字节流、DataInputStream和DataOutputStream的使用方法，以及RandomAccessFile的特性和示例代码。

摘要由CSDN通过智能技术生成

12.1带缓冲的流

12.2datainputstream和dataoutputstream

12.3randomaccessfile

12.1带缓冲的流

一、什么是带缓冲的流

在字符流中可以使用带缓冲的字符流提高文件读写的效率，这种效率的提高是显著的而且有时是必须的。带缓冲提供一个较大的缓冲区，通过减少文件读取或写入次数以提高IO流的效率，比如相比较使用一个int的长度是4byte临时变量，使用而默认的BufferedReader缓冲区大小是4k byte，减少读取的次数是4×1024/8=1024倍。

缓存流可以修饰原始的字节流和字符流，带缓存的字节流类是：java.io.BufferedInputStream和java.io.BufferedOutputStream，而带缓存的字符流是：java.io.BufferedReader和java.io.BufferedWriter。在学习javaIO时会发现该API下存在大量的修饰器模式，修饰器模式下以一种功能”低级”的流去修饰功能更为“高级”流，从而得到更为高级的功能。BufferedReader的构造器有两个构造函数：

BufferedReader(Reader in)

BufferedReader(Reader in, int size)

前面一种方式使用一个Reader的实例去修饰BufferedReader，使用默认大小的缓冲器的带缓冲字符流。而第二种构造缓冲器长度是由size设定。

跟BufferedReader一样，BufferedWriter的构造器也有两种重载的格式：

BufferedWriter(Writer out)

BufferedWriter(Writer out, int size)

字节缓冲输入/输出是一个非常普通的性能优化。Java 的BufferedInputStream 类允许把任何InputStream 类“包装”成缓冲流并使它的性能提高。BufferedInputStream 有两个构造函数：

BufferedInputStream(InputStream inputStream)

BufferedInputStream(InputStream inputStream, int bufSize)

而对应的缓冲输出流BufferedOutputStream

BufferedOutputStream与任何一个OutputStream相同，因为BufferedOutputStream是通过减小系统写数据的时间而提高性能的，可以调用flush( )方法生成缓冲器中待写的数据。下面是两个可用的构造函数：

BufferedOutputStream(OutputStream outputStream)

BufferedOutputStream(OutputStream outputStream, int bufSize)

第一种形式创建了一个使用512字节缓冲器的缓冲流。第二种形式，缓冲器的大小由bufSize参数传入。

在带缓冲的输出流中，一般都增加了flush()方法，flush()方法的作用是确保数据缓冲器确实被写到实际的输出流。用BufferedWriter可以通过减小数据被实际的写到输出流的次数而提高程序的性能。对于字节流缓冲流（buffered stream），通过把内存缓冲器连到输入/输出流扩展一个过滤流类。该缓冲器允许Java对多个字节同时进行输入/输出操作，提高了程序性能。

二、带缓存的字符流

使用带缓存的字符流修饰原始的字符流，代码如下：

public void input() {
	try {
			// 带缓冲的字符流
		BufferedReader bufreader = new BufferedReader(
		            new FileReader("e://abc.txt"));
		while (bufreader.ready()) {
			// 可以一次读取一行
			System.out.println(bufreader.readLine());
		}
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	}

}

public void output() {
	try {

		BufferedWriter writer = new BufferedWriter(
		           new FileWriter(new File("d://abc.txt")));			
		writer.write("大家好啊!I say:\" \";\r\n");
		writer.write("不好");
		writer.flush();//要调用flush方法
		writer.close();

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

三、带缓存的字节流

我们已经学过带缓冲的字符流BufferedReader和BufferedWriter，带缓冲的字节流跟前者非常相似，要改写上面的程序非常简单，只需要分别创建BufferedInputStream /BufferedOutputStream对象，将原来代码中的fis和fout进行修饰即可，对大量的文本读取性能有很大提高。示例代码如下：

public void input() {
    try {
        InputStream input = new FileInputStream("e://abc.txt");
        // 如果修饰得是字节流，带缓冲的字节流
        BufferedInputStream buinput = new BufferedInputStream(input);
        // 每次读取数据的临时变量，每次读32位4byte
        int tmp = 0;
        // 循环读取，最后读到文件末尾返回-1
        while ((tmp = buinput.read()) != -1) {
        // 每读一次写一次
        System.out.println((char)tmp);
        }
        buinput.close();
    
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

public void output() {
    try {
        FileOutputStream output = new FileOutputStream("e://abc.txt");
        BufferedOutputStream buoutput = new BufferedOutputStream(output);
        buoutput.write('a');
        buoutput.write('b');
        buoutput.flush();
        // 释放资源
        buoutput.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

12.2datainputstream和dataoutputstream

datainputstream和dataoutputstream

一、datainputstream和dataoutputstream

使用BufferedInputStream/BufferedOutStream读写的并不是纯二进制数据，因此在有些时候，比如网络互传时会有出现文件无法恢复的问题，除非是纯文本文件。要解决文件流的通用性就必须使用纯二进制的方式读写数据，这时我们可以选择使用DataInputStream

/DataOutputStream对数据使用二进制的方式进行读写，比如以DataInputStream为例，字节入流的API结构]显示了其继承于java.io. FilterInputStream。DataInputStream可以被认为是“更高级”的类，在编程中需要使用修饰其他的InputStream来进行使用，考虑到效率，推荐这个被修饰的类为带缓冲的流，比如：BufferedInputStream。DataOutputStream的情况也是如此，就不需我们再次累述。

DataInputStream的构造器：

DataInputStream(InputStream in)

DataOutputStream的构造器：

DataOutputStream(OutputStream out)

java.io.DataInputStream dis = new java.io.DataInputStream(

new BufferedInputStream(new URL(srcUri).openStream()));

/*生成二进制输出流 ,使用FileOutputStream--修饰-->BufferedOutputStream

--修饰-->DataOutputStream*/

java.io.DataOutputStream dos = new java.io.DataOutputStream(

new BufferedOutputStream(new FileOutputStream(targetFile)));

二、示例代码

    public static void copy(String srcpath, String targetpath) {

        DataInputStream input = null;
        DataOutputStream output = null;

        try {
            input = new DataInputStream(new BufferedInputStream(
                    new FileInputStream(new File(srcpath))));
            output = new DataOutputStream(new BufferedOutputStream(
                    new FileOutputStream(new File(targetpath))));

            int temp;

            while ((temp = input.read()) != -1) {
                output.write(temp);
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                input.close();
                output.flush();
                output.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

12.3randomaccessfile

randomaccessfile

一、RandomAccessFile讲解

RandomAccessFile类不属于InputStream或者OutputStream分层结构的一部分，它实现了DataInput和DataOutput。RandomAccessFile用于包含了已知长度记录的文件，我们可以使用seek()方法从一条记录移至另一条，可在一个文件里向前或向后移动，然后读取或修改那部分的记录，不像之前的InputStream和OutputStream的实现类那样，每次都从头开始读取。

构造器要求使用者传入一个变量指出对象只是随机读（“r”），还是读写兼施（“rw”）。getFilePointer()用于了解当前在文件的什么地方，seek()用于移至文件内的一个新地点。length()用于判断文件的最大长度。

二、示例代码

	public static void main(String[] args) {
		//mode模式   r只读 rw 读写
		try {
			RandomAccessFile rafile=new RandomAccessFile(new File("e://ram.txt"), "rw");
		
		    System.out.println("文件长度："+rafile.length());
		    
		    //改变光标的位置：
		    rafile.seek(3L);
		    System.out.println("光标的位置："+rafile.getFilePointer());
		    
		    //主意光标。覆盖字符
		    rafile.writeBytes("abc");
		    
		    int temp;
		    temp=rafile.read();//从当前光标的位置开始往后读取
		    while(temp!=-1){
		    	System.out.println("光标的位置："+rafile.getFilePointer());
		    	System.out.println((char)temp);
		    	temp=rafile.read();//读取下一个
		    }
		    
		    rafile.close();
		
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}