[关闭]
@nextleaf 2018-08-22T10:12:18.000000Z 字数 15655 阅读 963

2018-08-21 工作日志

工作日志 Java IO 流

Java IO流

流

Java IO类的继承结构

Java IO流图

四个抽象类

字符流：Reader、Writer
字节流：InputStream、OutputStream

File类常用方法

createNewFile()
mkdir()
boolean mkdirs()
exists()
delete()
getName()
getAbsoluteFile() 等

FileInputStream和 FileOutputStream

这两类都是用于处理字节流（文件）

OutputStreamWriter和IntputStreamReader

这两类都是用于处理字符流(转换流)

FileReader类和FileWriter类

这两类都是用于处理字符流（文件）

BufferedWriter(继承于Writer)的write方法：

将给定数组的字符存入此流的缓冲区中，根据需要将缓冲区(默认大小可能是8192字节)的内容刷新到底层流。但是，如果请求的长度≥此缓冲区大小，则此方法将刷新该缓冲区并将各个字符直接写入底层流。
bufferedWriter.write(chars);//将char数组写入缓冲区(如果读取的字符少于数组长度，则以'\u0000'填充。)

BufferedReader(继承于Reader)的read(char[] cbuf,int off,int len)方法：

如果第一次对底层流调用 read返回-1（指示文件末尾,即空文件），则此方法返回-1，否则此方法返回实际读取的字符数。

flush()

将缓冲区的内容写入文件并刷新该流的缓冲区

close()

关闭此流，但会先执行flush()。

处理流和节点流

通常，处理流套着节点流，节点流里套着文件

  1. ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));

字节流与字符流的区别

字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件。
字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close或flush方法的话，则不会输出任何内容。
字符流只能处理字符文件，字节流则可以处理字节文件和字符文件。

序列化

■所谓对象序列化就是将对象的状态转换成字节流,保存在文件虫,以后可以通过读取文件再生成相同状态的对象。
■序列化分为两大部分:序列化和反序列化。序列
化是这个过程的第一部分,将数据分解成字节流,
以便存储在文件中或在网络上传输。反序列化就是
打开字节流并重构对象.

JAVA对象序列化

Java序列化比较简单,只需实现Java.Io.Serializable接口的类对象就可以转换成字节流或从字节流恢复,不需要在类中增加任何代码。
java.Io包有两个序列化对象的类。
Objectoutputstream负责将对象写入字节流
Objectlnputstream从字节流重构对象。

附

