devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java 基本IO操作_javabyte[] data = {};

作者：秋刀鱼在做梦 | 2024-07-16 00:13:15

赞

踩

javabyte[] data = {};

1.JAVA IO
IO指的是输入与输出，Input和Output

java将输入与输出比作流: 流可以理解为是

顺着同一个方向移动的过程，即:流动的概念
输入流:想象为是一个"管道"，链接着我们写的java程序与另一端的管道，而流动的方向
       是从另一端移动到我们的程序的过程,是一个获取的过程，操作为"读"
输出流:方向从我们写的程序到另一端的方向，操作为:"写"

java为了规范流的行为，定义了两个超类:
java.io.InputStream和java.io.OutputStream
java.io.InputStream是所有字节输入流的超类(同时是抽象类)
    定义了几个常见的抽象方法:
    int read():读取一个字节
    int read(byte[] data):块读取操作

java.io.OutputStream是所有字节输出流的超类(同时是抽象类)
    void write(int d):写出一个字节
    void write(byte[] data):块写操作

    void write(byte[] data,int off,int len):块写部分数据。

文件流:
java.io.FileInputStream和FileOutputStream
文件流继承自java.io.InputStream和OutputStream
这对流是用来读写文件的流

  1. public class FOSDemo {
  2.     public static void main(String[] args) throws IOException {
  3.  
  4.         /*
  5.             常见构造器:
  6.             FileOutputStream(String pathname)
  7.             参数为写出的文件的路径
  8.  
  9.             FileOutputStream(File file)
  10.             参数为写出的文件所对应的File实例
  11.  
  12.             创建文件输出流时，如果指定的文件不存在文件流会自动将该文件创建出来
  13.             但是如果指定的文件所在的目录不存在时，实例化会抛出异常:
  14.             java.io.FileNotFoundException
  15.             即:文件没找到异常
  16.          */
  17.         //向当前目录下的fos.dat文件中写入数据
  18.         /*
  19.             相对路径中"./"可以忽略不写，默认就是从"./"开始的
  20.             比如: "./fos.dat"等价与"fos.dat"
  21.                  "./demo/fos.dat"等价于"demo/fos.dat"
  22.          */
  23.         FileOutputStream fos = new FileOutputStream("fos.dat");
  24. //        File file = new File("fos.dat");
  25. //        FileOutputStream fos = new FileOutputStream(file);
  26.         /*
  27.             字节输出流的超类OutputStream上定义了写出一个字节的基础操作
  28.             void write(int d):写出一个字节
  29.  
  30.             因此文件流上就具有该方法，实现的目标就是将字节写入到文件中
  31.  
  32.             该方法要求传入一个int值，作用是将该int值对应的2进制的低八位
  33.             写入到文件中。
  34.                                        vvvvvvvv
  35.             00000000 00000000 00000000 00000000
  36.          */
  37.  
  38.         /*
  39.             fos.write(1)
  40.  
  41.             int型整数1的2进制：
  42.             00000000 00000000 00000000 00000001
  43.                                        ^^^^^^^^
  44.                                        写出的字节
  45.  
  46.            写出后，fos.dat文件中内容为:
  47.            00000001
  48.  
  49.          */
  50.         fos.write(-1);
  51.         /*
  52.             fos.write(2)
  53.  
  54.             int型整数2的2进制：
  55.             00000000 00000000 00000000 00000010
  56.                                        ^^^^^^^^
  57.                                        写出的字节
  58.  
  59.            写出后，fos.dat文件中内容为:
  60.            00000001 00000010
  61.          */
  62.         fos.write(2);
  63.  
  64.         System.out.println("写出完毕!");
  65.         fos.close();
  66.  
  67.     }
  68. }

