1.字节流 FileInputStream、FileOutputStream
①FileInputStream
1 import java.io.FileInputStream; 2 3 public class FileInputStreamDemo { 4 public static void main(String[] args) throws Exception { 5 FileInputStream in = new FileInputStream("D:\\a.txt"); 6 // 构建一个字节数组作为缓冲区 7 byte[] bs = new byte[10]; 8 // 定义一个变量来记录读取的字节个数 9 int len = -1; 10 while ((len = in.read(bs)) != -1) { 11 System.out.println(new String(bs, 0, len, "utf-8")); 12 } 13 in.close(); 14 } 15 }
②FileOutputStream
1 import java.io.FileOutputStream; 2 3 public class FileOutputStreamDemo { 4 public static void main(String[] args) throws Exception { 5 //true是追加。不加true,或者是false会新建并覆盖已有的。 6 FileOutputStream out = new FileOutputStream("D:\\a.txt", false); 7 // 字节流身上没有缓冲区 8 out.write("缓冲区".getBytes("utf-8")); //utf-8编码 9 out.write("abc".getBytes()); 10 out.close(); 11 } 12 }
关于流中的异常处理
1.将刘对象放在try之外声明并且赋值为null，放到try内初始化。
2.在关流之前需要判断流对象是否初始化成功（判断流对象是否为null）。
3.关流之后需要将流对象强制置为null，防止关流失败流对象依然占用文件。
4.需要在关流之前手动冲刷缓冲区以防关流失败导致一部分数据死在缓冲区中。
③用FileInputStream、FileOutputStream复制文件
1 import java.io.FileInputStream; 2 import java.io.FileNotFoundException; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 6 public class CopyFileDemo { 7 public static void main(String[] args) { 8 FileInputStream in = null; 9 FileOutputStream out = null; 10 try { 11 in = new FileInputStream("D:\\a.zip"); 12 out = new FileOutputStream("C:\\a.zip"); 13 // 构建一个字节数组作为缓冲区 14 byte[] bs = new byte[1024 * 1024 * 10]; 15 // 定义一个变量来记录每次读取的字节个数 16 int len = -1; 17 while ((len = in.read(bs)) != -1) { 18 out.write(bs, 0, len); 19 } 20 } catch (FileNotFoundException e) { 21 e.printStackTrace(); 22 } catch (IOException e1){ 23 e1.printStackTrace(); 24 } finally{ 25 if(in != null){ 26 try { 27 in.close(); 28 } catch (IOException e) { 29 e.printStackTrace(); 30 } finally { 31 in = null; 32 } 33 } 34 if(out != null){ 35 try { 36 out.close(); 37 } catch (IOException e) { 38 e.printStackTrace(); 39 } finally { 40 out = null; 41 } 42 } 43 } 44 } 45 }
2.转换流 InputStreamReader、OutputStreamWriter
①InputStreamReader 将字节转化为字符的流
1 import java.io.FileInputStream; 2 import java.io.InputStreamReader; 3 4 public class InputStreamReaderDemo { 5 public static void main(String[] args) throws Exception { 6 // 底层靠的是FileInputStream 7 // 读取出来的是字节，但是展现的是字符---将字节转化为字符 8 InputStreamReader in = new InputStreamReader(new FileInputStream("D:\\test.txt"), "utf-8"); 9 char[] cs = new char[3]; 10 in.read(cs); 11 in.close(); 12 System.out.println(cs); 13 } 14 }
②OutputStreamWriter 将字符转化为字节的流
1 import java.io.FileOutputStream; 2 import java.io.IOException; 3 import java.io.OutputStreamWriter; 4 5 public class OutputStreamWriterDemo { 6 public static void main(String[] args) throws IOException { 7 // OutputStreamWriter将字符转化为字节的流 8 // 实际上是用FileOutputStream来写出数据 9 // 传入的参数是字符形式，但是最后以字节形式向外写出---字符转字节 10 OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream("D:\\test.txt"), "utf-8"); 11 ow.write("转换流"); 12 ow.close(); 13 } 14 }
③用InputStreamReader、OutputStreamWriter改变文件的编码
1 import java.io.FileInputStream; 2 import java.io.FileOutputStream; 3 import java.io.IOException; 4 import java.io.InputStreamReader; 5 import java.io.OutputStreamWriter; 6 7 public class ChangeEncode { 8 public static void main(String[] args) { 9 changeEncode("srcTest.txt", "destTest.txt", "gbk", "utf-8"); 10 System.out.println("over"); 11 12 } 13 public static void changeEncode(String srcFile, String destFile, String srcEncodeType, String dstEncodeType){ 14 InputStreamReader isr = null; 15 OutputStreamWriter osw = null; 16 17 try { 18 isr = new InputStreamReader(new FileInputStream(srcFile),srcEncodeType); 19 osw = new OutputStreamWriter(new FileOutputStream(destFile),dstEncodeType); 20 char[] cs = new char[1024]; 21 int len = 0; 22 while((len = isr.read(cs)) != -1){ 23 osw.write(cs, 0, len); 24 osw.flush(); 25 } 26 } catch (Exception e) { 27 e.printStackTrace(); 28 } finally { 29 if(isr != null){ 30 try { 31 isr.close(); 32 } catch (IOException e) { 33 e.printStackTrace(); 34 } finally { 35 isr = null; 36 } 37 } 38 if(osw != null){ 39 try { 40 osw.close(); 41 } catch (IOException e) { 42 e.printStackTrace(); 43 } finally { 44 osw = null; 45 } 46 } 47 } 48 } 49 }
效果：
3.字符流 FileReader，FileWriter
①FileReader
Demo1：单个字符读取
1 import java.io.FileReader; 2 3 public class FileReaderDemo1 { 4 public static void main(String[] args) throws Exception { 5 // 创建了一个输入流对象指向了要读取的文件 6 FileReader reader = new FileReader("D:\\a.txt"); 7 // 返回的是这字符所对应的编码 8 // int i = reader.read(); 9 // 定义一个变量来存储读取的字符 10 int i = -1; 11 // 如果读取到文件的末尾，则返回一个-1 12 while ((i = reader.read()) != -1) { 13 System.out.println((char)i); 14 } 15 reader.close(); 16 } 17 }
Demo2：多个字符读取
1 import java.io.FileReader; 2 3 public class FileReaderDemo2 { 4 public static void main(String[] args) throws Exception { 5 FileReader reader = new FileReader("D:\\a.docx"); 6 // 提供一个字符数组作为缓冲区 7 char[] cs = new char[20]; 8 // 定义一个变量来记录每次读取到的字符个数 9 int i = -1; 10 // 如果读取到了末尾同样返回一个-1 11 // 返回本次读取到的字符个数 12 while ((i = reader.read(cs)) != -1) { 13 System.out.println(new String(cs, 0, i)); 14 } 15 reader.close(); 16 } 17 }
②FileWriter
import java.io.FileWriter; import java.io.IOException; public class FileWriterDemo1 { public static void main(String[] args) throws IOException { FileWriter writer = new FileWriter("D:\\a.txt"); writer.write("def"); writer.flush(); writer.close(); writer = null; System.out.println(writer); } }
③用FileReader，FileWriter复制文件
1 import java.io.FileReader; 2 import java.io.FileWriter; 3 import java.io.IOException; 4 5 public class CopyFile { 6 public static void main(String[] args) { 7 FileReader reader = null; 8 FileWriter writer = null; 9 try { 10 reader = new FileReader("D:\\a.txt"); 11 writer = new FileWriter("D:\\b.txt"); 12 char[] cs = new char[10]; 13 int i = -1; 14 while ((i = reader.read(cs)) != -1) { 15 writer.write(cs, 0, i); 16 } 17 writer.flush(); 18 } catch (Exception e) { 19 e.printStackTrace(); 20 } finally { 21 if (reader != null) { 22 try { 23 reader.close(); 24 } catch (IOException e) { 25 e.printStackTrace(); 26 } finally { 27 reader = null; 28 } 29 } 30 if (writer != null) { 31 try { 32 writer.close(); 33 } catch (IOException e) { 34 e.printStackTrace(); 35 } finally { 36 writer = null; 37 } 38 } 39 } 40 } 41 }