Java核心知识点-字节流和字符流详解

字节流与和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？

区别：实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图12-6所示。

下面以两个写文件的操作为主进行比较，但是在操作时字节流和字符流的操作完成之后都不关闭输出流。

范例：使用字节流不关闭执行

Java代码  

  1. package org.lxh.demo12.byteiodemo;
  2. import java.io.File;
  3. import java.io.FileOutputStream;
  4. import java.io.OutputStream;
  5. public class OutputStreamDemo05 {
  6. public static void main(String[] args) throws Exception {   // 异常抛出，  不处理
  7. // 第1步：使用File类找到一个文件
  8. File f = new File("d:" + File.separator + "test.txt"); // 声明File  对象
  9. // 第2步：通过子类实例化父类对象
  10. OutputStream out = null;
  11. // 准备好一个输出的对象
  12. out = new FileOutputStream(f);
  13. // 通过对象多态性进行实例化
  14. // 第3步：进行写操作
  15. String str = "Hello World!!!";
  16. // 准备一个字符串
  17. byte b[] = str.getBytes();
  18. // 字符串转byte数组
  19. out.write(b);//读一个写一个，没有缓存
  20. // 将内容输出
  21. // 第4步：关闭输出流
  22. // out.close();
  23. // 此时没有关闭
  24. }
  25. }

程序运行结果：

此时没有关闭字节流操作，但是文件中也依然存在了输出的内容，证明字节流是直接操作文件本身的。而下面继续使用字符流完成，再观察效果。

范例：使用字符流不关闭执行

Java代码  

  1. package org.lxh.demo12.chariodemo;
  2. import java.io.File;
  3. import java.io.FileWriter;
  4. import java.io.Writer;
  5. public class WriterDemo03 {
  6. public static void main(String[] args) throws Exception { // 异常抛出，  不处理
  7. // 第1步：使用File类找到一个文件
  8. File f = new File("d:" + File.separator + "test.txt");// 声明File 对象
  9. // 第2步：通过子类实例化父类对象
  10. Writer out = null;
  11. // 准备好一个输出的对象
  12. out = new FileWriter(f);
  13. // 通过对象多态性进行实例化
  14. // 第3步：进行写操作
  15. String str = "Hello World!!!";
  16. // 准备一个字符串
  17. out.write(str);//读出来写到缓存（内存）中，还没写到磁盘上
  18. // 将内容输出
  19. // 第4步：关闭输出流
  20. // out.close();
  21. // 此时没有关闭
  22. }
  23. }

程序运行结果：

程序运行后会发现文件中没有任何内容，这是因为字符流操作时使用了缓冲区，而   在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的，所以得出结论：字符流使用了缓冲区，而字节流没有使用缓冲区。

提问：什么叫缓冲区？

在很多地方都碰到缓冲区这个名词，那么到底什么是缓冲区？又有什么作用呢？

回答：缓冲区可以简单地理解为一段内存区域。

可以简单地把缓冲区理解为一段特殊的内存。

某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能。

在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区暂存数据。

如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。

范例：强制性清空缓冲区

Java代码  

  1. package org.lxh.demo12.chariodemo;
  2. import java.io.File;
  3. import java.io.FileWriter;
  4. import java.io.Writer;
  5. public class WriterDemo04 {
  6. public static void main(String[] args) throws Exception { // 异常抛出不处理
  7. // 第1步：使用File类找到一个文件
  8. File f = new File("d:" + File.separator + "test.txt");// 声明File
  9. 对象
  10. // 第2步：通过子类实例化父类对象
  11. Writer out = null;
  12. // 准备好一个输出的对象
  13. out = new FileWriter(f);
  14. // 通过对象多态性进行实例化
  15. // 第3步：进行写操作
  16. String str = "Hello World!!!";
  17. // 准备一个字符串
  18. out.write(str);
  19. // 将内容输出
  20. out.flush();
  21. // 强制性清空缓冲区中的内容
  22. // 第4步：关闭输出流
  23. // out.close();
  24. // 此时没有关闭
  25. }
  26. }

程序运行结果：

此时，文件中已经存在了内容，更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。

提问：使用字节流好还是字符流好？

学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？

回答：使用字节流更好。

在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。

字节流与字符流主要的区别是他们的的处理方式

流分类：

1.Java的字节流

InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先。

2.Java的字符流