文件输入流读取文件数据

  1. public class FISDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         FileInputStream fis = new FileInputStream("./fos.dat");
  4.         /*
  5.             InputStream这个超类上定义了基础的读取字节的方法:
  6.             int read()
  7.             读取1个字节，将读取到的字节(8位2进制)放在返回的int值对应的2进制的
  8.             最低8位上。如果返回的int值为整数-1则表示流读取到了末尾。
  9.  
  10.             文件流实现了该方法，作用是从文件中顺序的读取每一个字节。
  11.          */
  12.         /*
  13.             fos.dat文件中的内容:
  14.             00000001 00000010
  15.             ^^^^^^^^
  16.  
  17.             int d = fis.read();//第一次调用相当于读取文件的第一个字节
  18.             读取到的字节是:00000001
  19.  
  20.             而read方法返回的int值2进制的样子:
  21.             00000000 00000000 00000000 00000001
  22.             |-----前24位2进制全部补0---| |读取的字节|
  23.          */
  24.         int d = fis.read();//第一次调用相当于读取文件的第一个字节
  25.         System.out.println(d);//1
  26.         /*
  27.             fos.dat文件中的内容:
  28.             00000001 00000010
  29.                      ^^^^^^^^
  30.  
  31.             d = fis.read();//第二次调用相当于读取文件的第二个字节
  32.             读取到的字节是:00000010
  33.  
  34.             而read方法返回的int值2进制的样子:
  35.             00000000 00000000 00000000 00000010
  36.             |-----前24位2进制全部补0---| |读取的字节|
  37.          */
  38.         d = fis.read();//2
  39.         System.out.println(d);
  40.         /*
  41.             fos.dat文件中的内容:
  42.             00000001 00000010 文件末尾(没有第三个字节)
  43.                               ^^^^^^^^
  44.  
  45.             d = fis.read();//第三次调用相当于读取文件的第三个字节
  46.             读取到的字节是:没有读取到数据
  47.  
  48.             而read方法返回的int值2进制的样子:
  49.             11111111 11111111 11111111 11111111
  50.             -1则表示流读取到了末尾。
  51.          */
  52.         d = fis.read();
  53.         System.out.println(d);
  54.  
  55.         fis.close();
  56.     }
  57. }
文件复制
思路:
1:先创建一个文件输入流用于读取原文件
2:再创建一个文件输出流用于将数据抄到复制的文件中
3:顺序的从原文件中读取每一个字节并写入到复制的文件中
  1. public class CopyDemo {
  2.     public static void main(String[] args) throws IOException {
  3. //        FileInputStream fis = new FileInputStream("image.jpg");
  4. //        FileOutputStream fos = new FileOutputStream("image_cp.jpg");
  5.  
  6.         FileInputStream fis = new FileInputStream("setup.exe");
  7.         FileOutputStream fos = new FileOutputStream("setup_cp.exe");
  8.  
  9.         /*
  10.             例如:
  11.             image.jpg文件内容
  12.             01111001 11001100 00001111 11110000 10101010 01010101...
  13.             ^^^^^^^^
  14.             第一次调用:
  15.             byte d = fis.read();
  16.             d的2进制:00000000 00000000 00000000 01111001
  17.  
  18.             目标是将读取到的第一个字节写入到复制文件的第一个字节的位置上
  19.             第一次调用
  20.             fos.write(d);
  21.             写的是d的2进制的低八位到文件image_cp.jpg中
  22.             d的2进制:00000000 00000000 00000000 01111001
  23.                                                ^^^^^^^^
  24.                                                写出的字节
  25.             image_cp.jpg文件内容:
  26.             01111001
  27.          */
  28.         int d = 0;
  29.         long start = System.currentTimeMillis();
  30.         while((d = fis.read()) != -1) {
  31.             fos.write(d);
  32.         }
  33.         long end = System.currentTimeMillis();
  34.         System.out.println("复制完毕!耗时:"+(end-start)+"ms");
  35.         fis.close();
  36.         fos.close();
  37.     }
  38. }
