黑马程序员——IO流字符流

最新推荐文章于 2015-12-16 13:37:52 发布
最新推荐文章于 2015-12-16 13:37:52 发布
阅读量470 收藏
点赞数
分类专栏： 黑马程序员Java基础 文章标签： 黑马程序员 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W49408322/article/details/38701323
版权
------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

 

 

字符流读取流

1、IO流用来处理设备之间的数据传输。

2、Java对数据的操作是通过流的方式。

3、Java用于操作流的对象都封装在IO包中。

4、流按操作数据分为两种：字节流与字符流。

5、流按流向分为：输入流，输出流。

IO  字符流的抽象基类

Reader,      Writer

字节流的抽象基类

InputStream,  OutputStream

注意：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

既然IO流是用于操作数据的，

那么数据的最常见体现形式是：文件。

那么先以操作文件为主来演示。

IO流（文本写入）

writer抽象类

abstract void

close()
关闭此流，但要先刷新它。

abstract void

flush()
刷新该流的缓冲。

void

write(char[] cbuf)
写入字符数组。

abstract void

write(char[] cbuf, int off, int len)
写入字符数组的某一部分。

void

write(int c)
写入单个字符。

void

write(String str)
写入字符串。

void

write(String str, int off, int len)
写入字符串的某一部分。

 

 

FileWriter类

构造方法摘要

FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。

/*

需求:在硬盘上，创建一个文件并写入一些文字数据。

找到一个专门用于操作文件的Writer子类对象。FileWriter。 后缀名是父类名。 前缀名是该流对象的功能。

*/

import java.io.Writer;

import java.io.FileWriter;

import java.io.IOException;

public class Test{

    public static void main(String...args)throws IOException{

        /*创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件.

而且该文件会被创建到指定目录下，如果该目录下已有同名的文件，将被覆盖。

其实该步就是明确数据要存放的目的地*/

        Writer w = new FileWriter("1.Java");

        /*调用writer方法，将字符串写入到流中，会抛IO异常.*/

        w.write("黑马程序员——戒风");

        /*刷新该流的缓冲。将数据刷新到文件中*/

        //w.flush();

        /*关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。

将数据刷到目的地中。

和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。*/

        w.close();

    }

}

IO流(IO异常处理方式)

import java.io.Writer;

import java.io.FileWriter;

import java.io.IOException;

public class Test{

    public static void main(String...args){

        Writer w = null;

        try{

            w =new FileWriter("1.Java");

            w.write("黑马程序员——戒风");

        }

        catch(IOException e){

            System.out.println("写入失败"+e);

        }

        finally{

            try{

                if(w!=null)

                w.close();

            }

            catch(IOException e){

                System.out.println("关闭失败"+e);

            }

        }

    }

}

文件的续写

FileWriter类

构造方法摘要

FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

/*

Windows中，换行是 \r\n。

Linux 是\n。

*/

import java.io.Writer;

import java.io.FileWriter;

import java.io.IOException;

public class Test{

    public static void main(String...args){

        Writer w = null;

        try{

            //为true表示不覆盖已有文件，并且续写

            w = new FileWriter("1.Java",true);

            w.write("黑马程序员——jiefeng");

            w.write("\r\n换行");

        }

        catch(IOException e){

            System.out.println(e);

        }

        finally{

            try{

                if(w!=null)

                w.close();

            }

            catch(IOException e){

                System.out.println(e);

            }

        }

   }

}

IO流(文本文件读取方式一)

Reader抽象类

int

read()
读取单个字符。

abstract void

close()
关闭该流并释放与之关联的所有资源。

构造方法摘要

FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。

import java.io.Reader;

import java.io.FileReader;

import java.io.IOException;

public class Test{

   public static void main(String...args) throws IOException{

        /*

创建一个文件读取流对象，和指定名称的文件相关联。

要保证该文件是已经存在的，如果不存在，会发生异常 FileNotFoundException

*/

        Reader r = new FileReader("C:\\1.Java");

        int ch =0;

        while((ch=r.read())!=-1){

            System.out.print((char)ch);

        }

    }

}

