JAVA的I/O（输入输出）流

1. List item

I/O流

1、I/O流定义

I/O流（Input/Output）输入输出流，实现数据的读写

2、分类

2.1按流向分类

按流向分类：分为输出流和输入流，输出流以OutputStream和Writer作为基类；输入流以InputStream和Reader作为基类。

2.2按处理数据单元分类

按处理数据单元分类：分为字节流和字符流，字节输入流以InputStream作为基类，字节输出以OutputStream作为基类；字符输入流以Reader作为基类，字符输出流以Writer作为基类，

2.3类结构

InputStream和OutputStream, Reader和Writer四个类为最上层的类，其他类均为其子类和孙子类

3、字节流

3.1字节流输入输出

3.1.1字节流输入

字节流的输入最上层类使用InputStream
常用方法如下
1.int read()：从输入流读取一个8位的字节，把它转换为0-255之间的整数，并返回这一整数，当读取完成时，将返回-1。

2.int read(byte[] b)从输入流读取若干字节，把它们保存到参数b指定的字节数组中，返回的整数表示读取字节的数目。

3.int read(byte[] b,int off,int len)从输入流读取若干字节，把它们保存到参数b指定的字节数组中，off指定字节数组开始保存数据的起始下标，len表示读取的字节数目。

4.void close()关闭此输入流并释放与该流关联的所有系统资源。

5.int available():可以从输入流中读取的字节数目。

InputStream的常用子类为FileInputStream，其常用的构造方法为：

FileInputStream(File file)

FileInputStream(String name)

3.1.2实现步骤

1.引入相关类：
import java.io.File;
import java.io.FileInputStream;
2.构造文件输入对象：
FileInputStream fis= new FileInputStream(“c:\test.txt”);
3.读取文件数据：
fis.available();
fis.read();
4.关闭文件：
fis.close();

3.1.3代码实现

读取文件内容

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

