【java学习笔记-io流文件读写和键盘读写】带缓存的输入／输出流和数据输入／输出流

秒速五厘米 2022-10-18 04:55 217阅读 0赞

### 文章目录 ###

*   *  字节流类
     *  带缓存的输入／输出流
     *   *  BufferedReader与BufferedWriter类
         *  下面的例子程序演示了read()方法，从控制台读取字符直到用户键入“q”：
         *  下面一个例子：从键盘读取字符，直到输入stop停止
         *  文本输出PrintWriter流：
         *  PrintWriter注意事项
     *  文件的读写
     *   *  读取文本单行文字并输出
     *  键盘读取--Scanner对象
     *  数据输入／输出流（DataInputStream类与DataOutputStream类）
     *  字符流的输入/输出类

--------------------

## 字节流类 ##

字节流由两个类层次结构定义。在顶层有两个抽象类：InputStream 和 OutputStream。  
每个抽象类都有多个具体的子类，这些子类对不同的外设进行处理，例如磁盘文件，网络连接，甚至是内存缓冲区，要使用流类，必须导入Java.io包。

## 带缓存的输入／输出流 ##

缓存是I/O的一种性能优化。缓存流为I/O流增加了内存缓存区。有了缓存区，使得在流上执行skip()、mark()和reset()方法都成为可能。  
BufferedInputStream与BufferedOutputStream类 BufferedInputStream类可以对所有InputStream类进行带缓存区的包装以达到性能的优化。  
BufferedInputStream类有两个构造方法： 　BufferedInputStream(InputStream in)。 　BufferedInputStream(InputStream in,int size)。  
第一种形式的构造方法创建了一个带有32个字节的缓存流；第二种形式的构造方法按指定的大小来创建缓存区。  
**一个最优的缓存区的大小，取决于它所在的操作系统、可用的内存空间以及机器配置**。从构造方法可以看出，BufferedInputStream对象位于InputStream类对象之前。  
字节数据读取文件的过程：

文件：–>InputStream -->BufferedInputStream–>目的地  
（BufferedInputStream读取文件过程）

使用BufferedOutputStream输出信息和用OutputStream输出信息完全一样，只不过BufferedOutputStream有一个flush()方法用来将缓存区的数据强制输出完。  
BufferedOutputStream类也有两个构造方法： 　BufferedOutputStream(OutputStream in)。 　BufferedOutputStream(OutputStream in,int size)。  
第一种构造方法创建一个有32个字节的缓存区，第二种构造方法以指定的大小来创建缓存区。  
*注意： flush()方法就是用于即使在缓存区没有满的情况下，也将缓存区的内容强制写入到外设，习惯上称这个过程为刷新。flush()方法只对使用缓存区的OutputStream类的子类有效。当调用close()方法时，系统在关闭流之前，也会将缓存区中的信息刷新到磁盘文件中。*

### BufferedReader与BufferedWriter类 ###

BufferedReader 支持缓冲输入流。它最常见的构造函  
数如下：  
BufferedReader(Reader inputReader)  
这里，inputReader是链接被创建的BufferedReader实例的流。Reader是一个抽象类。它的一个具体的子类是InputStreamReader，该子类把字节转换成字符。为获得链接System.in的一个InputStreamReader的对象，用下面的构造函数：  
InputStreamReader(InputStream inputStream)  
BufferedReader类与BufferedWriter类分别继承Reader类与Writer类。这两个类同样具有内部缓存机制，并可以以行为单位进行输入／输出。  
BufferedReader类常用的方法如下：  
　read()方法：读取单个字符。  
　readLine()方法：读取一个文本行，并将其返回为字符串。若无数据可读，则返回null。  
　BufferedWriter类中的方法都返回void。常用的方法如下。 　  
write(String s, int off, int len)方法：写入字符串的某一部分。  
flush()方法：刷新该流的缓存。 　  
newLine()方法：写入一个行分隔符。

因为System .in引用了InputStream 类型的对象，它可以用于inputStream。综上所述，下面的一行代码创建了与键盘相连的BufferedReader对象。  
BufferedReader br = new BufferedReader(new  
InputStreamReader(System.in));  
当该语句执行后，br是通过System.in生成的链接控制台的字符流。  
在使用BufferedWriter类的Write()方法时，数据并没有立刻被写入输出流，而是首先进入缓存区中。**如果想立刻将缓存区中的数据写入输出流，一定要调用flush()方法**。

### 下面的例子程序演示了read()方法，从控制台读取字符直到用户键入“q”： ###