IO流(文本文件读取方式二)

Reader抽象类

int

read(char[] cbuf)
将字符读入数组。

import java.io.Reader;

import java.io.FileReader;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        Reader r = new FileReader("C:\\1.Java");

        char[]buf = new char[1024];

        int len =0;

        while((len=r.read(buf))!=-1){

            sop(new String(buf,0,len));

        }

    }

    public static void sop(Object obj){

        System.out.println(obj);

    }

}

IO流(文本文件读取练习)

import java.io.Reader;

import java.io.FileReader;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        Reader r = new FileReader("1.Java");

        char []buf = new char[1024];

        for(int len =0;(len=r.read(buf))!=-1;){

            sop(new String(buf,0,len));

        }

    }

    public static void sop(Object obj){

        System.out.println(obj);

    }

}

IO流(文本文件写入练习)

import java.io.Writer;

import java.io.FileWriter;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        Writer r = new FileWriter("1.Java");

        for(int x=1;x<=5;x++){

            r.write("戒风"+x+"\r\n");

            r.flush();

        }

        r.close();

        System.out.println(“Good!”);

    }

}

IO流(拷贝文本文件)

复制的原理，其实就是将一个文件的数据存储到另一个文件中

/*

1、在C盘创建一个文件，用于存储C盘文件中的数据

2、定义读取流和C盘文件关联

3、通过不断的读写完成数据存储

4、关闭资源

*/

import java.io.IOException;

import java.io.Writer;

import java.io.Reader;

import java.io.FileWriter;

import java.io.FileReader;

public class Test{

    public static void main(String... args){

        Reader r =null;

        Writer w =null;

        try{

            r = new FileReader("C:\\1.Java");

            w =new FileWriter("C:\\2.Java");

            char[] buf =new char[1024];

            for(int len=0;(len=r.read(buf))!=-1;){

                w.write(new String(buf,0,len));

            }

        }

        catch(IOException e){

            System.out.println(e);

        }

        finally{

            try{

                if(r!=null)

                r.close();

                System.out.println(“Good!”);

            }

            catch(IOException e){

                System.out.println(e);

            }

            finally{

                try{

                    if(w!=null)

                    w.close();

                }

                catch(IOException e){

                    System.out.println(e);

                }

            }

        }

    }

}

字符流的缓冲区

1、缓冲区的出现提高了对数据的读写效率。

2、对应类。

(1)、BufferedWriter

(2)、BufferedReader

3、缓冲区要结合流才可以使用。

4、在流的基础上对流的功能进行了增强。

BufferWriter

void

newLine()
写入一个行分隔符。

/*

缓冲区的出现是为了提高流的操作效率而出现的

所以在创建缓冲区之前，必须要先有流对象。

*/

import java.io.IOException;

import java.io.Writer;

import java.io.FileWriter;

import java.io.BufferedWriter;

public class Test{

    public static void main(String...args) throws IOException{

        Writer w = new FileWriter("C:\\1.Java");

        /*

为了提高字符写入流的效率，加入了缓冲技术，只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可

*/

       BufferedWriter bw = newBufferedWriter(w);

        bw.write("黑马程序员");

        /*

当然如果要刷新的话，当然是要刷新缓存区的flush，

因为数据写到缓冲区里面去了。

如果刷新流对象是刷不出来东西的。关闭也一样

*/

        bw.newLine();

        bw.write("我来了");

        bw.flush();

        //bw.close();

        /*其实这个流可以不用关闭也行。因为缓存区必须有流，而流对象关闭了。

缓存区对象也就自动释放了*/

        w.close();

        System.out.println("ok!!!");

    }

}

IO流(BufferedReader)

BufferedReader

String

readLine()
读取一个文本行。

readLine() 读取一个文本行。返回：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null ,所有要手动写入换行.

/*
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine ，方便于对文本数据的获取
当返回 null 时，表示读到文件的末尾
readLine() 方法返回的时候只返回回车符之前的数据内容，并不返回回车符
*/

import java.io.Reader;

import java.io.FileReader;

import java.io.IOException;

import java.io.BufferedReader;

public class Test{

