流的概念

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

字节流与字符流

内容操作就四个类：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. java零基础之---常见java面试题

    看到别人分享的面试题,感觉蛮全面的,分享出来,慢慢研究答案. 一.Java 基础 1.JDK 和 JRE 有什么区别? 2.== 和 equals 的区别是什么? 3.两个对象的 hashCode() ...

  2. 基于socket的netty demo

    前面一文说了 基于http的netty demo 和http不一样,http可以用浏览器来充当客户端调用,所以基于socket的netty,必须要编写客户端和服务器的代码 实现功能: 客户端给服务器发 ...

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

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

  4. AOP的姿势之 简化混用 MemoryCache 和 DistributedCache 的方式

    0. 前言 之前写了几篇文章介绍了一些AOP的知识, 但是还没有亮出来AOP的姿势, 也许姿势漂亮一点, 大家会对AOP有点兴趣 内容大致会分为如下几篇:(毕竟人懒,一下子写完太累了,没有动力) AO ...

  5. ConcurrentHashMap 并发之美

    一.前言 她如暴风雨中的一叶扁舟,在高并发的大风大浪下疾驰而过,眼看就要被湮灭,却又在绝境中绝处逢生 编写一套即稳定.高效.且支持并发的代码,不说难如登天,却也绝非易事. 一直有小伙伴向我咨询关于Co ...

  6. Hive 中的四种排序详解，再也不会混淆用法了

    Hive 中的四种排序 排序操作是一个比较常见的操作,尤其是在数据分析的时候,我们往往需要对数据进行排序,hive 中和排序相关的有四个关键字,今天我们就看一下,它们都是什么作用. 数据准备 下面我们 ...

  7. hive优化之小文件合并

    文件数目过多,会给HDFS带来压力,并且会影响处理效率,可以通过合并Map和Reduce的结果文件来消除这样的影响: set hive.merge.mapfiles = true ##在 map on ...

  8. RHEL8/CentOS8的网络IP配置

    rhel8与7的区别 在rhel7上,同时支持network.service和NetworkManager.service(简称NM).默认情况下,这2个服务都有开启,但许多人都会将NM禁用掉. 在r ...

  9. Redis核心原理-简单动态字符串SDS

    SDS简介 Redis是C语言编写的,但没有使用c语言的字符串结构,而是自己实现了一套简单动态字符串 simple dynamic string 简称SDS,SDS兼容C语言的字符串类型,原理类似Ja ...

  10. #2020征文-开发板# 用鸿蒙开发AI应用（三）软件篇

    目录: 前言 HarmonyOS 简介 DevEco Device Tool(windows下) 获取源码(切换到ubuntu) 烧录程序(切换回windows) 前言上一篇,我们在 Win10 上用 ...