Reader是所有读取字符串输入流的祖先，而writer是所有输出字符串的祖先。

InputStream，OutputStream,Reader,writer都是抽象类。所以不能直接new

字节流是最基本的，所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的

但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化

这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联

在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

在从字节流转化为字符流时，实际上就是byte[]转化为String时，

public String(byte bytes[], String charsetName)

有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统的lang

而在字符流转化为字节流时，实际上是String转化为byte[]时，

byte[]    String.getBytes(String charsetName)

也是一样的道理

至于java.io中还出现了许多其他的流，按主要是为了提高性能和使用方便，

如BufferedInputStream,PipedInputStream等

（注意：BufferedInputStream稍有不同，它是带缓存的)

再解释一遍：不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！这就是两者的区别

下面是字节流和字符流常见用法：

首先看个图：（如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！）

先简单介绍下FilterInputStream:这个流用于对基础流的过滤操作，即对基础流进行包装，使之拥有更多实用的功能

这是java io 比较基本的一些处理流，除此之外我们还会提到一些比较深入的基于io的处理类，比如console类，SteamTokenzier,Externalizable接口，Serializable接口等等一些高级用法极其原理。

一、java io的开始：文件

1. 我们主要讲的是流，流的本质也是对文件的处理，我们循序渐进一步一步从文件将到流去。

2. java 处理文件的类 File,java提供了十分详细的文件处理方法，举了其中几个例子，其余的可以去

Java代码  

  1. package com.hxw.io;
  2. import java.io.*;
  3. public class FileExample{
  4. public static void main(String[] args) {
  5. createFile();
  6. }
  7. /**
  8. * 文件处理示例
  9. */
  10. public static void createFile() {
  11. File f=new File("E:/电脑桌面/jar/files/create.txt");
  12. try{
  13. f.createNewFile();  //当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
  14. System.out.println("该分区大小"+f.getTotalSpace()/(1024*1024*1024)+"G"); //返回由此抽象路径名表示的文件或目录的名称。
  15. f.mkdirs();  //创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
  16. //            f.delete(); //  删除此抽象路径名表示的文件或目录
  17. System.out.println("文件名  "+f.getName());  //  返回由此抽象路径名表示的文件或目录的名称。
  18. System.out.println("文件父目录字符串 "+f.getParent());// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
  19. }catch (Exception e) {
  20. e.printStackTrace();
  21. }
  22. }
  23. }

二、字节流:

1.字节流有输入和输出流，我们首先看输入流InputStream,我们首先解析一个例子（FileInputStream）。

Java代码  

  1. package com.hxw.io;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. public class FileCount {
  7. /**
  8. * 我们写一个检测文件长度的小程序，别看这个程序挺长的，你忽略try catch块后发现也就那么几行而已。
  9. */
  10. publicstatic void main(String[] args) {
  11. //TODO 自动生成的方法存根
  12. int count=0;  //统计文件字节长度
  13. InputStreamstreamReader = null;   //文件输入流
  14. try{
  15. streamReader=newFileInputStream(new File("D:/David/Java/java 高级进阶/files/tiger.jpg"));
  16. /*1.new File()里面的文件地址也可以写成D:\\David\\Java\\java 高级进阶\\files\\tiger.jpg,前一个\是用来对后一个
  17. * 进行转换的，FileInputStream是有缓冲区的，所以用完之后必须关闭，否则可能导致内存占满，数据丢失。
  18. */
  19. while(streamReader.read()!=-1) {  //读取文件字节，并递增指针到下一个字节
  20. count++;
  21. }
  22. System.out.println("---长度是： "+count+" 字节");
  23. }catch (final IOException e) {
  24. //TODO 自动生成的 catch 块
  25. e.printStackTrace();
  26. }finally{
  27. try{
  28. streamReader.close();
  29. }catch (IOException e) {
  30. //TODO 自动生成的 catch 块
  31. e.printStackTrace();
  32. }
  33. }
  34. }
  35. }

我们一步一步来，首先，上面的程序存在问题是，每读取一个自己我都要去用到FileInputStream，我输出的结果是“---长度是： 64982 字节”，那么进行了64982次操作！可能想象如果文件十分庞大，这样的操作肯定会出大问题，所以引出了缓冲区的概念。可以将streamReader.read()改成streamReader.read(byte[]b)此方法读取的字节数目等于字节数组的长度，读取的数据被存储在字节数组中，返回读取的字节数，InputStream还有其他方法mark,reset,markSupported方法，例如：

