java字节流和字符流操作文件，指定编码写入和读取，递归创建上层目录

秒速五厘米 2022-06-07 07:18 135阅读 0赞

java的IO流分两种流   
字节流 InputStream OutputStream   
字符流 Reader Writer   
他们都是抽象类   
具体实现   
字节流 FileInputStream FileOutputStream   
字符流 FileReader FileWriter

字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点.  
     所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列.  
      字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。

字节流转换成字符流可以用 InputSteamReader OutputStreamWriter   
转换成BufferdReader BufferedWriter 他们具有缓冲区   
例如：读取文件 从字节流输入到字符流输入   
定义一个字节流：

// 定义一个指向D:/TEXT.TXT 的字节流  
FileInputStream fileInputStream = new FileInputStream("d:/text.txt");

//字节流转换成InputStreamReader   
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);

//InputStreamReader 转换成带缓存的bufferedReader   
BufferedReader bufferedReader = new BufferedReader(inputSteamReader);

Java的IO流分为字符流（Reader,Writer）和字节流(InputStream,OutputStream)，字节流顾名思义字节流就是将文件的内容读取到字节数组，然后再输出到另一个文件中。而字符流操作的最小单位则是字符。可以先看一下ＩＯ流的概述：![920265-20161022104031576-533780218.png][]

动态获取文件长度创建接收数组，系统自动判定转义目录斜杠，讲述字节流、字符流、buffer流三种方式针对text文件的写入、读取、创建、追加等操作

递归创建上层目录

