黑马程序员——Java之IO流

——–Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一：字符流
数据最常见的体现形式是：文件
需求：在硬盘上，创建一个文件，并写入一些文字数据。
用于操作操作文件的Writer的子类FileWriter，后缀名是父类名。前缀名是该流对象的功能。
操作步骤：
1.创建一个FileWriter对象。该对象一被初始化就必须明确要被操作的文件，该文件会被创建到指定目录下，如果该目录下已经有同名文件，将被覆盖
FileWriter fw=new FileWriter(“demo.txt”);
2.调用write方法，将字符串写入到流中。
fw.write();
3.刷新流对象中的缓冲中的数据，将数据刷到目的地
fw.flush();
4.关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷到目的地中。和flush的区别，flush刷新后，流可以继续使用，close刷新后
将会将流关闭。
fw.close();
IO异常的处理方式：

FileWriter fw=null;

            try {
                fw=new FileWriter("demo.txt");
                fw.write("sdfasd");
            } catch (IOException e) {
                e.printStackTrace();
            }finally{

                try {
                        if(fw!=null)
                        fw.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }

            }
    }

文件的续写：
传递一个true参数，代表不覆盖已有文件，并在已知文件的末尾处进行数据续写。
FileWriter fw=new FileWriter(“demo.txt”，true);
换行转义字符：\r\n

文件的读取方式一：
FileReader();
1.创建一个FileReader对象。文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的，如果不存在会发生异常
FileReader fr=new FileReader(“demo.txt”);
2.调用读取流的对象的read方法
(1)int ch=fr.read();一次读一个字符，会自动往下读。
(2)读出所有字符
while（(ch=fr.read())!=-1）
{
System.out.println((char)ch);
}

3.关闭流资源，
fr.close();
文件的读取方式2：通过字符数组进行读取
1.创建一个FileReader对象。文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的，如果不存在会发生异常
FileReader fr=new FileReader(“demo.txt”);
2.定一个字符数组，用于存储读到字符，该rrad(char[])返回的是读到的字符个数。
char[] buf=new char[1024]；一般定义1024-2个字节。
int num=0;
while（(num=fr.read(buf))!=-1）
{
System.out.println((new String(buf,0,num));
}
二：关于reader与writer的两个练习
练习 1：读取一个.java文件。并打印在控制台上。

FileReader fr=null;
        char[] buf=new char[1024];
        int num=0;
        try {
            fr= new FileReader("a.txt");

            try {
                while((num=fr.read(buf))!=-1){
                    System.out.print(new String(buf,0,num));
                }
            } catch (IOException e) {

                e.printStackTrace();
            }



        } catch (FileNotFoundException e) {

            e.printStackTrace();
        }
        finally
        {
                   try {
                               if(fr!=null)
                    fr.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }       
        }

练习2：将C盘的一个文本文件拷贝到D盘(数组相当于存储之中的媒介)
步骤：新建一个文件用于存储要被拷贝的文件
2.定义读取流和源文件关联
3.通不过不断读写完成数据存储
4.关闭资源

  FileWriter fw=null;
      FileReader fr=null;
      try {
          fw=new FileWriter("b.txt");
          fr=new FileReader("a.txt");
          char[] buf=new char[1024];
          int num=0;
          while ((num=fr.read(buf))!=-1){
              fw.write(buf,0,num);
          }
    }
      catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
      finally
        {
           try {
                fr.close();
            } catch (IOException e) {

                e.printStackTrace();
            }       

           try {
                fw.close();
            } catch (IOException e) {

                e.printStackTrace();
            }       
        }

三：字符流的缓冲区
缓冲区的出现提高了对数据的读写效率
对应类：
BUfferWriter
BufferedReader
特点：缓冲区要结合流才可以使用，在创建缓冲区之前，必须要有流对象。在流的基础上对流的功能进行了增强。
BUfferWriter步骤:
1.创建一个字符写入流对象
FileWriter fw=new FileWriter(“a.txt”);
2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
bufferedWriter bufw=new BufferedWriter(fw);
buff.write(“asdasdas”);
bufw.newLine();//换行符，跨平台的
3.将缓冲区刷新
bufw.flush;
4.关闭缓冲区，就是在关闭缓冲区中的流对象
bufw.close();

BufferedReader步骤
1.创建一个字符写入流对象
FileReader fr=new FileReader (“a.txt”);
2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
BufferedReader bufr=new BufferedReader (fr);
3.读取流对象:该缓冲区提供了一个一次读取一行的方法。当返回null时表示，文件读到末尾
String line=null;
while((line=bufr.readLine())!=null)
{
String s=line;}
4.关闭
bufr.close();
readLine()方法的原理：
无论是读一行，获取多个字符，最终都是在硬盘上一个一个读取，最终使用额还是read方法一次读一个的方法。

练习3：通过缓冲区复制一个文件

BufferWriter bufw=null;
     BufferReader bufr=null;
      try {
          bufw=new BufferWriter(new FileWriter("b.txt"));
          bufr=new BufferReader(new FileReader("a.txt"));
         String line=null;
          while ((line=buffr.read(buf))!=null){
              bufw.write(line);
                    bufw.newLine();
                    bufw.flsuh；
          }
    }
      catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
      finally
        {
           try {
                fr.close();
            } catch (IOException e) {

                e.printStackTrace();
            }       

           try {
                fw.close();
            } catch (IOException e) {

                e.printStackTrace();
            }       
        }

练习4：自定义一个功能和readline一致的方法，来模拟BufferedReader();方法的功能

public class MyBufferedReader extends Reader {

        private Reader r;


        public MyBufferedReader(Reader r) {
            super();
            this.r = r;
        }
        //可以一次读取一行的方法
        public String myReadLine() throws IOException
        {
            //定义一个临时容器。StringBulider容器，应用于存储字符数组
            StringBuilder sb=new StringBuilder();
            int ch=0;
            while((ch=r.read())!=-1){
                if(ch=='\r')
                        continue;
                if(ch=='\n')
                    return sb.toString();
                else
                    sb.append((char)ch);
            }

            if(sb.length()!=0)
                return sb.toString();
            return null;
        }
}

带有行号的缓冲区：
LineNumberReader lnr=new LineNumberReader();

获取行号:lnr.getLineNumber();
设置行号从几开始：lnr.setLineNumber(100);

LineNumberReader 步骤
1.创建一个字符写入流对象
FileReader fr=new FileReader (“a.txt”);
2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
LineNumberReader lnfr=new LineNumberReader (fr);
3.读取流对象:该缓冲区提供了一个一次读取一行的方法。当返回null时表示，文件读到末尾
String line=null;
while((line=lnfr.readLine())!=null)
{
String s=line;
String linenum=lnfr.getLineNumber();
}
4.关闭
lnfr.close();

练习5：自定义带行号的MyLineNumber;:

public class MyLineBufferReader extends MyBufferedReader {

    public MyLineBufferReader(Reader r) {
        super(r);

    }

    private int LineNumber;

    public int getLineNumber() {
        return LineNumber;
    }

    public void setLineNumber(int lineNumber) {
        LineNumber = lineNumber;
    }

    public String myReadLine() throws IOException
    {
        LineNumber++;
        return super.myReadLine();
    }

}