今日内容

• IO流

• 字节流

• 字符流

• 异常处理

要点注意：

字符流，只能操作文本文件，不能操作图片，视频等非文本文件。所以，当我们单纯的就是想操作文本文件，就使用字符流，其他情况一律使用字节流。

如果开启多个流，流的关闭顺序，先开的后关，后开的先关

当读取到文件的末尾时没有代码后，返回一个-1

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

IO流：

I:intput:  输入(读取，把硬盘中数据，读取到内存中使用)
O:output:  输出(写出，把内存当中的数据写入到磁盘中保存起来)
流：数据(字节，字符)1个字符=2个字节，1个字节=8个二进制

IO分类：

	输入流：把数据读取到内存中的流	输出流：把数据输出到设备内(硬盘内)
字节流：以字节为单位，读写数据的流。	字节输入流InputStream	字节输出流OutputStream
字符流：以字符为单位，读写数据的流。	字符输入流Reader	字符输出流Writer

字节流：

　　一切皆为字节(所有的传输流底层都是二进制字节传输)

字节输出流【OutputStream】：

java.io.OutputStream此抽象类是表示输出字节流的所有类的超类，将指定的字节信息写入到目的地。他定义了字节输出流的基本共性的API方法：

public void close():  关闭此输出流并释放与此流相关的其他任何系统资源。
public void flush():  刷新此输出流，并强制任何缓冲的输出字节信息被写入。
public void write(byte[] b):  将b.length字节从指定的字节数组写入到此输出流中。
public void write(byte[] b,int off,int len):  从指定的字节数组写入len个字节，从偏移量off开始，输出到此输出流中
public abstract void write(int b):  将指定的字节输出到此输出流中。

备注：close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

　　java.io.FileOutputStream类 是文件字节输出流，用于将数据写入到文件(磁盘)中，

构造方法

public FileOutputStream(File file):  创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
public FileOutputStream(String name):  创建文件输出流已指定的文件名称写入到文件中

当你创建一个文件的时候，必须先传递一个文件路径，该路径下，如果没有这个文件，会创建该文件，如果有这个文件，会清空这个文件的内容.

        //1.创建一个FileOutputStream类对象，构造方法和传递写入数据的目的地
        FileOutputStream fos = new FileOutputStream("day28_IO\\a.txt");
        //2.调用FileOutputStream类对象write，把数据写入到文件中
        fos.write(97);//采用的阿斯克码表写入
        //3.释放资源
        fos.close();

再次往该文件添加信息，并且保留源文件

public FileOutputStream(File file,boolean append):  创建文件输出流以写入由指定的File对象表示的文件中。(boolean作用是判断要不要在末尾添加)
public FileOutputStream(String name,boolean append) :  创建文件输出流以指定的名称写入文件中。

这两个构造方法，参数中都需要传入一个boolean类型的值，true表示的追加数据，false表示清空原有数据，这样的情况下创建输出流对象，就可以指定是否需要在文件的末尾追加。

代码演示：

    //1.创建对象
    FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", true);
    //2.调用write()
    fos.write("HelloWorld".getBytes());
    //3.关闭流对象
    fos.close();

 

换行

Windows系统里边，换行符号是'\r\n'。把以指定的是否需要追加续写换行。
Linux系统里面，换行符号是'/n'
mac系统里面,换行符号是'/r'
Unix系统里，每行结尾只有换行，即'\n'
回车符\r   和   换行符\n

public static void main(String[] args) throws IOException {
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", true);
        // 实现数据换行
        fos.write("\r\n".getBytes());
        //2.调用write()
        fos.write("Java31".getBytes());
        //3.关闭流对象
        fos.close();
    }

字节输入流【InputStream】

java.io.InputStream此抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存(工作台)中，

public void close():  关闭次输入流并释放与此流相关的其他的任何系统资源
public abstract int read():  从输入流中读取数据的下一个字节。
public int read(byte[] b):  从输入流中读取一些字节数，并将它们存储到字节数组b当中

备注：close方法，当完成流的相关操作后，需要调用此方法关闭输入流，释放系统资源。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节(显示在工作台)。

构造方法

FileInputStream(File file): 通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的File对象file命名。FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream，改文件由文件系统中的路径名name命名。

当你创建一个流对象时，必须传入一个文件路径，该路径下，如果没有该文件，会抛出FileNotFoundException


代码示例:

 // 1. 创建一个FileInputStream类对象，构造方法中绑定要读取的文件
FileInputStream fis = new FileInputStream("day28_IO\\c.txt");
// 2. 使用FileInputStream类对象中的方法read(),读取文件中的数据
 int len = 0 ;// 表示记录读取到的字节
    while ( (len = fis.read()) != -1) {
        System.out.print((char)len+"");// Hello
    }
// 3. 释放资源，关闭流对象。
fis.close();

