流的概念

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

字节流与字符流

内容操作就四个类：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. MongoDb学习（四）--Repository----语法关键字

    表7.查询方法支持的关键字 关键词 样品 逻辑结果 After findByBirthdateAfter(Date date) {"birthdate" : {"$gt& ...

  2. DML、DDL、DCL

    总体解释:DML(data manipulation language):       它们是SELECT.UPDATE.INSERT.DELETE,就象它的名字一样,这4条命令是用来对数据库里的数据 ...

  3. LInux学习笔记之常用命令

    以下命令主要是平时用到的命令,对于一些经常用到的,就收集资料,归纳一下. 指令目录: 1.yum命令: 2.wget命令: 3.tar命令: 4../configure,make,make insta ...

  4. 别再费劲去找后台的前端框架了，2021 年就用 Fantastic-admin 吧

    前言 你知道光是基于 Vue 的后台框架在 Github 上有多少个仓库么? 如果你搜索 vue admin 会得到 13120 个仓库,如果用 vue 后台 会得到 7596 个仓库,如果把两者结合 ...

  5. netty核心组件之channel、handler、ChannelHandlerContext、pipeline

    channel介绍: netty中channel分为NioServerScoketChannel和NioSocketChannel,分别对应java nio中的ServerScoketChannel和 ...

  6. 【Git】4、创建代码仓库，HTTP、SSH拉取远端代码

    拉取远端代码:使用Git命令下载远程仓库到本地 文章目录 拉取远端代码:使用Git命令下载远程仓库到本地 1.创建远程代码仓库 2.创建仓库 3.进入仓库 4.HTTP(S)获取远程仓库 首次拉取 更 ...

  7. 【Web】实现动态文章列表

    简单记录 -慕课网- 步骤二:动态文章列表效果 实现这个 一个网页中常见的文章列表效果. 怎么实现文章列表案例 分解一波,CSS来改变样式 标题标签 HTML的无序列表 去掉项目符号 符号所占空间 列 ...

  8. 【Linux】cp命令的各种妙用

    CP 功能: 复制文件或目录 说明: cp指令用于复制文件或目录,如同时指定两个以上的文件或目录,且最后的目的地是一个已经存在的目录,则它会把前面指定的所有文件或目录复制到此目录中.若同时指定多个文件 ...

  9. leetcode刷题录-1395

    目录 题目 思考过程 查看别人分享的思路 总结 题目 题目地址:https://leetcode-cn.com/problems/count-number-of-teams/ n 名士兵站成一排.每个 ...

  10. 负载均衡和故障转换（Failover）的连接RAC方法

    TAF:Transparent Application Failover,透明的应用切换,即在切换的过程中,用户感知不到.可以实现会话的切换(无法实现事务的切换,即没有提交的事务会回滚),即在不断开连 ...