（java总结）IO字节流

package Demo43;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

/**
java.io.OutPutStream: 字节输出流
*/
/*

 此抽象是表示输出字节流的所有超类。
定义了一些类共性的成员方法：
    public void close()：关闭此输出流并释放与此流相关的任何资源
    public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出
    public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
    public void write(byte[] b, int off, int len)：从指定的字节数组写入len字节，从偏移量off开始输出到此流
    public abstract void write(int b)：将指定的字节输出流

java.io.FileOutputStream 继承 OutputStream
FileOutputStream:文件字节输出流
作用：把内存中的数据写入硬盘文件中

构造方法：
    FileOutputStream(String name):创建一个向具有指定name的文件中写入数据的输出文件流
    FileOutputStream(File file):创建一个向File对象的文件中写入数据的输出文件流
    参数：String name：目的地是一个文件的路径
         File file：目的地是一个文件
    作用：
        1、创建一个FileOutputStream对象
        2、会根据构造方法中传递的文件/文件路径，创建一个空的文件
        3、会把FileOutputStream对象指向创建的文件

写入数据的原理(内存->硬盘)
    java程序 -->JVM(java虚拟机) -->OS(操作系统) -->OS调用写数据的方法 -->把数据写入文件中

字节输出流的使用步骤：
        1、创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        2、调用FileOutputStream对象中的方法write，把数据写入文件中
        3、释放资源

 */
public class DemoOutPutStream {
    public static void main(String[] args) throws IOException {
        //创建一个FileOutputStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream fos = new FileOutputStream("E:\\hadoop\\iol\\a.txt");
        //调用FIleOutputStream对象中的方法write，把数据写入文件中
        // public abstract void write(int b)：将指定的字节写入输出流
        fos.write(97);
        fos.close();

        //创建FIleOutputStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream foss = new FileOutputStream(new File("E:\\hadoop\\iol\\b.txt"));
       //调用FIleOutputStream对象中的方法write，把数据写入文件中
        //在文件中显示100
        foss.write(49);
        foss.write(48);
        foss.write(48);

      /*
        public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
        一次写入多个字节：
            如果写的第一个字节是正数(0-127),那么现实的时候会查询ASCII表
            如果写的第一个字节是负数，那么第一个字节和第二个字节，两个字节组成一个中文显示，查询系统默认编码表(GBK)
       */
      byte[] byes = {65,66,67,68,69};
      foss.write(byes);

      /*
        public void write(byte[] b, int off, int len)：
                    int off:数组的开始索引
                    int len：写几个字节
        从指定的字节数组写入len字节，从偏移量off开始输出到此流
       */
      foss.write(byes,1,2);

      /*
      写入字符的方法：可以使用String类中的方法把字符串转换为字节数组
            byte[] getBytes() 把字符串转换为字节数组
       */
        byte[] bytes = "你好".getBytes();
        System.out.println(Arrays.toString(bytes));
        foss.write(bytes);

        fos.close();
    }
}

package Demo43;

import java.io.FileOutputStream;
import java.io.IOException;

/*
追加/续写：使用俩个参数的构造方法
    FileOutputStream(String name, boolean append)创建一个向具有指定name的文件中写入数据的输出文件流
    FileOutputStream(File file, boolean append)创建一个向File对象的文件中写入数据的输出文件流
    参数：
        String name    File file：写入数据的目的地
        boolean append：追加写开关
        false：创建一个心得文件，覆盖源文件
        true：会追加在文件末尾

    写换行：写换行符号
        windows:\r\n
        linux:/n
        mac:/r



 */
public class DemoOutputStream01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("E:\\hadoop\\iol\\a.txt",true);
        for (int i = 0; i < 10; i++) {
            fos.write("你好".getBytes());
            //   写换行：写换行符号
            fos.write("\r\n".getBytes());
        }

        fos.close();
    }
}

package Demo43;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * java.io.InputStream: 字节输入流
 * 所有输入流的超类
 */