markSupported 判断该输入流能支持mark 和 reset 方法。

mark用于标记当前位置；在读取一定数量的数据(小于readlimit的数据)后使用reset可以回到mark标记的位置。

FileInputStream不支持mark/reset操作；BufferedInputStream支持此操作；

mark(readlimit)的含义是在当前位置作一个标记，制定可以重新读取的最大字节数，也就是说你如果标记后读取的字节数大于readlimit，你就再也回不到回来的位置了。

通常InputStream的read()返回-1后，说明到达文件尾，不能再读取。除非使用了mark/reset。

2.FileOutputStream 循序渐进版， InputStream是所有字节输出流的父类，子类有ByteArrayOutputStream,FileOutputStream,ObjectOutputStreanm,这些我们在后面都会一一说到。先说FileOutputStream

我以一个文件复制程序来说，顺便演示一下缓存区的使用。(Java I/O默认是不缓冲流的，所谓“缓冲”就是先把从流中得到的一块字节序列暂存在一个被称为buffer的内部字节数组里，然后你可以一下子取到这一整块的字节数据，没有缓冲的流只能一个字节一个字节读，效率孰高孰低一目了然。有两个特殊的输入流实现了缓冲功能，一个是我们常用的BufferedInputStream.)

Java代码  

  1. package com.hxw.io;
  2. import java.io.*;
  3. public class FileCopy {
  4. public static void main(String[] args) {
  5. // TODO自动生成的方法存根
  6. byte[] buffer=new byte[512];   //一次取出的字节数大小,缓冲区大小
  7. int numberRead=0;
  8. FileInputStream input=null;
  9. FileOutputStream out =null;
  10. try {
  11. input=new FileInputStream("D:/David/Java/java 高级进阶/files/tiger.jpg");
  12. out=new FileOutputStream("D:/David/Java/java 高级进阶/files/tiger2.jpg"); //如果文件不存在会自动创建
  13. while ((numberRead=input.read(buffer))!=-1) {  //numberRead的目的在于防止最后一次读取的字节小于buffer长度，
  14. out.write(buffer, 0, numberRead);       //否则会自动被填充0
  15. }
  16. } catch (final IOException e) {
  17. // TODO自动生成的 catch 块
  18. e.printStackTrace();
  19. }finally{
  20. try {
  21. input.close();
  22. out.close();
  23. } catch (IOException e) {
  24. // TODO自动生成的 catch 块
  25. e.printStackTrace();
  26. }
  27. }
  28. }
  29. }

3.读写对象：ObjectInputStream 和ObjectOutputStream ，该流允许读取或写入用户自定义的类，但是要实现这种功能，被读取和写入的类必须实现Serializable接口，其实该接口并没有什么方法，可能相当于一个标记而已，但是确实不合缺少的。实例代码如下：

Java代码  

  1. package com.hxw.io;
  2. import java.io.*;
  3. public class ObjetStream {
  4. /**
  5. * @param args
  6. */
  7. public static void main(String[] args) {
  8. // TODO自动生成的方法存根
  9. ObjectOutputStream objectwriter=null;
  10. ObjectInputStream objectreader=null;
  11. try {
  12. objectwriter=new ObjectOutputStream(new FileOutputStream("D:/David/Java/java 高级进阶/files/student.txt"));
  13. objectwriter.writeObject(new Student("gg", 22));
  14. objectwriter.writeObject(new Student("tt", 18));
  15. objectwriter.writeObject(new Student("rr", 17));
  16. objectreader=new ObjectInputStream(new FileInputStream("D:/David/Java/java 高级进阶/files/student.txt"));
  17. for (int i = 0; i < 3; i++) {
  18. System.out.println(objectreader.readObject());
  19. }
  20. } catch (IOException | ClassNotFoundException e) {
  21. // TODO自动生成的 catch 块
  22. e.printStackTrace();
  23. }finally{
  24. try {
  25. objectreader.close();
  26. objectwriter.close();
  27. } catch (IOException e) {
  28. // TODO自动生成的 catch 块
  29. e.printStackTrace();
  30. }
  31. }
  32. }
  33. }
  34. class Student implements Serializable{
  35. private String name;
  36. private int age;
  37. public Student(String name, int age) {
  38. super();
  39. this.name = name;
  40. this.age = age;
  41. }
  42. @Override
  43. public String toString() {
  44. return "Student [name=" + name + ", age=" + age + "]";
  45. }
  46. }

