Java第三十天，I/O操作

一、基本概念

输入输出一般是相对与内存、CPU寄存器、当前进程来说的

输入：从硬盘、键盘等外部设备读取数据到内存、当前进程或CPU寄存器中

输出：利用当前进程将数据写入到硬盘、终端显示屏等外部设备中

二、Java中IO操作的方法——字节流、字符流

	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Writer

三、OutputStream

该类是所有字节输出流的抽象父类

1.公共方法

void close() ===> 关闭输出流并释放系统资源

void flush() ===> 刷新输出流并强制缓冲的输出字节被写出

void write(byte[] b) ===> 将b.length字节从指定的字节数组写入此输出流

void write(byte[] b，int off，int len) ===> 从指定的字节数组写入len个字节，从偏移off开始输出到此输出流

abstract void write(int b) ===> 将指定的字节写入此输出流

2.直接子类

ByteArrayOutputStream

FileOutputStream

FilterOutputStream

ObjectOutputStream

OutputStream

PipedOutputStream

3.FileOutputStream使用

（1）构造方法

FileOutputstream(File file) ===> 创建文件输出流

FileOutputstream(File file，boolean append) ===> 创建文件输出流,第二个参数指出是否追加写入

Fileoutputstream(String name) ===> 创建文件输出流以指定的名称写入文件

FileOutputstream(String name，boolean append) ===> 创建文件输出流，第二个参数指出是否追加写入

（2）具体代码实现

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class MyWrite {
    public static void main(String[] args) throws IOException {

        for (int i = 97; i < 117; i++) {

            File file1 = new File("F:\a.txt");
            String file2 = new String("F:\b.txt");
            File file3 = new File("F:\c.txt");
            String file4 = new String("F:\d.txt");
            FileOutputStream fosA = new FileOutputStream(file1);
            FileOutputStream fosB = new FileOutputStream(file2);
            FileOutputStream fosC = new FileOutputStream(file3,true);
            FileOutputStream fosD = new FileOutputStream(file4,true);
            fosA.write(i);
            fosB.write(i);
            fosC.write(i);
            fosD.write(i);
            fosA.close();
            fosB.close();
            fosC.close();
            fosD.close();
        }

        File file5 = new File("F:\e.txt");
        FileOutputStream fosE = new FileOutputStream(file5);
        byte[] bytes1 = {97,98,99,100,101,102,103,104,105,106,107};
        fosE.write(bytes1);
        fosE.close();

        File file6 = new File("F:\f.txt");
        FileOutputStream fosF = new FileOutputStream(file6);
        byte[] bytes2 = {97,98,99,100,101,102,103,104,105,106,107};
        fosF.write(bytes2,0,2);
        fosF.close();

        File file7 = new File("F:\g.txt");
        FileOutputStream fosG = new FileOutputStream(file7);
        byte[] bytes3 = "我爱Java".getBytes();
        fosG.write(bytes3);
        fosG.close();
    }
}

（3）注意事项

• 创建文件，写入文件，关闭文件都有异常，可以直接处理三个异常中最顶层的父类异常——IOException
• 任意的记事本（例如记事本，notepad++......），在打开文件的时候都会查询编码表，把字节准换成字符表示，若二进制的数值是0-127，则会查询accii表，否则查询系统默认码表（例如GBK,UTF-8）
• 当一次性写入多个字节的时候，若第一个字节是正数（0-127），那么显示的时候会查询ascii码表；若第一个字节为负数，那么显示的时候，第一个字节会和第二（二三）个字节组合成一个中文字符显示。GBK中两个字节表示一个中文，UTF-8中，三个字节表示一个中文
• mac系统的换行是/r，linux系统的换行是/n，Windows系统的换行是

四、InputStream

该类是所有字节输入流的抽象父类

1.公共方法

int available() ===> 返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞

void close() ===> 关闭此输入流并释放与流相关联的任何系统资源

void mark(int readlimit) ===> 标记此输入流中的当前位置

boolean markSupported() ===> 测试这个输入流是否支持mark和reset方法

abstract int read() ===> 从输入流读取数据的下一个字节

int read(byte[]b) ===> 从输入流读取一些字节数，并将它们存储到缓冲区b

int read(byte[] b，int off，int len) ===> 从输入流读取最多1en字节的数据到一个字节数组

void reset() ===> 将此流重新定位到上次在此输入流上调用mark方法时的位置

long skip(long n) ===> 跳过并丢弃来自此输入流的n字节数据

2.直接子类

AudioInputStream

ByteArrayInputStream

FileInputStream

FilterInputStream

InputStream

ObjectInputStream

PipedInputStream

SequenceInputStream

StringBufferInputStream

3..FileInputStream使用