    public static void main(String...args) throws IOException{

        Reader r = new FileReader("C:\\1.Java");

        /*

为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数

*/

        BufferedReader br = newBufferedReader(r);

        for(String line = null;(line=br.readLine())!=null;){

            System.out.print(line);

            System.out.println();

        }

    }

}

IO流(通过缓冲区复制文本文件)

/*

通过缓冲区复制一个 .Java 文件

*/

import java.io.IOException;

import java.io.BufferedWriter;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.FileWriter;

public class Test{

    public static void main(String...args){

        BufferedReader br = null;

        BufferedWriter bw = null;

        try{

            br =new BufferedReader(new FileReader("C:\\1.Java"));

            bw = new BufferedWriter(new FileWriter("C:\\2.Java"));

            for(String line = null;(line=br.readLine())!=null;){

                bw.write(line);

                bw.newLine();

                bw.flush();

            }

        }

        catch(IOException e){

            throw new RuntimeException("读写失败");

        }

        finally{

            try{

                if(br!=null)

                br.close();

            }

            catch(IOException e){

                throw new RuntimeException("读取关闭失败");

            }

            try{

                if(bw!=null)

                bw.close();

            }

            catch(IOException e){

                throw new RuntimeException("写入关闭失败");

            }

            System.out.println("ok!!!");

        }

    }

}

IO流(readLine的原理)

不论是读一行，获取多个字符，其实最终都是在硬盘上一个一个读取，所以最终使用的还是 read() 方法一次读一个的方法。

因为跨平台性，换行符不一样，所以读取的时候缓存中不存入换行，让使用者自己输入换行。

IO流(MyBufferedReader)

明白了BufferedReader 类中特有方法 readLine 的原理后，

可以自定义一个类中包含一个功能和readLine一致的方法

来模拟一下BufferedReader的readLine方法。

import java.io.IOException;

import java.io.BufferedWriter;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.Reader;

public class Test{

    public static void main(String... args) throws IOException{

        Reader r = new FileReader("C:\\1.Java");

        MyBufferedReader br = newMyBufferedReader(r);

        for(String line =null;(line=br.myReadLine())!=null;){

            System.out.print(line);

            System.out.println();

        }

    }

}

class MyBufferedReader{

    private Reader r;

    MyBufferedReader(Reader r){

        this.r=r;

    }

    public String myReadLine() throws IOException{

        /*

定义一个临时容器，原BufferedReader封装的是字符数组

为了方便，定义一个StringBuilder容器，因为最终还是要将数据变成字符串

*/

        StringBuilder sb = newStringBuilder ();

        int len = 0;

        while((len = r.read())!=-1){

            if(len=='\r')

            continue;

            if(len=='\n')

            return sb.toString();

            else

            sb.append((char)len);

        }

        //防止最后一行没有换行的情况

        if(sb.length()!=0)

        return sb.toString();

        else

        return null;

    }

    public void myClose() throws IOException{

        r.close();

    }

}

IO流(装饰设计模式)

1、当想要对已有对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能，那么该自定义类称为装饰类。
2、装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的功能，提供更强的功能。

（可以理解为打扮，比如自己如果要去面试的化，咱们要把自己打扮一下，把自己搞上点新鲜的衣服，但是最后还是一个人，只是身上多个点东西，这就是装饰）

IO流(装饰和继承的区别)

以前是通过继承将每一个子类都具备父类的功能。

那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下装饰类的内容。

将需要被装饰的对象。传递进来。也就是，谁需要被装饰，谁就作为参数传递给装饰类。

这样继承体系就变得很简单。优化了体系结构。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

IO流(自定义装饰类)

abstract class Person{

    public abstract void chifan();

}

class Qiongren extends Person{

    public void chifan(){

        System.out.println("吃饭");

    }

}

class Furen extends Person{

    private Person p;

    Furen(Person p){

        this.p=p;

    }

    public void chifan(){

        System.out.println("开胃酒");

        p.chifan();

        System.out.println("甜点");

        System.out.println("来一根,当然我不好这口");

   }

}

public class Test{