运行后系统输出：

Student [name=gg, age=22]

Student [name=tt, age=18]

Student [name=rr, age=17]

4.有时没有必要存储整个对象的信息，而只是要存储一个对象的成员数据，成员数据的类型假设都是Java的基本数据类型，这样的需求不必使用到与Object输入、输出相关的流对象，可以使用DataInputStream、DataOutputStream来写入或读出数据。下面是一个例子：（DataInputStream的好处在于在从文件读出数据时，不用费心地自行判断读入字符串时或读入int类型时何时将停止，使用对应的readUTF()和readInt()方法就可以正确地读入完整的类型数据。）

Java代码  

  1. package com.hxw;
  2. public class Member {
  3. private String name;
  4. private int age;
  5. public Member() {
  6. }
  7. public Member(String name, int age) {
  8. this.name = name;
  9. this.age = age;
  10. }
  11. public void setName(String name){
  12. this.name = name;
  13. }
  14. public void setAge(int age) {
  15. this.age = age;
  16. }
  17. public String getName() {
  18. return name;
  19. }
  20. public int getAge() {
  21. return age;
  22. }
  23. }

打算将Member类实例的成员数据写入文件中，并打算在读入文件数据后，将这些数据还原为Member对象。下面的代码简单示范了如何实现这个需求。

Java代码  

  1. package com.hxw;
  2. import java.io.*;
  3. public class DataStreamDemo
  4. {
  5. public static void main(String[]args)
  6. {
  7. Member[] members = {newMember("Justin",90),
  8. newMember("momor",95),
  9. newMember("Bush",88)};
  10. try
  11. {
  12. DataOutputStreamdataOutputStream = new DataOutputStream(new FileOutputStream(args[0]));
  13. for(Member member:members)
  14. {
  15. //写入UTF字符串
  16. dataOutputStream.writeUTF(member.getName());
  17. //写入int数据
  18. dataOutputStream.writeInt(member.getAge());
  19. }
  20. //所有数据至目的地
  21. dataOutputStream.flush();
  22. //关闭流
  23. dataOutputStream.close();
  24. DataInputStreamdataInputStream = new DataInputStream(new FileInputStream(args[0]));
  25. //读出数据并还原为对象
  26. for(inti=0;i<members.length;i++)
  27. {
  28. //读出UTF字符串
  29. String name =dataInputStream.readUTF();
  30. //读出int数据
  31. int score =dataInputStream.readInt();
  32. members[i] = newMember(name,score);
  33. }
  34. //关闭流
  35. dataInputStream.close();
  36. //显示还原后的数据
  37. for(Member member : members)
  38. {
  39. System.out.printf("%s\t%d%n",member.getName(),member.getAge());
  40. }
  41. }
  42. catch(IOException e)
  43. {
  44. e.printStackTrace();
  45. }
  46. }
  47. }

5.PushbackInputStream类继承了FilterInputStream类是iputStream类的修饰者。提供可以将数据插入到输入流前端的能力(当然也可以做其他操作)。简而言之PushbackInputStream类的作用就是能够在读取缓冲区的时候提前知道下一个字节是什么，其实质是读取到下一个字符后回退的做法，这之间可以进行很多操作，这有点向你把读取缓冲区的过程当成一个数组的遍历，遍历到某个字符的时候可以进行的操作，当然，如果要插入，能够插入的最大字节数是与推回缓冲区的大小相关的，插入字符肯定不能大于缓冲区吧！下面是一个示例。

Java代码  

  1. package com.hxw.io;
  2. import java.io.ByteArrayInputStream; //导入ByteArrayInputStream的包
  3. import java.io.IOException;
  4. import java.io.PushbackInputStream;
  5. /**
  6. * 回退流操作
  7. * */
  8. public class PushBackInputStreamDemo {
  9. public static void main(String[] args) throws IOException {
  10. String str = "hello,rollenholt";
  11. PushbackInputStream push = null; // 声明回退流对象
  12. ByteArrayInputStream bat = null; // 声明字节数组流对象
  13. bat = new ByteArrayInputStream(str.getBytes());
  14. push = new PushbackInputStream(bat); // 创建回退流对象，将拆解的字节数组流传入
  15. int temp = 0;
  16. while ((temp = push.read()) != -1) { // push.read()逐字节读取存放在temp中，如果读取完成返回-1
  17. if (temp == ‘,‘) { // 判断读取的是否是逗号
  18. push.unread(temp); //回到temp的位置
  19. temp = push.read(); //接着读取字节
  20. System.out.print("(回退" + (char) temp + ") "); // 输出回退的字符
  21. } else {
  22. System.out.print((char) temp); // 否则输出字符
  23. }
  24. }
  25. }
  26. }

