OutputStream-InputStream-FileOutputStream-FileInputStream-BufferedOutputStream-BufferedInputStream-四种复制方式-单层文件夹复制

    字节流两套:
         java.lang.Object--java.io.OutputStream--java.io.FileOutputStream
         java.lang.Object--java.io.InputStream--java.io.FileInputStream
==================================================================
一.OutputStream 抽象类(java.io) 字节输出流
     概述:OutputStream 类就是专门用于从程序中将数据写入到介质中;
     定义:public abstract class OutputStream extends Object implements Closeable, Flushable
         OutputStream 类:此抽象类是表示输出字节流的所有类的超类。
     Direct Known Subclasses:FileOutputStream,PipedOutputStream
     注意:io流不能操作文件夹(文件夹中当然不能直接写内容!!!)
             操作的最小单位是bit(位)
             存储的最小单位是byte(字节)
             1byte = 8 bit
     构造方法:OutputStream()
     常用方法:
         public void close() throws IOException{}: 关闭流
         public void flush() throws IOException{}: 刷新流
         public void write(byte[] b) throws IOException{}:-->输出流对象
         public void write(byte[] b, int off, int len) throws IOException{}:-->输出流对象
     抽象方法: public abstract write(int b):(抽象方法) -->输出流对象

二.FileOutputStream 类(java.io)字节输出流的子类
     概述:OutputStream 常用子类; 
     构造方法:该类使用构造方法时,可直接创建文件,若文件存在则直接覆盖,想要不被覆盖,构造时传入参数(true);
         FileOutputStream(String name) throws FileNotFoundException:创建一个向具有指定名称的文件中写入数据的输出文件流。
                                     Name 表示一个文件的路径,可以是相对的也可以是绝对的!
         FileOutputStream(File file) throws FileNotFoundException:创建一个向指定 File 对象表示的文件中写入数据的文件输出流.
         续写:
             FileOutputStream(File file, boolean append) throws FileNotFoundException:创建一个向指定 File 对象表示的文件中写入数据的文件输出流
                                                         需要传递append的值为:true即可,则不覆盖已存在文件,而是在文件后续写;
             FileOutputStream(String name, boolean append)throws FileNotFoundException:创建一个向具有指定 name 的文件中写入数据的输出文件流。
         换行:
             使用字符流的时候,可以直接写入:“ ”;
             使用字节流的时候,需要写入“ ”的字节数组;
     常用方法:
         public void write(byte[] b) throws IOException{}: b.length 个字节从指定 byte 数组写入此文件输出流中。
         public void write(byte[] b, int off, int len) throws IOException{}:将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
         public void write (int b) throws IOException{}:将指定字节个数写入此文件输出流.
         public void close() throws IOException{}:关闭此文件输出流并释放与此流有关的所有系统资源。

        继承OutputStream抽象类的flush()方法

        String 类的一个常用方法:
             public byte[] getBytes(){}:使用平台的默认字符集将此 String 拆分为 byte 序列，并将结果存储到一个新的 byte 数组中。
======================================================================
         java.lang.Object--java.io.InputStream--java.io.FileInputStream
======================================================================
三.InputStream 抽象类(java.io) 字节输入流
     定义:public abstract class InputStream extends Object implements Closeable
     概述:InputStream 此抽象类是表示字节输入流的所有类的超类。
     Direct Known Subclasses:FileInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream
     抽象方法:
         public abstract int read() throws IOException:
     常用方法:
         public int read(byte[] b)  throws IOException{}:读取字节数组;
         public int read(byte[] b, int off, int len) throws IOException{}:读取部分字节数组;
         public void close() throws IOException{}:关闭流;

四.FileInputStream 类(java.io) 字节输入流的子类
     概述:InputStream 类的常用子类;FileInputStream 类是专门用于从文件中读取字节数据的流,读取到的内容以十进制的数据的形式返回;
         如果想要将十进制的数据转换成对应的字符,需要程序员对照码表转换;
         具体转换方式有2种:
             1:直接强转成char类型的字符;(适用于一个数字)
             2:使用String类的构造方法;(适用于一个或多个数字)
     构造方法:
         FileInputStream(String name) throws FileNotFoundException:通过打开一个到实际文件的连接来创建一个 FileInputStream，
                                     该文件通过文件系统中的路径名 name 指定。
         FileInputStream(File file) throws FileNotFoundException:通过打开一个到实际文件的连接来创建一个 FileInputStream，
                                     该文件通过文件系统中的 File 对象 file 指定。
     常用方法:
         public int read() throws IOException {}:从此输入流中读取一个数据字节。返回的是读取到的这个字节的码值!
         public int read(byte[] b) throws IOException {}:从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。返回的是读取到的字节的个数!
         public int read(byte[] b, int off, int len) throws IOException {}:从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。返回的是读取到的字节的个数!
         public void close() throws IOException{}:关闭此文件输入流并释放与此流有关的所有系统资源。
====================================================================
     高效字节流两套:
         java.lang.Object--java.io.OutputStream--java.io.FilterOutputStream--java.io.BufferedOutputStream
         java.lang.Object--java.io.InputStream--java.io.FilterInputStream--java.io.BufferedInputStream
==================================================================
五.BufferedOutputStream 类(java.io)
     定义:public class BufferedOutputStream extends FilterOutputStream
         属于OutputStream的孙子类
     构造方法:BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
     常用方法:
         public void flush() throws IOException{}:
         public void write(byte[] b, int off, int len) throws IOException{}:
         public void write(int b) throws IOException{}:

        继承自FilterOutputStream的close()方法;