当读取到文件的末尾时没有代码后，返回一个-1.

//1.创建对象
FileInputStream fis = new FileInputStream("day28_IO\\c.txt");
            int len = 0;//记录读取到的有效字节个数
            byte[] bytes = new byte[1024];//整数单位 1024
            while ((len=fis.read(bytes))!=-1){
                //byte[]  转换成String
                //String（byte[] bytes, int offset, int length）  把字节数组的一部分转换成字符串
                //System.out.print( Arrays.toString(bytes)+"");//
                System.out.println(new String(bytes,0,len));

备注：使用数组读取，每次可以读取多个字节，减少了系统间的IO操作次数，从而提高了读取的效率，建议使用。

备注：如果开启多个流，流的关闭顺序，先开的后关，后开的先关

 

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存当中

public void close():  关闭此输入流并且释放与此流相关的其他系统资源
public int read():   从输入流中读取一个字符
public int  read(char[] chuf):  从输入流中一次读取多个字符，并将它们存储到字符数组chuf当中

FileReader类

java.io.FileReader类主要是用于读取字符文件的便携类。构造方法使用时默认的编码字符集和默认的字节缓冲区。
备注：
1.字符编码：字节与字符的对应规则，Windows系统中的中文编码默认是GBK编码表，idea采用的是UTF_8

2.字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法
FileReader(File file): 创建一个新的FileReader对象，指定需要读取的file对象
FileReader()(String filename):创建一个新的FileReader对象， 指定需要读取的文件名称。
  当你创建一个流对象时， 必须传入一个文件路径。类似于FileInputStream.

 

代码示例：

//1.创建对象，构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader(" day28_ IO\\c.txt");
//2.使用该对象中的方法read()来读取文件数据
// int read() 读取单个字符并返回
/*int len = fr.read();
System . out . println( (char)len);// 72 H  张*/
int len = 0;//记录读取的字符
while ((len = fr.read()) != -1) {
System.out.print((char)len);
}

使用字符数组读取数据：read(char[] chuf),每次读取chuf的长度的字符到有效字符的个数。当他读取到末尾的时候，返回-1。

//1.创建对象，构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader("day28 IO\\c.txt");
char[] chuf  = new char[1024];
int len = 0;//记录的是每次读取的有效的字符个数
//2.使用该对象中的方法read()来读取文件数据
while ((len = fr.read(chuf))!=-1){
//字符数组转换成字符串
System.out.println( new String(chuf,0,len));
}
// 3.释放资源，关闭此输入流。
fr.close();

 

 

字符输出流【Writer】

java.io.Writer抽象类是表示用于输出字符流的所有类的超类，将指定的字符信息写入到目的地中。

void write(int c): 写入单个字符。
void write(char[] chuf): 写入字符数组
abstract void write(char[] chuf, int off,int len):写入char[] 数组的一部分，off开始的len个字符个数
void write(String str):  写入字符串。
void write(String str,int off,int len): 写入字符串的一部分，从字符串的起始索引off开始，写入len个字符个数。
void flush(): 刷新该流的缓冲。
void close(): 关闭此流，但是需要先刷新它。

FileWrite类

java.io.FileWriter 类是用于写入字符到文件中。构造方法使用系统默认的字符编码和默认的字节缓冲区。

构造方法：
FileWrite(File file): 创建一个新的FileWrite,指定写入的file对象。
FileWrite(String filename): 创建一个新的FileWriter，指定需要写入的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

代码示例

    public static void main(String[] args) throws IOException {
        //1.创建一个FileWriter对象，构造方法中绑定需要写入数据的目的地。
        FileWriter fw = new FileWriter("day28_IO\\e.txt");
        //2.使用fileWriter对象中的方法writer，把数据写入到内存缓冲区中(字符转换为字节的过程)
        //void write(int c)  写入单个字符
        fw.write(107);//  K
        //3.使用FileWriter对象中的方法flush，把内存缓冲区中的数据刷新到文件中
        //fw.flush();
        //4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
        fw.close();
    }

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写入字符到文件中。但是关闭流对象，是无法继续写入数据到文件中。如果既想写入数据到文件中，又想继续使用流对象，那么就需要flush方法。

flush :刷新缓冲区，流对象可以继续使用
close：先刷新缓冲区，然后会通知系统释放资源，关闭流对象，流对象不可以再使用

JDK7异常处理

可以使用try-with-resourse语句，该语句确保了每个资源在语句结束时关闭，所谓的资源(resource)是指在程序完成后，必须要关闭的对象。

格式：

try(创建流对象语句，如果多个请使用分号隔开){
    //可能产生异常的代码
}catch(异常类型  异常变量名){
    //异常处理逻辑
}

 

 

 

 

标签：字符,读取,文件,int,写入,IO,字节,day28
来源： https://www.cnblogs.com/rxqq/p/14141644.html