    public static void main(String...args){

        Qiongren q =new Qiongren();

        Furen f =new Furen(q);

        f.chifan();

    }

}

IO流(LineNumberReader)

LineNumberReader

int

getLineNumber()
获得当前行号。

void

setLineNumber(int lineNumber)
设置当前行号。

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.LineNumberReader;

import java.io.IOException;

public class Test{

    public static void main(String... args) throws IOException{

        BufferedReader br = newBufferedReader(new FileReader("C:\\1.Java"));

        LineNumberReader lnr = new  LineNumberReader(br);

        lnr.setLineNumber(100);

        for(String line =null;(line=lnr.readLine())!=null;){

            System.out.println(lnr.getLineNumber()+":"+line);

        }

        lnr.close();

    }

}

IO流(MyLineNumberReader)

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

class MyLineNumberReader{

    private BufferedReader  br;

    private int LineNumber;

    MyLineNumberReader(BufferedReader br){

        this.br=br;

    }

    public void setLineNumber(int LineNumber){

        this.LineNumber = LineNumber;

    }

    public int getLineNumber(){

        return++LineNumber;

    }

    public String readLine()throws IOException{

        return br.readLine();

    }

    public void myClose() throws  IOException{

        br.close();

    }

}

public class Test{

    public static void main(String...args) throws IOException{

        BufferedReader bfr = newBufferedReader(new FileReader("C:\\1.Java"));

        MyLineNumberReader my = newMyLineNumberReader(bfr);

        my.setLineNumber(100);

        for(String line = null;(line=my.readLine())!=null;){

            System.out.println(my.getLineNumber()+":"+line);

        }

        my.myClose();

    }

}