int available() ===> 返回该输入流中可以读取（或跳过）的字节数的估计值
关闭此输入流并释放与流相关联的任何系统资源。
voidmark(int readlimit)
标记此输入流中的当前位置。
booleanmarksupported()
测试这个输入流是否支持mark和reset方法。
abstract intread()从输入流读取数据的下一个字节。
intread(byte[]b)
从输入流读取一些字节数，并将它们存储到缓冲区b。
intread(byte[]b，int off，int len)
从输入流读取最多len字节的数据到一个字节数组。
voidreset()
将此流重新定位到上次在此输入流上调用mark方法时的位置。
1ongskip(long n)
跳过并丢弃来自此输入流的n字节数据。

import java.io.FileInputStream;
import java.io.IOException;

public class MyRead {
    public static void main(String[] args) {

        int data;
        try {
            FileInputStream file = new FileInputStream("F:\info.txt");
            while( (data = file.read())!= -1){
                System.out.print(data + " ");
            }
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            FileInputStream file = new FileInputStream("F:\info.txt");
            int len = file.available();
            byte[] bytes = new byte[len];
            file.read(bytes);
            System.out.println("
" + new String(bytes));
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


注意：
1.read方法每读一次，指针向后移一位
2.String(byte[] bytes) ===> 通过使用平台的默认字符集解码指定的字节数组来构造新的String 
3.当我们要利用流进行文件复制的时候，就不可能使用InputStream.available()方法获取整个文件的字节长度，因为这个长度很有可能超过Java虚拟机甚至外部系统的缓冲内存，这个时候就需要用到read(byte[] b, int off, int len) 或 read(byte[] b) 方法进行复制了。但是用这样的方法进行复制或读取中文时，可能会出现问题。因为一个汉字不是一个字节，而是两个或三个字节。

五、Reader

该类是字符输入流的最顶层抽象父类

1.公共方法

abstract void close() ===> 关闭流并释放系统资源

voidmark(int readAheadLimit) ===> 标记流中的当前位置

booleanmark supported() ===> 判断该流是否支持mark()操作

int read() ===> 读一个字符

int read(char[] cbuf) ===> 将字符读入数组

abstract int read(char[] cbuf，int off，int len) ===> 将字符读入数组的一部分

int read(CharBuffer target) ===> 尝试将字符读入指定的字符缓冲区

boolean ready() ===> 告诉这个流是否准备好被读取

void reset() ===> 重置流

long skip(long n) ===> 跳过字符

2.直接子类

BufferedReader

CharArrayReader

FilterReader

InputStreamReader

PipedReader

StringReader

3.

• java.lang.Object
• • java.io.Reader
  • • java.io.InputStreamReader

    • • java.io.FileReader

（1）构造方法

FileReader(File file)

FileReader(String fileName)

（3）具体使用

import java.io.FileReader;
import java.io.IOException;

public class MyFileReader {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("F:\data.txt");
        int info ;
        while((info = file.read()) != -1){
            System.out.print((char)info);
        }
        file.close();

        FileReader fileTwo = new FileReader("F:\data.txt");
        char[] array = new char[100];
        int len;
        while((len = fileTwo.read(array)) != -1){
            System.out.println("
" + new String(array));
        }
        fileTwo.close();
    }
}

六、Writer

这是字符输出流中最顶层的抽象父类

1.公共方法

Writer append(char c) ===> 将指定的字符附加到此writer

Writer append(CharSequence csq) ===> 将指定的字符序列附加到此writer

Writer append(CharSequence csq，int start，int end) ===> 将指定字符序列的子序列附加到此writer

abstract void close() ===> 关闭流，先刷新

abstract void flush() ===> 刷新流

void write(char[] cbuf) ===> 写入一个字符数组

abstract void write(char[] cbuf，int off，int len) ===> 写入字符数组的一部分

void write(int c) ===> 写一个字符

void write(string str) ===> 写一个字符串

void write(string str，int off，int len) ===> 写一个字符串的一部分

2.直接子类

BufferedWriter

CharArrayWriter

FilterWriter

OutputStreamWriter

PipedWriter

PrintWriter

StringWriter

3.

• java.lang.Object
• • java.io.Writer
  • • java.io.OutputStreamWriter

    • • java.io.FileWriter

import java.io.FileWriter;
import java.io.IOException;

public class MyFileWriter {
    public static void main(String[] args) throws IOException {
        FileWriter file = new FileWriter("F:\data.txt");

        file.write(100);
        file.flush();
        file.write("英雄联盟");
        file.flush();
        char[] chars ={67,68,69,70};
        file.write(chars);
        file.flush();
        file.close();
    }
}



注意：
1.使用字符输出流时，需要知道，该对象会先将字符写入缓冲中（该过程发生的是字符转换字节的过程），然后调用flush()方法才会写入文件中
2.close()方法执行时，也会先执行fluse()方法完成数据的写入
3.close()方法和fluse()方法都会执行数据的写入，但是fluse()以后，该对象还可以继续写入。close()方法执行之后，系统资源会被释放，该对象不可再次使用
4.构建FileWriter对象时，第二个布尔类型参数可以绝对是否是对该文件追加写入。true是追加，false不追加
5.windows换行符是
，Linux换行符是/n，mac换行符是/r