通过提高每次读写的数据量减少实际读写的次数可以提高读写效率
一组字节一组字节的读写数据称为块读写
  1. public class CopyDemo2 {
  2.     public static void main(String[] args) throws IOException {
  3.         FileInputStream fis = new FileInputStream("setup.exe");
  4.         FileOutputStream fos = new FileOutputStream("setup_cp.exe");
  5.  
  6.         /*
  7.             java.io.InputStream上定义了块读字节数据的方法
  8.             int read(byte[] data)
  9.             一次性读取给定字节数组总长度的字节量并从字节数组第一个位置开始将读取到的
  10.             数据全部存入数组，返回值为实际读取到的字节数。如果返回值为-1则表示读取
  11.             到了流的末尾。
  12.  
  13.             setup.exe文件内容
  14.             00110011 11001100 10101010 01010101 11110000 00001111
  15.  
  16.             byte[] data = new byte[4];//创建一个4字节长度的数组
  17.             data:{00000000,00000000,00000000,00000000}
  18.             int len;//用来表示每次实际读取到的字节数
  19.  
  20.             setup.exe文件内容
  21.             00110011 11001100 10101010 01010101 11110000 00001111
  22.             ^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^
  23.             //第一次调用
  24.             len = fis.read(data);//因为数组长度是4，所以可以一次性读4个字节
  25.             data:{00110011,11001100,10101010,01010101}//将读取的4字节存入数组
  26.             len:4   4表示实际读取到了4个字节
  27.  
  28.  
  29.             setup.exe文件内容
  30.             00110011 11001100 10101010 01010101 11110000 00001111 文件末尾
  31.                                                 ^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^
  32.                                                 实际只能读取到2字节
  33.             //第二次调用
  34.             len = fis.read(data);//因为数组长度是4，所以可以一次性读4个字节，但实际仅读取到了2个字节
  35.             data:{11110000,00001111,10101010,01010101}
  36.                  | 本地读取到的2字节 | |  上次的旧数据   |
  37.             len:2    本次实际读取到了2个字节，意味着data数组只有前2个字节有用
  38.  
  39.             setup.exe文件内容
  40.             00110011 11001100 10101010 01010101 11110000 00001111 文件末尾
  41.                                                                   ^^^^^^^
  42.                                                                   没有数据了
  43.             //第三次调用
  44.             len = fis.read(data);//一个字节都没有读取到
  45.             data:{11110000,00001111,10101010,01010101}
  46.                  |              都是旧数据            |
  47.             len:-1 已经是文件末尾了！
  48.  
  49.  
  50.  
  51.             java.io.OutputStream超类上提供了块写操作
  52.             void write(byte[] data)
  53.             将给定的字节数组中所有数据一次性写出
  54.  
  55.             void write(byte[] data,int off,int len)
  56.             一次性将给定的字节数组从下标off处开始的连续len个字节一次性写出
  57.          */
  58.  
  59.         byte[] data = new byte[1024*10];//10kb
  60.         int len;//记录每次实际读取到的字节数
  61.         //16:45回来
  62.         long start = System.currentTimeMillis();
  63.         while( (len = fis.read(data)) != -1 ){
  64.             fos.write(data,0,len);
  65.         }
  66.         long end = System.currentTimeMillis();
  67.         System.out.println("复制完毕，耗时:"+(end-start)+"ms");
  68.  
  69.         fis.close();
  70.         fos.close();
  71.     }
  72. }
