Java 文件读写

内容太乱，请移步：Java中的File类和IO流

文件类的继承关系.png

1、File类

File类与FileInputStream类的区别：
FileInputStream类关注的是文件内容，而File类关注的是文件在磁盘上的存储。
File不属于文件流,只能代表一个文件或是目录的路径名而已。
详见：https://www.jianshu.com/p/5c2f50a8e874

2、FileInputStream类

以字节为单位（非unicode）的流处理。字节序列即：二进制数据。与编码无关，不存在乱码问题。
FileInputStream类的主要方法有：
Read（），read（byte[] b），read（byte[],int off,int len）,available();

FileInputStream类与FileReader类的区别：
FileInputStream：以字节流方式读取；FileReader：把文件转换为字符流读入；
InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。用Reader读取出来的是char（16位,unicode编码）数组或者String ，使用InputStream读取出来的是byte（8位）数组。

InputStreamReader可以将读入的stream转换成字符流方式，是stream和reader之间的桥梁，其子类是FileReader。

FileInputStream类以二进制输入/输出，I/O速度快且效率搞，但是它的read（）方法读到的是一个字节（二进制数据），很不利于人们阅读；而FileReader类弥补了这个缺陷，可以以文本格式输入/输出，非常方便；

FileReader与InputStreamReader涉及编码转换(指定编码方式或者采用os默认编码)，可能在不同的平台上出现乱码现象！而FileInputStream以二进制方式处理，不会出现乱码现象.

FileInputStream是在Socket通讯时会用到很多，如将文件流以Stream的方式传向服务器！

3、FileReader类

与它的父类InputStreamReader的主要不同在于构造函数，当要指定编码方式时，必须使用InputStreamReader类；而FileReader构造函数的参数与FileInputStream同，为File对象或表示path的String，可以看出，当要根据File对象或者String读取一个文件时，用FileReader。

FileReader fr = new FileReader("ming.txt"); 
　　 char[] buffer = new char[1024]; 
　　 int ch = 0; 
　　while((ch = fr.read())!=-1 ) 
　　{ 
　　　System.out.print((char)ch); 
　　} 

4、InputStreamReader类

以文本格式输入/输出，可以指定编码格式；
主要方法： getEncoding()，read();

InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt")); 
　　while((ch = isr.read())!=-1) 
　　{ 
　　　System.out.print((char)ch); 
　　} 

5、BufferedReader类

BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取分行文本很适合，BufferedReader是针对Reader的，不直接针对文件，也不是只针对文件读取。

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt"))); 
　　 String data = null; 
　　 while((data = br.readLine())!=null) 
　　 { 
　　　 System.out.println(data); 
　　 } 

6、BufferedInputStream类

BufferedInputStream必须传入一个InputStream(一般是FileInputStream)
常用方法：

• public int read();//从该输入流中读取一个字节
• public int read(byte[] b,int off,int len);//从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。

示例：

/**
 * BufferedInputStream:缓冲输入流
 * FileInputStream:文件输入流
 */
public class FileReadToString {
    public static void main(String[] args){
        try {
            FileInputStream fis=new FileInputStream("WynnNi.txt");
            BufferedInputStream bis=new BufferedInputStream(fis);
            String content=null;
             //自定义缓冲区
            byte[] buffer=new byte[10240];
            int flag=0;
            while((flag=bis.read(buffer))!=-1){
                content+=new String(buffer, 0, flag);
            }
            System.out.println(content);
            //关闭的时候只需要关闭最外层的流就行了
            bis.close();
        } catch (Exception e) {
                e.printStackTrace();
        }
    }
}

7、BufferedOutputStream类

创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

常用方法：

• public void write(int b);//向输出流中输出一个字节。
• public void write(byte[] b,int off,int len); //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
• public void flush();//刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中。

示例：

/**
 * BufferedOutputStream:缓冲输出流
 * FileOutPutStream:文件输出流
 */
public class StringOutPutToFile {
    public static void main(String[] args){
        try {
            FileOutputStream fos=new FileOutputStream("WynnNi.txt");
            BufferedOutputStream bos=new BufferedOutputStream(fos);
            String content="xxxxxxxxx！";
            bos.write(content.getBytes(),0,content.getBytes().length);
            bos.flush();
            bos.close();
        } catch (Exception e) {
                e.printStackTrace();
        }
    }
}

3、实际应用

被调用方如何将文件传输给调用方并在本地输出文件

1、被调用方将文件读入缓冲区byte[]

2、将缓冲区数据转换成String传递，String str = Base64.getEncoder().encodeToString(bytes);

3、接收方将String反转为byte[]，bytes=Base64.getDecoder().decode(str);

4、接收方将缓冲区输出到文件

3.1 文件简单读写

public class ReadFile {
    public static void main(String[] args) {
        File file = new File("new Hello.txt");
        if(file.exists()){
            System.err.print("exsit");
            try (FileInputStream fis = new FileInputStream(file)) {//文件输入流 这是字节流

                InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//inputstreamReader是一个字节流，将字节流和字符流转化的时候，就需要制定一个编码方式，不然就会乱码
                BufferedReader br = new BufferedReader(isr);//字符缓冲区

                String line;
                while((line = br.readLine())!=null){//这里将缓冲区里的内容如果非空就读出来打印
                    System.out.println(line);
                }
                br.close();//最后将各个线程关闭
                isr.close();
                fis.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        File newfile = new File("newtext.txt");
        try {
            FileOutputStream fos = new FileOutputStream(newfile);//这里如果文件不存在会自动创建文件
            OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");//和读取一样这里是转化的是字节和字符流
            BufferedWriter bw = new BufferedWriter(osw);//这里是写入缓冲区

            bw.write("厉害了我的哥");//写入字符串

            bw.close();//和上面一样 这里后打开的先关闭 先打开的后关闭
            osw.close();
            fos.close();
            System.out.println("done");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

参考文档：

• https://www.cnblogs.com/wynn-ni/p/12147198.html
• https://blog.csdn.net/zhangbinu/article/details/51362612/
• Java中的File类和IO流