黑马程序员——21，字符流FileReader,FileWriter,BufferedWriter,BufferedReader，装饰设计模式，LineNumberReader

最新推荐文章于 2022-05-31 14:54:31 发布
最新推荐文章于 2022-05-31 14:54:31 发布
阅读量908 收藏 1
点赞数
分类专栏： Java学习笔记 文章标签： 黑马程序员 字符流 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dangaodeaiyi/article/details/47374211
版权

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

          

      黑马程序员——21，字符流FileReader,FileWriter,BufferedWriter,BufferedReader，装饰设计模式，LineNumberReader

/*

字符流的缓冲区技术：

对于一些大文件，如果读取一个字符才写一个字符，读写操作过于频繁。

为了解决这个问题，引入了缓冲区技术。

缓冲区技术是在流的基础上（必须要先有流）增强了流对于数据的操作效率。

就如同在水龙头上拿水喝，原本是一滴一滴喝的，但是现在用了一个杯子装着来喝，更有效率。

*/

 

import java.io.*;
class   Ioliou7
{
         public   static  void   main(String[] args)
         {
                   FileWriter   fw=null;
                   BufferedWriter    bfw=null;
                   try
                   {
                      fw=new FileWriter("f:\\yuyuyu.txt");
                      bfw=new BufferedWriter(fw);
                   //把写入流对象传给缓冲区构造函数
                      bfw.write("假面骑士01号登场！");
                   //实际上把字符写入流的还是fw调用底层资源实现的
                   bfw.newLine();
                   //换行
                     bfw.write("假面骑士02号登场！");
                      bfw.flush();
                   //这里还是要刷新才把存在流的数据传倒文件里面
                  
                   }
                   catch(IOException  e)
                   {
                            throw   new RuntimeException("写操作有误");
                   }
                   finally
                   {
                            try
                            {
                            if(bfw!=null)
                            {
                          bfw.close();
                          //关闭流，
                   /*
                   bfw.close();本质上关闭流的还是fw底层调用close()方法实现的，
                   所以就不用再写fw.close();了
                   */              
           }                                   
                            }
                            catch(IOException   e)
                            {
                                     throw  new  RuntimeException("bfw.close();出问题抛出异常了");
                            }
                   }
 
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj);                             
         }
}

——————分割线——————

 

/*

字符流的读取缓冲区技术

BufferedReader

 

 

*/

import  java.io.*;
class  Ioliou8
{
         publicstatic void main(String[] args)
         {
                   FileReader   fr=null;
       BufferedReader   bfr=null;
                   try
                   {
                      fr=new  FileReader("e:\\JAVAwenjian\\Ioliou8.java");
          bfr=new   BufferedReader(fr); 
                  
                   String   s=null;
                   while((s=bfr.readLine())!=null)
                   /*
                   readLine()一行一行的读取，不包含任何行终止符，如果没有数据读取就返回null，
                   但是不返回回车符，所以输出打印或者写入的时候要记得换行。
                   readLine读取数据本质上还是要调用read方法一个一个读取的
                   */
                   {
           soc(s);
                   }
                           
                   }
                   catch(IOException  e)
                   {
                            throw  new RuntimeException("读操作出问题");
                   }
                   finally
                   {
                        try
                        {
                                      if(bfr!=null)
                                        bfr.close();
                        }
                        catch (IOException  e)
                        {
                                throw new  RuntimeException("读操作出问题");
                        }
                   }
 
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj);                                
         }
}

————————分割线————

 

/*

字符流利用缓冲区进行复制操作文件

把e:\\JAVAwenjian\\Ioliou8.java复制到d盘中。

 

*/

import java.io.*;
class  Ioliou9
{
         public   static  void  main(String[] args)
         {
         FileWriter  fw=null;
         FileReader  fr=null;
         BufferedWriter  bfw=null;
         BufferedReader  bfr=null;
       try
       {
                     fw=new FileWriter("d:\\Ioliou8_copy.java");//建立字符流写入对象
                     fr=new FileReader("e:\\JAVAwenjian\\Ioliou8.java");//建立字符流读取对象
                     bfw=new  BufferedWriter(fw);//建立字符流写入缓冲区
                     bfr=new  BufferedReader(fr);//建立字符流读取缓冲区
 
         String   s=" ";
         while((s=bfr.readLine())!=null)
                     {
                        
                       bfw.write(s);
                            bfw.newLine();//换行
                     }
       
                           
       }
       catch (IOException  e)
       {
                            throw   new  RuntimeException("复制操作出问题");
       }
                   finally
                   {
                            try
                            {
                                     if(bfw!=null)
                                       bfw.close();
                            }
                            catch(IOException  e)
                            {
                                     throw   new RuntimeException(" bfw.close();出问题");
                            }
                     try
                     {
                              if(bfr!=null)
                                       bfr.close();
                     }
                     catch (IOException  e2)
                     {
                              throw new RuntimeException("bfr.close();出问题");
                     }
                  
                   }
 
 
         }
         public  static  void  soc(Object  obj)
         {
             System.out.println(obj);                          
         }
}

