文件写入与读取

1.流的基类

字节流的两个基类InputStream和OutputStream:以字节为单位，是所有字节输入和输出流的父类；

字符流的两个基类Reader和Writer:以字符（两个字节）为单位。

凡是以InputStream和OutputStream结尾的类型为字节流，凡是以Reader或Writer结尾的均为字符流。

 import java.io.*;
 
 public class FileInputStreamTest {//字节流读取文件
 
     public static void main(String[] args) throws IOException {
         //创建字节输入流
          File file=new File("文件路径");
        FileInputStream fis = new FileInputStream(file);
         //定义结束标志,可用字节数组读取
           int i =0 ;
           while((i = fis.read())!=-1){ 
            //i 就是从文件中读取的字节，读完后返回-1
          }
          //关闭流
          fis.close();
          //处理异常
    }
 }

 

   import java.io.*;
  
  public class FileOutputStreamTest {//字节流写入文件
  
      public static void main(String[] args) throws IOException {
          //指定要写到的文件目录及名称
        File file =new File("文件路径");
        //创建文件读入流对象
        FileOutputStream fos =new FileOutputStream(file);
        //定义结束标志
        fos.write(要写出的字节或者字节数组);
        //刷新和关闭流
        fos.flush();
        fos.close();
        //处理异常
    }
 }

 

import java.io.*;

public class FileReaderTest{//字符流读取文件
    public static void main(String[] args) throws IOException{
        FileReader fr = null;
        try{
            //创建字符输入流
            fr = new FileReader("FileReaderTest.java");
            //创建一个长度为32的“竹筒”
            char[] cbuf = new char[32];
            //用于保存实际读取的字符数
            int hasRead = 0;
            //使用循环来重复“取水”过程
            while ((hasRead = fr.read(cbuf)) > 0 ){
                //取出“竹筒”中水滴（字节），将字符数组转换成字符串输入！
                System.out.print(new String(cbuf , 0 , hasRead));
            }
        }
        catch (IOException ioe){
            ioe.printStackTrace();
        }
        finally{
            //使用finally块来关闭文件输入流
            if (fr != null){
                fr.close();
            }
        }
    }
}

 

import java.io.*;
public class FileOutputStreamTest {//通过字节流实现文件复制（读取写入）
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建字节输入流
            fis = new FileInputStream("FileOutputStreamTest.java");
            //创建字节输入流
            fos = new FileOutputStream("newFile.txt");
            byte[] bbuf = new byte[32];
            int hasRead = 0;
            //循环从输入流中取出数据
            while ((hasRead = fis.read(bbuf)) > 0) {
                //每读取一次，即写入文件输出流，读了多少，就写多少。
                fos.write(bbuf, 0, hasRead);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            //使用finally块来关闭文件输入流
            if (fis != null) {
                fis.close();
            }
            //使用finally块来关闭文件输出流
            if (fos != null) {
                fos.close();
            }
        }
    }
}

import java.io.*;

public class FileWriterTest {//向文件中输入字符

    public static void main(String[] args) throws IOException {
        FileWriter fw = null;
        try {
            //创建字符输出流
            fw = new FileWriter("poem.txt");
            fw.write("锦瑟 - 李商隐\r\n");
            fw.write("锦瑟无端五十弦，一弦一柱思华年。\r\n");
            fw.write("庄生晓梦迷蝴蝶，望帝春心托杜鹃。\r\n");
            fw.write("沧海月明珠有泪，蓝田日暖玉生烟。\r\n");
            fw.write("此情可待成追忆，只是当时已惘然。\r\n");
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            //使用finally块来关闭文件输出流
            if (fw != null) {
                fw.close();
            }
        }
    }
}

2.缓冲技术：

Java使用了文件缓冲技术，其优点有：
    提高了I/O的性能
    在内存中开辟一块区域，称为缓冲区
    当缓冲区满时一次写入到磁盘中。

缓冲流是对流的操作的功能的加强，提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高，所以在创建缓冲流的对象时应该要传入要加强的流对象。
相关的Java类：
    BufferedInputStream/BufferedOutputStream：适合于包容二进制数据的文件
    BufferReader/BufferWriter：适合于读写文本文件。

//从文件中读入字串

        //指定要写到的文件目录及名称
        File file =new File("文件路径");
        //2.创建文件读入流对象
        FileOutputStream fos =new FileOutputStream(file);
        //3.创建缓冲流对象加强fos功能

       BufferedOutputStream bos=new BufferedOutputStream(fos);