文件复制,FileInputStream访问文件，字节流

  1. package com.nl.sx820.io.stream;
  3. import java.io.*;
  5. /**
  6.  * Created with IntelliJ IDEA 2018.
  7.  * Description: FileInputStream 文件拷贝
  8.  *
  9.  * @author: 黄昭鸿
  10.  * @date: 2018-08-21
  11.  * Time: 10:05
  12.  */
  13. public class FileInputStreamDemo {
  14.     public static void main(String[] args) {
  15.         //源文件路径
  16.         String source = "E:" + File.separator + "Downloads" + File.separator + "a1.png";
  17.         //目标路径
  18.         String target = "E:" + File.separator + "Downloads" + File.separator + "a2.png";
  20.         copyFile(source, target);
  21.     }
  23.     public static void copyFile(String src, String target) {
  24.         /**
  25.          * Description: 创建文件副本
  26.          * @author 黄昭鸿
  27.          * @date 2018/8/21 12:06
  28.          * @param [src, target]
  29.          * @return void
  30.          */
  31.         //源文件路径
  32.         File file = new File(src);
  33.         byte[] bufs = readOldFile(file);
  34.         //若文件存在
  35.         if (bufs != null) {
  36.             System.out.println(aBooleanNewFile(new File(target), file.getName(), bufs));
  37.         }
  38.     }
  40.     public static byte[] readOldFile(File file) {
  41.         if (file.exists()) {
  42.             try {
  43.                 byte[] buf;
  44.                 InputStream in = new FileInputStream(file);
  45.                 if (file.isFile()) {
  46.                     buf = new byte[(int) file.length()];
  47.                     in.read(buf);
  48. /*                    byte[] buff=new byte[1024];
  49.                     int temp;
  50.                     while ((temp=in.read(buff))!=-1){
  51.                         outputStream.write(buff);
  52.                     }*/
  54.                     //System.out.println(new String(buf));
  56.                     in.close();
  57.                     return buf;
  58.                 } else {
  59.                     in.close();
  60.                     System.out.println("不是文件");
  61.                     return null;
  62.                 }
  63.             } catch (IOException e) {
  64.                 e.printStackTrace();
  65.             }
  66.         } else {
  67.             System.out.println("路径不存在");
  68.         }
  69.         return null;
  70.     }
  72.     public static boolean aBooleanNewFile(File newfile, String name, byte[] bytes) {
  73.         if (newfile.exists()) {
  74.             if (newfile.isFile()) {
  75.                 System.out.println("覆写");
  76.                 return writefile(newfile, bytes);
  77.             } else if (newfile.isDirectory()) {
  78.                 newfile = new File(newfile, File.separator + name);
  79.                 System.out.println("新建文件" + newfile.getAbsolutePath());
  80.                 return writefile(newfile, bytes);
  81.             } else {
  82.                 System.out.println("!");
  83.                 return false;
  84.             }
  85.         } else {
  86.             //file.createNewFile();
  87.             System.out.println("新建副本" + newfile.getAbsolutePath());
  88.             return writefile(newfile, bytes);
  89.         }
  90.     }
  92.     public static boolean writefile(File newfile, byte[] bytes) {
  93.         try {
  94.             OutputStream outputStream = new FileOutputStream(newfile);
  95.             outputStream.write(bytes);
  96.             outputStream.flush();
  97.             System.out.println("文件已写入");
  98.             outputStream.close();
  99.         } catch (FileNotFoundException e) {
  100.             e.printStackTrace();
  101.         } catch (IOException e) {
  102.             e.printStackTrace();
  103.         }
  104.         return true;
  105.     }
  106. }

字节流与字符流

  1. package com.nl.sx820.io.stream;
  3. import java.io.*;
  4. import java.nio.charset.StandardCharsets;
  6. /**
  7.  * Created with IntelliJ IDEA 2018.
  8.  * Description: 文件内容读取和写入、字节流和字符流
  9.  *  字节流与字符流的区别：
  10.  * 字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件。
  11.  * 字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close或flush方法的话，则不会输出任何内容。
  12.  * 字符流只能处理字符文件，字节流则可以处理字节文件和字符文件
  13.  * @author: 黄昭鸿
  14.  * @date: 2018-08-20
  15.  * Time: 17:52
  16.  */
  17. public class StreamDemo {
  18.     public static void main(String[] args) {
  19.         //转换流,字符流,InputStreamReader、OutputStreamWriter
  20.         System.out.println("-----InputStreamReader、OutputStreamWriter-转换流,字符流---------------");
  21.         sssssssssss();
  23.         System.out.println("-------字符流——访问文件---FileReader、FileWriter-------");
  24.         File file = new File("E:" + File.separator + "Downloads" + File.separator + "nextleafwin.txt");
  25.         File newFile = new File("E:" + File.separator + "Downloads" + File.separator + "NewNextleafwin.txt");
  26.         rf(file);
  27.         //如果文件不存在，FileWriter的write()方法会自动新建文件
  28.         wf(newFile, "Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。一个流可以理解为一个数据的序列。");
  29.         System.out.println();
  31.         //字节流：DataInputStream、DataOutputStream
  32.         System.out.println("------特殊字节流-----DataInputStream、DataOutputStream----------");
  33.         aVoid();
  35.     }
  37.     /**
  38.      * Description:转换流——字符输入输出流（InputStreamReader、OutputStreamWriter）
  39.      *
  40.      * @return void
  41.      * @author 黄昭鸿
  42.      * @date 2018/8/21 14:20
  43.      */
  44.     private static void sssssssssss() {
  45.         StringBuffer stringBuffer = new StringBuffer();
  46.         try {
  47.             //创建一个输入流对象来读取文件：(还可以使用一个文件对象来创建一个输入流对象来读取文件)
  48.             InputStream fileInputStream = new FileInputStream("E:" + File.separator + "Downloads" + File.separator + "nextleafwin.txt");
  50.             //读取到StringBuffer中
  51.             InputStreamReader reader = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8);
  52.             while (reader.ready()) {
  53.                 // 转成char加到StringBuffer对象中
  54.                 stringBuffer.append((char) reader.read());
  55.             }
  56.             System.out.println("啦啦啦" + stringBuffer.toString());
  58.             //也可以
  59.             /*File file=new File("E:" + File.separator + "Downloads" + File.separator + "nextleafwin.txt");
  60.             byte[] buf=new byte[(int)file.length()];
  61.             InputStream in=new FileInputStream(file);
  62.             in.read(buf);
  63.             System.out.println(new String(buf));*/
  65.             //关闭读取流
  66.             reader.close();
  67.             //关闭输入流,释放系统资源
  68.             fileInputStream.close();
  69. /*
  70. 这里的代码也可以实现文件读取，但会影响上面的读取流代码，只能选其一使用
  71.             //从文件输入流一次读取一个字节
  72.             System.out.println("从文件输入流一次读取一个字节");
  73.             byte byteData;
  74.             while ((byteData = (byte) fileInputStream.read()) != -1) {
  75.                 System.out.print((char) byteData);
  76.             }
  77.             System.out.println();*/
  79.         } catch (IOException e) {
  80.             e.printStackTrace();
  81.         }
  83.         //使用字符串类型的文件名来创建一个输出流对象(也可以使用一个文件对象来创建一个输出流来写文件)
  84.         try {
  85.             //BufferedOutputStream bos  = new BufferedOutputStream(new FileOutputStream("your output file  path"));
  86.             //如果文件不存在会自动新建
  87.             OutputStream fileOutputStream = new FileOutputStream("E:" + File.separator + "Downloads" + File.separator + "新nextleafwin.txt");
  88.             //默认为操作系统默认编码,windows上是gbk
  89.             OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream, StandardCharsets.UTF_8);
  90.             //使用line.separator系统变量来换行，如下
  91.             String lineSeparator = System.getProperty("line.separator");
  92.             fileOutputStream.write(lineSeparator.getBytes());
  94.             //字符串转为字节数组，写入file
  95.             fileOutputStream.write("字符串转为字节数组".getBytes());
  97.             // 写入到缓冲区
  98.             writer.append("中文输入");
  99.             writer.append(stringBuffer);
  100.             //System.out.println(stringBuffer);
  101.             //换行
  102.             writer.append("\r\n");
  104.             // 刷新缓存冲,写入到文件,直接close也会写入
  105.             writer.flush();
  107.             // 关闭写入流,同时会把缓冲区内容写入文件
  108.             writer.close();
  110.             // 关闭输出流,释放系统资源
  111.             fileOutputStream.close();
  113.         } catch (IOException e) {
  114.             e.printStackTrace();
  115.         }
  116.     }
  118.     //文件内容读取
  119.     public static void rf(File file) {
  120.         if (file.isFile()) {
  121.             try {
  122.                 // 创建 FileReader 对象
  123.                 FileReader fileReader = new FileReader(file);
  124.                 System.out.println("读取的内容为：");
  125. /*              byte byteData;
  126.                 while ((byteData = (byte) fileReader.read()) != -1) {
  127.                     System.out.print((char) byteData);
  128.                 }
  129.                 System.out.println();*/
  130.                 char[] a = new char[(int) file.length()];
  131.                 // 读取数组中的内容
  132.                 fileReader.read(a);
  133.                 for (char c : a) {
  134.                     System.out.print(c);
  135.                 }
  136.                 fileReader.close();
  137.             } catch (IOException e) {
  138.                 e.printStackTrace();
  139.             }
  140.         } else {
  141.             System.out.println("不是一个文件，读取？？");
  142.         }
  143.     }
  145.     //文件内容写入
  146.     //如果文件不存在，FileWriter的write()方法会自动新建文件
  147.     public static void wf(File file, String writeString) {
  148.         try {
  149.             if (file.exists()) {
  150.                 if (file.isDirectory()) {
  151.                     file = new File(file, File.separator + "aNewFile.txt");
  152.                     file.createNewFile();
  153.                     // creates a FileWriter Object
  154.                     FileWriter writer = new FileWriter(file);
  155.                     // 向文件写入内容
  156.                     System.out.println("开始写入到" + file.getAbsolutePath());
  157.                     writer.write(writeString);
  158.                     writer.flush();
  159.                     writer.close();
  160.                 } else if (file.isFile()) {
  161.                     //覆写
  162.                     System.out.println("覆写!");
  163.                     file.createNewFile();
  164.                     FileWriter writer = new FileWriter(file);
  165.                     System.out.println("开始写入到" + file.getAbsolutePath());
  166.                     writer.write(writeString);
  167.                     writer.flush();
  168.                     writer.close();
  169.                 }
  170.             } else {
  171.                 //新建
  172.                 System.out.println("新建" + file.getAbsolutePath());
  173.                 file.createNewFile();
  174.                 FileWriter writer = new FileWriter(file);
  175.                 writer.write(writeString);
  176.                 writer.flush();
  177.                 writer.close();
  178.             }
  179.         } catch (IOException e) {
  180.             e.printStackTrace();
  181.         }
  182.     }
  184.     public static void writing(File file, String writeString) {
  185.         FileWriter writer;
  186.         try {
  187.             writer = new FileWriter(file);
  188.             writer.write(writeString);
  189.             writer.flush();
  190.             writer.close();
  191.         } catch (IOException e) {
  192.             e.printStackTrace();
  193.         }
  194.     }
  196.     //特殊流--字节流(DataInputStream、DataOutputStream)
  197.     public static void aVoid() {
  198.         File newfile = new File("E:" + File.separator + "Downloads" + File.separator + "特殊字节流.txt");
  200.         DataInputStream dataInputStream = null;
  201.         DataOutputStream dataOutputStream = null;
  202.         try {
  203.             dataInputStream = new DataInputStream(new FileInputStream(newfile));
  204.             dataOutputStream = new DataOutputStream(new FileOutputStream(newfile));
  205.             //写入Java类型
  206.             dataOutputStream.writeBoolean(true);
  207.             dataOutputStream.writeChar('和');
  208.             dataOutputStream.writeInt(1);
  209.             dataOutputStream.writeDouble(3.141592653);
  210.             dataOutputStream.close();
  212.             //读出文件内容
  213.             System.out.println(dataInputStream.readBoolean());
  214.             System.out.println( dataInputStream.readChar());
  215.             System.out.println(dataInputStream.readInt());
  216.             System.out.println(dataInputStream.readDouble());
  217.             dataInputStream.close();
  218.         } catch (IOException e) {
  219.             e.printStackTrace();
  220.         }finally {
  221.             try {
  222.                 if (dataInputStream!=null){
  223.                     dataInputStream.close();
  224.                 }
  225.                 if (dataOutputStream!=null){
  226.                     dataOutputStream.close();
  227.                 }
  228.             } catch (IOException e) {
  229.                 e.printStackTrace();
  230.             }
  231.         }
  232.     }
  233. }

