Java--I/O流_2

常用类

FileReader

• FileReader 字符输入流

  • new Filereader(File/String);
  • read:每次读取单个字符，返回该字符，如果到文件末尾返回-1
  • read(char[]):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
  • 相关API
    • new String（char[]）将char[]转换成String
    • new String（char[],off,len）将char[]的指定部分转换成String

  @Test
      public void fileReader(){
          //创建一个FileReader对象
          FileReader fileReader = null;
         int data = 0;
          try {
              fileReader = new FileReader("D:\\a.txt");
              //循环读取
              while ((data = fileReader.read())!=-1) {
                  System.out.print((char)data);
              }
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }finally{
  						//关闭文件
              if(fileReader!=null){
                  try {
                      fileReader.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  

  FileWriter

• FileWriter 字符输出流

  • new FileWriter（File/String）:覆盖模式，相当于流的指针在首端
  • new FileWriter（File/String，true）:追加模式，相当于流的指针在尾端
  • write(int) :写入单个字符
  • write(char[]) :写入指定数组
  • write(char[]，off,len) :写入指定数组的指定部分
  • write(String):写入整个字符串
  • write(String,off,len):写入指定字符串的指定部分
  • 注意：FileWriter使用后，必须要关闭或刷新，否则写入不到指定的文件

  @Test
      public void fileWriter(){
          //要写入的数据
          String data = "过了很久终于我愿抬头看\n你就在对岸走的好慢";
          //创建一个FileWriter对象
          FileWriter fileWriter = null;
          try {
              fileWriter = new FileWriter("D:\\a.txt",true);
              fileWriter.write(data);
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }finally{
  						//关闭文件
              if(fileWriter!=null){
                  try {
                      fileWriter.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  

  ---

  缓存是I/O的一种性能优化。缓存流为I/O增加了缓存区，使得在流上执行skip()、mark（），reset（）方法成为可能

  节点流和处理流

  • 节点流可以从一个特定的数据源读写数据，如FileReader，FileWriter
  • 处理流是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter

BufferedReader

• BufferedReader

  • 按照字符读取文件，尽量用来读取文本文件
  • 关闭时，只关闭外层流即可,底层会自动关闭节点流

  @Test
      public void BufferReader_() throws IOException {
          //建立路径
          String filePath = "D:\\a.txt";
          //创建BufferedReader对象
          BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
          //读取
          String line;
          //按行读取，返回为空是说明文件读取完毕
          while((line = bufferedReader.readLine())!=null){
              System.out.println(line);
          }
          //关闭流
          bufferedReader.close();
      }
  

BufferedWriter

• BufferedWriter

  @Test
      public void BufferWriter_() throws IOException {
          //建立路径
          String filePath = "D:\\a.txt";
          //创建BufferedReader对象,true追加写入
          BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
  
          String line = "";
          bufferedWriter.write("过了很久终于我愿抬头看");
  				bufferedWriter.newLine();
          //关闭流
          bufferedWriter.close();
      }
  

文件拷贝

1.创建输入流对象，读取文件

2.创建输出流对象，将读取到的文件写入到指定文件

3.定义一个数组用来暂时储存文件数据，使用数组可以提高读取效率

4.因为不能一次性读取完，所以使用循环来读取

5.读取完记得关闭文件，以防占用资源

@Test
    public void copy(){
        //1.创建输入流对象，读取文件
        //2.创建输出流对象，将读取到的文件写入到指定文件

        String fileinPath = new String("D:\\1.jpg");
        String fileoutPath = new String("D:\\1\\1.jpg");
        FileInputStream fileinput = null;
        FileOutputStream fileoutput = null;

        //定义一个字节数组，提高读取效率
        byte []buffer = new byte[1024];
        //用来判断是否读到文件末尾
        int read = 0;
        try {
            fileinput = new FileInputStream(fileinPath);
            fileoutput = new FileOutputStream(fileoutPath);

            while((read=fileinput.read(buffer))!=-1){
                //边读边写
                fileoutput.write(buffer,0,read);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
						//关闭
            if(fileoutput!=null){
                try {
                    fileoutput.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fileinput!=null){
                try {
                    fileinput.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }