IO（input 输入 ，output 输出）

IO流体系结构

屏幕截图 2022-04-13 212540.jpg

File类的使用

1.File类的一个对象，代表一个个文件或一个文件目录（俗称：文件夹）
2.File类声明在java.io包下
3.File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成
4.后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”

创建File类的实例

File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)
屏幕截图 2022-04-11 101802.jpg

  1. public void test1(){
  2.         //构造器1
  3.         File file1 = new File("hello.txt");//相对于当前module
  4.         File file2 = new File("F:\\code\\day01\\hi.txt");
  6.         //构造器2
  7.         File file3 = new File("F:\\code","day01");
  9.         //构造器3
  10.         File file4 = new File(file3,"hi.txt");
  11.     }

路径分类

相对路径：相较于某个路径下，指明的路径
绝对路径：包含盘符在内的文件或文件目录的路径

路径分隔符

windows：\
unix：/

File类常用方法

屏幕截图 2022-04-11 105031.jpg

  1. public void test2(){
  2.         File file1 = new File("hello.txt");
  3.         File file2 = new File("E:\\IO\\hi.txt");
  5.         System.out.println(file1.getAbsolutePath());
  6.         System.out.println(file1.getPath());
  7.         System.out.println(file1.getName());
  8.         System.out.println(file1.getParent());
  9.         System.out.println(file1.length());
  10.         System.out.println(file1.lastModified());
  12.         System.out.println();
  14.         System.out.println(file2.getAbsolutePath());
  15.         System.out.println(file2.getPath());
  16.         System.out.println(file2.getName());
  17.         System.out.println(file2.getParent());
  18.         System.out.println(file2.length());
  19.         System.out.println(file2.lastModified());
  20.     }
  1. public void test3(){
  2.         //如下的两个方法适用于文件目录
  3.         //文件需真实存在
  4.         File file = new File("F:\\code\\daily");
  6.         String[] list = file.list();
  7.         for (String s : list){
  8.             System.out.println(s);
  9.         }
  11.         File[] files = file.listFiles();
  12.         for (File f : files){
  13.             System.out.println(f.toString());
  14.         }
  15.     }
  1. public void test4(){
  3.         //要想保证返回true，需要file1在硬盘存在，且file2不能存在
  4.         File file1 = new File("hello.txt");
  5.         File file2 = new File("E:\\IO\\hi.txt");
  7.         boolean renameTo = file1.renameTo(file2);
  8.         System.out.println(renameTo);
  10.     }

屏幕截图 2022-04-11 112659.jpg

  1. public void test5(){
  2.         File file1 = new File("hello.txt");
  4.         System.out.println(file1.isDirectory());
  5.         System.out.println(file1.isFile());
  6.         System.out.println(file1.exists());
  7.         System.out.println(file1.canRead());
  8.         System.out.println(file1.canWrite());
  9.         System.out.println(file1.isHidden());
  11.         System.out.println();
  13.         File file2 = new File("E:\\IO");
  14.         System.out.println(file2.isDirectory());
  15.         System.out.println(file2.isFile());
  16.         System.out.println(file2.exists());
  17.         System.out.println(file2.canRead());
  18.         System.out.println(file2.canWrite());
  19.         System.out.println(file2.isHidden());
  20.     }

屏幕截图 2022-04-11 133509.jpg

  1. public void test6() throws IOException {
  2.         //文件创建
  3.         File file1 = new File("hi.txt");
  4.         if (!file1.exists()){
  5.             file1.createNewFile();
  6.             System.out.println("创建成功");
  7.         }else{
  8.             file1.delete();
  9.             System.out.println("删除成功");
  10.         }
  11.     }
  12.     @Test
  13.     public void test7(){
  14.         //文件目录的创建
  15.         File file1 = new File("e:\\IO\\io1\\io3");
  17.         boolean mkdir = file1.mkdir();
  18.         if (mkdir) {
  19.             System.out.println("创建成功1");
  20.         }
  22.         File file2 = new File("e:\\IO\\io1\\io4");
  24.         boolean mkdir1 = file2.mkdirs();
  25.         if (mkdir1) {
  26.             System.out.println("创建成功2");
  27.         }
  28.     }

IO流

流的分类

1.操作数据单位：字节流、字符流
2.数据的流向：输入流、输出流
3.流的角色：节点流、处理流
屏幕截图 2022-04-11 151441.jpg

流的体系结构

抽象基类 节点流 缓冲流
InputStream FileInputStream BufferedInputStream
OutputStream FileOutputStream BufferedOutputStream
Reader FileReader BufferedReader
Witer FileWriter BufferedWriter

FileReader读入数据操作

说明：
1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
2.异常处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理
3.读入的文件一定要存在，否则就会报FileNotFoundException

  1. public void testFileReader(){
  2.         FileReader fr = null;
  3.         try {
  4.             //1.实例化File类的对象，指明要操作的文件
  5.             File file = new File("hello.txt");
  6.             //2.提供具体的流
  7.             fr = new FileReader(file);
  9.             //3.数据的读入
  10.             //read():返回读入的一个字符。如果达到文件末尾，返回-1
  11.             //方式一
  12.         /*int data = fr.read();
  13.         while (data != -1){
  14.             System.out.println((char)data);
  15.             data = fr.read();
  16.         }*/
  17.             //方式二 语法上针对于方式一的修改
  18.             int data;
  19.             while ((data = fr.read()) != -1){
  20.                 System.out.println((char) data);
  21.             }
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }finally {
  25.             //4.流的关闭操作
  26.             try {
  27.                 if (fr != null)
  28.                 fr.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  34.     }

使用read(char[] cbuf)读入数据

  1. public void testFileReader1() {
  2.         FileReader fr = null;
  3.         try {
  4.             //1.File类的实例化
  5.             File file = new File("hello.txt");
  6.             //2.FileReader流的实例化
  7.             fr = new FileReader(file);
  9.             //3.读入的操作
  10.             //read(char[] cbuf):返回每次读入cbuf数组中的字符个数，如果达到文件末尾，返回-1
  11.             char[] cbuf = new char[5];
  12.             int len;
  13.             while ((len = fr.read(cbuf)) != -1){
  15.                 //方式一：
  16.                 //错误的写法
  17.                /* for (int i =0;i < cbuf.length;i++){
  18.                     System.out.print(cbuf[i]);
  19.                 }*/
  21.                 //正确的写法
  22.                 for (int i =0;i < len;i++){
  23.                     System.out.print(cbuf[i]);
  24.                 }
  26.                 //方式二：
  27.                 //错误的写法
  28.                 /*String str = new String(cbuf);
  29.                 System.out.print(str);*/
  31.                 //正确的写法
  32.                 String str = new String(cbuf,0,len);
  33.                 System.out.print(str);
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         }finally {
  40.             if (fr != null)
  41.             try {
  42.                 //4.资源关闭
  43.                 fr.close();
  44.             } catch (IOException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  49.     }

FileWriter写出数据操作

说明：
1.输出操作，对应的File可以不存在。并不会报异常
2.File对应的硬盘中的文件如果不存在，输出的过程中，会自动创建此文件
File对应的硬盘中的文件如果存在：
如果流使用的构造器是：FileWriter（file，false）/FileWriter（file）:对原有文件的覆盖
如果流使用的构造器是：FileWriter（file，true）：不会对原有文件覆盖，而是在原有文件基础上追加内容

  1. public void testFileWriter() {
  2.         FileWriter fw = null;
  3.         try {
  4.             //1.提供File类的对象，指明写出到的文件
  5.             File file = new File("hello1.txt");
  7.             //2.提供FileWriter的对象，用于数据的写出
  8.             fw = new FileWriter(file);
  10.             //3.写出的操作
  11.             fw.write("I have a dream!\n");
  12.             fw.write("You need to have a dream！");
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         } finally {
  16.             //4.流资源关闭
  17.             try {
  18.                 if (fw != null){
  19.                     fw.close();
  20.                 }
  21.             } catch (IOException e) {
  22.                 e.printStackTrace();
  23.             }
  25.         }
  26.     }

FileReader和FileWriter实现文本的复制

  1. public void testFileReaderFileWriter() {
  2.         FileReader fr = null;
  3.         FileWriter fw = null;
  4.         try {
  5.             //1.创建File类的对象，指明读入和写出的文件
  6.             File srcFile = new File("hello.txt");
  7.             File destFile = new File("hello2.txt");
  9.             //2.创建输入流和输出流的对象
  10.             fr = new FileReader(srcFile);
  11.             fw = new FileWriter(destFile);
  13.             //3.数据的读入和写出操作
  14.             char[] cbuf = new char[5];
  15.             int len;//记录每次读入到cbuf数组中的字符的个数
  16.             while ((len = fr.read(cbuf)) != -1){
  17.                 //每次写出len个字符
  18.                 fw.write(cbuf,0,len);
  20.             }
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         } finally {
  24.             //4.关闭流资源
  25.             try {
  26.                 if (fw != null)
  27.                     fw.close();
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  32.             try {
  33.                 if (fr != null)
  34.                 fr.close();
  35.             } catch (IOException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         }
  39.     }

FileInputStream和FileOutputStream的使用

结论：
1.文本文件(.txt , .java , .c , .cpp),使用字符流处理
2.非文本文件(.jpg , .mp3 , .avi , .doc , .ppt , …),使用字节流处理

FileInputStream和FileOutputStream读写文本文件

  1. public void testFileInputStream() {
  2.     //使用字节流FileInputStream处理文本文件，可能出现乱码
  3.         FileInputStream fis = null;
  5.         try {
  6.             //1.造文件
  7.             File file = new File("hello.txt");
  9.             //2.造流
  10.             fis = new FileInputStream(file);
  12.             //3.读数据
  13.             byte[] buffer = new byte[5];
  14.             int len;//记录每次读取的字节的个数
  15.             while((len = fis.read(buffer)) != -1){
  16.                 String str = new String(buffer,0,len);
  17.                 System.out.print(str);
  18.             }
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             if (fis != null) {
  23.                 //4.关闭资源
  24.                 try {
  25.                     fis.close();
  26.                 } catch (IOException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.             }
  30.         }
  31.     }

FileInputStream和FileOutputStream读写非文本文件

  1. public void testFileInputOutputStream() {
  3.         FileInputStream fis = null;
  4.         FileOutputStream fos = null;
  5.         try {
  6.             File srcFile = new File("记.jpg");
  7.             File destFile = new File("记1.jpg");
  9.             fis = new FileInputStream(srcFile);
  10.             fos = new FileOutputStream(destFile);
  12.             //复制过程
  13.             byte[] buffer = new byte[5];
  14.             int len;
  15.             while((len = fis.read(buffer)) != -1){
  16.                 fos.write(buffer,0,len);
  17.             }
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             if (fos != null){
  22.                 try {
  23.                     fos.close();
  24.                 } catch (IOException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.             }
  28.             if (fis != null){
  29.                 try {
  30.                     fis.close();
  31.                 } catch (IOException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }
  36.     }

FileInputStream和FileOutputStream复制文件

  1. //指定路径下文本的复制
  2.     public void copyFile(String srcPath,String destPath){
  3.         FileInputStream fis = null;
  4.         FileOutputStream fos = null;
  5.         try {
  6.             File srcFile = new File(srcPath);
  7.             File destFile = new File(destPath);
  9.             fis = new FileInputStream(srcFile);
  10.             fos = new FileOutputStream(destFile);
  12.             //复制过程
  13.             byte[] buffer = new byte[5];
  14.             int len;
  15.             while((len = fis.read(buffer)) != -1){
  16.                 fos.write(buffer,0,len);
  17.             }
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             if (fos != null){
  22.                 try {
  23.                     fos.close();
  24.                 } catch (IOException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.             }
  28.             if (fis != null){
  29.                 try {
  30.                     fis.close();
  31.                 } catch (IOException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }
  36.     }
  38. @Test
  39.     public void testCopyFile(){
  40.         long start = System.currentTimeMillis();
  42.         String srcPath = "hello.txt";
  43.         String destPath = "hello3.txt";
  44.         copyFile(srcPath,destPath);
  46.         long end = System.currentTimeMillis();
  48.         System.out.println("复制操作花费的时间为：" + (end - start));
  49.     }

缓冲流的使用

作用：提高流的读取、写入的速度
原因：内部提供了一个缓冲区

实现非文本文件的复制

使用BufferedInputStream和BufferedOutputStream

  1. public void test1() throws FileNotFoundException {
  2.         FileInputStream fis = null;
  3.         FileOutputStream fos = null;
  4.         BufferedInputStream bis = null;
  5.         BufferedOutputStream bos = null;
  7.         try {
  8.             //1.造文件
  9.             File srcFile = new File("记.jpg");
  10.             File destFile = new File("记2.jpg");
  11.             //2.造流
  12.             //2.1 造节点流
  13.             fis = new FileInputStream((srcFile));
  14.             fos = new FileOutputStream((destFile));
  15.             //2.2 造缓冲流
  16.             bis = new BufferedInputStream((fis));
  17.             bos = new BufferedOutputStream((fos));
  19.             //3.复制的细节：读取、写入
  20.             byte[] buffer = new byte[10];
  21.             int len;
  22.             while ((len = bis.read(buffer)) != -1){
  23.                 bos.write(buffer,0,len);
  24.             }
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         } finally {
  28.             //4.资源关闭
  29.             //要求：先关闭外层的流，再关闭内层的流
  30.             if (bos != null){
  31.                 try {
  32.                     bos.close();
  33.                 } catch (IOException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.             if (bis != null){
  38.                 try {
  39.                     bis.close();
  40.                 } catch (IOException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.             //说明：关闭外层流的同时，内层流也会自动进行关闭。关于内层流的关闭，我们可以省略
  45.             /*fos.close();
  46.             fis.close();*/
  47.         }

实现文本文件复制

使用BufferedReader和BufferedWriter

  1. public void testBufferedReaderBufferedWriter(){
  2.         BufferedReader br = null;
  3.         BufferedWriter bw = null;
  5.         try {
  6.             //创建文件和相应的流
  7.             br = new BufferedReader(new FileReader(new File("hello.txt")));
  8.             bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));
  10.             //读写操作
  11.             //方式一：使用char[]数组
  12.             /*char[] cbuf = new char[1024];
  13.             int len;
  14.             while ((len = br.read(cbuf)) != -1 ){
  15.                 bw.write(cbuf,0,len);
  16.                 //bw.flush();
  17.             }*/
  19.             //方式二：使用String
  20.             String data;
  21.             while((data = br.readLine()) != null){
  22.                 //方法一：
  23.                 bw.write(data + "\n");//data中不包含换行符
  24.                 //方法二：
  25.                 bw.write(data);//data中不包含换行符
  26.                 bw.newLine();
  27.             }
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             //关闭资源
  33.             if (bw != null){
  34.                 try {
  35.                     bw.close();
  36.                 } catch (IOException e) {
  37.                     e.printStackTrace();
  38.                 }
  39.             }
  40.             if (br != null){
  41.                 try {
  42.                     br.close();
  43.                 } catch (IOException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.             }
  47.         }
  48.     }

练习

图片加密

解密：将fis与fos中文件相互交换即可完成

  1. public void test2(){
  2.         FileInputStream fis = null;
  3.         FileOutputStream fos = null;
  4.         try {
  5.             fis = new FileInputStream("记.jpg");
  6.             fos = new FileOutputStream("记secret.jpg");
  8.             byte[] buffer = new byte[20];
  9.             int len;
  10.             while ((len = fis.read(buffer)) != -1){
  11.                 //字节数组进行修改
  12.                 //错误的
  13.                 /*for (byte b : buffer){
  14.                     b = (byte) (b ^ 5);
  15.                 }*/
  16.                 //正确的
  17.                 for (int i = 0;i < len;i++){
  18.                     buffer[i] = (byte) (buffer[i] ^ 5 );
  19.                 }
  20.                 fos.write(buffer,0,len);
  21.             }
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         } finally {
  25.             if (fis != null){
  26.                 try {
  27.                     fis.close();
  28.                 } catch (IOException e) {
  29.                     e.printStackTrace();
  30.                 }
  31.             }
  33.             if (fos != null){
  34.                 try {
  35.                     fos.close();
  36.                 } catch (IOException e) {
  37.                     e.printStackTrace();
  38.                 }
  39.             }
  40.         }
  41.     }

转换流的使用

1.转换流：属于字符流
InputStreamReader：将一个字节的输入流转换为字符的输入流
OutputStreamWriter：将一个字符的输出流转换为字节的输出流
2.作用：提供字节流与字符流之间的转换
3.解码：字节、字节数组 —-> 字符数组、字符串
编码：字符数组、字符串 —-> 字节、字节数组

  1. public void test1() {
  3.         InputStreamReader isr = null;
  4.         try {
  5.             FileInputStream fis = new FileInputStream("hello.txt");
  6.             //参数二指明了字符集，具体使用哪个字符集，取决于文件保存时使用的字符集
  7.             isr = new InputStreamReader(fis,"UTF-8");
  8.             //InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
  10.             char[] cbuf = new char[20];
  11.             int len;
  12.             while((len = isr.read(cbuf)) != -1){
  13.                 String str = new String(cbuf,0,len);
  14.                 System.out.println(str);
  15.             }
  16.         } catch (IOException e) {
  17.             e.printStackTrace();
  18.         } finally {
  19.             if (isr != null){
  20.                 try {
  21.                     isr.close();
  22.                 } catch (IOException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }
  26.         }
  27.     }

实现读入与写出

  1. public void test2() {
  3.         InputStreamReader isr = null;
  4.         OutputStreamWriter osw = null;
  5.         try {
  6.             File file1 = new File("hello.txt");
  7.             File file2 = new File("hello_gbk.txt");
  9.             FileInputStream fis = new FileInputStream(file1);
  10.             FileOutputStream fos = new FileOutputStream(file2);
  12.             isr = new InputStreamReader(fis, "UTF-8");
  13.             osw = new OutputStreamWriter(fos, "gbk");
  15.             char[] cbuf = new char[20];
  16.             int len;
  17.             while ((len = isr.read(cbuf)) != -1) {
  18.                 osw.write(cbuf, 0, len);
  19.             }
  20.         } catch (IOException e) {
  21.             e.printStackTrace();
  22.         } finally {
  23.             if (isr != null){
  24.                 try {
  25.                     isr.close();
  26.                 } catch (IOException e) {
  27.                     e.printStackTrace();
  28.                 }
  29.             }
  30.             if (osw != null){
  31.                 try {
  32.                     osw.close();
  33.                 } catch (IOException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.         }
  40.     }

字符集

屏幕截图 2022-04-13 145539.jpg

对象流

序列化过程

将内存中的java对象保存到磁盘中或通过网络传输出去
使用ObjectOutputStream实现

  1. public void test1(){
  2.         ObjectOutputStream oos = null;
  3.         try {
  4.             oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
  6.             oos.writeObject(new String("我爱北京"));
  8.             oos.flush();//刷新操作
  9.         } catch (IOException e) {
  10.             e.printStackTrace();
  11.         } finally {
  12.             if (oos != null){
  13.                 try {
  14.                     oos.close();
  15.                 } catch (IOException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.             }
  19.         }
  20.     }

反序列化过程

将磁盘文件中的对象还原为内存中的一个Java对象
使用ObjectInputStream实现

  1. public void test2(){
  2.         ObjectInputStream ois = null;
  3.         try {
  4.             ois = new ObjectInputStream(new FileInputStream("object.txt"));
  6.             Object obj = ois.readObject();
  7.             String str = (String) obj;
  8.             System.out.println(str);
  9.         } catch (IOException e) {
  10.             e.printStackTrace();
  11.         } catch (ClassNotFoundException e) {
  12.             e.printStackTrace();
  13.         } finally {
  14.             if (ois != null){
  15.                 try {
  16.                     ois.close();
  17.                 } catch (IOException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         }
  22.     }

自定义类的序列化与反序列化操作

自定义类的要求
1.需要实现接口：Serializable
2.当前类提供一个全局变量：serialVersionUID
3.除了当前类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的（默认情况下，基本数据类型可序列化）
补：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
过程与序列化和反序列化一致

serialVersionUID的说明

屏幕截图 2022-04-14 112932.jpg

RandomAccessFile的使用

1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
3.如果RandomAccessFile作为输出流时，写出到文件如果不存在，则在执行过程中自动创建，如果写出到文件存在，则会对原有文件内容进行覆盖。（默认情况下从头覆盖）
屏幕截图 2022-04-15 171456.jpg

实现读取与写入操作

  1. public void test1() {
  3.         RandomAccessFile raf1 = null;
  4.         RandomAccessFile raf2 = null;
  5.         try {
  6.             raf1 = new RandomAccessFile(new File("data.txt"),"r");
  7.             raf2 = new RandomAccessFile(new File("data1.txt"),"rw");
  9.             byte[] buffer = new byte[10];
  10.             int len;
  11.             while((len = raf1.read(buffer)) != -1){
  12.                 raf2.write(buffer,0,len);
  13.             }
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         } finally {
  17.             if (raf1 != null){
  18.                 try {
  19.                     raf1.close();
  20.                 } catch (IOException e) {
  21.                     e.printStackTrace();
  22.                 }
  23.             }
  24.             if (raf2 != null){
  25.                 try {
  26.                     raf2.close();
  27.                 } catch (IOException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.         }
  32.     }

实现数据的插入

  1. public void test2() {
  2.         RandomAccessFile raf1 = null;
  3.         try {
  4.             raf1 = new RandomAccessFile("hello.txt","rw");
  6.             raf1.seek(3);//将指针调到角标为3的位置
  7.             //保存指针3后面的所有数据到StringBuilder中
  8.             StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
  9.             byte[] buffer = new byte[20];
  10.             int len;
  11.             while ((len = raf1.read(buffer)) != -1){
  12.                 builder.append(new String(buffer,0,len));
  13.             }
  14.             //调回指针，写入”xyz“
  15.             raf1.seek(3);
  16.             raf1.write("xyz".getBytes(StandardCharsets.UTF_8));
  17.             //将StringBuilder中的数据写入到文件中
  18.             raf1.write(builder.toString().getBytes(StandardCharsets.UTF_8));
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             if (raf1 != null){
  23.                 try {
  24.                     raf1.close();
  25.                 } catch (IOException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.         }
  30.     }

其他流的使用

标准流的输入、输出流

1.System.in：标准的输入流，默认从键盘输入
System.out：标准的输出流，默认从控制台输出
2.System类的setIn(InputStream is) / setOut(PrintStream ps)重新指定输入和输出流
实例：将读取到的整行字符串转成大写输出，直至当输入”e“或”exit“时，退出程序
方法一：使用Scanner实现，调用next()返回一个字符串
方法二：使用System.in实现。System.in —-> 转换流 —-> BufferedReader的readLine()

  1. //方法二
  2. public class OtherStreamTest {
  5.     public static void main(String[] args) {
  8.             BufferedReader br = null;
  9.             try {
  10.                 InputStreamReader isr = new InputStreamReader(System.in);
  11.                 br = new BufferedReader(isr);
  14.                 while (true) {
  15.                     System.out.println("请输入字符串:");
  16.                     String data = br.readLine();
  17.                     if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
  18.                         System.out.println("程序结束");
  19.                         break;
  20.                     }
  21.                     String upperCase = data.toUpperCase();
  22.                     System.out.println(upperCase);
  23.                 }
  24.             } catch (IOException e) {
  25.                 e.printStackTrace();
  26.             } finally {
  27.                 if (br != null){
  28.                     try {
  29.                         br.close();
  30.                     } catch (IOException e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                 }
  34.             }
  37.         }
  38.     }

打印流

PrintStream和PrintWriter 都是输入流
提供了一系列重载的print()和println()

数据流

DataInputStream和DataOutputStream
作用：用于读取或写出基本数据类型的变量或字符串
实例：
注意：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致

  1. public void test1(){
  3.             DataOutputStream dos = null;
  4.             try {
  5.                 dos = new DataOutputStream(new FileOutputStream("data.txt"));
  7.                 dos.writeUTF("Y三角");
  8.                 dos.writeInt(19);
  9.                 dos.writeBoolean(true);
  10.             } catch (IOException e) {
  11.                 e.printStackTrace();
  12.             } finally {
  13.                 if (dos != null){
  14.                     try {
  15.                         dos.close();
  16.                     } catch (IOException e) {
  17.                         e.printStackTrace();
  18.                     }
  19.                 }
  20.             }
  21.         }
  25. public void test2() throws IOException {
  26.         //将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中
  28.            DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
  31.                 String name = dis.readUTF();
  32.                 int age = dis.readInt();
  33.                 boolean isMale = dis.readBoolean();
  36.             System.out.println("name：" + name);
  37.             System.out.println("age：" + age);
  38.             System.out.println("isMale：" +isMale);
  40.             dis.close();
  41.         }