6.SequenceInputStream:有些情况下，当我们需要从多个输入流中向程序读入数据。此时，可以使用合并流，将多个输入流合并成一个SequenceInputStream流对象。SequenceInputStream会将与之相连接的流集组合成一个输入流并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。 合并流的作用是将多个源合并合一个源。其可接收枚举类所封闭的多个字节流对象。

Java代码  

  1. package com.hxw.io;
  2. import java.io.*;
  3. import java.util.Enumeration;
  4. import java.util.Vector;
  5. public class SequenceInputStreamTest {
  6. /**
  7. * @param args
  8. *            SequenceInputStream合并流，将与之相连接的流集组合成一个输入流并从第一个输入流开始读取，
  9. *            直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
  10. *            合并流的作用是将多个源合并合一个源。可接收枚举类所封闭的多个字节流对象。
  11. */
  12. public static void main(String[] args) {
  13. doSequence();
  14. }
  15. private static void doSequence() {
  16. // 创建一个合并流的对象
  17. SequenceInputStream sis = null;
  18. // 创建输出流。
  19. BufferedOutputStream bos = null;
  20. try {
  21. // 构建流集合。
  22. Vector<InputStream> vector = new Vector<InputStream>();
  23. vector.addElement(new FileInputStream("D:\text1.txt"));
  24. vector.addElement(new FileInputStream("D:\text2.txt"));
  25. vector.addElement(new FileInputStream("D:\text3.txt"));
  26. Enumeration<InputStream> e = vector.elements();
  27. sis = new SequenceInputStream(e);
  28. bos = new BufferedOutputStream(new FileOutputStream("D:\text4.txt"));
  29. // 读写数据
  30. byte[] buf = new byte[1024];
  31. int len = 0;
  32. while ((len = sis.read(buf)) != -1) {
  33. bos.write(buf, 0, len);
  34. bos.flush();
  35. }
  36. } catch (FileNotFoundException e1) {
  37. e1.printStackTrace();
  38. } catch (IOException e1) {
  39. e1.printStackTrace();
  40. } finally {
  41. try {
  42. if (sis != null)
  43. sis.close();
  44. } catch (IOException e) {
  45. e.printStackTrace();
  46. }
  47. try {
  48. if (bos != null)
  49. bos.close();
  50. } catch (IOException e) {
  51. e.printStackTrace();
  52. }
  53. }
  54. }
  55. }

7.PrintStream 说这个名字可能初学者不熟悉，如果说System.out.print()你肯定熟悉，System.out这个对象就是PrintStream，这个我们不做过多示例

三、字符流（顾名思义，就是操作字符文件的流）

1.java 使用Unicode存储字符串，在写入字符流时我们都可以指定写入的字符串的编码。前面介绍了不用抛异常的处理字节型数据的流ByteArrayOutputStream，与之对应的操作字符类的类就是CharArrayReader,CharArrayWriter类，这里也会用到缓冲区，不过是字符缓冲区，一般讲字符串放入到操作字符的io流一般方法是

CharArrayReaderreader=mew CharArrayReader(str.toCharArray()); 一旦会去到CharArrayReader实例就可以使用CharArrayReader访问字符串的各个元素以执行进一步读取操作。不做例子

2.我们用FileReader ，PrintWriter来做示范

