流的概念

程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。

字节流与字符流

内容操作就四个类：OutputStream、InputStream、Writer、Reader

字节流

  • 字节输出流OutputStream

Clonseable表示可以关闭的操作，因为程序运行到最后肯定要关闭。

Fluashable表示刷新，清空内存中的数据。

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class OutputStreamDemo01{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        OutputStream out = null ;   // 准备好一个输出的对象

        out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组

        out.write(b) ;                      // 将内容输出，保存文件

        // 第4步、关闭输出流

        out.close() ;                       // 关闭输出流

    }

};

在操作的时候，如果文件本身不存在，则会为用户自动创建新文件。

在操作输出流的时候，也可以使用write(int i)的方法写出数据。

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class OutputStreamDemo02{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        OutputStream out = null ;   // 准备好一个输出的对象

        out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组

        for(int i=0;i<b.length;i++){        // 采用循环方式写入

            out.write(b[i]) ;   // 每次只写入一个内容

        }

        // 第4步、关闭输出流

        out.close() ;                       // 关闭输出流

    }

};

以上的操作中在写入数据之后，文件之前的内容应经不存在了，因为在io操作中默认的情况是将其进行覆盖的，那么如果现在要想执行追加的功能，则必须设置追加的操作。

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class OutputStreamDemo03{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        OutputStream out = null ;   // 准备好一个输出的对象

        out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组

        for(int i=0;i<b.length;i++){        // 采用循环方式写入

            out.write(b[i]) ;   // 每次只写入一个内容

        }

        // 第4步、关闭输出流

        out.close() ;                       // 关闭输出流

    }

};

程序本身是可以追加内容了，但是没有换行，是直接追加到末尾的。

如果在文件中想换行的话，使用“\r\n”完成。

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class OutputStreamDemo04{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        OutputStream out = null ;   // 准备好一个输出的对象

        out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容

        // 第3步、进行写操作

        String str = "\r\nHello World!!!" ;     // 准备一个字符串

        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组

        for(int i=0;i<b.length;i++){        // 采用循环方式写入

            out.write(b[i]) ;   // 每次只写入一个内容

        }

        // 第4步、关闭输出流

        out.close() ;                       // 关闭输出流

    }

};
  • 字节输入流InputStream

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class InputStreamDemo01{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        InputStream input = null ;  // 准备好一个输入的对象

        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中

        input.read(b) ;     // 读取内容

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流

        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出

    }

};

功能虽然实现了，但是存在问题？ 数据的长度、数组的空间。

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class InputStreamDemo02{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        InputStream input = null ;  // 准备好一个输入的对象

        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中

        int len = input.read(b) ;       // 读取内容

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流\

        System.out.println("读入数据的长度：" + len) ;

        System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出

    }

};

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class InputStreamDemo03{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        InputStream input = null ;  // 准备好一个输入的对象

        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定

        int len = input.read(b) ;       // 读取内容

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流\

        System.out.println("读入数据的长度：" + len) ;

        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出

    }

};

以上是直接使用byte数组的方式完成的。

现在使用public abstract int read() throws IOException读取内容。

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class InputStreamDemo04{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        InputStream input = null ;  // 准备好一个输入的对象

        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定

        for(int i=0;i<b.length;i++){

            b[i] = (byte)input.read() ;     // 读取内容

        }

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流\

        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出

    }

};

以上的操作只适合于知道输入流的大小，如果现在不知道输入流大小。

import java.io.File ;

import java.io.InputStream ;

import java.io.FileInputStream ;

public class InputStreamDemo05{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        InputStream input = null ;  // 准备好一个输入的对象

        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        byte b[] = new byte[1024] ;     // 数组大小由文件决定

        int len = 0 ;

        int temp = 0 ;          // 接收每一个读取进来的数据

        while((temp=input.read())!=-1){

            // 表示还有内容，文件没有读完

            b[len] = (byte)temp ;

            len++ ;

        }

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流\

        System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出

    }

};

当不知道读取内容多大的时候，可以使用读取内容返回值为-1 为读完的标志。

字符流

  • 字符输出流Writer

字符流的操作比字节流操作好在一点，就是可以直接输出字符串了。不用再进行转换操作了。

import java.io.File ;

import java.io.Writer ;

import java.io.FileWriter ;

public class WriterDemo01{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        Writer out = null ; // 准备好一个输出的对象

        out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        out.write(str) ;                        // 将内容输出，保存文件

        // 第4步、关闭输出流

        out.close() ;                       // 关闭输出流

    }

};

使用字符流默认情况下依然是覆盖已有的文件，如果想要追加的话，则直接在FileWriter上增加一个可追加的标记即可。

import java.io.Writer ;

import java.io.FileWriter ;

public class WriterDemo02{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        Writer out = null ; // 准备好一个输出的对象

        out = new FileWriter(f,true)  ; // 通过对象多态性，进行实例化

        // 第3步、进行写操作

        String str = "\r\nLIXINGHUA\r\nHello World!!!" ;        // 准备一个字符串