向文件中写入文本数据
  1. public class WriteStringDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         /*
  4.             构造器:
  5.             FileOutputStream(String pathname)
  6.             FileOutputStream(File file)
  7.             以上这两种方式创建的文件流为覆盖模式。
  8.             覆盖模式指:文件流在创建时，如果指定的文件已经存在了则会将该文件内容全
  9.             部清空。
  10.  
  11.  
  12.             FileOutputStream(String pathname,boolean append)
  13.             FileOutputStream(File file,boolean append)
  14.             这两种构造器要求再传入一个boolean参数，如果参数值为true，则文件流
  15.             采取追加模式。
  16.             追加模式指:文件流再创建时，如果指定的文件已经存在了，则原内容全部保留
  17.             新写入的数据会陆续追加到文件中
  18.          */
  19.         FileOutputStream fos = new FileOutputStream("demo.txt",true);
  20.         /*
  21.             UTF-8
  22.             英文占1字节，中文占3字节
  23.          */
  24.         String line = "一给窝里giao~~";
  25.         byte[] data = line.getBytes(StandardCharsets.UTF_8);
  26.         fos.write(data);
  27.  
  28. //        String line1 = "我太难了~~~";
  29. //        byte[] data1 = line1.getBytes(StandardCharsets.UTF_8);
  30. //        fos.write(data1);
  31. //
  32. //        String line2 = "嘿嘿嘿~";
  33. //        byte[] data2 = line2.getBytes(StandardCharsets.UTF_8);
  34. //        fos.write(data2);
  35.  
  36.  
  37.         System.out.println("写出完毕!");
  38.         fos.close();
  39.  
  40.     }
  41. }
读取文件中的文本数据
  1. public class ReadStringDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         File file = new File("demo.txt");
  4.         //将demo.txt文件中所有数据读取回来
  5.         FileInputStream fis = new FileInputStream(file);
  6.         long len = file.length();//获取文件的大小，单位字节
  7.         byte[] data = new byte[(int)len];//常见与文件大小一致的字节数组
  8.         fis.read(data);//块读，将文件所有字节读到data数组中
  9.         /*
  10.             Standard 标准
  11.             Charsets 字符集
  12.          */
  13.         String line = new String(data, StandardCharsets.UTF_8);
  14.         System.out.println(line);
  15.         fis.close();
  16.     }
  17. }
JAVA将流分为了两类:节点流与处理流
节点流:又称为低级流，是实际链接程序与另一端的"管道"，负责实际读写数据的流。
      读写一定是建立在低级流的基础上进行的。
处理流:又称为高级流，不能独立存在，必须链接在其它流上，目的是当数据流经当前
      流时对数据进行某种加工处理，简化我们相应的操作。
实际开发中，我们总是会串联一组高级流到一个低级流上，以流水线式的加工处理完成
读写的操作，这个过程也成为"流的链接"

缓冲流:
java.io.BufferedInputStream和BufferedOutputStream
它们同样继承自InputStream和OutputStream

缓冲流的功能是提高读写效率。
  1. public class CopyDemo3 {
  2.     public static void main(String[] args) throws IOException {
  3.         FileInputStream fis = new FileInputStream("setup.exe");
  4.         BufferedInputStream bis = new BufferedInputStream(fis);
  5.  
  6.         FileOutputStream fos = new FileOutputStream("setup_cp.exe");
  7.         //缓冲流内部缓冲区默认为8kb
  8. //        BufferedOutputStream bos = new BufferedOutputStream(fos);
  9.         //重载的构造器可以自行指定缓冲区大小
  10.         BufferedOutputStream bos = new BufferedOutputStream(fos,1024*10);
  11.         int d = 0;
  12.         long start = System.currentTimeMillis();
  13.         while((d = bis.read()) != -1) {
  14.             bos.write(d);
  15.         }
  16.         long end = System.currentTimeMillis();
  17.         System.out.println("复制完毕!耗时:"+(end-start)+"ms");
  18.         bis.close();
  19.         bos.close();
  20.     }
  21. }
缓冲输出流写出数据的缓冲区问题
  1. public class FlushDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         FileOutputStream fos = new FileOutputStream("bos.txt");
  4.         BufferedOutputStream bos = new BufferedOutputStream(fos);
  5.         String line = "该配合你演出的我演视而不见。";
  6.         byte[] data = line.getBytes(StandardCharsets.UTF_8);
  7.         bos.write(data);
  8.         System.out.println("写出完毕");
  9.         /*
  10.             java.io.Flushable接口,里面定义了抽象方法flush(),作用是将缓冲流的
  11.             缓冲区中已经缓存的数据一次性写出
  12.             java.io.OutputStream实现了该接口，这意味着所有的字节输出流都有这个
  13.             方法，但是只有缓冲输出流真正实现了该方法的功能，其它的高级输出流flush
  14.             方法的作用仅仅是调用其连接的流的flush方法将该动作传递下去，直到传递给
  15.             缓冲流的flush做实际操作。
  16.          */
  17. //        bos.flush();//冲
  18.         bos.close();
  19.  
  20.     }
  21. }
