黑马程序员_IO流字符流

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

IO流

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

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

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

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

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

 

字符流的抽象基类

 Reader,Writer

字节流的抽象基类

 InputStrea,OutputStream

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

 

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

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

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

FileWriter  fw =  new FileWriter("demo.Java");

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

w.write("abc");

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

//w.flush();

//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。   将数据刷到目的地中。 
//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭

//w.close();

 

IO流(IO异常处理方式)

import java.io.*;

class io1

{

         publicstatic void main(String[] args) throws IOException

         {

                   BufferedReaderbufr = null;

                   BufferedWriterbufw=  null;

                   try

                   {

                            bufr= new BufferedReader(new FileReader("123.txt"));

                            bufw= new BufferedWriter(new FileWriter("321.txt"));

                            Stringline = null;

                            while((line = bufr.read(buf))!=null)

                            {

                                     bufw.write(line);

                                     bufw.flush();

                            }

                   }

                   catch(Exception e )

                   {

                            thrownew RuntimeException("读写失败");

                   }

                   finally

                   {

                            try

                            {

                                     if(bufr!=null)

                                               bufr.cliose();

                            }

                            catch(Exception e )

                            {

                                     thrownew RuntimeException("读取关闭失败");

                            }

                            try

                            {

                                     if(bufw!=null)

                                               bufw.cliose();

                            }

                            catch(Exception e )

                            {

                                     thrownew RuntimeException("希尔关闭失败");

                            }

                   }

IO流(文件的续写)——不是new对象进行覆盖

FileWriter fw = new FileWriter(“demo.txt”,true);

fw.write(“haha”);

fw.close();

 

//以下是针对其的练习，包括(1)读取一个字符、(2)读取字符数组、(3)将的一个文本文件复制到另一个文件中,(4)创建一个字符写入流对象中、(5)过缓冲区复制文本

import java.io.*;

import java.util.*;

class Io

{

         publicstatic void main(String[] args) throws IOException

         {       

                   /*

                   //(1)文本文件————读取一个字符

                   FileReaders  = new FileReader("123.txt");

                   intnum = 0;

                   while((num = s.read())!= -1)

                   {

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

                   }

                   */

 

                   /*

                   //(2)文本文件————读取字符数组

                   FileReaders  = new FileReader("123.txt");

                   char[]buf = new char[2];

                   intss = s.read(buf);

                   System.out.println(ss+newString(buf));

        

                   (2.1)文本文件————读取字符数组

                   FileReaders  = new FileReader("123.txt");

                   char[]buf = new char[2];

                   intss = 0;

                   while((ss=s.read(buf))!=-1)

                   {

                            System.out.println(newString(buf,0,ss));

                   }

                   */

                  

                   /*

                   //(3.1)将的一个文本文件复制到另一个文件中

                   FileWriterfw = new FileWriter("321.txt");

                   FileReaderfr = new FileReader("123.txt");

                   intnum = 0;

                   while((num = fr.read())!=-1)

                   {

                            fw.write(num);

                   }

                   fw.close();

                   fr.close();         

        

                   //(3.2)将的一个文本文件复制到另一个文件中

                   FileWriterfw = new FileWriter("321.txt");

                   FileReaderfr = new FileReader("123.txt");

                   char[]ch = new char[1024];

                   intnum = 0;

                   while((num = fr.read(ch))!=-1)

                   {

                            fw.write(newString(ch,0,num));

                   }

                   fw.close();

                   fr.close();

                   */    

                   //缓冲区是为了提高流的效率而出现的，提供了一个跨平台的换行符newLine()

 

                   //(4)创建一个字符写入流对象中

                   //FileWriters = new FileWriter("123.txt");

                   //BufferedWriterbufw = new BufferedWriter(s);

                   //bufw.write("@11111");

                   //bufw.flush();

                   //bufw.close();

 

                   //(5.1)创建一个流读取对象和文件关联

                   //FileReaderfr = new FileReader("123.txt");

                   //BufferedReaderbufr = new BufferedReader(fr);

                   //Strings = bufr.readLine();

                   //System.out.println(s);

                   //bufr.close();

 

                   //(5.1)创建一个流读取对象和文件关联

                   //FileReaderfr = new FileReader("123.txt");

                   //BufferedReaderbufr = new BufferedReader(fr);

                   //Stringline = null

                   //while((line = fr.read(bufr))!= null)

                   //{

                   //      System.out.println(line);

                   //}

                   //bufr.close();

 

                   //(6)通过缓冲区复制文本

                  

                   BufferedReaderbufr = new BufferedReader(new FileReader("123.txt"));

                   BufferedWriterbufw= new BufferedWriter(new FileWriter("321.txt"));

                   Stringline = null;

                   while((line = bufr.readLine())!=null)

                   {

                            bufw.write(line);

                            bufw.flush();

                   }

                   bufw.close();

                   bufr.close();

         }

}

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

装饰模式比继承模式要更灵活，避免了继承体系的臃肿，降低了类与类之间的关系

 

IO流(LineNumberReader)

import java.io.*;

class LineNumberReaderDemo

{

         publicstatic void main(String[] args) throws IOException

         {

                   FileReaderfr = new FileReader("123.txt");

                   //MyBufferedReaderbuf = new MyBufferedReader(fr);

                   LineNumberReaders = new LineNumberReader(fr);

                   Stringline = null;

                   s.setLineNumber(100);//从100行开始打印

                            while((line = s.readLine())!=null)

                            {

                                               System.out.println(s.getLineNumber()+line);

                            }

                            s.close();

         }       

}

 

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------