        out.write(str) ;                        // 将内容输出，保存文件

        // 第4步、关闭输出流

        out.close() ;                       // 关闭输出流

    }

};
  • 字符输入流Reader

以字符数组的形式读取数据：

import java.io.File ;

import java.io.Reader ;

import java.io.FileReader ;

public class ReaderDemo01{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        Reader input = null ;   // 准备好一个输入的对象

        input = new FileReader(f)  ;    // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        char c[] = new char[1024] ;     // 所有的内容都读到此数组之中

        int len = input.read(c) ;       // 读取内容

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流

        System.out.println("内容为：" + new String(c,0,len)) ;  // 把字符数组变为字符串输出

    }

};

采用循环的方式，通过文件是否读到低的形式读取：

import java.io.File ;

import java.io.Reader ;

import java.io.FileReader ;

public class ReaderDemo02{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        Reader input = null ;   // 准备好一个输入的对象

        input = new FileReader(f)  ;    // 通过对象多态性，进行实例化

        // 第3步、进行读操作

        char c[] = new char[1024] ;     // 所有的内容都读到此数组之中

        int temp = 0 ;  // 接收每一个内容

        int len = 0 ;       // 读取内容

        while((temp=input.read())!=-1){

            // 如果不是-1就表示还有内容，可以继续读取

            c[len] = (char)temp ;

            len++ ;

        }

        // 第4步、关闭输出流

        input.close() ;                     // 关闭输出流

        System.out.println("内容为：" + new String(c,0,len)) ;  // 把字符数组变为字符串输出

    }

};

字节流与字符流的区别

验证字符流使用了缓存：

import java.io.File ;

import java.io.OutputStream ;

import java.io.FileOutputStream ;

public class OutputStreamDemo05{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        OutputStream out = null ;   // 准备好一个输出的对象

        out = new FileOutputStream(f)  ;    // 实例化

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组

        out.write(b) ;      // 写入数据

        // 第4步、关闭输出流

        // out.close() ;                        // 关闭输出流

    }

};

在使用字节流操作中，及时没有关闭，最终也是可以输出的。

import java.io.File ;

import java.io.Writer ;

import java.io.FileWriter ;

public class WriterDemo03{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        Writer out = null ; // 准备好一个输出的对象

        out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        out.write(str) ;                        // 将内容输出，保存文件

        // 第4步、关闭输出流

        // out.close() ;                        // 此时，没有关闭

    }

};

import java.io.File ;

import java.io.Writer ;

import java.io.FileWriter ;

public class WriterDemo04{

    public static void main(String args[]) throws Exception{    // 异常抛出，不处理

        // 第1步、使用File类找到一个文件

        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象

        // 第2步、通过子类实例化父类对象

        Writer out = null ; // 准备好一个输出的对象

        out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化

        // 第3步、进行写操作

        String str = "Hello World!!!" ;     // 准备一个字符串

        out.write(str) ;                        // 将内容输出，保存文件

        // 第4步、关闭输出流

        out.flush() ;   // 强制性清空缓冲区中的内容

        // out.close() ;                        // 此时，没有关闭

    }

};

操作范例



import java.io.* ;

public class Copy{

    public static void main(String args[]){

        if(args.length!=2){     // 判断是否是两个参数

            System.out.println("输入的参数不正确。") ;

            System.out.println("例：java Copy 源文件路径 目标文件路径") ;

            System.exit(1) ;    // 系统退出

        }

        File f1 = new File(args[0]) ;   // 源文件的File对象

        File f2 = new File(args[1]) ;   // 目标文件的File对象

        if(!f1.exists()){

            System.out.println("源文件不存在！") ;

            System.exit(1) ;

        }

        InputStream input = null ;      // 准备好输入流对象，读取源文件

        OutputStream out = null ;       // 准备好输出流对象，写入目标文件

        try{

            input = new FileInputStream(f1) ;

        }catch(FileNotFoundException e){

            e.printStackTrace() ;

        }

        try{

            out = new FileOutputStream(f2) ;

        }catch(FileNotFoundException e){

            e.printStackTrace() ;

        }

        if(input!=null && out!=null){   // 判断输入或输出是否准备好

            int temp = 0 ;

            try{

                while((temp=input.read())!=-1){ // 开始拷贝

                    out.write(temp) ;   // 边读边写

                }

                System.out.println("拷贝完成！") ;

            }catch(IOException e){

                e.printStackTrace() ;

                System.out.println("拷贝失败！") ;

            }

            try{

                input.close() ;     // 关闭

                out.close() ;       // 关闭

            }catch(IOException e){

                e.printStackTrace() ;

            }

        }

    }

}

原文地址

原文地址：http://lib.csdn.net/article/javase/2895?knId=215

原文作者：waldmer

