字节流相关操作，基本字节流的Copy文件

package OneStage.OneStageG.IObetyBuff;
/*
IO流：实质就是用来处理设备间传输数据的问题：
     文件的复制，文件上传，下载（硬盘与内存之间数据传输问题）
     输入：读数据，指把硬盘上的数据，读到内存中
     输出：写数据，指把内存中的数据，写到硬盘中
IO流的分类（根据数据类型来分）：字节流，字符流
     字节流：字节输入流和字符输出流 （最底层的流，万用流）
     字符流：字符输入流和字符输出流 （主要是操作文本文件，用记事本打开可以用看懂的）
一. 字节流的相关操作
    字节流抽象基类：
    InputStream: 字节流的输入流抽象超类 eg:子类 FileInputStream
    outputStream:字节流的输出流抽象超类 eg:子类 FileOutputStream

 */

import java.io.*;

public class IODemoA {
    public static void main(String[] args) throws IOException {
        //定义一个文件路径
        String pathAndNane = "JavaOfBase\\src\\OneStage\\OneStageG\\IObetyBuff\\text.txt";
        //定义一个文件对象
        File test2File = new File("JavaOfBase\\src\\OneStage\\OneStageG\\IObetyBuff\\test2.txt");
        File test3File = new File("JavaOfBase\\src\\OneStage\\OneStageG\\IObetyBuff\\test3.txt");
        /*
        创建字节流输出对象，并关联到指定的文件，如果这个方法不存在，就按字符串内容创建文件
        FileOutputStream(String ss) 第一种构造方式 传字符串
        FileOutputStream(File ff) 第二种构造方式 传文件对象 （规范）
        FileOutputStream(test3File, true);第三种构造方法，让文件可以追加写入，参数值为：true
         */
        FileOutputStream testFOS = new FileOutputStream(pathAndNane);
        FileOutputStream test2FOS = new FileOutputStream(test2File);
        FileOutputStream test3FOS = new FileOutputStream(test3File, true);
        //调用write(int b ),write(byte[] b),write(byte[] int off,int len)方法写入数据
        testFOS.write(97);
        testFOS.write(98);
        byte[] b = {97,98,99,100,101};
        byte[] bys = "EFGHKLMN".getBytes();
        test2FOS.write(b);
        test2FOS.write(bys);
        test2FOS.write(bys,2,4);
        /*
        向文件写入数据的时候，换行的处理，不同的操作系统，对换行符的标识是不一样的
        windows：\r\n, Linux:\n, Mac:\r
         */
        test2FOS.write("\r\n".getBytes());
        test2FOS.write("我爱Java".getBytes());
        /*
        文件追加写入数据
        FileOutputStream(test3File, true);第三种构造方法，让文件可以追加写入，参数值为：true
         */
        test3FOS.write("我在学习Java".getBytes());
        test3FOS.write("\r\n".getBytes());
        //☆ 关闭释放资源 让与此流相关的操作全部断开，其它的程序才可以访问这些文件
        testFOS.close();
        test2FOS.close();
        test3FOS.close();

    }
}

 字节流，读取文件

 /*
字节流读取数据方法
 */
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class IODemoB {
    public static void main(String[] args) throws IOException {
    //声名读取文件的路径和名称
    String path = "JavaOfBase\\src\\OneStage\\OneStageG\\IObetyBuff\\readDemo.txt";
    //定义文件对象
        File pathAndName = new File(path);
        FileInputStream fileInp = new FileInputStream(pathAndName);
        /*
          read()返回为什么是int 因为是字节读取，所以底层是整数，一次只读一个字节
          当读取到没有字符的时候，返回-1，这样可以用来判断是否读到文件尾,可以做循环遍历
         */
        int readByte ;
        /*
        fileInp.read() 读取数据
        readByte=fileInp.read() 赋值操作
        对返回的值做了判断
         */
        while ((readByte=fileInp.read())!=-1){
            System.out.print((char)readByte);
        }
        //关闭字节文件读取流
        fileInp.close();

    }
}
-------一次读一个字节数组数据------
 public class ReadByByteArray {
    public static void main(String[] args) throws IOException {
        //定义一个文件路径
        String filePath = "JavaOfBase\\src\\OneStage\\OneStageG\\IObetyBuff\\text.txt";
        //生成文件对象
        File srcFile = new File(filePath);
        //构造一个读取文件流
        FileInputStream srcFileStream = new FileInputStream(srcFile);
        //定义一个接收的字节数组
        byte[] bysTemp = new byte[1024];
        /*
        /获得读取数据的长度
        // int len = srcFileStream.read(bysTemp);
        len:返回的是读取到的字节长度，当没读取到数据时，就返回-1，这个可以用来判断数据是否读完了
         */
        int len;
        while ((len =srcFileStream.read(bysTemp))!=-1){
            System.out.println(len);
            //调用String（）中的方法，将字节转化成字符
            String contTemp = new String(bysTemp);
            System.out.print(contTemp);
        }
        //关闭流
        srcFileStream.close();
    }
}

-----字节缓冲流，读写文件-------

 

/*
字节缓冲输出流：ufferedOutputStream 基于字节流对象，创建一个缓冲区，将件多次写入缓冲区中，然后利用字节流对象调用底层对象方法写入字节，
             不必每个字节调用底层的方法，提高效率
 字节缓冲输入流：BufferedInputStream 基于字节流对象，创建一个缓冲区数组，一次性多读多个字节，读取效率高。
 */

public class BetyBuffStreamDemo {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        //申明文件路径
        String srcPath = "JavaOfBase\\src\\OneStage\\OneStageG\\IObetyBuff\\jdk9.CHM";
        String decPath="JavaOfBase\\src\\OneStage\\OneStageF\\jdk9.CHM";
        //创建文件对象
        File srcFile = new File(srcPath);
        File decFile = new File(decPath);
        //创建文件流对象
        FileInputStream srcInputStream = new FileInputStream(srcFile);
        FileOutputStream decOutputStream = new FileOutputStream(decFile);
        //创建字节缓冲流对象
        BufferedInputStream srcBuffInputStream = new BufferedInputStream(srcInputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(decOutputStream);
        //定义一个数组大小 缓冲区大小
        byte[] bys = new byte[1024];
        //定义一个读写数据结尾的标记
        int flagLen;
        //边读数据，边写数据
        while ((flagLen=srcBuffInputStream.read(bys,0,bys.length))!=-1){
            decOutputStream.write(bys,0,bys.length);
        }
        //关闭字节缓冲流
        srcBuffInputStream.close();
        bufferedOutputStream.close();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}