import java.io.*;
    class BRRead { 
    public static void main(String args[])
    throws IOException
    { 
    char c;
    BufferedReader br = new
    BufferedReader(new InputStreamReader(System.in));
    System.out.println("Enter characters, 'q' to quit.");
    // read characters
    do { 
    c = (char) br.read();
    System.out.println(c);
    } while(c != 'q');
    }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]

### 下面一个例子：从键盘读取字符，直到输入stop停止 ###

class nn { 
        public static void main(String args[])
                throws IOException { 
    // create a BufferedReader using System.in
            BufferedReader br = new BufferedReader(new
                    InputStreamReader(System.in));
            String str[] = new String[100];
            System.out.println("Enter lines of text.");
            System.out.println("Enter 'stop' to quit.");
            for (int i = 0; i < 100; i++) { 
                str[i] = br.readLine();
                if (str[i].equals("stop")) break;
            }
            System.out.println("\nHere is your file:");
    // display the lines
            for (int i = 0; i < 100; i++) { 
                if (str[i].equals("stop")) break;
                System.out.println(str[i]);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]

### 文本输出PrintWriter流： ###

这个类拥有以文本格式打印字符串和数字的方法。  
PrintStream 定义的write( )的最简单的形式如下：  
void write(int byteval)  
该方法按照byteval指定的数向文件写字节。尽管byteval 定义成整数，但只有低位的8个字节被写入.  
例子：

// Demonstrate System.out.write().
    class WriteDemo { 
    public static void main(String args[]) { 
        PrintWriter iout = new PrintWriter("D:\\Error.txt","UTF-8");
                        iout.println("sf");
                        iout.flush();
                        iout.close();
    }
    }

对于实际的程序，Java推荐的向控制台写数据的方法是用  
PrintWriter流。PrintWriter是基于字符的类。用基于字符类向控制台写数据使程序更为国际化。  
PrintWriter定义了多个构造函数，我们所用到的一个如下：  
PrintWriter(OutputStream outputStream, boolean flushOnNewline)  
PrintStream类型的对象的行为看起来确实很像打印写出器，但是与打印写出器不同的是，它们允许我们用write（int）和write（byte\[\]）方法输出原生字节。

### PrintWriter注意事项 ###

注意！  
  
iout.flush();  
iout.close();  
必须写，否则无法写入到文本文件！！！！！  
优点：使用PrintWriter使实际的应用程序更容易国际化

public class PrintWriterDemo { 
    public static void main(String args[]) { 
    PrintWriter pw = new PrintWriter(System.out, true);
    pw.println("This is a string");
    int i = -7;
    pw.println(i);
    double d = 4.5e-7;
    pw.println(d);
    }
    }

该程序的输出如下：  
This is a string  
\-7  
4.5E-7

## 文件的读写 ##

两个最常用的流类是FileInputStream和FileOutputStream，**它们生成与文件链接的字节流**。为打开文件，你只需创建这些类中某一个类的一个对象，在构造函数中以参数形式指定文件的名称。这两个类都支持其他形式的重载构造函数。下面是我们将要用到的形式：  
FileInputStream(String fileName) throws FileNotFoundException  
FileOutputStream(String fileName) throws FileNotFoundException  
对文件的操作结束后，需要调用close( )来关闭文件。  
向文件中写数据，需用FileOutputStream定义的write()方法。它的最简单形式如下：  
void write(int byteval) throws IOException

### 读取文本单行文字并输出 ###

本实例向指定的磁盘文件中写入数据，并通过BufferedReader类将文件中的信息分行显示。代码如下：

import java.io.*;
    
    public class Student { 
        public static void main(String[] args) throws FileNotFoundException { 
            String content[] = { "nice", "哥哥好","加油哦哈哈哈"};
            File file = new File("word.txt");
            try { 
                FileWriter fw = new FileWriter(file);
                BufferedWriter bufw = new BufferedWriter(fw);
                for (int k = 0; k < content.length; k++) { 
                    bufw.write(content[k]);//将字符串数组中的元素写入到磁盘文件
                    bufw.newLine();//将数组中单个元素以单行的形式写入文件
                }
                bufw.close();//关闭流
                fw.close();
            } catch (Exception e) { 
                e.printStackTrace();
            }
    
        try
        { 
            FileReader fr = new FileReader(file);
            BufferedReader bffr = new BufferedReader(fr);
            String s = null;
            int i = 0;
            while((s=bffr.readLine())!=null){ 
                i++;
                System.out.println("第"+i+"行"+s);
            }
            bffr.close();
            fr.close();
        }
        catch(Exception e1)
        { 
            e1.printStackTrace();
        }
    
    }
    }

https://www.waveshare.net/wiki/IMX219-120\_Camera

## 键盘读取–Scanner对象 ##

要想通过控制台进行输入，首先需要构造一个Scanner对象，并与“标准输入流”System.in关联。

Scanner in = new Scanner(System.in);
            String name = in.nextLine();//读取一行 可以包含空格
            String first = in.next();//以空白符作为分隔符
            int age = in.nextInt();//读取整数
            double money = in.nextDouble();
            Console cons = System.console();//用于读取密码的类
            String username = cons.readLine("name:");
            char[] password = cons.readPassword("password:");

·boolean hasNextInt（）  
·boolean hasNextDouble（）

## 数据输入／输出流（DataInputStream类与DataOutputStream类） ##

DataInputStream类与DataOutputStream类允许应用程序以与机器无关的方式从底层输入流中读取基本Java数据类型。也就是说，当读取一个数据时，不必再关心这个数值应当是哪种字节。  
DataInputStream类与DataOutputStream类的构造方法如下。 　DataInputStream(InputStream in)：  
使用指定的基础InputStream创建一个DataInputStream。 　DataOutputStream(OutputStream out)：创建一个新的数据输出流，将数据写入指定基础输出流。  
DataOutputStream类提供了如下3种写入字符串的方法。 　writeBytes(String s)。 　  
writeChars(String s)。 　  
writeUTF(String s)。  
由于Java中的字符是Unicode编码，是双字节的，writeBytes只是将字符串中的每一个字符的低字节内容写入目标设备中；而writeChars将字符串中的每一个字符的两个字节的内容都写到目标设备中；writeUTF将字符串按照UTF编码后的字节长度写入目标设备，然后才是每一个字节的UTF编码。 DataInputStream类只提供了一个readUTF()方法返回字符串。这是因为要在一个连续的字节流读取一个字符串，如果没有特殊的标记作为一个字符串的结尾，并且不知道这个字符串的长度，就无法知道读取到什么位置才是这个字符串的结束。DataOutputStream类中只有writeUTF()方法向目标设备中写入字符串的长度，所以也能准确地读回写入字符串。

附录：  
流类 含义  
BufferedInputStream 缓冲输入流  
BufferedOutputStream 缓冲输出流  
ByteArrayInputStream 从字节数组读取的输入流  
ByteArrayOutputStream 向字节数组写入的输出流  
DataInputStream 包含读取Java标准数据类型方法的输入流  
DataOutputStream 包含编写Java 标准数据类型方法的输出流  
FileInputStream 读取文件的输入流  
FileOutputStream 写文件的输出流  
FilterInputStream 实现 InputStream  
FilterOutputStream 实现 OutputStream  
InputStream 描述流输入的抽象类  
OutputStream 描述流输出的抽象类  
PipedInputStream 输入管道  
PipedOutputStream 输出管道  
PrintStream 包含print( ) 和 println( )的输出流  
PushbackInputStream 支持向输入流返回一个字节的单字节的“unget”的输入流  
RandomAccessFile 支持随机文件输入/输出  
SequenceInputStream 两个或两个以上顺序读取的输入流组成的输入流

## 字符流的输入/输出类 ##

字符流类由两个类层次结构定义。顶层有两个抽象类：Reader和Writer。这些抽象类处理统一编码的字符流。

BufferedReader 缓冲输入字符流  
BufferedWriter 缓冲输出字符流  
CharArrayReader 从字符数组读取数据的输入流  
CharArrayWriter 向字符数组写数据的输出流  
FileReader 读取文件的输入流  
FileWriter 写文件的输出流  
FilterReader 过滤读  
FilterWriter 过滤写  
InputStreamReader 把字节转换成字符的输入流  
LineNumberReader 计算行数的输入流  
OutputStreamWriter 把字符转换成字节的输出流  
PipedReader 输入管道  
PipedWriter 输出管道  
PrintWriter 包含print( )和println( )的输出流  
PushbackReader 允许字符返回到输入流的输入流  
Reader 描述字符流输入的抽象类  
StringReader 读取字符串的输入流  
StringWriter 写字符串的输出流  
Writer 描述字符流输出的抽象类  
其中两个最重要的是read()和write()，它们分别进行字符数据的读和写。这些方法被派生流类重载。

注意：**Java没有像标准C的函数scanf()或C++输入操作符那样的统一的控制台输入**方法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70]: /images/20221014/f89e15d872af40b6bf684ef73a90eb3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMzU4NTc0_size_16_color_FFFFFF_t_70 1]: /images/20221014/e4706765f69d457cb1e5819e21efa445.png