标准的JAVA BEAN规则
应当有无参构造器
属性应当有对应的get，set方法

Person : 人

使用当前类的实例测试对象流的序列化与反序列化操作
序列化:将一个对象按照其结构转化为一组字节的过程
反序列化:将一组字节还原为一个对象的过程
  1. public class Person implements Serializable {
  2.     /*
  3.         当一个类实现了可序列化接口后，建议明确添加序列化版本号。
  4.         这样当我们进行对象的反序列化时，如果当前类的结构改变了(比如新添加了属性)
  5.         由于版本号没有改变，那么反序列化就可以成功。
  6.         如果不指定序列化版本号，那么对象在序列化时对象输出流会根据当前类结构生成
  7.         一个版本号，但是缺点是只要当前类结构改变了，版本号也会一同变化，这会导致
  8.         之前序列化的对象都无法反序列化成功，会抛出异常:java.io.InvalidClassException
  10.         建议通读文档
  11.         Serializable接口的描述
  12.      */
  13.     public static final long serialVersionUID = 1L;
  14.     private String name;//名字
  15.     private int age;//年龄
  16.     private String gender;//性别
  17.     /*
  18.         被关键字:transient修饰的属性，对象序列化时该属性的值会被忽略。
  19.         忽略不必要的属性可以达到的对象序列化"瘦身"的目的,减小不必要的开销。
  20.      */
  21.     private transient String[] otherInfo;//其它信息
  22.  
  23. //    private int salary;
  24.  
  25.     public Person(){}
  26.  
  27.     public Person(String name, int age, String gender, String[] otherInfo) {
  28.         this.name = name;
  29.         this.age = age;
  30.         this.gender = gender;
  31.         this.otherInfo = otherInfo;
  32.     }
  33.  
  34.     public String getName() {
  35.         return name;
  36.     }
  37.  
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  41.  
  42.     public int getAge() {
  43.         return age;
  44.     }
  45.  
  46.     public void setAge(int age) {
  47.         this.age = age;
  48.     }
  49.  
  50.     public String getGender() {
  51.         return gender;
  52.     }
  53.  
  54.     public void setGender(String gender) {
  55.         this.gender = gender;
  56.     }
  57.  
  58.     public String[] getOtherInfo() {
  59.         return otherInfo;
  60.     }
  61.  
  62.     public void setOtherInfo(String[] otherInfo) {
  63.         this.otherInfo = otherInfo;
  64.     }
  65.  
  66.     @Override
  67.     public String toString() {
  68.         return "Person{" +
  69.                 "name='" + name + '\'' +
  70.                 ", age=" + age +
  71.                 ", gender='" + gender + '\'' +
  72.                 ", otherInfo=" + Arrays.toString(otherInfo) +
  73.                 '}';
  74.     }
  75. }
对象流java.io.ObjectOutputStream和ObjectInputStream
对象流是一对高级流，功能是进行对象序列化与反序列化。方便我们读写java对象

  1. public class OOSDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         //将一个Person对象写入文件保存
  4.         String name = "苍老师";
  5.         int age = 18;
  6.         String gender = "女";
  7.         String[] otherInfo = {"身高168","是个演员","来自日本","88,90","是我们的启蒙老师"};
  8.         Person p = new Person(name,age,gender,otherInfo);
  9.         FileOutputStream fos = new FileOutputStream("person.obj");
  10.         ObjectOutputStream oos = new ObjectOutputStream(fos);
  11.         /*
  12.             ObjectOutputStream提供了一个独有的序列化对象的方法:
  13.             void writeObject(Object obj)
  14.             该方法会将给定的对象按照其结构转换为一组字节并通过其链接的流将字节写出。
  15.  
  16.             如果该方法抛出异常:
  17.             java.io.NotSerializableException
  18.             则说明给定的对象没有实现序列化接口:java.io.Serializable
  19.             还要求该类中所有的引用类型属性也需要实现该接口
  20.             常用的数据类型:
  21.             String,包装类,数组等都实现可序列化接口
  22.          */
  23.         oos.writeObject(p);
  24.  
  25.         System.out.println("写出完毕!");
  26.         oos.close();
  27.  
  28.     }
  29. }