public class FileInputStreamStu {
    public static void main(String[] args) {
        FileInputStream fis = null;
        //创建file Input Streamduix
        try {
            fis = new FileInputStream("D:\\test.txt");//文件内容为a,ab,abc
            System.out.println(fis.available());//获取文件字节数
            int data;
            byte[] b = new byte[1024];//创建一个数组用来读取文件
            while ((data = fis.read(b)) != -1) {
                System.out.println(data);
                //遍历输出
//                for (int i = 0; i < b.length; i++) {
//                    System.out.println((char) b[i]);
                //                }
                for (byte a : b) {
                    System.out.println(a);
                    System.out.println((char) a);
                }//强转为字符串
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();//关闭输入流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.1.4字节流输出

字节流的输输出都使用OutputStream
常用方法如下：
void write(int c) 输出一个字节流。
void write(byte[] buf)输出参数buf指定的字节数组。
void write(byte[] b, int off, int len)把byte数组中从偏移量off开始的len个字节写入输出流。
void flush()强制把缓冲区的数据写到输出流中。
void close()关闭此输出流。
OutputStream的子类FileOutputStream常用的构造方法为：
FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)

3.1.5实现步骤

1.引入相关类：
import java.io.IOException;
import java.io.FileOutputStream;
2.构造文件输出流：
FileOutputStream fos = new FileOutputStream(“text.txt”);
3.把数据写入文件：
String str =“好好学习Java”;
byte[] words = str.getBytes();
fos.write(words,0, words.length);
4.关闭文件流：
fos.close();

3.1.6代码实现

数据写入

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamStu {
   public static void main(String[] args) {
        FileOutputStream fos =null; //创建输出对象
        try {
          fos = new FileOutputStream("D:\\idfile2.txt",true);//创建输出对象，true为增加写入，不加就是覆盖写入
          String info ="good good tudy day day up";//定义一个字符串
          fos.write(97);//写出数据
          fos.write(info.getBytes());//写入字符串获取的字节数组
          String info1 ="我爱你中国";
          byte []bytes=info1.getBytes();
          System.out.println(info1.length());//字符串长度
          System.out.println(info1.getBytes().length);//字节数组长度
          fos.write(info1.getBytes(),0 ,info1.getBytes().length);//写入
          fos.flush();//刷新缓冲区写入数据
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

4字符流

4.1字符流输入输出

4.1.1字符流输入

字符流输入最上层类使用Reader类。
常用的方法：
int read()：从数据流中读取整数
int read(char[] c)：读取指定字符串
int read(char[] c,int off,int len)：把字符数组中从偏移量off开始的len个字符读入。
void close( )；关闭数据流

常用的Reader的孙子类：FileReader的构造方法有；
FileReader(File file)
FileReader(String name)
读取文件过程：
1.引入资源
2.创建FileReader对象
3.Read（）读取文件
4.关闭字符流

4.1.2中文乱码情况

解决中文的乱码情况：
方法1:手工调整编码格式与程序环境编码格式一致。
方法2：使用Reader子类InputStreamReader。
其构造方法：
InputStreamReader(InputStream in)
InputStreamReader(InputStream in,String charsetName)

4.1.3缓冲区

使用BufferedReader类提高字符流读取文本文件的效率，BufferedReader类是Reader类的子类，BufferedReader类带有缓冲区，按行读取内容的readLine()方法
BufferedReader常用的构造方法：BufferedReader(Reader in)
子类BufferedReader特有的方法：readLine()

4.1.4BufferedReaderer读取文件

1.引入相关的类：
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;
2.构造BufferedReader和FileReader对象
Reader fr=new FileReader("C:\myTest.txt ");
BufferedReader br=new BufferedReader(fr);
3.调用方法读取数据：
br.readLine();
4.关闭文件流对象：
br.close();
fr.close();

4.1.5代码实现

import java.io.*;

public class BufferedReaderStu {
    public static void main(String[] args) {
        Reader fr =null;
        BufferedReader bf =null;
        FileInputStream fis =null;
        try {//创建文件构造对象，设置编码方式
            fis =new FileInputStream("D:\\idfile.txt");
            fr =new InputStreamReader(fis,"utf8");
            bf =new BufferedReader(fr);
            //读取输入流
            String content ="";
            while ((content= bf.readLine())!=null){
                System.out.println(content);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
        try {//关闭文件流
            fis.close();
            fr.close();
            bf.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

4.1.6字符流输出

字符流输出最上层类为Writer类
Writer类常用方法
write(String str):写入字符串str
write(String str,int off,int len)：把字符串str从偏移量off开始的len个字节写入输出流。
void close()；关闭文件流
void flush()：刷新缓冲区

FileWriter类是Writer的孙子类,其构造方法为：
FileWriter (File file)
FileWriter (String name)

4.1.7中文乱码情况

使用Writer子类OutputStreamWriter解决中文乱码情况。
常用的构造方法
OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String charsetName)

4.1.8缓冲区

BufferedWriter类是Writer类的子类，BufferedWriter类带有缓冲区，常用的构造方法：
BufferedWriter(Writer out)

4.1.9写入步骤

1.引入相关类：
import java.io.FileWriter;
import java.io.BufferedWriter；
import java.io.IOException;
2.构造BufferedWriter对象和FileWriter对象：
FileWriter fw=new FileWriter(“C:\myTest.txt”);
BufferedWriter bw=new BufferedWriter(fw);
3.调用方法写入数据：
bw.write(“hello”);
4。刷新缓冲区，关闭文件流：
bw.flush();
fw.close();

4.1.10代码实现

import java.io.*;

public class BufferedWriterStu {
    public static void main(String[] args) {
        //Writer fw =null;
        BufferedWriter bw =null;
        OutputStreamWriter osw=null;
        FileOutputStream fos =null;
        try {//构造对象
            fos=new FileOutputStream("D:\\bufferedWrite.txt");
            osw =new OutputStreamWriter(fos,"UTF8");
            bw =new BufferedWriter(osw);
            //写入数据
            bw.write("今天最高温度25度");
            bw.newLine();
            bw.write("适合出去玩");
            bw.newLine();
            bw.write("收到请回答");
            bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {//关闭文件流
                bw.close();
                fos.close();
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}