六.BufferedInputStream 类(java.io)
     定义:public class BufferedInputStream extends FilterInputStream
     构造方法:BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流in，以便将来使用。
     常用方法:
         public void close() throws IOException{}:关闭流;
         public int read() throws IOException{}:读取;
         public int read(byte[] b, int off, int len) throws IOException{}:以字节数组形式读取;

=============================================================
七.四种方式复制文件:
1:高效字节流加数组

//1:高效流加数组,复制"E:\JAVAPractice\IO\1.jpg"
 import java.io.BufferedInputStream;
 import java.io.FileInputStream;
 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 public class Copy01{
     public static void main(String[] args) throws IOException{
         //抓取开始时间
        long t1 = System.currentTimeMillis();
         //创建高效流
        BufferedInputStream bin = new BufferedInputStream(new FileInputStream("E:\JAVAPractice\IO\1.jpg"));
         BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("E:\JAVAPractice\IO\1_1.jpg"));
         //定义字节数组存储读取内容
        byte[] b = new byte[1024];
         int i = -1;//读取到的字节个数
        while((i = bin.read(b)) != -1){
             bout.write(b,0,i);
             bout.flush();
         }
         bout.close();
         bin.close();
         //抓取程序结束时间
        long t2 = System.currentTimeMillis();
        System.out.println("耗时:"+(t2-t1)/1000.0);//耗时:0.25
     }
 }

2:基本字节流加数组

//2:基本流加数组,复制"E:\JAVAPractice\IO\1.jpg
 import java.io.FileOutputStream;
 import java.io.FileInputStream;
 import java.io.IOException;
 public class Copy02{
     public static void main(String[] args) throws IOException{
         //记录程序开始时间
        long t1 = System.currentTimeMillis();
         //创建基本字节流对象
        FileInputStream in = new FileInputStream("E:\JAVAPractice\IO\1.jpg");
         FileOutputStream out = new FileOutputStream("E:\JAVAPractice\IO\1_2.jpg");
         //定义数组存储读取到的数据
        byte[] b = new byte[1024];
         int i = -1;//读取到的字节个数
        while((i = in.read(b)) != -1){
             out.write(b,0,i);
             out.flush();
         }
         //关闭流
        in.close();
         out.close();
         //记录程序结束时间
        long t2 = System.currentTimeMillis();
         System.out.println("耗时:"+(t2-t1)/1000.0);//耗时:0.344
     }
 }

3:高效字节流逐字节

//3:高效流逐字节,复制"E:\JAVAPractice\IO\1.jpg
 import java.io.BufferedInputStream;
 import java.io.FileInputStream;
 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 public class Copy03{
     public static void main(String[] args) throws IOException{
         //记录系统时间
        long t1 = System.currentTimeMillis();
         //创建高效字符流
        BufferedInputStream bin = new BufferedInputStream(new FileInputStream("E:\JAVAPractice\IO\1.jpg"));
         BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("E:\JAVAPractice\IO\1_3.jpg"));
         //定义i为ASCII码值
        int i = -1;
         while((i = bin.read()) != -1){
             bout.write(i);
         }
         //关闭流
        bin.close();
         bout.close();
         //记录系统时间
        long t2 = System.currentTimeMillis();
         System.out.println("耗时:"+(t2-t1)/1000.0);//耗时:0.625
     }
 }

4:基本字节流逐字节复制

//4:基本流逐字节复制,E:\JAVAPractice\IO\1.jpg
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 public class Copy04{
     public  static void main(String[] args) throws IOException{
         //记录系统时间
        long t1 = System.currentTimeMillis();
         //创建基本字节流对象
        FileInputStream in = new FileInputStream("E:\JAVAPractice\IO\1.jpg");
         FileOutputStream out = new FileOutputStream("E:\JAVAPractice\IO\1_4.jpg");
         //定义不在ASCII码值范围内的i
         int i = -1;
         while((i = in.read()) != -1){
             out.write(i);
             out.flush();
         }
         //关闭流
        out.close();
         in.close();
         //记录系统时间
        long t2 = System.currentTimeMillis();
         System.out.println("耗时:"+(t2-t1)/1000.0);//耗时:52.383
     }
 }

===============================
八.单层文件夹复制

//复制E:\JAVAPractice\IO\demo该单层文件夹下所有txt格式文件
import java.io.File;
 import java.io.IOException;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 public class DirCopy{
     public static void main(String[] args) throws IOException{
         //创建源文件夹对象
        File src = new File("E:\JAVAPractice\IO\demo");
         //创建目标文件夹对象
        File dest = new File("E:\JAVAPractice\IO\democopy");
         dest.mkdir();
         //获取源文件夹中所有对象
        File[] files = src.listFiles();
         //迭代
        for(File f : files){
            //将所有文件包装成输入流对象
            FileInputStream in = new FileInputStream(f);
             //i表示读取的字节数
            int i = -1;
             byte[] b = new byte[1024];
             //准备输出流对象
            File fileOut = new File(dest,f.getName());
             FileOutputStream out = new FileOutputStream(fileOut);
             while((i = in.read(b)) != -1){
                 out.write(b,0,i);
                 out.flush();
             }
             out.close();//out在foreach内定义,所以在foreach内关闭
            in.close();//同上
        }
         System.out.println("操作完成");
     }
 }

多层文件夹复制--递归调用???