使用对象输入流反序列化对象
  1. public class OISDemo {
  2.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  3.         FileInputStream fis = new FileInputStream("person.obj");
  4.         ObjectInputStream ois = new ObjectInputStream(fis);
  5.         /*
  6.             对象输入流提供了一个独有的方法:
  7.             Object readObject()
  8.             作用是先通过其链接的流读取一组字节，然后将其还原为对应的java对象并返回。
  9.             返回时统一以Object形式返回，所以实际接收后可造型为实际类型去使用。
  10.  
  11.             在进行反序列化时如果抛出下面异常:
  12.             java.io.InvalidClassException
  13.             原因:
  14.             读取到的对象的序列化版本号与当前类的序列化版本号不一致导致的。
  15.  
  16.          */
  17.         Person person = (Person)ois.readObject();
  18.         /*
  19.             如果执行下面代码会抛出异常:java.io.EOFException
  20.             EOF:end of file 文件的末尾
  21.             意味着如果使用对象流读取文件时在没有读取完一个对象的所有数据就已经达到
  22.             文件末尾时会抛出该异常。
  23.             这里的原因是:
  24.             上面已经执行了readObject将文件中的对象数据都读取完毕经还原了
  25.             然后下面有执行一次readObject,此时文件中已经没有数据了，所以会抛出
  26.             文件末尾异常
  27.          */
  28. //        System.out.println(ois.readObject());
  29.         System.out.println(person);
  30.  
  31.         ois.close();
  32.  
  33.     }
  34. }
JAVA将流按照读写单位划分为字节流与字符流
 java.io.InputStream和OutputStream是所有字节输入流与输出流的超类

 java.io.Reader和Writer则是所有字符输入流与输出流的超类

 InputStream和OutputStream 与 Reader和Writer 是平级关系，相互不存在继承关系

 字符流里也同样定义了对应的读取和写出方法，只是单位都以字符为最小单位读写。


 转换流
 java.io.InputStreamReader和OutputStreamWriter
 它们是常用的字符流的一对实现类，同时它们也是一对高级流。
 它在流连接中的作用2个:
 1:衔接字节流与字符流
 2:将字节与字符进行转换方便读写。
  1. public class OSWDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         //向文件osw.txt中写入字符串
  4.         FileOutputStream fos = new FileOutputStream("osw.txt");
  5.         /*
  6.             转换流通常需要传入第二个参数用来明确字符集。这样通过当前流写出的字符
  7.             都会按照该字符集转换为字节后写出
  8.          */
  9.         OutputStreamWriter osw = new OutputStreamWriter(
  10.                 fos,StandardCharsets.UTF_8);
  11.  
  12.         //转换流会将写出的字符串转换为字节后再通过链接的文件流写入文件。
  13.         osw.write("摩擦摩擦~在光滑的马路牙子上打出溜滑~");
  14.         osw.write("我的滑板鞋~时尚时尚最时尚~");
  15.         System.out.println("写出完毕!");
  16.         osw.close();
  17.     }
  18. }