public static void mkDir(File file)\{  
  if(file.getParentFile().exists())\{  
   file.mkdir();  
  \}else\{  
   mkDir(file.getParentFile());  
   file.mkdir();  
  \}

文件工具类如下

import java.io.File;  
import java.io.IOException;  
public class FileUtils \{  
public static final String encode = "UTF-8";  
/\*\*获取目录下的所有文件和目录列表完整地址输出\*/  
public static void nowFileLists(String fileName) throws IOException\{  
File f=new File(fileName);  
File\[\] str=f.listFiles();  
for (int i = 0; i < str.length; i++) \{  
System.out.println(str\[i\]);  
\}  
\}  
/\*\*判断文件是否存在\*/  
public static boolean exitsFile(String fileName) throws IOException\{  
File file = new File(fileName);  
boolean flag = false;  
if(file.exists())\{  
flag = true;  
\}  
return flag;  
\}  
/\*\*判断是否是文件夹\*/  
public static boolean isDirectory(String fileName) throws IOException\{  
File file = new File(fileName);  
boolean flag = false;  
//判断是否是目录   只有当文件夹存在的情况才能判断  
if(exitsFile(fileName))\{  
if(file.isDirectory())\{  
flag=true;  
\}  
\}  
return flag;  
\}  
  
/\*\*创建文件\*/  
public static void createFile(String fileName) throws IOException\{  
File file = new File(fileName);  
file.createNewFile();  
\}  
\}

字节流操作文件

import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import com.cn.utils.FileUtils;  
public class ByteFiles \{  
/\*\*  
\* 字节流操作文件  
\*/  
public static void main(String \[\] args)\{  
String fileName = "D:"+File.separator+"byteFile.txt";  
try \{  
if(!FileUtils.exitsFile(fileName))\{  
FileUtils.createFile(fileName);  
\}  
writeContext(fileName);  
redaContext(fileName);  
\} catch (IOException e) \{  
e.printStackTrace();  
\}  
\}  
//写入指定格式的文件内容  
public static void writeContext(String fileName) throws IOException\{  
File file = new File(fileName);  
OutputStream outs = new FileOutputStream(file,true);  
String content = "\\r\\n窗前明月光";  
outs.write(content.getBytes("UTF-8"));  
outs.close();  
\}   
//写入指定格式的文件内容  
public static void redaContext(String fileName) throws IOException\{  
File file = new File(fileName);  
InputStream in = new FileInputStream(file);  
byte b \[\] = new byte \[(int) file.length()\];  
//字节流读取文件方式一全部读取  
in.read(b);  
in.close();  
String content = new String(b);  
System.out.println("byte方式一全部读取：\\r\\n"+content);  
//字节流读取文件方式二  逐行读取  
InputStream inn = new FileInputStream(file);  
byte bb \[\] = new byte \[(int) file.length()\];  
int count =0;  
int temp=0;  
while((temp=inn.read())!=(-1))\{  
  bb\[count++\]=(byte)temp;  
\}  
inn.close();  
content = new String(bb);  
System.out.println("byte方式二全部读取：\\r\\n"+content);  
\}   
\}

字符流操作文件

import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.io.OutputStream;  
import java.io.OutputStreamWriter;  
import com.cn.utils.FileUtils;  
public class CharFiles \{  
/\*\*  
\* 字符流操作文件  
\*/  
public static void main(String \[\] args)\{  
String fileName = "D:"+File.separator+"charFile.txt";  
try \{  
if(!FileUtils.exitsFile(fileName))\{  
FileUtils.createFile(fileName);  
\}  
writeContext(fileName);  
redaContext(fileName);  
\} catch (IOException e) \{  
e.printStackTrace();  
\}  
\}  
//写入指定格式的文件内容  
public static void writeContext(String fileName) throws IOException\{  
File file = new File(fileName);  
OutputStream outs = new FileOutputStream(file,true);  
OutputStreamWriter out = new OutputStreamWriter(outs,"UTF-8");  
String content = "\\r\\n我是字符流写入";  
out.write(content);  
out.close();  
\}   
//写入指定格式的文件内容  
public static void redaContext(String fileName) throws IOException\{  
File file = new File(fileName);  
InputStreamReader inr = new InputStreamReader(new FileInputStream(file),"UTF-8");  
char b \[\] = new char \[(int) file.length()\];  
//字符流读取文件方式一全部读取  
inr.read(b);  
inr.close();  
String content = new String(b);  
System.out.println("char方式一全部读取：\\r\\n"+content);  
//字符流读取文件方式二  逐行读取  
InputStreamReader inrr = new InputStreamReader(new FileInputStream(file),"UTF-8");  
char bb \[\] = new char \[(int) file.length()\];  
int count =0;  
int temp=0;  
while((temp=inrr.read())!=(-1))\{  
  bb\[count++\]=(char)temp;  
\}  
inrr.close();  
content = new String(bb);  
System.out.println("char方式二全部读取：\\r\\n"+content);  
\}   
\}

使用buffer流操作文件

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.IOException;  
import java.io.InputStreamReader;  
import java.io.OutputStreamWriter;  
import java.io.UnsupportedEncodingException;  
import java.util.ArrayList;  
import java.util.List;  
import com.cn.utils.FileUtils;  
public class BufferReadWriteFile \{  
public static void main(String\[\] args) \{  
String fileName = "D:"+File.separator+"buffer.txt";  
try \{  
if(!FileUtils.exitsFile(fileName))\{  
FileUtils.createFile(fileName);  
\}  
bufferWite(fileName);  
bufferRead(fileName);  
\} catch (IOException e) \{  
e.printStackTrace();  
\}  
\}  
//使用buffer流进入写入文件  
public static void bufferWite(String fileName)\{  
OutputStreamWriter outt;  
try \{  
outt = new OutputStreamWriter(new FileOutputStream(fileName,true),"UTF-8");  
BufferedWriter wites = new BufferedWriter(outt);  
wites.write("\\r\\n我是buffer流文件操作");  
wites.close();  
\} catch (UnsupportedEncodingException e2) \{  
e2.printStackTrace();  
\} catch (FileNotFoundException e2) \{  
e2.printStackTrace();  
\} catch (IOException e) \{  
e.printStackTrace();  
\}  
\}  
//使用buffer流进入读取文件  
public static void bufferRead(String fileName)\{  
        BufferedReader reader = null;  
        InputStreamReader inputFileReader = null;  
        String content = "";  
        List<String> readContextList = new ArrayList<String>();  
        String tempString = null;  
        try \{  
            inputFileReader = new InputStreamReader(new FileInputStream(fileName),"UTF-8");  
            reader = new BufferedReader(inputFileReader);  
            // 一次读入一行，直到读入null为文件结束  
            while ((tempString = reader.readLine()) != null) \{  
                content += "\\r\\n"+tempString;  
                readContextList.add(tempString);  
            \}  
            reader.close();  
        \} catch (IOException e) \{  
            e.printStackTrace();  
           
        \} finally \{  
            if (reader != null) \{  
                try \{  
                    reader.close();  
                \} catch (IOException e1) \{  
                \}  
            \}  
        \}  
        System.out.println(content);  
\}  
\}

[920265-20161022104031576-533780218.png]: /images/20220607/d9ef187545764a8c8e96b4f6c511031d.png