黑马程序员---2015.6.24java基础笔记--FileWriter- FileReader-BufferedWriter-BufferedReader

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

IO--FileWriter FileReader BufferedWriter BufferedReader

1.FileWriter练习

/*
    字节流两个基类。
    InputStream  OutputStream
    
    字符流两个基类
    Reader Writer
    
    既然IO流是用于操作数据的，那么数据的最常见体现形式：文件
    
    需求：在硬盘上，创建一个文件，并写入数据
    找到专门用于操作文件的Writer子类对象，FileWriter.
    
*/
import java.io.*;
class FileWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个FileWriter对象，该对象一被初始化就必须明确被操作的文件。
        //而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖。
        //该步就是确定数据要存放的目的地
        FileWriter fw = new FileWriter("demo.txt");
        
        //调用write方法，将字符串写入流中
        fw.write("hello IO");
        
        //刷新流对象中的缓冲数据，将数据刷到目的地中
        fw.flush();
        
        //关闭流资源，但是关闭前会刷新一次内部的缓冲中的数据
        //将数据刷到目的地中
        //和flush的区别，close后流关闭
        fw.close();

    }
}

2.FileWriterDemo2

/*
    完整的在硬盘上写入数据
*/
import java.io.*;
class FileWriterDemo2
{
    public static void main(String[] args)
    {
        FileWriter fw = null;
        try
        {
                fw = new FileWriter("demo.txt");
                fw.write("hello my IO");
                
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }    
        finally
        {
            try
            {    
                if(fw != null)
                {
                    fw.close();    
                }
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
        }        
    }
}

3.FileWriter将数据写入已有数据的文件中
        FileWriter fw = new FileWriter("demo.txt",true);

/*
    对已有文件，数据的续写
    使用 new FileWriter(String fileName,boolean append);
*/
import java.io.*;
class FileWriterDemo3
{
    public static void main(String[] args)
    {
        FileWriter fw = null;
        try
        {
            //文件不存在则创建，文件已存在的话，在文件末尾处数据续写
                fw = new FileWriter("demo.txt",true);
                //windows的换行 \r\n
                fw.write("\r\nhello my IO");    
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }    
        finally
        {
            try
            {    
                if(fw != null)
                {
                    fw.close();    
                }
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
        }        
    }
}

4.FileReaderDemo 一个一个字符的读

import java.io.*;
class FileReaderDemo
{
    public static void main(String[] args) throws Exception
    {
        //创建一个读取流，和指定名称的文件关联起来
        //保证该文件是已经存在的，如果不存在会发生，
        //FlieNotFoundException
        FileReader fr = new FileReader("demo.txt");
        
        //读到ch = -1;就停止
        int ch =0;
        System.out.println("ch="+(char)ch);
        
        while((ch = fr.read())!= -1)
        {
            System.out.println("ch="+(char)ch);;
        }
    }
    
}    

5.FileReaderDemo2

/*
    第二种方式，通过字符数组进行读取
        将字符读入字符数组。
        int read(char[] cbuf);
        再打印字符数组
        
    比read()要好，因为read()是读取一个字符打印一个。
    int read(char[] cbuf);是将读取到的字符放到数组中再一块打印
*/
import java.io.*;
class FileReaderDemo2
{
    public static void main(String[] args) throws Exception
    {
        FileReader fr = new FileReader("demo.txt");
        //创建一个2k大小的字符数组
        char [] buff = new char[1024];
        int num = 0;
        while((num=fr.read(buff))!= -1)
        {
            //读取数组buff 从0开始，一共num位。
            System.out.println(new String(buff,0,num));
        }
        
    }    
}    

6.//读取一个文件

import java.io.*;
class FileReaderTest
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("FileReaderDemo2.java");
        char[] buff = new char[1024];
        int count = 0;
        while((count=fr.read(buff))!=-1)
        {
            System.out.println(new String(buff,0,count));
        }
    }
}

7.
字符流的缓冲区：
    提高了对数据的读写效率。
对应的类
    BufferedWriter
    BufferedReader
缓冲区要结合流才可以使用。
    在流的基础上对流功能进行了增强    
    
8.写入缓冲区BufferedWriterDemo

/*
    缓冲区的出现是为了提高流的操作效率而出现的。
    所以在创建缓冲区之前，必须要先有流对象
    
    该缓冲区中提供了一个跨平台的换行符。
    newLine();
    
    该程序演示，写入缓冲区
*/
import java.io.*;
class BufferedWriterDemo
{
        public static void main(String[] args) throws Exception
        {
            FileWriter fw = new FileWriter("buf.txt");
            BufferedWriter bufw = new BufferedWriter(fw);
            
            for(int x = 0;x<5;x++)
            {
                bufw.write("abcd"+x);
                //换行符，适用于windows和linux平台
                //windows \r\n
                //linux   \n
                bufw.newLine();
            }
            bufw.close();
        }
}        

9.BufferedReaderDemo字符读取缓冲区

/*
    字符读取缓冲区
    该缓冲区提供了一个一次读一行的方法readLine()，方便于对文本的获取
    当返回null 表示读到了末尾
    
    readLine()并不换行
*/
import java.io.*;
class BufferedReaderDemo
{
        public static void main(String[] args) throws Exception
        {
            //创建一个读的流对象和文件关联
            FileReader fr = new FileReader("buf.txt");
            //创建该流的缓冲区
            BufferedReader  bufr = new BufferedReader(fr);
            String temp = null;
            //读取一行
            while((temp = bufr.readLine()) != null)
            {
                System.out.println(temp);
            }
        }
}    

10.CopyTextBuffer

/*
    通过缓冲区复制一个.java文件
*/
import java.io.*;
class CopyTextBuffer
{
        public static void main(String[] args)
        {
            //创建读 和 写 的缓冲流
            BufferedReader bufr = null;
            BufferedWriter bufw = null;
            
            try
            {
                //读的缓冲流指向文件读流对象
                bufr = new BufferedReader(new FileReader("buf.txt"));
                //写的缓冲流指向文件写流对象
                bufw = new BufferedWriter(new FileWriter("buf_copy.txt"));
                String temp = null;
                
                while((temp = bufr.readLine())!= null)
                {
                    bufw.write(temp);
                    bufw.newLine();
                    bufw.flush();
                }
            }
            catch(IOException e)
            {
                throw new RuntimeException("读取出错。。");
            }
            finally
            {
                try
                {    
                    if(bufr == null)
                    {
                        bufr.close();    
                    }
                    
                    if(bufw == null)
                    {
                        bufw.close();
                    }
                }
                catch(IOException e)
                {
                    throw new RuntimeException("关闭资源出错");    
                }
            }
            
        }
}