Java代码  

  1. package com.hxw.io;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.io.PrintWriter;
  6. import java.nio.CharBuffer;
  7. public class Print {
  8. /**
  9. * @param args
  10. */
  11. public static void main(String[] args) {
  12. // TODO自动生成的方法存根
  13. char[] buffer=new char[512];   //一次取出的字节数大小,缓冲区大小
  14. int numberRead=0;
  15. FileReader reader=null;        //读取字符文件的流
  16. PrintWriter writer=null;    //写字符到控制台的流
  17. try {
  18. reader=new FileReader("D:/David/Java/java 高级进阶/files/copy1.txt");
  19. writer=new PrintWriter(System.out);  //PrintWriter可以输出字符到文件，也可以输出到控制台
  20. while ((numberRead=reader.read(buffer))!=-1) {
  21. writer.write(buffer, 0, numberRead);
  22. }
  23. } catch (IOException e) {
  24. // TODO自动生成的 catch 块
  25. e.printStackTrace();
  26. }finally{
  27. try {
  28. reader.close();
  29. } catch (IOException e) {
  30. // TODO自动生成的 catch 块
  31. e.printStackTrace();
  32. }
  33. writer.close();       //这个不用抛异常
  34. }
  35. }
  36. }

3.相对我们前面的例子是直接用FileReader打开的文件，我们这次使用链接流，一般比较常用的都用链接流，所谓链接流就是就多次对流的封装，这样能更好的操作个管理数据，（比如我们利用DataInputStream（BufferedInputStream(FileInputStream)）将字节流层层包装后，我们可以读取readByte(),readChar()这样更加具体的操作，注意，该流属于字节流对字符进行操作，）字符流用CharArrayReader就可以了。下面的示例我们将用到j2se
5中的一个可变参数进行一个小度扩展。使用BufferedWriter 和BufferedReader用文件级联的方式进行写入，即将多个文件写入到同一文件中（自带缓冲区的输出输出流BufferedReader和BufferedWriter,该流最常用的属readLine()方法了，读取一行数据，并返回String）。

Java代码  

  1. package com.hxw.io;
  2. import java.io.BufferedReader;
  3. import java.io.BufferedWriter;
  4. import java.io.FileReader;
  5. import java.io.FileWriter;
  6. import java.io.IOException;
  7. import java.util.Iterator;
  8. public class FileConcatenate {
  9. /**
  10. * 包装类进行文件级联操作
  11. */
  12. public static void main(String[] args) {
  13. // TODO自动生成的方法存根
  14. try {
  15. concennateFile(args);
  16. } catch (IOException e) {
  17. // TODO自动生成的 catch 块
  18. e.printStackTrace();
  19. }
  20. }
  21. public static voidconcennateFile(String...fileName) throws IOException{
  22. String str;
  23. //构建对该文件您的输入流
  24. BufferedWriter writer=new BufferedWriter(new FileWriter("D:/David/Java/java 高级进阶/files/copy2.txt"));
  25. for(String name: fileName){
  26. BufferedReader reader=new BufferedReader(new FileReader(name));
  27. while ((str=reader.readLine())!=null) {
  28. writer.write(str);
  29. writer.newLine();
  30. }
  31. }
  32. }
  33. }

4.Console类,该类提供了用于读取密码的方法，可以禁止控制台回显并返回char数组，对两个特性对保证安全有作用，平时用的不多，了解就行。

5.StreamTokenizer 类，这个类非常有用，它可以把输入流解析为标记（token）, StreamTokenizer 并非派生自InputStream或者OutputStream，而是归类于io库中，因为StreamTokenizer只处理InputStream对象。

首先给出我的文本文件内容：

‘水上漂‘

青青草

"i love wyhss"

{3211}

23223 3523

i love wyh ，。

. ,

下面是代码：

