流的概念

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

字节流与字符流

内容操作就四个类：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. Eclipse 使用svn时出现 “Previous operation has not finished; run 'cleanup' if it was interrupted“问题

    在执行svn操作的时候出现了下面的问题 commit -m "" E:/eclipse/workplace/BRobotAPP/blockly/googleDemo/blockly ...

  2. NC65在日常开发中常用的代码写法

    标题 NC65开发相关代码 版本 1.0.1 作者 walton 说明 收集NC在日常开发中常用的代码写法,示例展示 1.查询 1.1 通过BaseDAO查询结果集并转换 //通过BaseDAO进行查 ...

  3. MFC3 基本对话框的使用（三） 滑块与进度条（sdnu）（C++大作业）

    一.完成界面 运行前: 运行后: 二.工具 (1)滑块 (2)进度条 (3)文本框 (4)文本示例 (5)按钮 三.添加变量 四.添加事件 右键单击主对话框空白部分,打开类向导,选择"消息& ...

  4. Spring Security OAuth2.0认证授权二：搭建资源服务

    在上一篇文章[Spring Security OAuth2.0认证授权一:框架搭建和认证测试](https://www.cnblogs.com/kuangdaoyizhimei/p/14250374. ...

  5. netty启动流程

    本文通过对netty服务端.客户端的启动流程分析, 让大家对netty是如何启动运行的. 废话不多说,上源码!!! 建议读者学习netty下的jar类型为 netty-example,里面有很多exa ...

  6. nginx 重写去掉index.php

    if (!-e $request_filename) { rewrite ^/(.*)$ /index.php?s=$1 last; }

  7. Oracle控制文件多路复用以及Oracle备份重建控制文件

    控制文件中记录了oracle数据库的物理结构,也就是记录了数据库数据文件和日志文件的位置,控制文件中还记录了多种SCN,用这些SCN来确定数据文件和日志文件是否是正确的.如果不正确那么数据库就需要恢复 ...

  8. LeetCode682 棒球比赛

    题目描述: 你现在是棒球比赛记录员.给定一个字符串列表,每个字符串可以是以下四种类型之一:1.整数(一轮的得分):直接表示您在本轮中获得的积分数.2. "+"(一轮的得分):表示本 ...

  9. .NET Core学习笔记（9）——Entity Framework Core之Code First

    上篇我们介绍了怎么通过已有的SQLServer表来创建实体类,本篇我们改用Code First的方式,由C#代码书写的实体类来生成SQLServer表.并且通过简单的Console APP往SQLSe ...

  10. Subline Text 3 安装

    Subline Text 3 下载 下载链接 http://www.sublimetext.com/3 ,下载Subline Text3的安装包,这里以 64位的windows10为例,如果是其他操作 ...