转换输入流测试字符流读取字符的操作
  1. public class ISRDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         FileInputStream fis = new FileInputStream("osw.txt");
  4.         InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
  5.         /*
  6.             字符流的读取字符方法:
  7.             int read()
  8.             读取一个字符，返回值实际上是一个char.但是是以int型返回。意味着返回的int
  9.             值低16位有效。如果返回值为int型-1表示末尾。
  10.  
  11.          */
  12. //        int d = isr.read();
  13.         /*
  14.             osw.txt UTF-8编码的
  15.             11101000 10001100 10000011
  16.                     V 将utf-8编码转换为unicode2字节返回
  17.             10000011 00000011
  18.          */
  19.         int d;
  20.         while((d = isr.read())!=-1) {
  21.             System.out.print((char) d);
  22.         }
  23.         isr.close();
  24.  
  25.     }
  26. }
缓冲字符流
 java.io.BufferedWriter和BufferedReader
 缓冲字符流是一对高级流，且是一对字符流。
 功能:块写文本数据加速

 java.io.PrintWriter
 具有自动行刷新的缓冲字符输出流
  1. public class PWDemo {
  2.     public static void main(String[] args) throws FileNotFoundException {
  3.         //向文件pw.txt中写入文本数据
  4.         PrintWriter pw = new PrintWriter("pw.txt");
  5.         pw.println("super idol的笑容都没你的甜。");
  6.         pw.println("八月正午的阳光都没你耀眼。");
  7.         System.out.println("写出完毕!");
  8.         pw.close();
  9.  
  10.     }
  11. }
在流连接中使用PrintWriter
  1. public class PWDemo2 {
  2.     public static void main(String[] args) throws FileNotFoundException {
  3.         //如果希望有追加模式，则需要自行创建文件输出流并指定
  4.         FileOutputStream fos = new FileOutputStream("pw.txt",true);
  5.         //在转换流上加上字符集，可以按照指定字符集写出。
  6.         OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
  7.         BufferedWriter bw = new BufferedWriter(osw);
  8.         /*
  9.             当PrintWriter第一个参数为流时，我们就支持再传入一个boolean值参数，如果该值为true则
  10.             打开了自动行刷新功能。每当我们调用println方法后就会自动flush一次
  11.             注意:调用print方法并不会自动flush！！！！！！！
  12.          */
  13.         PrintWriter pw = new PrintWriter(bw,true);
  14.  
  15. //        FileOutputStream fos = new FileOutputStream("pw.txt",true);
  16. //        BufferedOutputStream bw = new BufferedOutputStream(osw);
  17.         /*
  18.             不要将PW直接链接在缓冲字节输出流上，因为PW内部总是链接这BW这个缓冲字符输出流了。
  19.             不需要在缓冲字节流上再缓冲了，会降低效率
  20.          */
  21. //        PrintWriter pw = new PrintWriter(bw);
  22.  
  23.         Scanner scanner = new Scanner(System.in);
  24.         while(true) {
  25.             String line = scanner.nextLine();
  26.             if("exit".equalsIgnoreCase(line)){
  27.                 break;
  28.             }
  29.             pw.println(line);
  30.         }
  31.         System.out.println("写出完毕!");
  32.  
  33.         pw.close();
  34.  
  35.     }
  36. }
使用缓冲字符输入流java.io.BufferedReader读取文本数据
 缓冲字符输入流是一个高级流，有两个主要功能:
 1:块读文本数据加速
 2:可以按行读取字符串
  1. public class BRDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         //将当前源代码输出到控制台上
  4.         FileInputStream fis = new FileInputStream("./src/io/BRDemo.java");
  5.         InputStreamReader isr = new InputStreamReader(fis);
  6.         BufferedReader br  = new BufferedReader(isr);
  7.         String line;
  8.         /*
  9.             BufferedReader的readLine方法是它的独有方法，作用是读取一行字符串
  10.             该方法返回的字符串不包含最后的换行符。如果读取了一个空行(这一行只有换行符)，那么
  11.             返回值为空字符串，即:""。如果返回值为null则表示流读取到了末尾。
  12.          */
  13.         while((line = br.readLine()) != null) {
  14.             System.out.println(line);
  15.         }
  16.         br.close();
  17.     }
  18. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/831510
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号