流的概念

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

字节流与字符流

内容操作就四个类：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. JavaDailyReports10_12

    运算级自增自减运算符大于取值运算符*,大于取地址运算符! 1 #include<stdio.h> 2 #include<string.h> 3 #define OK 1 4 # ...

  2. JavaDailyReports10_06

    今日收获: 一.所有引用类型变量的初始化一定要使用new 关键字定义声明,空指针异常的错误原因可能是变量没有初始化导致的. 每一个类体的数据成员一定要在实例化的同时赋值,用一个实例化的类实现问题中最小 ...

  3. Java学习日报7.17

    控制台运行

  4. 本地项目上传至GitHub

    本地项目上传至GitHub 使用git上传 一.安装git 直接官网下载,安装即可. git官网下载 github下载 按照好后大概就是这个样子 二.创建公钥和私钥 有的就可跳过此步骤 我们双击打开g ...

  5. Redis基础篇（七）哨兵机制

    上一篇文章介绍了高可靠方案:主从集群模式.通过主从库的读写分离,来保证服务的可靠性. 当某个从库出现故障时,不影响服务的使用,主库仍然可以处理写命令,其他从库可以处理读命令.但主库发生故障,就不能处理 ...

  6. mysql词法分析和语法分析

    如果没有命中查询缓存,就要开始真正执行语句了.首先,MySQL 需要知道你要做什么,因此需要对 SQL 语句做解析.分析器先会做"词法分析".你输入的是由多个字符串和空格组成的一条 ...

  7. ES6 对象拓展方法

    一,ES6 对象拓展方法 ES6为对象提供了一些拓展方法,下面列举几个比较常见的对象拓展方法.

  8. 壁球小游戏详解（附有源码.cpp）

    1.在python中安装pygame 2.将下列源码复制过去,运行. #引用 import pygame, sys #初始化 pygame.init() size = width, height = ...

  9. Java开发手册之安全规约

    1.用户敏感数据禁止直接展示,必须对展示数据进行脱敏.例如手机号.银行卡号等,中间要用*隐藏. 2.发贴.评论.发送即时消息等用户生成内容的场景必须实现防刷.文本内容违禁词过滤等风控策略,一般是用验证 ...

  10. [翻译]Azure 网关迁移至 .NET Core 3.1 性能提升一倍

    原文:[Azure Active Directory's gateway is on .NET Core 3.1!] Azure Active Directory 的网关服务是一个反向代理,它为构成 ...