Java代码之读写示例

0x00 前言

最近这几个月一直在学java，这几天为了搞懂Java的读写代码，特意总结了一下写法和意义。

0x01 代码详情

package readwrite_test;

import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.BufferedReader;  
import java.io.BufferedWriter;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.IOException;

public class zhuge_1 {  
    public static void main(String[] args) {
        readFileChar("E:/11.txt");
        readFileByte("E:/11.txt");
        writeFileChar("E:/11.txt","E:/22.txt");
        writeFileByte("E:/11.txt","E:/22.txt");
    }
    
    private static void readFileChar(String path){
    	/*
    	 * @以字符流形式读取文件
    	 */
        FileReader fr = null;
        BufferedReader br  = null;
        try {
            File file = new File(path);  //把当前路径字符串转换为File类型
            fr = new FileReader(file);  // 以字符形式读取数据流中数据
            br = new BufferedReader(fr); //从字符输入流中读取文本并缓冲字符，以便有效地读取字符，数组和行
            String line = "";
            while((line = br.readLine()) != null){ // readLine() 包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为返回null 
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
        	// FileReader(File file) 可能会产生的异常
            e.printStackTrace();
        } catch (IOException e) {
        	// BufferedReader.readLine() 可能会产生的异常
            e.printStackTrace();
        }finally{
            try {
                if(br != null) br.close(); //关闭字符形式读取的流数据
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static void readFileByte(String path){
    	/*
    	 * @以字节流形式读取文件（原始流）
    	 */
        FileInputStream fis = null;
        BufferedInputStream bis  = null;
        try {
            File file = new File(path);  //把当前路径字符串转换为File类型
            fis = new FileInputStream(file);  //以字节流的形式读取数据
            bis = new BufferedInputStream(fis);  //从字节输入流中读取文本并缓冲字符，以便有效地读取字符，数组和行
            int buf = 0;
            while((buf=bis.read()) != -1){  // 当read()读取的下一个字节达到流的末尾时返回 -1
                System.out.print((char)buf);  //对通过read()函数返回的int类型数据转换为字符形式并输出
            }
        } catch (FileNotFoundException e) {
        	// FileInputStream(File file) 构造方法可能产生的异常
            e.printStackTrace();
        } catch (IOException e) {
        	// BufferedInputStream.read() 的可能会产生的异常
            e.printStackTrace();
        }finally{
            try {
                if(bis != null) bis.close(); // 关闭字节形式读取的流数据
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static void writeFileChar(String path1,String path2){
    	/*
    	 * @以字符流形式写入文件
    	 */
        File file1 = new File(path1);
        File file2 = new File(path2);
        FileReader fr = null;
        BufferedReader br = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fr = new FileReader(file1);  // 以字符流的形式读取file1文件
            br = new BufferedReader(fr); // 从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取
            fw = new FileWriter(file2);  // 以字符流的形式进行写入文件
            bw = new BufferedWriter(fw);  // 将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入
            String line = "";
            while((line=br.readLine()) != null){  // readLine() 包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为返回null
                bw.write(line+"\n");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(br != null) br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bw != null) bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    private static void writeFileByte(String path1,String path2){
        File file1 = new File(path1);
        File file2 = new File(path2);
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(file1);  // 以字节流的形式读取数据
            bis = new BufferedInputStream(fis);  // 从字节输入流中读取文本并缓冲字符，以便有效地读取字符，数组和行
            fos = new FileOutputStream(file2);  // FileOutputStream用于写入诸如图像数据的原始字节流
            bos = new BufferedOutputStream(fos);  // 该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。
            int tmp = 0;
            while((tmp = bis.read()) != -1){  // 当read()读取的下一个字节达到流的末尾时返回 -1
                bos.write(tmp);  //从指定的字节数组写入len个字节，从偏移off开始到缓冲的输出流。
            }
            bos.flush();  // 刷新缓冲输出流。 这将强制任何缓冲输出字节写入底层输出流。
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace(); 
        }finally{
            try {
                if(bis != null) bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(bos != null) bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}