Java学习【阶段一[10】IO（02 字节流）

package Xuexi.demo06.IO;

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

/*
    java.io.OutputStream:字节输出流。此抽象类是表示输出字节流的所有类的超类。

    定义了一些子类共性的成员方法：
    void close() 关闭此输出流并释放与此流有关的所有系统资源。
    void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
    void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
    void write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
    abstract void write(int b) 将指定的字节写入此输出流。

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

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

     写入数据的原理（内存到硬盘）
     java成-->JVM-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中

     字节输出流的使用步骤（重点）：
     1、创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
     2、调用FileOutputStream对象中的方法write，把数据写入到文件中
     3、释放资源（流使用会占用一定内存，使用完毕要清空内存，提供程序效率）

 */
public class Demo01OutputStream {
    public static void main(String[] args)throws IOException {
        //1、创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos=new FileOutputStream("09\\a.txt");
       // 2、调用FileOutputStream对象中的方法write，把数据写入到文件中
        fos.write(97);
        //3、释放资源（流使用会占用一定内存，使用完毕要清空内存，提供程序效率）
        fos.close();
    }
}

 2、一次写多个字节流的方法

package Xuexi.demo06.IO;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.Arrays;

/*
    一次写多个字节的方法：
        -public void write(byte[] b);将 b.length字节从指定的字节数组写入此输出流。
        -public void write(byte[] b,int off,int len):从指定的字节数组写入len字节，从偏移量off 开始输出到此输出流
 */
public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //创建FileOutputStream对象，构造方法中绑定要写入数据的目的地
        FileOutputStream fos=new FileOutputStream(new File("09\\b.txt"));
        //调用FileOutputStream对象中的方法write，把数据写到文件中
        //在文件中显示100，写3个字节
        fos.write(49);
        fos.write(48);
        fos.write(48);
        /*
            public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
            一次写多个字节：
                如果写的第一个字节是正数（0-127），那么显示的时候会查询ASCII表
                如果写的第一个字节是负数，那么第一个字节和第二个字节两个字节组成一个中文显示，查询系统默认码表（GBK）
         */
        byte[]btes={65,66,67,68,69};//ABCDE
        fos.write(btes);
        /*
         -public void write(byte[] b,int off,int len):把字节数组的一部分写入文件
         int off:字节的开始索引
         int len:写几个字节
         从指定的字节数组写入len字节，从偏移量off 开始输出到此输出流
         */
        fos.write(btes,1,2);//BC
        /*
            写入字符的方法：可以使用String类中的方法把字符串转化为字节数组
            byte[] getBytes()把字符串转换为字节数组
         */
        byte[]bytes2="你好".getBytes();
        System.out.println(Arrays.toString(bytes2));//[-28, -67, -96, -27, -91, -67]
        fos.write(bytes2);
        //释放资源
        fos.close();

    }
}

3、字节输出流的续写和换行

package Xuexi.demo06.IO;

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

/*
    追加写/续写：使用两个参数的构造方法
    FileOutputStream(File file, boolean append)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流
    参数：
        String name,File file:写入数据的目的地
        boolean append：追加写开关 true:创建对象不会覆盖原文件，继续在文件的末尾追加写数据
        false：创建一个新文件，覆盖原文件
     写换行：写换行符号
     windows:\r\n
     linux:/n
     mac:/r
 */
public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("09\\c.txt",true);
        for (int i = 0; i <=10 ; i++) {
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

package Xuexi.demo06.IO;

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：文件字节输入流
        作用：把硬盘文件中的数据读取到内存中使用

        构造方法：
            FileInputStream(String name)
            FileInputStream(File file)
            参数：读取文件的数据源
            String name：文件路径
            File file：文件
            构造方法的作用：
            1、会创建一个 FileInputStream对象
            2、会把 FileInputStream对象指定构造方法要读取的文件

            读取数据的原理
             硬盘到内存
             java程序-->JVM-->OS-->OS读取数据的方法-->读取文件
             使用步骤：
             1、创建 FileInputStream对象，构造方法要绑定要读取的数据源
             2、使用 FileInputStream对象中的方法read读取文件
             3、释放资源
             */
public class Demo01InputStream {
    public static void main(String[] args) throws IOException {

       // 1、创建 FileInputStream对象，构造方法要绑定要读取的数据源
        FileInputStream fis=new FileInputStream("09\\a.txt");
        //2、使用 FileInputStream对象中的方法read读取文件
        //int read()从输入流中读取数据的下一个字节。读取到文件末尾返回-1
        int len=fis.read();
        System.out.println(len);//97 a

        len=fis.read();
        System.out.println(len);//98 b

        len=fis.read();
        System.out.println(len);//99 c

        len=fis.read();
        System.out.println(len);//-1

       
       /*
            读取文件是一个重复过程，使用循环优化
            while循环结束条件，读取到-1结束

            布尔表达式(len =fis.read())!=-1
            1、fis.read（）读取一个字节
            2、len=fis.read()：把读取字节赋值给len
            3、判断变量len是否不等于-1
        */
       int len1=0;//记录读取到的字节
        while ((len1 =fis.read())!=-1){
            System.out.println((char)len1);
        }
        //3、释放资源
        fis.close();
    }
}