合并：BufferedInputStream bis =new BufferedInputStream(new FileInputStream(new File("文件路径")));

 

缓冲技术示例：

import java.io.*;
 
public class BufferedStreamDemo {//利用缓冲字节流复制文件
    public static void main(String[] args) {
        try {
            byte[] data = new byte[1]; 

            File srcFile = new File("BufferedStreamDemo.java"); 
            File desFile = new File("BufferedStreamDemo.java.bak"); 

            BufferedInputStream bufferedInputStream = 
                new BufferedInputStream(
                         new FileInputStream(srcFile)); 
            BufferedOutputStream bufferedOutputStream = 
                new BufferedOutputStream(
                         new FileOutputStream(desFile));
 
            System.out.println("复制文件：" + 
                             srcFile.length() + "字节");

            while(bufferedInputStream.read(data) != -1) { 
                bufferedOutputStream.write(data); 
            }
            
            // 将缓冲区中的数据全部写出 
            bufferedOutputStream.flush();
 
            // 关闭流 
 
            bufferedInputStream.close(); 
            bufferedOutputStream.close(); 

            System.out.println("复制完成"); 
        } 
        catch(IOException e) { 
            e.printStackTrace(); 
        } 
    }
}

import java.io.*; 
 
public class BufferedReaderWriterDemo { //利用缓冲字符流将键盘输入直接保存到文件中
    public static void main(String[] args) { 
        try { 
            System.out.println("输入文本，键入quit结束");
           // 缓冲System.in输入流
            BufferedReader bufReader = 
                new BufferedReader(
                      new InputStreamReader(System.in)); 
           // 缓冲FileWriter字符输出流
            BufferedWriter bufWriter = 
                new BufferedWriter(new FileWriter("Hello.txt")); 
 
            String input = null; 

           // 每读一行进行一次写入动作
            while(!(input = 
                      bufReader.readLine()).equals("quit")) { 
                bufWriter.write(input); 
                 // newLine()方法写入与操作系统相依的换行字符
                bufWriter.newLine(); 
            } 
 
            bufReader.close(); 
            bufWriter.close(); 
        } 
         
        catch(IOException e) { 
            e.printStackTrace(); 
        } 
    } 
} 

在字符读入缓冲流BufferedReader 中还提供了读一行的方法 readLine() 可以读取一行文本
在字符写出缓冲流BufferedWriter 中还提供了写入一个行行分隔符的方法writeLine(),用于写出时换行

3.按分隔符读取字串

Scanner类有一个useDelimiter方法，可以指定分隔符（以正则表达式方式表达，如果不指定，则默认是空格），然后以这个分隔符去切割字串。

示例设置一文本文件的内容为逗号或“ ^”分隔的字串，程序读取并显示它。 Scanncer在底层使用了BufferredReader读取数据

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Scanner;

public class ScannerDemo {

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(new BufferedReader(new FileReader(
                "mytext.txt")));) {

            scanner.useDelimiter("[,|^]");
            while (scanner.hasNext()) {
                System.out.println(scanner.next());
            }
            System.out.println("Done!");
        } catch (FileNotFoundException e) {

            e.printStackTrace();
        }
    }

}

4.流的转换

InputStreamReader和OutputStreamWriter可以将字节流转换为字符流。（ 这类流是用于将字符转换为字节输入输出，用于操作字符文件，属于字符流的子类，所以后缀为reader，writer；前缀inputstream，outputstream；）

示例将System.In（InputStream类型的实例）转换为字符输入流BufferedReader的实例，从而可以一次从键盘读取一行。

 

import java.io.*;

public class KeyinTest {

    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            //将Sytem.in对象转换成Reader对象
            InputStreamReader reader = new InputStreamReader(System.in);
            //将普通Reader包装成BufferedReader
            br = new BufferedReader(reader);
            String buffer = null;
            //采用循环方式来一行一行的读取
            while ((buffer = br.readLine()) != null) {
                //如果读取的字符串为"exit"，程序退出
                if (buffer.equals("exit")) {
                    System.out.println("程序退出……");
                    System.exit(1);
                }
                //打印读取的内容
                System.out.println("输入内容为:" + buffer);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } //关闭输入流
        finally {
            try {
                br.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }
}