Java IO--字节流与字符流OutputStream/InputStream/Writer/Reader的更多相关文章

  1. JAVA IO 字节流与字符流

    文章出自:听云博客 题主将以三个章节的篇幅来讲解JAVA IO的内容 . 第一节JAVA IO包的框架体系和源码分析,第二节,序列化反序列化和IO的设计模块,第三节异步IO. 本文是第一节.     ...

  2. Java IO 字节流与字符流 （二）

    1. 什么是流 Java中的流是对字节序列的抽象,我们可以想象有一个水管,只不过现在流动在水管中的不再是水,而是字节序列.和水流一样,Java中的流也具有一个“流动的方向”,通常可以从中读入一个字节序 ...

  3. Java IO 字节流与字符流 （三）

    概述 IO流用来处理设备之间的数据传输 Java对数据的操作时通过流的方式 Java用于操作流的对象都在IO包中 流按操作的数据分为:字节流和字符流 流按流向不同分为:输入流和输出流 IO流常用基类 ...

  4. Java IO 字节流与字符流 （五）

    Java的IO流分为字符流(Reader,Writer)和字节流(InputStream,OutputStream),字节流顾名思义字节流就是将文件的内容读取到字节数组,然后再输出到另一个文件中.而字 ...

  5. 字节流和字符流（InputStream类和OutputStream类）

    java流包括字节流和字符流,字节流通过I/O设备以字节数据的方式读入,而字符流则是通过字节流读入数据转换成字符"流"的形式由用户驱使. InputStream是所有字节输入流的父 ...

  6. java中字节流与字符流的区别

    字节流 在I/O类库中,java.io.InputStream和java.io.OutputStream分别表示字节输入流和字节输出流,它们都是抽象类,不能实例化,数据流中的最小单位是字节,所以叫做字 ...

  7. Java中字节流和字符流的比较（转）

    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操 ...

  8. java中字节流和字符流的区别

    流分类: 1.Java的字节流   InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先.2.Java的字符流  Reader是所有读取字符串输入流的祖先,而 ...

  9. Java的字节流，字符流和缓冲流对比探究

    目录 一.前言 二.字节操作和字符操作 三.两种方式的效率测试 3.1 测试代码 3.2 测试结果 3.3 结果分析 四.字节顺序endian 五.综合对比 六.总结 一.前言 所谓IO,也就是Inp ...

随机推荐

  1. 为什么import React from 'react'，React首字母必须大写？

    很奇怪的是,明明没有用到 React,但是我不得不 import React.这是为什么? import React from 'react'; export default function (pr ...

  2. MQ关于实现最终一致性分布式事务原理解析

    本文讲述阿里云官方文档中关于通过MQ实现分布式事务最终一致性原理 概念介绍 事务消息:消息队列 MQ 提供类似 X/Open XA 的分布式事务功能,通过消息队列 MQ 事务消息能达到分布式事务的最终 ...

  3. pixi.js 图像资源(svg)转纹理

    当Pixi使用WebGL去调用GPU渲染图像时,需要先将图像转化为GPU可以处理的版本.而能够被GPU处理的图像就叫做纹理,在pixi中使用纹理缓存来存储和引用所有纹理.通过将纹理分配给精灵,再将精灵 ...

  4. 第十二章节 BJROBOT 摄像头寻线 【ROS全开源阿克曼转向智能网联无人驾驶车】

    关于摄像头:普通摄像头, USB 免驱摄像头都可以使用. 1.如下图所示,用红色胶布在地板上贴一条线,小车摆放在线的一头处,让线在小车的中间位置,摄像头角度往下调整倾斜一点,好让摄像头识别到红线.注意 ...

  5. dede织梦技巧：教你彻底解决dede按权重排序的问题(转)

    dede排序对网站来说一直存在问题,默认是按照最新发布时间排序.这样排序有个问题,一旦更新之后即被视为最新发布,于是原本做好的排序瞬间就乱了. 这种时候,按权重排序是个很好的选择,但按权重排序到处存在 ...

  6. yolov5实战之皮卡丘检测

    前言 从接触深度学习开始一直都做的是人脸识别,基本上也一直都在用mxnet. 记得之前在刚接触的时候看到博客中写到,深度学习分三个层次,第一个层次是分类,第二个层次是检测,第三个层次是分割.人脸识别算 ...

  7. win10中安装Linux子系统

    前言 Win10的Linux子系统闻名已久,今天就来操作一下 正文 限制 该功能是win10 1809 及之后才加入的功能,故请先核对版本. 开启功能 打开windows设置 设置 -> 更新和 ...

  8. WEB开发框架性能排行与趋势分析2-三大惊喜变化

    WEB开发框架性能排行与趋势分析2-三大惊喜变化 Web框架性能排名 上一次基于TechEmpower的<Web Framework Benchmarks>性能基准测试的解读之后,时隔两年 ...

  9. Linux 安装JDK配置环境(rpm安装和压缩版安装)

    jdk安装 (rpm安装) jdk下载地址: https://www.oracle.com/cn/java/technologies/javase/javase-jdk8-downloads.html ...

  10. 【Linux】E297: Write error in swap file 解决办法

    今天登陆到服务器上,发现通过vi 打开文件就会报错: E297: Write error in swap file E303: Unable to open swap file for "c ...