————————分割线——————

 

/*

建立一个自己的BufferedReader

这种设计模式也被称之为装饰设计模式，

自定义一个类把已有的对象传进来，

然后针对已有的功能进行强化。

*/

import java.io.*;
class  MyBufferedReader 
{
         private   FileReader  fr=null;
         MyBufferedReader(FileReader   fr)
         {
                this.fr=fr;               
         }
         StringBuffer   sb=new StringBuffer();
         public  String readLine()throws  IOException
         {
                   char   ch=' ';
        int  i=0;
                   while((i=fr.read())!=-1)
                   {
           if(i=='\r')
                continue;
                            if(i=='\n')
                return  sb.toString();
                       ch=(char)i;
                       sb.append(ch);
                  
             }
                   if(sb!=null)
            return  sb.toString();
                   return  null;
                   /*
                   sb.toString()返回的是容器内部的字符串,
                   写返回值的时候千万不要直接写return  sb
                   sb是StringBuffer型的容器！
              */
         }
         public  void  close()throws  IOException
         {
              fr.close();         
         }
         public  static void  soc(Object  obj)
         {
        System.out.println(obj); 
         }
        
}
class  Ioliou10
{
         public   static  void   main(String[] args) 
         {
                MyBufferedReader  bfr =null ;
                FileReader  fr=null;
                   try
                   {
                fr=new FileReader("f:\\yuyuyu.txt");
                bfr=new  MyBufferedReader(fr);
                     String  s=bfr.readLine();
                     soc(s); 
                   }
                   catch(IOException  e)
                   {
                            throw  new RuntimeException("操作异常");
                   }
                   finally
                   {
                       try
                       {
                                     if(bfr!=null)
                                       bfr.close();
                       }
                       catch (IOException  e)
                       {
                                     throw  new RuntimeException("bfr.close();出问题了");
                       }
                   }
 
 
                  
         }
         public  static void  soc(Object  obj)
         {
            System.out.println(obj);           
         }
}

——————分割线————

 

 

/*

装饰类的介绍：(装饰设计模式)

通常自定义一个类，传进已有的对象，然后增加已有的功能。

装饰类和被装饰类都有着相同的功能，只不过前者功能更强。

所以，一般装饰类和被装饰类在同一个体系中，

而且装饰类记得要覆盖父类的抽象方法，

注意是否要抛出异常。

*/

import java.io.*;
class  MyBufferedReader  extends  Reader
{
         private   FileReader  fr=null;
         MyBufferedReader(FileReader   fr)
         {
                this.fr=fr;               
         }
         StringBuffer   sb=new StringBuffer();
         public  String readLine()throws  IOException
         {
                   char   ch=' ';
                   int  i=0;
                   while((i=fr.read())!=-1)
                   {
                if(i=='\r')
                continue;
                            if(i=='\n')
                return  sb.toString();
                ch=(char)i;
                 sb.append(ch);
                  
             }
                   if(sb!=null)
                  return  sb.toString();
                   return  null;
         }
         public  void  close()throws  IOException
         {
              fr.close();         
         }
         public  static void  soc(Object  obj)
         {
        System.out.println(obj); 
         }
         //下面记得要覆盖Reader类中的抽象方法
 
         public  int  read(char[]   cbuf,int  off,int len)throws  IOException
         {
                   return   fr.read(cbuf,off,len);
                              
         }
 
}
class  Ioliou11
{
         public   static  void   main(String[] args) 
         {
              MyBufferedReader  bfr =null ;
               FileReader  fr=null;
                   try
                   {
               fr=new FileReader("f:\\yuyuyu.txt");
               bfr=new  MyBufferedReader(fr);
                     String  s=bfr.readLine();
                     soc(s); 
                   }
                   catch(IOException  e)
                   {
                            throw  new RuntimeException("操作异常");
                   }
                   finally
                   {
                       try
                       {
                                     if(bfr!=null)
                                       bfr.close();
                       }
                       catch (IOException  e)
                       {
                                     throw  new RuntimeException("bfr.close();出问题了");
                       }
                   }
 
 
                  
         }
         public  static void  soc(Object  obj)
         {
            System.out.println(obj);           
         }
}

