Day20 IO流1

最新推荐文章于 2022-05-06 15:22:19 发布

神一样的我

最新推荐文章于 2022-05-06 15:22:19 发布

阅读量170

点赞数

分类专栏： Java SE

本文链接：https://blog.csdn.net/qq_21953671/article/details/79069766

版权

Java SE 专栏收录该内容

32 篇文章 2 订阅

订阅专栏

File类

文件和目录路径名的抽象表示形式。一个File对象可以代表一个文件或目录

可以实现获取文件和目录属性等功能
可以实现对文件和目录的创建、删除等功能

File不能访问文件内容
File file = new File(“d:\test\java.txt”);
File file = new File(“d:/test/java.txt”);
File file = new File(“java.txt”);
路径可以是绝对路径和相对路径，分隔符采用\或者/

通过File对象可以访问文件的属性。
public String getName() public String getPath()
public boolean isFile() public boolean isDirectory()
public boolean canRead() public boolean canWrite()
public boolean exists() public long length()
public boolean isHidden() public long lastModified()
public File [] listFiles();

通过File对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。
public boolean createNewFile()throws IOException
public boolean delete()
public boolean mkdir()， mkdirs() 注意两个的区别！！
可以实现获取文件和目录属性等功能

import java.io.File;
import java.util.Date;
public class TestFile1 {

    public static void main(String[] args) {
        //创建一个File对象，指向一个文件或者目录
        //File file = new File("e:\\readme.txt");
        //File file = new File("e:/readme.txt");
        //File file = new File("readme.txt");//??? 当前目录下 当前项目
        //通过File对象获取指定文件或者目录的属性
        File file = new File("e:/");
        System.out.println(file.getName());//文件名称
        System.out.println(file.exists());//存在
        System.out.println(file.length());//长度

        System.out.println(file.getPath());//路径
        System.out.println(file.getAbsolutePath());//绝对路径
        System.out.println(file.getParent());//上级路径
        //System.out.println(file.getParentFile());

        System.out.println(file.canRead());
        System.out.println(file.canWrite());
        System.out.println(file.isHidden());//隐藏文件

        //
        File [] files = file.listFiles();//当前目录下的所有文件和子目录，并且使用File来指向每个文件和子目录
        //String []  files2 = file.list();当前目录下的所有文件和子目录的名称


        //遍历数组，实现dir
        for(File f : files){
            //输出时间
            System.out.print(new Date(f.lastModified()).toLocaleString());
            //f.isDirectory()  f.isFile()
            if(f.isDirectory()){
                System.out.print("   <DIR>            ");
            }else{
                System.out.print("            "+f.length());
            }
            //输出文件或目录的名称
            System.out.println(f.getName());
        }
    }
}

可以实现对文件和目录的创建、删除等功能

import java.io.File;
import java.io.IOException;

/**
 * 认识File类
 * 
 * 可以实现对文件和目录的创建、删除等功能

 * @author Administrator
 *
 */
public class TestFile2 {