戒风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员——IO流—整理笔记
nanfp的博客
07-05 728
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 今天刚学完IO流，下面整理一下我的学习笔记。         ①根据处理数据的数据类型的不同可以分为：字节流（抽象基类为InPutStream和OutPutStream）和字符流（抽象基类为Reader和Writer）。          注意：由这四个类派生出来的子类名称都是以其父类名作
java——IO流技术.pdf
04-03
### Java IO流技术详解 #### 一、IO流概述 在Java编程中，**IO流**(Input/Output Stream)主要用于实现数据的输入与输出操作。无论是文件读写、网络通信还是程序间的交互，几乎所有的数据交换都依赖于IO流。 #####...
黑马程序员——IO流
codeting的博客
12-16 359
最近学习了Java的IO流部分，下面作一些简单的总结：    首先，Java中IO流的作用是处理设备之间的数据传输。按照操作数据可以分为字符流和字节流，按照流向可以分为输入流和输出流。Java用来操作流的对象都封装在io包中，下面我引用了一张别人的框架图，清晰地罗列出了IO流的体系结构。 下面，对一些常用的流举例示范： 字符流 //对FileReader和FileWriter的
黑马程序员——IO流（字符流）
cmj的博客
09-17 316
字符流：Reader字符输入流 和 Writer字符输出流 跟踪行号的输入流————LineNumberReader，它是BufferedReader的直接子类 转换流：InputStreamReader 和 OutputStreamWriter
黑马程序员——IO流体系
guojiadui的博客
05-16 386
黑马程序员——IO流体系——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- java作为一种面向对象语言，程序的一切都动作行为都是通过对象完成。所谓IO流，就是把数据的传输行为封装成了对象，对于数据的传输过程，也就变成了对IO流对象的操作过程：IO流的分类1.按数据的传输方向分类（也就根据数据的传输方向分，数据的源头与数据目的地）： 输入流：硬盘、网络、或输入
黑马程序员——IO流学习笔记
weizhilin046的博客
12-13 409
IO流 一、概念 流按操作数据分：字节流，字符流 按流向分为：输入流输出流 英文编码表：ASICCI码 汉子编码表：GB2312,扩容后GBK 国际标准码表：UNICODE，优化后变为utf-8； 字符流读取的时候用什么码表可以有我们自己指定，这样处理文字就变得很方便 所以处理文字用字符流方便，处理图片用字节流方便，通用字节流 四个流的基类：InputStream,OutputS
黑马程序员——IO流(下)
u013763802的博客
09-12 323
——- android培训、java培训、期待与您交流！ ———- 有时候我们用记事本编写JAVA程序时，控制台报告异常，指定在某行错误，我们能不能带行号打印出我们所编写的JAVA程序呢?答案是可以的！我们来学习一下类 LineNumberReader。 LineNumberReader类：定义：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineN
黑马程序员——IO流(上)
u013763802的博客
09-12 390
——- android培训、java培训、期待与您交流！ ———- IO(Input Output)流概述*IO流用于处理设备之间数据传输 *JAVA对数据操作通过流的方式 *JAVA用于处理的对象都在IO包中 *流按照操作数据分为两种：字节流与字符流（字节流就是我们常用指种种文件如:视频，图片等[由二进制数构构成]字符流就是我们常常用到的文本） *流按照流向分为输入流输出流 IO流常用基类*字节
黑马程序员——IO流（其他流）
cmj的博客
09-20 412
ObjectInputStream 和 ObjectOutputStream 操作对象的流 DataInputStream 和 DataOutputStream 操作基本数据类型的流 PrintStream 和 PrintWriter 打印流 PipedInputStream 和 PipedOutputStream 管道流 ByteArrayInputStream 和 ByteArrayOutputStream 操作字节数组的流 SequenceInputStream 合并流 字符编码
黑马程序员——IO流（字节流）
cmj的博客
09-17 336
IO（Input Output）流 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 IO流常用基类 字节流的抽象基类    InputStream    OutputStream 字符流的抽象基类  Reader   Writer 注：有
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
本资料包“Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar”提供了一个深入学习Java IO流的全面资源，包含实例题目、源代码以及PPT教学材料，适合对Java IO有进阶需求的开发者。 1. **Java ...
IO流——文件操作字符流
12-22
1. 文件操作输入字符流 FileReader 文件操作输入字符流 Constructor 构造方法 FileReader(File file) 根据File类对象创建对应的FileReader字符流输入对象 FileReader(String pathName) 根据String类型文件路径...
IO流之字符流（下）
12-22
1.1 文件操作字符流 1.1.1 字符流特征 字符流 = 字节流 + 解码过程 字节组合操作 == 》 对应当前环境编码集的一个字符，如果字符找不到，该数据无效，需要被删除 1.1.2 文件操作输入字符流 FileReader constructor ...
Java 中IO流字符流详解及实例
08-30
Java 中IO流字符流详解及实例 Java 中的 IO 流字符流是指 Java 语言中对基本输入/输出流的扩展，用于处理字符流。字符流是指将文本文件或字符串按照某种编码方案（如 UTF-8、UTF-16BE、GBK 等）序列化为字节序列的...
黑马程序员——集合工具类
W49408322的专栏
08-20 781
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Collections:集合框架的工具类。里面定义的都是静态方法。（相信Java的新手们都知道，如果一个类全都是静态方法的话，那么这个类肯定不能创建对象，也不需要给你提供对象的获取方法，因为静态都是优先于对象存在的） Collections和Coll
黑马程序员——泛型(Generic)
W49408322的专栏
08-20 710
入门泛型的基本应用 代码示例： package com.itheima.day02; import java.util.ArrayList; public class GenericTest1 {     public staticvoidmain(String[] args) {         ArrayList collection1 = new ArrayLis
黑马程序员——Java基础__多线程（下）
W49408322的专栏
08-20 656
面向对象——多线程（下） 线程间的通信 线程间通信——等待唤醒机制 wait(), notify(), notifyAll(), 都使用在同步中，因为要对持有监视器（锁）的线程操作。 思考：为什么操作线程的方法wait notify notifyAll定义在了Object类中？ 因为这些方法是监视器的方法。监视器其实就是锁。锁可以是任意的对象，任意的对象调用的方式一定定义在Obj
黑马程序员——反射
W49408322的专栏
08-20 628
 Java 面向对象——反射 理解反射的概念 反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的
黑马程序员io流笔记
最新发布
07-29
在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等二进制对象时更常用，而字符流在处理中文时更为方便。\[1\]\[2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值