Java代码  

  1. package com.hxw.io;
  2. import java.io.BufferedReader;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.io.StreamTokenizer;
  6. /**
  7. * 使用StreamTokenizer来统计文件中的字符数
  8. * StreamTokenizer 类获取输入流并将其分析为“标记”，允许一次读取一个标记。
  9. * 分析过程由一个表和许多可以设置为各种状态的标志控制。
  10. * 该流的标记生成器可以识别标识符、数字、引用的字符串和各种注释样式。
  11. *
  12. *  默认情况下，StreamTokenizer认为下列内容是Token: 字母、数字、除C和C++注释符号以外的其他符号。
  13. *  如符号"/"不是Token，注释后的内容也不是，而"\"是Token。单引号和双引号以及其中的内容，只能算是一个Token。
  14. *  统计文章字符数的程序，不是简单的统计Token数就万事大吉，因为字符数不等于Token。按照Token的规定，
  15. *  引号中的内容就算是10页也算一个Token。如果希望引号和引号中的内容都算作Token，应该调用下面的代码：
  16. *    st.ordinaryChar(‘\‘‘);
  17. * st.ordinaryChar(‘\"‘);
  18. */
  19. public class StreamTokenizerExample {
  20. /**
  21. * 统计字符数
  22. * @param fileName 文件名
  23. * @return    字符数
  24. */
  25. public static void main(String[] args) {
  26. String fileName = "D:/David/Java/java 高级进阶/files/copy1.txt";
  27. StreamTokenizerExample.statis(fileName);
  28. }
  29. public static long statis(String fileName) {
  30. FileReader fileReader = null;
  31. try {
  32. fileReader = new FileReader(fileName);
  33. //创建分析给定字符流的标记生成器
  34. StreamTokenizer st = new StreamTokenizer(new BufferedReader(
  35. fileReader));
  36. //ordinaryChar方法指定字符参数在此标记生成器中是“普通”字符。
  37. //下面指定单引号、双引号和注释符号是普通字符
  38. st.ordinaryChar(‘\‘‘);
  39. st.ordinaryChar(‘\"‘);
  40. st.ordinaryChar(‘/‘);
  41. String s;
  42. int numberSum = 0;
  43. int wordSum = 0;
  44. int symbolSum = 0;
  45. int total = 0;
  46. //nextToken方法读取下一个Token.
  47. //TT_EOF指示已读到流末尾的常量。
  48. while (st.nextToken() !=StreamTokenizer.TT_EOF) {
  49. //在调用 nextToken 方法之后，ttype字段将包含刚读取的标记的类型
  50. switch (st.ttype) {
  51. //TT_EOL指示已读到行末尾的常量。
  52. case StreamTokenizer.TT_EOL:
  53. break;
  54. //TT_NUMBER指示已读到一个数字标记的常量
  55. case StreamTokenizer.TT_NUMBER:
  56. //如果当前标记是一个数字，nval字段将包含该数字的值
  57. s = String.valueOf((st.nval));
  58. System.out.println("数字有："+s);
  59. numberSum ++;
  60. break;
  61. //TT_WORD指示已读到一个文字标记的常量
  62. case StreamTokenizer.TT_WORD:
  63. //如果当前标记是一个文字标记，sval字段包含一个给出该文字标记的字符的字符串
  64. s = st.sval;
  65. System.out.println("单词有： "+s);
  66. wordSum ++;
  67. break;
  68. default:
  69. //如果以上3中类型都不是，则为英文的标点符号
  70. s = String.valueOf((char) st.ttype);
  71. System.out.println("标点有： "+s);
  72. symbolSum ++;
  73. }
  74. }
  75. System.out.println("数字有 " + numberSum+"个");
  76. System.out.println("单词有 " + wordSum+"个");
  77. System.out.println("标点符号有： " + symbolSum+"个");
  78. total = symbolSum + numberSum +wordSum;
  79. System.out.println("Total = " + total);
  80. return total;
  81. } catch (Exception e) {
  82. e.printStackTrace();
  83. return -1;
  84. } finally {
  85. if (fileReader != null) {
  86. try {
  87. fileReader.close();
  88. } catch (IOException e1) {
  89. }
  90. }
  91. }
  92. }
  93. }
//自己试一试
FileInputStream fis=new FileInputStream(new File("D://test.txt"));
		byte[] buf=new byte[5];
		while(fis.read(buf)!=-1)//最后指针指向结尾。
			System.out.println(new String(buf));

		FileInputStream fis2=new FileInputStream(new File("D://test.txt"));
		FileOutputStream fos=new FileOutputStream(new File("d://test2.txt"),true);//追加到文件尾部
		BufferedOutputStream bos=new BufferedOutputStream(fos);
		int len;
		int n = 0;
		 while ((len=fis2.read(buf)) != -1) {
	           bos.write(buf, 0, len);
	           n++;
	     }
		 System.out.println(n);
		 String str="add some words in the file.";
		bos.write(str.getBytes());
		bos.flush();
		fis.close();
		bos.close();
时间： 2024-08-05 02:02:32

Java核心知识点-字节流和字符流详解的相关文章

【Java IO流】字节流和字符流详解

字节流和字符流 对于文件必然有读和写的操作,读和写就对应了输入和输出流,流又分成字节和字符流. 1.从对文件的操作来讲,有读和写的操作——也就是输入和输出. 2.从流的流向来讲,有输入和输出之分. 3.从流的内容来讲,有字节和字符之分. 这篇文章先后讲解IO流中的字节流和字符流的输入和输出操作. 一.字节流 1)输入和输出流 首先,字节流要进行读和写,也就是输入和输出,所以它有两个抽象的父类InputStream.OutputStream. InputStream抽象了应用程序读取数据的方式,即