    public static void main(String[] args) {
        //创建一个File，指向一个文件
        //File file = new File("e:/readme2.txt");
        ///File file = new File("e:/abc/readme2.txt");
        File file = new File("e:/abc/def/ghi/jkl/readme2.txt");
        //如果该文件不存在，就创建。如果存在，就删除
        boolean flag = file.exists();
        if(flag){//存在
            file.delete();
        }else{//不存在
            //
            File dir = file.getParentFile();
            if(!dir.exists()){
                //dir.mkdir();//创建一个子目录 make directory 
                dir.mkdirs();//创建多级子目录
            }
            try {
                file.createNewFile();//创建文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

IO流基础知识

这里写图片描述

IO流类的分类

流的方向：
输入流：数据源到程序(InputStream、Reader读进来)
输出流：程序到目的地(OutPutStream、Writer写出去)

处理数据单元：
字节流：按照字节读取数据(InputStream、OutputStream)
字符流：按照字符读取数据(Reader、Writer)
这里写图片描述
功能不同：
节点流：可以直接从数据源或目的地读写数据。
处理流(包装流)：不直接连接到数据源或目的地，是其他流进行封装。目的主要是简化操作和提高性能.
节点流和处理流的关系：
节点流处于io操作的第一线，所有操作必须通过他们进行；
处理流可以对其他流进行处理(提高效率或操作灵活性)

IO流类的体系

InputStream和OutputStream
Java语言中最基本的两个字节输入输出类。
其他所有字节输入输出流类都继承自这两个基类。
这两个类都是抽象类，不能创建它们的实例，只能使用它们的子类.

这里写图片描述
Reader和Writer
Java语言中最基本的两个字符输入输出类。
其他所有字符输入输出流类都继承自这两个基类。
这两个类都是抽象类，不能创建它们的实例，只能使用它们的子类.

这里写图片描述

文件字节流FileInputStream和FileOutputStream

1.完成基本文件复制

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 功能：使用文件字节流实现文件的复制
 * 
 * 1.如何创建输入流
 *  
 * File file1 = new File("e:/readme.txt");
   InputStream fis = new FileInputStream(file1);
 * 
 * InputStream fis = new FileInputStream("e:/readme.txt");
 * 
 * 2.如何创建输出流
 *      File file2 = new File("e:/readme2.txt");
        OutputStream fos = new FileOutputStream(file2);
 * 
 *  OutputStream fos = new FileOutputStream("e:/readme2.txt");
 * 3.如何使用输入流和输出流
 *  n = fis.read();
 *  fos.write(n);
 * 
 * 4.如何关闭流
 * 
 *  fis.close();
 *  fos.close();
 *  流使用完毕一定要关闭，垃圾回收器无能为力
 *  
 *  
 * @author Administrator
 *
 */
public class TestCopy1 {

    public static void main(String[] args) throws IOException {
        //1.创建一个输入流和输出流
//      File file1 = new File("e:/readme.txt");
//      InputStream fis = new FileInputStream(file1);
        //InputStream fis = new FileInputStream(new File("e:/readme.txt"));
        InputStream fis = new FileInputStream("e:/readme.txt");
//      File file2 = new File("e:/readme2.txt");
//      OutputStream fos = new FileOutputStream(file2);
        //OutputStream fos = new FileOutputStream(new File("e:/readme2.txt"));//默认覆盖
        //OutputStream fos = new FileOutputStream("e:/readme2.txt");
        OutputStream fos = new FileOutputStream(new File("e:/readme2.txt"), true);//追加

        //2.使用输入流和输出流完成复制
        //2.1准备一个中转站：水杯
        int n; //

        //2.2借助循环和中转站完成复制操作
        n = fis.read(); //从文件中读取一个字节 byte

        while(n != -1){
            //写一个字节到目的文件（将水杯的水放入水缸）
            fos.write(n);
            //再读一个字节（再接一杯水）
            n = fis.read();
        }


        //3.关闭输入流和输出流
        fis.close();
        fos.close();

    }
}

2.完善文件复制–中转站使用字节数组

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 功能：使用文件字节流实现文件的复制
 *  
 *  缺点1：可以实现复制，但是汉字无法正常显示
 *  缺点2：中转站太小，影响效率
 *  缺点3：没有进行异常处理try-catch
 *  
 * @author Administrator
 *
 */
public class TestCopy2 {

    public static void main(String[] args) throws IOException {
        //1.创建一个输入流和输出流
//      File file1 = new File("e:/readme.txt");
//      InputStream fis = new FileInputStream(file1);
        //InputStream fis = new FileInputStream(new File("e:/readme.txt"));
        InputStream fis = new FileInputStream("e:/JDK_API_1_6_zh_CN.CHM");
//      File file2 = new File("e:/readme2.txt");
//      OutputStream fos = new FileOutputStream(file2);
        //OutputStream fos = new FileOutputStream(new File("e:/readme2.txt"));//默认覆盖
        OutputStream fos = new FileOutputStream("e:/JDK_API_1_6_zh_CN2.CHM");
        //OutputStream fos = new FileOutputStream(new File("e:/readme2.txt"), true);//追加

        //2.使用输入流和输出流完成复制
        //2.1准备一个中转站：水桶
        byte [] buf = new byte[1024];

        //2.2借助循环和中转站完成复制操作
        int len = fis.read(buf); //读取文件的内容到buf数组，返回的真正读取的字节数。文件结束，返回-1
        while(len !=-1){
            //写数组的内容到目的文件
            //fos.write(buf);//写1024
            fos.write(buf, 0, len);
            //再读一次
            len = fis.read(buf);
        }

        //3.关闭输入流和输出流
        fis.close();
        fos.close();

    }
}

3.完善文件复制–进行异常处理

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 功能：使用文件字节流实现文件的复制
 * 
 *  记住：使用字节流不仅可以复制文本文件（.txt, .java）,
 *  而且可以复制二进制文件（音频 视频 ....）
 *  使用字节流可以复制所有文件
 *  
 *  doc文件是二进制文件
 * @author Administrator
 *
 */
public class TestCopy3 {

    public static void main(String[] args) {
        InputStream fis = null;
        OutputStream fos = null;
        try{
            //1.创建一个输入流和输出流
            fis = new FileInputStream("e:/JDK_API_1_6_zh_CN.CHM");
            fos = new FileOutputStream("e:/JDK_API_1_6_zh_CN2.CHM");
            //2.使用输入流和输出流完成复制
            //2.1准备一个中转站：水桶
            byte [] buf = new byte[1024];

            //2.2借助循环和中转站完成复制操作
            int len = fis.read(buf); //读取文件的内容到buf数组，返回的真正读取的字节数。文件结束，返回-1
            while(len !=-1){
                //写数组的内容到目的文件
                //fos.write(buf);//写1024
                fos.write(buf, 0, len);
                //再读一次
                len = fis.read(buf);
            }

        }catch(FileNotFoundException e){
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //3.关闭输入流和输出流
            try {
                if(fis != null){
                    fis.close();    
                }       
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fos != null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

文件字符流FileReader和FileWriter

文件字符流只能复制纯文本文件，字节流什么文件都能复制。
使用字符流完成文件的复制：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 使用字符流完成文件的复制
 * 
 * 1.如何区分是汉字还是英文
 *      英文字符一个字节， 第一个字节位是0
 *      汉字字符2个字节，第一个字节位是1
 *    
 * 2.其实只有字节流，没有字符流（字符流的底层使用的还是字节流）
 * 
 *  public FileReader(File file) throws FileNotFoundException {
        super(new FileInputStream(file));
    }

 * 3.字节流可以复制所有类型的文件
 *   字符流只能复制文本文件（记事本打开的文件）
 * 
 * @author Administrator
 *
 */
public class TestCopy3 {

    public static void main(String[] args) {
        Reader  fr = null;
        Writer  fw = null;
        try{
            //1.创建输入流和输出流
            fr = new FileReader(new File("e:/JDK_API_1_6_zh_CN.CHM"));
            fw = new FileWriter(new File("e:/JDK_API_1_6_zh_CN3.CHM"));

            //2.使用输入流和输出流
            //2.1指定一个中转站（一个字符数组）
            char [] cbuf = new char[1024];

            //2.2借助循环和中转站完成复制操作
            int len = fr.read(cbuf);
            while(len != -1){
                //输出
                //System.out.println(cbuf);
                //写
                fw.write(cbuf, 0, len);

                //读
                len = fr.read(cbuf);
            }
        }catch(FileNotFoundException e){
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //3.关闭输入流和输出流
            try {
                if(fr != null){
                    fr.close();
                }               
            } catch (IOException e) {
                e.printStackTrace();
            }

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

        }
    }

}

缓冲字节流BufferedInputStream和BufferedOputStream

BufferedInputStream和BufferedOutputStream
FileInputStream和FileOutputStream是节电流
BufferedInputStream和BufferedOutputStream是处理流（包装流）
读文件和写文件都使用了缓冲区，减少了读写次数，从而提高了效率

当创建这两个缓冲流的对象时时，会创建了内部缓冲数组，缺省使用32字节大小的缓冲区.
当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
当写入数据时，首先写入缓冲区，当缓冲区满时，其中的数据写入所连接的输出流。使用方法flush()可以强制将缓冲区的内容全部写入输出流

关闭流的顺序和打开流的顺序相反.只要关闭高层流即可，关闭高层流其实关闭的底层节点流
Flush的使用：手动将buffer中内容写入文件

功能：使用文件字节流实现文件的复制：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 功能：使用文件字节流实现文件的复制
 * 
 * 总结1：节点流和处理流
 *  节点流 FileInputStream  FileOutputStream 直接和数据源和目的地相连接，不可缺少
 *   处理流  BufferedInputStream  BufferedOutputStream  不直接和数据源和目的地相连接
 *      可以带来其他的好处：提高性能  简化操作
 *  节点流：FileReader  FileWriter
 *  处理流：BufferedReader  BufferedWriter
 * 
 * 总结2：关闭流的时候直接关闭高层流即可，不需要关闭底层流
 * 
 * 总结3：如何刷新输出缓冲区
 *    1.bos.close() 关闭流的时候会同时刷新输出缓冲区
    2.直接刷新  flush()
    3.输出缓冲区满后，自动刷新


 *  总结4：简化创建流的过程  
 * BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("e:/readme.txt")));
 *BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:/readme2.txt"));

 * @author Administrator
 *
 */
public class TestCopy2 {

    public static void main(String[] args) throws IOException {
        //1.创建一个输入流和输出流
//      File file1 = new File("e:/readme.txt");
//      InputStream fis = new FileInputStream(file1);
//      BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("e:/readme.txt")));
//      File file2 = new File("e:/readme2.txt");
//      OutputStream fos = new FileOutputStream(file2);
//      BufferedOutputStream bos = new BufferedOutputStream(fos);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:/readme2.txt"));

        //2.使用输入流和输出流完成复制
        //2.1准备一个中转站：水桶
        byte [] buf = new byte[1024];

        //2.2借助循环和中转站完成复制操作
        int len = bis.read(buf); //读取文件的内容到buf数组，返回的真正读取的字节数。文件结束，返回-1
        while(len !=-1){
            //写数组的内容到目的文件
            //fos.write(buf);//写1024
            bos.write(buf, 0, len);
            //再读一次
            len = bis.read(buf);
        }

        //3.关闭输入流和输出流
        bis.close();
//      //fis.close();
        bos.close();
        //fos.close();
        //bos.flush();

    }
}

这里写图片描述

缓冲字符流BufferedReader和BufferedWriter

BufferedReader
readLine() 读取一个文本行的数据

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

使用缓冲字符流是复制文本文件常用的方式

String str = br.readLine();
while(str != null){
   bw.write(str);
   bw.newLine();
   str = br.readLine();
}

通过按行读取实现文件复制：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 功能：通过按行读取实现文件复制
 * 
 * 思路1：使用字节流还是字符流
 *      使用字符流，对于字节流没有行的概念
 * 
 * 思路2：使用节点流还是处理流
 *      使用处理流
 *      节点流只提供了两种读写的方式
 *      1个字节 或者1个字节数组
 * 
 * BufferedReader和BufferedWriter
 * 好处1：提高了性能
 * 好处2：简化了操作
 * 
 * 注意1：readLine()的底层原理
 *  底层其实还是read(),遇到换行符，转换成字符串
 * 
 * 
 * 注意2：newLine()的底层原理
 *  不同的操作系统中换行符是不同的
 *  window
 *  linux
 *  mac
 *  （2）Windows系统里面，每行结尾是 回车+换行(CR+LF)，即“\r\n”；
（3）Unix系统里，每行结尾只有 换行CR，即“\n”；
（4）Mac系统里，每行结尾是 回车CR 即'\r'。
 * @author Administrator
 *
 */
public class TestCopy {

    public static void main(String[] args) throws IOException {
        //创建输入流和输出流
        BufferedReader br = new BufferedReader(new FileReader(new File("e:/log.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter("e:/log2.txt"));
        //使用输入流和输出流
        String str = br.readLine();
        while(str != null){
            //写一行
            bw.write(str);//只负责写，没有换行
            bw.newLine();//添加一个换行符
            //System.out.println();
            //bw.write("\r");
            //再读一行
            str = br.readLine();
        }       
        //关闭输入流和输出流
        br.close();
        bw.close();

    }

}

转换流InputStreamReader和OutputStreamWriter

InputStreamReader和OutputStreamWriter
为处理流
用于将字节流转化成字符流，字符流与字节流之间的桥梁
InputStreamReader的作用是把InputStream转换成Reader
OutputStreamWriter的作用是把OutputStream转换成Writer

存在将字节流转换成字符流的转换流，因为字符流操作文本更简单
不存在把字符流转换成字节流的转换流，因为没有必要
System.in代表标准输入，即键盘输入，是InputStream的实例

Reader reader = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(reader);
System.out.println("请输入用户名：");
String str = br.readLine();
System.out.println(str);

功能：将从键盘输入的一行行数据复制到一个文件中：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

/**
 * 功能：将从键盘输入的一行行数据复制到一个文件中

 * @author Administrator
 *
 */
public class TestCopy {

    public static void main(String[] args) throws IOException {
        //创建输入流和输出流
        //BufferedReader br = new BufferedReader(new FileReader(new File("e:/log.txt")));
        Scanner input = new Scanner(System.in);
        BufferedWriter bw = new BufferedWriter(new FileWriter("e:/log3.txt"));
        //使用输入流和输出流
        //String str = br.readLine();
        String str = input.nextLine();
        while(!"bye".equals(str)){
            //写一行
            bw.write(str);//只负责写，没有换行
            bw.newLine();//添加一个换行符

            //再读一行
            str = input.nextLine();
        }       
        //关闭输入流和输出流
        //br.close();
        input.close();
        bw.close();

    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

/**
 *功能：将从键盘输入的一行行数据复制到一个文件中
 * 
 * 
 * 转换流
 * 
 * 
 * 1.生活案例
 *  System.in     -----------转换流 -----------  Reader  ---------- BufferedReader（readLine()）
 *  三相插头        -----------（三相的插座）转换头（两相插头）-----------  两相插座
 *  适配器模式（转换器模式）
 *  
 * 2.Java中提供了哪些转换流
 *   InputStreamReader  将InputStream转换成Reader
 *   OutputStreamWriter 将 OutputStream转换成Writer
 *   ReaderInputStream 没有
 *   WriterOutputStream 没有
 *   只有将字节流转换成字符流的转换流
 *   
 * 3.InputStreamReader到底是Reader还是InputStream
 *  InputStreamReader是Reader的一个子类陈
 *   Reader reader = new InputStreamReader(is);
        public class InputStreamReader extends Reader {

        }
 * 4.标准输入输出设备
 *  System.in ：键盘
 *  System.out:显示器
 *  System.err：显示器
 * 
 * @author Administrator
 *
 */
public class TestCopy2 {

    public static void main(String[] args) throws IOException {

        //创建输入流和输出流
        InputStream is = System.in;     
        Reader reader = new InputStreamReader(is);//!!!!!
        BufferedReader br = new BufferedReader(reader);
        BufferedWriter bw = new BufferedWriter(new FileWriter("e:/log2.txt"));
        //使用输入流和输出流
        String str = br.readLine();
        while(!"bye".equals(str)){
            //写一行
            bw.write(str);//只负责写，没有换行
            bw.newLine();//添加一个换行符
            //System.out.println();
            //bw.write("\r");
            //再读一行
            str = br.readLine();
        }       
        //关闭输入流和输出流
        br.close();
        bw.close();

    }

}

打印流PrinterWriter和PrinterStream

PrintStream
PrintStream提供了一系列的print()和println()，可以实现将基本数据类型格式化成字符串输出。对象类型将先调用toString()，然后输出该方法返回的字符串
System.out就是PrintStream的一个实例，代表显示器
System.err 也是PrintStream的一个实例，代表显示器
PrintStream的输出功能非常强大，通常需要输出文本内容，都可以将输出流包装成PrintStream后进行输出
PrintStream的方法都不抛出IOException
PrintWriter
PrintStream的对应字符流，功能相同，方法对应。
PrintWriter的方法也不抛出IOException
复制文件时可以使用PrintWriter代替BufferedWriter完成，更简单
打印流的使用：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.Date;

/**
 * 1.PrintStream和PrintWriter
 *  都是输出流
 *  都是处理流（不是节点流）
 * 
 * 2.System.out是PrintStream的是变量
 * 
 * 3.System.out.println()的强大之处
 *  println()是PrintStream流的方法，
 *  可以将各种基本数据类型（int、double、boolean）和各种引用数据类型（String、Date、Student...）
 * 的数据以【字符串的形式】【直接】写入到目的地中，并且具有换行的功能
 *  直接：不需要转换成字节数组
 *      
 * @author Administrator
 *
 */
public class TestPrintStream {

    public static void main(String[] args) throws FileNotFoundException {
        //PrintStream ps = System.out;
        PrintStream ps = new PrintStream(new FileOutputStream(new File("e:/readme2.txt")));
        PrintStream ps2 = new PrintStream(new File("e:/readme2.txt"));
        PrintStream ps3 = new PrintStream("e:/readme2.txt");

        ps.println(123);//int
        ps.println(3.14);//double
        ps.println(true);//boolean
        ps.println("bjsxt");//String
        ps.println(new Date().toString());


//      System.out.println(123);//int
//      System.out.println(3.14);//double
//      System.out.println(true);//boolean
//      System.out.println("bjsxt");//String
//      System.out.println(new Date().toString());

    }

}



import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
/**
 * 
 * PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("e:/log2.txt")));
 * 
 * FileWriter:节点流  离不开
 * 
 * BufferedWriter() 处理流   带缓冲可以提高效率
 * 
 * PrintWriter  处理流   操作方法，直接输出还带换行
 * 
 * 装饰模式  继承的一种替代方案
 * @author Administrator
 *
 */
public class TestPrintWriter {

    public static void main(String[] args) throws Exception{
        //创建输入流和输出流
        BufferedReader br = new BufferedReader(new FileReader(new File("e:/log.txt")));
        //BufferedWriter bw = new BufferedWriter(new FileWriter("e:/log2.txt"));
        //PrintWriter pw = new PrintWriter(new FileWriter("e:/log2.txt"));
        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("e:/log2.txt")));
        //使用输入流和输出流
        String str = br.readLine();
        while(str != null){
            //写一行
            pw.println(str);
            //再读一行
            str = br.readLine();
        }       
        //关闭输入流和输出流
        br.close();
        pw.close();



        PrintWriter pw2 = new PrintWriter(new FileOutputStream(new File("e:/log2.txt")));
        PrintWriter pw3 = new PrintWriter("e:/log2.txt");
        PrintWriter pw4 = new PrintWriter(new File("e:/log2.txt"));
    }

}

小结

File类
IO流的原理
IO流的分类
文件流
缓冲流
转换流
打印流

编码题练习：
1.复制文件夹d:/sxtjava下面所有文件和子文件夹内容到d:/sxtjava2。
提示：涉及单个文件复制、目录的创建、递归的使用

import java.io.*;

public class TestCopyDir3 {

    public static void main(String[] args) {        
        //copyFile("e:/readme.txt","e:/readme2.txt");
        copyDir("e:/406sxt","e:/406sxt2");
    }

    public static void copyDir(String ssourceDir,String sdestDir){
        //创建一个空的目的文件夹
        File destDir = new File(sdestDir);
        if(!destDir.exists()){
            destDir.mkdir();
        }
        //得到源文件夹下的所有文件并复制到目的文件夹
        File sourceDir = new File(ssourceDir);
        File [] files = sourceDir.listFiles();//不仅有文件，还有目录
        for(File f :files){
            if(f.isFile()){
                //复制  copyFile("e:/406sxt/log.txt","e:/406sxt2/log.txt");
                // copyFile("e:/406sxt/readme.txt","e:/406sxt2/readme.txt");
                copyFile(ssourceDir+"/"+f.getName(),sdestDir+"/"+f.getName());
            }
            if(f.isDirectory()){
                //copyDir("e:/406sxt/20171215-IO流","e:/406sxt2/20171215-IO流");
                copyDir(ssourceDir+"/"+f.getName(),sdestDir+"/"+f.getName());
            }
        }
    }

    public static void copyFile(String sourceFile,String destFile){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try{
            //1.创建一个输入流和输出流
            File file1 = new File(sourceFile);
            InputStream fis = new FileInputStream(file1);
            bis = new BufferedInputStream(fis);

            File file2 = new File(destFile);
            OutputStream fos = new FileOutputStream(file2);
            bos = new BufferedOutputStream(fos);


            //2.使用输入流和输出流完成复制
            //2.1准备一个中转站：水桶
            byte [] buf = new byte[1024];

            //2.2借助循环和中转站完成复制操作
            int len = bis.read(buf); //读取文件的内容到buf数组，返回的真正读取的字节数。文件结束，返回-1
            while(len !=-1){
                //写数组的内容到目的文件
                //fos.write(buf);//写1024
                bos.write(buf, 0, len);
                //再读一次
                len = bis.read(buf);
            }
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //3.关闭输入流和输出流
            try {
                if(bis != null){
                    bis.close();
                }               
            } catch (IOException e) {
                e.printStackTrace();
            }       
            try {
                if(bos != null){
                    bos.close();
                }               
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}