/*
方法：
    int read()从输入流中读取数据的下一个字节
    int read(byte[] b)从输入流中读取一定数量的字节，将其存储在缓冲区数组b中
    void close() 关闭资源并释放

    java.io.FileInputStream extends InputStream
    文件字节输入流，
    作用：将硬盘文件中的数据读取到内存中

    构造方法：
        FileInputStream(String name)
        FileInputStream(File file)
        参数：String name：文件的路径
             File file：文件

      读数据的原理(内存->硬盘)
    java程序 -->JVM(java虚拟机) -->OS(操作系统) -->OS调用读数据的方法 -->读取文件

    字节输入流的使用步骤：
        1、创建FileInputStream对象，构造方法中绑定要读取的数据源
        2、使用FIleInputStream对象中的方法read，读取文件
        3、释放资源
 */
public class DemoInputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fils = new FileInputStream("E:\\hadoop\\iol\\a.txt");
        int len = 0;

        //len=fils.read())!=-1
        //如果直接写fils.read!=-1,则 只能输出最后一次
        while((len=fils.read())!=-1){
            System.out.println(len);
        }




        fils.close();
    }
}

package Demo43;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

/*
字节流一次读取多个字节的方法：
    int read(byte[] b)从输入流中读取一定数量的字节，将其存储在缓冲区数组b中
    明确两件事：
        1、方法的参数byte[]的作用
            起到缓冲作用，存储每次读取到的多个字节
            数组的长度一般定义为1024(1kb)或者1024的整数倍
        2、方法的返回值int是什么
            每次读取的有效字节个数

    String类的构造方法
        String(byte[] bytes):把字节数组转换成为字符串
        String(byte[] bytes, int offset, int length):把字节数组的一部分转换成为字符串，offset: 数组的开始所以，length：转换的字节个数
 */
public class DemoInputStream01 {
    public static void main(String[] args) throws IOException {
        FileInputStream file = new FileInputStream("E:\\hadoop\\iol\\a.txt");
        //数组具有缓冲的作用，一次读取两个
//        byte[] bytes = new byte[2];
//        int len = file.read(bytes);
//        System.out.println(len);
//        System.out.println(Arrays.toString(bytes));

        byte[] bytes1 = new byte[1024];//存储读取到的多个字节
        int len = 0;
        while((len =file.read(bytes1))!=-1){
            System.out.println(new String(bytes1,0,len));
        }

        file.close();
    }
}

package Demo43;

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

/*
文件的复制练习：一读一写
明确：
    数据源：
    数据源目的地

文件复制的步骤：
    1、创建一个字节输入流对象，构造方法中绑定要读取的数据源
    2、创建一个字节输出流对象，构造方法中药绑定要写入的目的地
    3、使用字节输入流对象中的方法read读取文件
    4、使用字节输出流中的方法write，把读取到的字节写入目的地
    5、释放资源
 */
public class DemoCopyFile {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        //    1、创建一个字节输入流对象，构造方法中绑定要读取的数据源
        FileInputStream files = new FileInputStream("E:\\hadoop\\testfile\\ceshi.jpg");
        //    2、创建一个字节输出流对象，构造方法中药绑定要写入的目的地
        FileOutputStream files1 = new FileOutputStream("E:\\hadoop\\testfile\\testfile1\\ceshi.jpg");
        //   3、使用字节输入流对象中的方法read读取文件

       //这种方法依稀只能一次读取一个字节
//        int len =0;
//        while((len = files.read())!=-1){
//            //4、使用字节输出流中的方法write，把读取到的字节写入目的地
//            files1.write(len);
//        }

        //使用数组缓冲读取多个字节
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len=files.read(bytes))!=-1){
            files1.write(bytes,0,len);
        }


        //5、释放资源
        //先关闭写的，在关闭读的
        files1.close();
        files.close();
        long end = System.currentTimeMillis();
        System.out.println("复制图片共用了" + (end-start) + "毫秒");
    }
}