Java SE入门及基础（45）

卷到起飞的数分

已于 2024-03-18 11:09:54 修改

阅读量939

点赞数 33

分类专栏： Java SE 文章标签： java 开发语言

于 2024-03-18 11:09:37 首次发布

本文链接：https://blog.csdn.net/m0_63181360/article/details/136802918

版权

Java SE 专栏收录该内容

66 篇文章 1 订阅

订阅专栏

BufferedOutputStream 构造方法

BufferedInputStream 构造方法

BufferedWriter 构造方法

BufferedReader 构造方法

Java SE文章参考:Java SE入门及基础知识合集-CSDN博客

I / O流(中)

3. 字符流

字符流来自官方的说明

The Java platform stores character values using Unicode conventions. Character stream I/O automatically translates this internal format to and from the local character set. In Western locales, the local character set is usually an 8-bit superset of ASCII.

Java 平台使用 Unicode 约定存储字符值。字符流 I / O 会自动将此内部格式与本地字符集转换。在西方语言环境中，本地字符集通常是ASCII 的 8 位超集。

All character stream classes are descended from Reader and Writer. As with byte streams, there are character stream classes that specialize in file I/O: FileReader and FileWriter.

所有字符流类均来自 Reader 和 Writer 。与字节流一样，也有专门用于文件 I / O 的字符流类：

FileReader 和 FileWriter 。

Writer 常用方法

public void write ( int c ) throws IOException ; // 写一个字符

public void write ( char cbuf []) throws IOException ; // 将给定的字符数组内容写入到文件中

// 将给定的字符数组中给定偏移量和长度的内容写入到文件中

abstract public void write ( char cbuf [], int off , int len ) throws IOException ;

public void write ( String str ) throws IOException ; // 将字符串写入到文件中

abstract public void flush () throws IOException ; // 强制将通道中的数据全部写出

abstract public void close () throws IOException ; // 关闭通道

FileWriter 构造方法

public FileWriter ( String fileName ) throws IOException ; // 根据提供的文件路径构建一条文件输出通道

// 根据提供的文件路径构建一条文件输出通道，并根据 append 的值决定是将内容追加到末尾还是直接覆盖

public FileWriter ( String fileName , boolean append ) throws IOException ;

public FileWriter ( File file ) throws IOException ; // 根据提供的文件信息构建一条文件输出通道

// 根据提供的文件信息构建一条文件输出通道，并根据 append 的值决定是将内容追加到末尾还是直接覆盖

public FileWriter ( File file , boolean append ) throws IOException ;

Reader 常用方法

public int read () throws IOException ; // 读取一个字符

public int read ( char cbuf []) throws IOException ; // 读取字符到给定的字符数组中

// 将读取的字符按照给定的偏移量和长度存储在字符数组中

abstract public int read ( char cbuf [], int off , int len ) throws IOException ;

abstract public void close () throws IOException ; // 关闭通道

FileReader 构造方法

public FileReader ( String fileName ) throws FileNotFoundException ; // 根据提供的文件路径构建一条文件输入通道

public FileReader ( File file ) throws FileNotFoundException ; // 根据提供的文件信息构建一条文件输入通道

综合练习

使用字符流实现磁盘文件拷贝功能

package com . we . io . _char ;

import java . io . * ;

public class Example3 {

        public static void main ( String [] args ) {

                String sourceFile = "F:\\AA\\io.txt" ;

                String destFile = "F:\\file\\a.txt" ;

                copyFile ( sourceFile , destFile );

        }

        public static void copyFile ( String sourceFile , String destFile ){

                File file = new File ( destFile );

                File parent = file . getParentFile ();

                if ( ! parent . exists ()) parent . mkdirs ();

                        try ( Reader reader = new FileReader ( sourceFile );

                                Writer writer = new FileWriter ( file )){

                                char [] buffer = new char [ 4096 ];

                                while ( true ){

                                        int len = reader . read ( buffer );

                                        if ( len == - 1 ) break ;

                                        writer . write ( buffer , 0 , len );

  }

                                writer . flush ();

                        } catch ( FileNotFoundException e ) {

                                e . printStackTrace ();

                        } catch ( IOException e ) {

                                e . printStackTrace ();

                        }

        }

}

4. 缓冲流

缓冲流来自官方的说明

Most of the examples we've seen so far use unbuffered I/O. This means each read or write request is handled directly by the underlying OS. This can make a program much less efficient, since each such request often triggers disk access, network activity, or some other operation that is relatively expensive.

到目前为止，我们看到的大多数示例都使用无缓冲的 I / O 。这意味着每个读取或写入请求均由基础操作系统直接处理。由于每个这样的请求通常会触发磁盘访问，网络活动或某些其他相对昂贵的操作，因此这可能会使程序的效率大大降低。

To reduce this kind of overhead, the Java platform implements buffered I/O streams. Buffered input streams read data from a memory area known as a buffer; the native input API is called only when the buffer is empty. Similarly, buffered output streams write data to a buffer, and the native output API is called only when the buffer is full.

为了减少这种开销， Java 平台实现了缓冲的 I / O 流。缓冲的输入流从称为缓冲区的存储区中读取数据；仅当缓冲区为空时才调用本机输入API 。同样，缓冲的输出流将数据写入缓冲区，并且仅在缓冲区已满时才调用本机输出API 。

There are four buffered stream classes used to wrap unbuffered streams: BufferedInputStream and BufferedOutputStream create buffered byte streams, while BufferedReader and BufferedWriter create buffered character streams.

有四种用于包装非缓冲流的缓冲流类： BufferedInputStream 和 BufferedOutputStream 创建缓冲的字节流，而BufferedReader 和 BufferedWriter 创建缓冲的字符流。

BufferedOutputStream 构造方法

public BufferedOutputStream ( OutputStream out ); // 根据给定的字节输出流创建一个缓冲输出流，缓冲区大小使用默认大小

public BufferedOutputStream ( OutputStream out , int size ); // 根据给定的字节输出流创建一个缓冲输出流，并指定缓冲区大小

BufferedInputStream 构造方法

public BufferedInputStream ( InputStream in ); // 根据给定的字节输入流创建一个缓冲输入流，缓冲区大小使用默认大小

public BufferedInputStream ( InputStream in , int size ); // 根据给定的字节输入流创建一个缓冲输入流，并指定缓冲区大小

BufferedWriter 构造方法

public BufferedWriter ( Writer out ); // 根据给定的字符输出流创建一个缓冲字符输出流，缓冲

区大小使用默认大小

public BufferedWriter ( Writer out , int sz ); // 根据给定的字符输出流创建一个缓冲字符输

出流，并指定缓冲区大小

BufferedReader 构造方法

public BufferedReader ( Reader in ); // 根据给定的字符输入流创建一个缓冲字符输入流，缓冲

区大小使用默认大小

public BufferedReader ( Reader in , int sz ); // 根据给定的字符输入流创建一个缓冲字符输入

流，并指定缓冲区大小