——————分割线——————

 

/*

LineNumberReader类的应用：

该类是BufferedReader类的子类

*/

 

import java.io.*;
class  Ioliou12
{
         public  static void  main(String[] args)
         {
                   FileReader   fr=null;
                 LineNumberReader   lnr=null;
                   try
                   {
                      fr=new FileReader("Ioliou12.java");
                   //建立读取流对象
                      lnr= new  LineNumberReader(fr);
                  
                   String   s=" ";
                   lnr.setLineNumber(123);
                   //设置行号从123的后一行开始
                   while((s=lnr.readLine())!=null)
                   {    
                        soc(lnr.getLineNumber()+":"+s);
                             //getLineNumber方法用来获取行号
                      
                   }       
                   }
                   catch(IOException  e)
                   {
                            throw  new RuntimeException("读取操作出问题");
                   }
                   finally
                   {
                            try
                            {
                                     if(inr!=null)
                          lnr.close();        
                            }
                            catch(IOException  e2)
                            {
                                     throw   new RuntimeException("lnr.close();出问题了");
                            }
                            
                   }
 
                  
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj);                           
         }
}

编译运行结果如图1所示：

     图1


 

蓝莓浆糊饼干
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java字符流.pdf
07-11
### Java字符流详解 #### 一、概述 Java中的字符流是一种高级的输入输出机制，主要用于处理文本数据。与字节流不同，字符流处理的基本单位是字符而非字节，因此更加适合处理文本数据。字符流是基于Unicode标准设计...
FileWriter和BufferedWriter用处，区别
热门推荐
yuzhuuse的专栏
02-20 1万+
如果单独使用FileWriter也可以。上面这个加了一个缓冲,缓冲写满后在将数据写入硬盘。你每写一个数据,硬盘就有一个写动作,性能极差。BufferedWriter是修饰者。FileWriter是被修饰者。这里有一个"修饰类"的概念。这样做极大的提高了性能。...
BufferedReader、LineNumberReader的作用与用法
根号三
05-26 1万+
一、BufferedReader提供了下面两个功能： 在普通Reader的基础上，提供了缓冲功能，可以更加高效的读取 提供了读取一行的功能：readLine() 二、LineNumberReader继承自BufferedReader，并且增加了下面两个功能： 获取行号：getLineNumber() 设置行号：setLineNumber()
JAVA IO（2）BufferedReader与BufferedWriter与装饰者设计模式
doncoder的博客
01-22 2288
BufferedReader和BufferedWriter各自带了数组缓冲，但读取方式仍然是使用的FileReader的read（）方法。有很多人说带缓冲会减少IO次数，但从读取方式IO次数并不会减少，只是会减少IO频率。缓冲去大小为8k，当调用BufferedReader的read（）方法时会从缓冲区中挨个读取一个字符。BufferedReader还带了一个readLine（）方法，可以每次读取...
FileReader、 FileWriter、readLine()和newLine()、LineNumberReader(二十一)
weixin_30835923的博客
05-09 148
1.字符流FileReader * 1.字符流是什么 　　* 字符流是可以直接读写字符的IO流 　　* 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出. * 2.FileReader, FileWriter 　　* FileReader类的read()方法可以按照字符大小读取 　　　　FileReader fr = new FileR...
Java输入输出系统之Reader和Writer
烧水匠
08-22 1206
Reader和Writer是另一种体系的I/O类，上一篇文章中学习的InputStream和OutputStream体系的类是按照字节（byte）读写数据，Reader和Writer体系的类则是使用字符（char）读写数据，Reader和Writer是体系的根类，它们都是抽象类。 为什么需要Reader和Writer String底层使用char数组来存储数据，每个char占用两个...
java基础之I/O流
10-12
I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流（Output Stream）。下面将详细解释这些概念以及它们在Java中的应用。 1. 字节流： - 输入流：...
Java中的IO流类详解
11-15
- 字符流是在字节流的基础上增加了编码表的支持，使得能够处理不同语言的文字。 2. **按数据流动方向分类**： - **输入流**：从外部设备读取数据到内存中。 - **输出流**：将内存中的数据写入外部设备。 #### ...
java IO流读写
10-29
在Java中，IO流分为两大类：字节流（Byte Stream）和字符流（Character Stream）。字节流处理单个字节的数据，而字符流则处理Unicode编码的16位字符。 1. **字节流**： - `InputStream` 和 `OutputStream` 是所有...
JAVA输入与输出 java流基本流程图
06-13
在Java中，输入和输出操作通过流（Stream）进行，这些流分为字节流和字符流两大类，每类又包含输入流和输出流。 **字节流** 字节流处理的是8位的字节数据，它主要用于处理二进制数据，如图像、音频文件等。Java的...
比较Filewriter 与bufferwriter
04-21
分别用FileWriter和BufferedWriter往文件中写入 *10万个随即数，比较用时的多少
java之Reader类与Writer类
qq_45577911的博客
10-29 1726
Reader类是字符输入流，它和InputStream类的区别是：InputStream类是一个字节流，以byte为单位读取；而Reader类是一个字符流，以char为单位读取。 Reader类最重要的方法是read()方法，使用这个方法读取字符流的下一个字符，范围是0~65535，当读到末尾没有字符时，返回-1. Reader的常用子类： 1、FileReader() //实现了文件字符流的输入（使用时要指定编码） 2、CharArrayReader()//实现了把一个char[]数组变成一个字符输入流
多线程基础之设计模式Read-Write-Lock模式
m0_51681531的博客
05-31 310
多线程基础之设计模式Read-Write-Lock模式
java类Writer和类Reader小结
weixin_34323858的博客
11-03 211
字段摘要 protected Object lock 用于同步针对此流的操作的对象。 构造方法摘要 protected Writer() 创建一个新的字符流 writer，其关键部分将同步 writer 自身。 protected Wr...
字符流与装饰设计
09-01 924
今天老师给我们讲的是字符流和装饰设计模式。 Reader: |--InputStreamReader           |--FileReader:专门用于处理文件的字符读取流对象。 Writer:       |--OutputStreamWriter
IO Reader和Writer类总结
u012230451的专栏
03-09 242
[b][*]概述[/b] Reader和Writer分别代表字符输入流和字符输出流,对于每一个字符,Java虚拟机会为其分配两个字节的内存.它们都都继承自抽象类Reader和Writer Java中,采用如下两种方法获取本地平台编码: [code="java"] System.out.println(System.getProperty("file.encoding")); Char...
Java——Reader与Writer流类的方法及其子类的方法实现
Monkey_D_Dc的博客
02-16 3319
使用Reader与Writer流类 InputStream和OutputStream类通常是用处理“字节流”即“位流”的，也就是说二进制文件，而Reader与Writerl类则是用来处理“字符流”的，也就是文本文件。与字节输入流的功能一样，字符输入流类Reader与Writer只是建立一条通往文本文件的通道，而要实现对字符数据的读写操作，还需要相应读、写方法来完成。 Reader类常用方法: ...
简单的Writer和Reader
weixin_33919941的博客
11-28 246
Writer用于写出去到文件中，Reader用于将外面的文件读进来控制台 Writer和Reader有许多子类，但是子类大多都是直接运用父类Writer和Reader的方法，而且Writer和Reader的方法不多，而且有共性，所以只需弄懂Writer和Reader的方法即可。 Writer和Reader都是抽象类，所以想输入输出只能用他们的子类 Writer Wr...
Java_io体系之Writer、Reader简介、走进源码——12
810364804
12-09 140
Java_io体系之Writer、Reader简介、走进源码——12 一：Writer 1、类功能简介： 字符输出流、本身是一个抽象类、是所有字符输出流的父类、与OutputStream相同的是、定义了所有字符输出流的标准、和一些必须具有的基本方法、和简单的实现其中有三个抽象方法必须要我们去实现的是write(char[] cbuf, int off, int l...
Java IO流深入解析：字符流(FileReader/FileWriter)的使用
`FileReader`和`FileWriter`是Java中处理字符流的两个基础类。`FileReader`用于读取字符，而`FileWriter`用于写入字符。例如，下面的代码展示了如何使用`FileReader`读取一个文本文件，并使用`FileWriter`写入数据：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值