文件,File类及其常用方法

  1. package com.nl.sx820.io;
  3. import java.io.File;
  4. import java.io.IOException;
  6. /**
  7.  * Created with IntelliJ IDEA 2018.
  8.  * Description:文件,File类及其常用方法
  9.  * 创建目录
  10.  * 创建文件
  11.  * 获取文件信息
  12.  * @author: 黄昭鸿
  13.  * @date: 2018-08-20
  14.  * Time: 14:53
  15.  */
  16. public class FileDemo {
  17.     public static void main(String[] args) {
  18.         //创建目录
  19.         File parent = new File("E:" + File.separator + "Downloads" + File.separator + "java创建的文件夹");
  20.         parent.mkdir();
  22.         //创建文件
  23.         try {
  24.             new File(parent + File.separator + "通用分隔符（File.separator）.txt").createNewFile();
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  29.         createNewFileTest();
  31.         //复制文件
  32.         //FileInputStreamDemo.copyFile("","");
  33.     }
  35.     public static void createNewFileTest() {
  36.         //在工作中用到通用分隔符File.separator
  37.         File parent2 = new File("E:" + File.separator + "Downloads" + File.separator + "java创建的文件夹2Test" + File.separator + "子文件夹");
  38.         File child = new File(parent2, "子File.txt");
  39.         try {
  40.             if (!parent2.exists()) {
  41.                 //parent.mkdir()只创建一个文件夹，parent.mkdirs()可创建多个文件夹
  42.                 parent2.mkdirs();
  43.                 child.createNewFile();
  44.                 System.out.println("文件目录及文件创建成功");
  45.             } else {
  46.                 child.createNewFile();
  47.                 System.out.println("文件创建成功");
  48.             }
  49.         } catch (IOException e) {
  50.             e.printStackTrace();
  51.         }
  52.         showInfo(parent2);
  53.         showListFiles(parent2);
  54.         showInfo(child);
  55.         showListFiles(child);
  56.         //1秒后删除
  57.         //timing(child);
  58.         //重命名
  59.         reName(child, "E:\\Downloads\\java创建的文件夹2Test\\子文件夹\\新的名字.txt");
  60.     }
  62.     public static void timing(File child) {
  63.         for (int i = 0; i < 10; i++) {
  64.             try {
  65.                 //线程休眠
  66.                 Thread.sleep(1600);
  67.             } catch (InterruptedException e) {
  68.                 e.printStackTrace();
  69.             }
  70.         }
  71.         child.delete();
  72.     }
  74.     public static void showInfo(File f) {
  75.         System.out.println("\n属性：");
  76.         System.out.println("文件绝对路径:" + f.getAbsolutePath());
  77.         System.out.println("文件名:" + f.getName());
  78.         System.out.println("父目录的路径:" + f.getParent());
  79.         System.out.println("是否时文件夹:" + f.isDirectory());
  80.         System.out.println("是否时文件:" + f.isFile());
  81.         System.out.println("文件长度(字节):" + f.length());
  82.         System.out.println("是否隐藏:" + f.isHidden());
  83.         System.out.println();
  85.     }
  87.     public static void showListFiles(File f) {
  88.         if (f.exists()) {
  89.             if (f.isDirectory()) {
  90.                 //System.out.println("包含的文件名列表:");
  91.                 //Console.log(f.list());
  92.                 System.out.println("[" + f.getAbsolutePath() + "]文件列表：");
  93.                 char str = ' ';
  94.                 System.out.println("文件名\t\t\t大小\t\t\t隐藏");
  95.                 for (File file : f.listFiles()) {
  96.                     if (file.isHidden()) {
  97.                         str = '✔';
  98.                     } else {
  99.                         str = ' ';
  100.                     }
  101.                     System.out.println(file.getName() + "\t\t" + file.length() + "字节\t\t" + str);
  102.                 }
  103.             } else {
  104.                 System.out.println("不是一个目录...");
  105.             }
  106.         } else {
  107.             System.out.println("路径不存在");
  108.         }
  109.     }
  111.     /**
  112.      * Description:
  113.      * 重命名
  114.      *
  115.      * @param file,name
  116.      * @return boolean
  117.      * @author 黄昭鸿
  118.      * @date 2018/8/20 18:30
  119.      */
  121.     public static boolean reName(File file, String name) {
  122.         if (file.exists()) {
  123.             if (file.isFile()) {
  124.                 System.out.println("新名：" + name);
  125.                 return file.renameTo(new File(name));
  126.             } else {
  127.                 System.out.println("不是一个文件");
  128.             }
  129.         } else {
  130.             System.out.println("路径不存在");
  131.             return false;
  132.         }
  133.         return false;
  134.     }
  135. }

RandomAccessFile类支持随机访问

  1. package com.nl.sx820.io;
  3. import org.junit.Test;
  5. import java.io.File;
  6. import java.io.FileNotFoundException;
  7. import java.io.IOException;
  8. import java.io.RandomAccessFile;
  10. /**
  11.  * Created with IntelliJ IDEA 2018.
  12.  * Description:RandomAccessFile类支持随机访问，既可当作输入流也可当作输出流
  13.  * 支持从文件任意位置读取和写入
  14.  *
  15.  * @author: 黄昭鸿
  16.  * @date: 2018-08-21
  17.  * Time: 15:16
  18.  */
  19. public class RandomAccessFileDemo {
  20.     /**
  21.      * Description:RandomAccessFile类
  22.      *  从文件任意位置读取和写入
  23.      * @author 黄昭鸿
  24.      * @date 2018/8/21 16:27
  25.      * @param
  26.      * @return void
  27.      */
  28.     @Test
  29.     public void test01() {
  30.         File file = new File("E:" + File.separator + "Downloads" + File.separator + "RandomAccessFile随机访问.mydata");
  31.         File newfile = new File("E:" + File.separator + "Downloads" + File.separator + "RandomAccessFile2.mydata");
  32.         RandomAccessFile randomAccessFile = null;
  33.         RandomAccessFile newRandomAccessFile = null;
  34.         try {
  35.             //one of {@code "r"}, {@code "rw"}, {@code "rws"}, or{@code "rwd"}
  36.             //r:只读，rw：读写
  37.             randomAccessFile = new RandomAccessFile(file, "r");
  38.             newRandomAccessFile = new RandomAccessFile(newfile, "rw");
  40.             //byte[] bytes=new byte[(int) file.length()];
  41.             byte[] bytes = new byte[20];
  42.             int len;
  43.             while ((len = randomAccessFile.read(bytes)) != -1) {
  44.                 //字节数据，写入的开始位置，长度(字节数)
  45.                 newRandomAccessFile.write(bytes, 0, len);
  46.             }
  47.         } catch (FileNotFoundException e) {
  48.             e.printStackTrace();
  49.         } catch (IOException e) {
  50.             e.printStackTrace();
  51.         } finally {
  52.             try {
  53.                 if (randomAccessFile != null) {
  54.                     randomAccessFile.close();
  55.                 }
  56.                 if (newRandomAccessFile != null) {
  57.                     newRandomAccessFile.close();
  58.                 }
  59.             } catch (IOException e) {
  60.                 e.printStackTrace();
  61.             }
  62.         }
  63.     }
  65.     /**
  66.      * Description: 从文件任意位置读取和写入
  67.      *
  68.      * @author 黄昭鸿
  69.      * @date 2018/8/21 16:26
  70.      * @param
  71.      * @return void
  72.      */
  73.     @Test
  74.     public void test02() {
  75.         File file = new File("E:" + File.separator + "Downloads" + File.separator + "RandomAccessFile随机访问.mydata");
  76.         RandomAccessFile randomAccessFile = null;
  77.         try {
  78.             //one of {@code "r"}, {@code "rw"}, {@code "rws"}, or{@code "rwd"}
  79.             randomAccessFile = new RandomAccessFile(file, "rw");
  80.             //将文件记录指针定位到pos位置，0123456...
  81.             randomAccessFile.seek(4);
  82.             System.out.println(randomAccessFile.getFilePointer());
  83.             /*从该文件读取下一行文本。此方法从文件中读取字节，从当前文件指针开始，直到到达行终止符或文件结束。每个字节通过将字符的低位八位的字节值设置为字符，并将字符的高八位设置为零来转换成字符。因此，此方法不支持完整的Unicode字符集。*/
  84.             String str=randomAccessFile.readLine();
  85.             System.out.println(randomAccessFile.getFilePointer());
  86.             randomAccessFile.seek(4);
  87.             System.out.println(randomAccessFile.getFilePointer());
  88.             randomAccessFile.write("abcd".getBytes());
  89.             System.out.println(randomAccessFile.getFilePointer());
  90.             randomAccessFile.write(str.getBytes());
  91.             System.out.println(randomAccessFile.getFilePointer());
  93.         } catch (FileNotFoundException e) {
  94.             e.printStackTrace();
  95.         } catch (IOException e) {
  96.             e.printStackTrace();
  97.         } finally {
  98.             try {
  99.                 if (randomAccessFile != null) {
  100.                     randomAccessFile.close();
  101.                 }
  102.             } catch (IOException e) {
  103.                 e.printStackTrace();
  104.             }
  105.         }
  106.     }
  108. }

FileReader和FileWriter（处理字符流）

  1. package com.nl.sx820.io.stream;
  3. import org.junit.Test;
  5. import java.io.*;
  7. /**
  8.  * Created with IntelliJ IDEA 2018.
  9.  * Description:字符流 以字符为单位，只可处理字符文件
  10.  * Reader类和Writer类是所有字符输入流和输出流超类（抽象类）,需要定义子类来实例化。
  11.  *
  12.  * @author: 黄昭鸿
  13.  * @date: 2018-08-21
  14.  * Time: 14:15
  15.  */
  16. public class FileReaderAndFileWriter {
  17.     @Test
  18.     public void testFileReader() {
  19.         //只可处理字符文件
  20.         File file = new File("E:" + File.separator + "Downloads" + File.separator + "testFileReader.txt");
  21.         FileReader fileReader = null;
  22.         try {
  23.             fileReader = new FileReader(file);
  24.             char[] chars = new char[20];
  25.             int len;
  26.             while ((len = fileReader.read(chars)) != -1) {
  27.                 System.out.println(new String(chars, 0, len));
  28.             }
  29.         } catch (FileNotFoundException e) {
  30.             e.printStackTrace();
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         } finally {
  34.             if (fileReader != null) {
  35.                 try {
  36.                     fileReader.close();
  37.                 } catch (IOException e) {
  38.                     e.printStackTrace();
  39.                 }
  40.             }
  41.         }
  42.     }
  43.     @Test
  44.     public void testBufferedReader() {
  45.         File sourcefile = new File("E:" + File.separator + "Downloads" + File.separator + "testFileReader.txt");
  46.         File targetfile = new File("E:" + File.separator + "Downloads" + File.separator + "newFileReader.txt");
  47.         BufferedReader bufferedReader = null;
  48.         BufferedWriter bufferedWriter = null;
  49.         try {
  50.             bufferedReader = new BufferedReader(new FileReader(sourcefile));
  51.             bufferedWriter = new BufferedWriter(new FileWriter(targetfile));
  53.             char[] chars = new char[1024];
  54.             int len;
  55.             //read(char[] cbuf,int off,int len)如果第一次对底层流调用 read 返回 -1（指示文件末尾,即空文件），则此方法返回 -1，否则此方法返回实际读取的字符数。
  56.             while ((len=bufferedReader.read(chars)) != -1) {
  57.                 //write()将给定数组的字符存入此流的缓冲区中，根据需要将缓冲区(默认大小可能是8192字节)的内容刷新到底层流。
  58.                 // 但是，如果请求的长度≥此缓冲区大小，则此方法将刷新该缓冲区并将各个字符直接写入底层流，此处缓冲区指定为1024字节。
  59.                 bufferedWriter.write(chars,0,len);
  60.                 //bufferedWriter.write(chars);将char数组写入缓冲区(如果读取的字符少于数组长度，则以'\u0000'填充。)
  62.                 //flush()，将缓冲区的内容写入文件并刷新该流的缓冲区
  63.                 //bufferedWriter.flush();
  64.                 //close()关闭此流，但会先执行flush()。
  65.             }
  66.         } catch (FileNotFoundException e) {
  67.             e.printStackTrace();
  68.         } catch (IOException e) {
  69.             e.printStackTrace();
  70.         } finally {
  71.             try {
  72.                 if (bufferedReader != null) {
  73.                     bufferedReader.close();
  74.                 }
  75.                 if (bufferedWriter != null) {
  76.                     bufferedWriter.close();
  77.                 }
  78.             } catch (IOException e) {
  79.                 e.printStackTrace();
  80.             }
  82.         }
  83.     }
  84. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注