字节流与字符流详解

字节流与字符流 先来看一下流的概念: 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成. 程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件. 字节流与字符流 在java.io包中操作文件内容的主要有两大类:字节流.字符流,两类都分为输入和输出操作.在字节流中输出数据主要是使用OutputStream完成,输入使的是InputStream,在字符流中输出主要是使用Writer类完成

深入理解JAVA I/O系列三：字符流详解

字符流为何存在 既然字节流提供了能够处理任何类型的输入/输出操作的功能,那为什么还要存在字符流呢?容我慢慢道来,字节流不能直接操作Unicode字符,因为一个字符有两个字节,字节流一次只能操作一个字节.如果JAVA不能直接操作字符,我会感到JAVA对这个世界满满的恶意,所以提供对直接的字符输入/输出的支持是很有必要的,因为我们的口号是:一次编写,到处运行. 字符流的概念 输出字符流:把要写入文件的字符序列(实际是unicode码元序列)转为指定编码方式下的字节序列,然后在写入文件中. 输入字符流

java知识点分享，IO流详解！

Java知识IO流详解有人觉得IO知识不太重要,其实不然,IO的使用范围很广,最能体现IO价值的就是网络上的数据传递,尤其是进入互联网时代后,各种常见的分布式架构,都少不了IO的体现.并且很多大厂的面试题中都会体现出对IO的重视,包括衍生出来的NIO.序列化等等.因此学好IO,变成了一件很重要的事情.IO基本概念IO可以简单的理解成INPUT和OUT,代表输入输出的意思.输入就是读,输出就是写.IO可以读写硬盘.光盘.内存.键盘.网络等资源上的数据.流IO中的流就相当于现实生活中的水流一样,一打

java IO的字节流和字符流及其区别

1. 字节流和字符流的概念    1.1 字节流继承于InputStream    OutputStream,    1.2 字符流继承于InputStreamReader    OutputStreamWriter.在java.io包中还有许多其他的流,主要是为了提高性能和使用方便. 2. 字节流与字符流的区别    2.1 要把一片二进制数据数据逐一输出到某个设备中,或者从某个设备中逐一读取一片二进制数据,不管输入输出设备是什么,我们要用统一的方式来完成这些操作,用一种抽象的方式进行描述,这

java IO之字节流和字符流-OutputSteam和InputStream

java中的IO流分为字节流和字符流:每种流又分输入流和输出流. 先来说一下输入流和输出流:输入输出是针对程序内存而言,那么输入就是向内存写入数据:输出就是从程序内存写出数据. 字节流使用过字节直接操作数据. 字符流则是通过字节写入到缓存,再通过缓存区操作数据. 字节流的父类为InputStream(输入流)和OutputStream(输出流). IntputStream的直接子类有:AudioInputStream,ByteArrayInputStream,FileInputStream,Fi

字符流，字节流，缓存流详解

package com.bjsxt.init;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.Input

JavaIO-字节流与字符流详解

在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据时要使用输入流读取数据,而当程序需要将一些数据保存起来时,就要使用输出流,可以通过图12-5表示出输入及输出的关系.   (点击查看大图)图12-5  输入.输出的关系 在java.io包中流的操作主要有字节流.字符流两大类,两类都有输入和输出操作.在字节流中输出数据主要使用OutputStream类完成,输入使用的是InputStream类.在字符流中输出主要是使用Writer类完成,输入主要是使用Reader类完成. 在Java中

java.io 字节流与字符流及简单实例

java io是java中非常基础的知识点,对于通信和不涉及到数据库的项目java io应该是要经常使用.java io分为字节流和字符流,分清字节流和字符流的异同是掌握java io的起点. 字节流,最小单位是字节,通信协议中的X-MODEM和Y-MODEM协议传输单位就是字节流.java io中与字节流相关的主要类有:InputStream,OutputStream,FileInputStream,FileOutputStream.与字符流有关的主要类有:Writer,Reader,File