6_IO流操作

java.io.InputStream:所有字节输入流的超类,其中定义了读取数据的方法

int read()：读取一个字节，返回的int值低8位为读取的数据。如果返回值为整数-1则表示读取到了
流的末尾

int read(byte[] data)：块读取，最多读取data数组总长度的数据并从数组第一个位置开始存入到
数组中，返回值表示实际读取到的字节量，如果返回值为-1表示本次没有读取到任何数据，是流的末尾。

java.io.OutputStream:所有字节输出流的超类,其中定义了写出数据的方法

void write(int d)：向文件中写入一个字节，写入的是int值2进制的低八位。
void write(byte[] data)：向文件中块写数据。将数组data中所有字节一次性写入文件。
void write(byte[] data,int off,int len)：向文件中快写数据。将数组data中从下标off开始的连
续len个字节一次性写入文件。

File 文件

文件输出流: java.io.FileOutputStream

文件输入流： java.io.FileInputStream

程序----->文件 输出流
文件----->程序 输入流

可以这样理解：输入流

输入流每次读取读取的是一个字节，用int 接收低八位来存，

但是每次只能读取一个字节，这是就用到了循环读取，读取不到返回-1

但是这样效率低，我们就想到了块读写，先建好一个存储空间，空间存满之后进行写出

类似搬砖，两地100米距离，我需要从A点运到B点，没有工具 我一次只能搬一块砖

第二天学聪明了，买了个车，一次能运100块，这一次是不是快了，这里的车就是你的储存空间

//记住节点流，低级流，所有的处理都是建立在这个基础上的
//在main方法里面写

//1.往文件写 用到的是 输出流
FileOutputStream fos = new FileOutputStream("fos.dat");
fos.write(1);
fos.write(5);
System.out.println("写出完毕!");
//注意！流使用完毕后要关闭，来释放底层资源
fos.close();

=========================================================================================
//2.从文件读 用到的是 输入流    一次读取一个字节，一个字节8位，如果没有返回-1
FileInputStream fis = new FileInputStream("fos.dat");
int d = fis.read();
System.out.println(d);
fis.close();
-------------------------------------------------------------------------------------------


//文件复制

package 文件;

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

public class 文件复制 {
    public static void main(String[] args) throws IOException {

        FileInputStream  fis = new FileInputStream("11.jpg");
        FileOutputStream fos = new FileOutputStream("22.jpg");

        int d ;
        while ((d = fis.read()) != -1){
            fos.write(d);
        }

        fis.close();
        fos.close();


    }

}

//了解
//块读写复制
package 文件;

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

public class 文件复制 {
    public static void main(String[] args) throws IOException {

        FileInputStream  fis = new FileInputStream("11.jpg");
        FileOutputStream fos = new FileOutputStream("22.jpg");

        //设置大小相当于一次读写的大小
        byte[] buf = new byte[1024 * 10];//10kb 
        int len;//记录每次实际读取到的字节数
        
        while ((len = fis.read(buf)) != -1) {
        fos.write(buf, 0, len);
        }

        fis.close();
        fos.close();


    }

}

写文本数据 ：和上面差不多

但是你要将文本数据转换成字节才能储存

String提供方法: byte[] getBytes(String charsetName) 将当前字符串转换为一组字节

//写入文件
FileOutputStream fos = new FileOutputStream("fos.txt",true);
String line = "你好你好，美丽的姑娘";
byte[] data = line.getBytes(StandardCharsets.UTF_8);
fos.write(data);
fos.close();

//读取文件，块读取
FileInputStream fis = new FileInputStream("fos.txt");
byte[] data = new byte[1024];//1kb
int len = fis.read(data);//块读操作，返回值表达实际读取到了多少字节
System.out.println("实际读取了:"+len+"个字节");

String line = new String(data,0,len,StandardCharsets.UTF_8);
System.out.println(line.length());//输出字符串长度
System.out.println(line);
fis.close();

缓冲流
java.io.BufferedOutputStream和BufferedInputStream.

//不需要自己买车了，老板送车，你会开就行
FileInputStream fis = new FileInputStream("ppt.pptx");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("ppt_cp.pptx");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int d;

while((d = bis.read())!=-1){//使用缓冲流读取字节
bos.write(d);//使用缓冲流写出字节
}

bis.close();//关闭流时只需要关闭高级流即可，它会自动关闭它连接的流
bos.close();

程序到文件

flush();//冲

BufferedOutputStream的问题 ----------缓冲输出流写出数据时的缓冲区问题

就像老板给你买了一辆车，老板说必须装满再来，

可是车没装满，这边已经没货了，这时候就必须给老板送货了

flush();//冲FileOutputStream fos = new FileOutputStream("bos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
String line = "让我掉下眼泪的";
byte[] data = line.getBytes(StandardCharsets.UTF_8);
bos.write(data);
System.out.println("写出完毕!");
bos.flush();//冲
bos.close();
---------------------------------------------------------------------------------
/*
高级流
对象流
java.io.ObjectOutputStream和ObjectInputSteam
对象流是一对高级流，在流连接中的作用是进行对象的序列化与反序列化。
对象序列化:将一个java对象按照其结构转换为一组字节的过程
对象反序列化:将一组字节还原为java对象(前提是这组字节是一个对象序列化得到的字节)
对象序列化的流连接操作原理图:
缓冲流的flush方法用于强制将缓冲区中已经缓存的数据一次性写出。
注:该方法实际上实在字节输出流的超类OutputStream上定义的，并非只有缓冲
输出流有这个方法。但是实际上只有缓冲输出流的该方法有实际意义，其他的流实现
该方法的目的仅仅是为了在流连接过程中传递flush动作给缓冲输出流。
*/

对象流

对象流是一对高级流，在流连接中的作用是进行对象的序列化与反序列化

java.io.ObjectOutputStream和ObjectInputSteam
序列化

ObjectOutputStream：
void writeObject(Object obj)

1.对象输出流在进行序列化对象时，
要求该对象所属的类必须实现接口:java.io.Serializable接口

//对象
Person p = new Person(name,age);
//低级流，也是地基
FileOutputStream fos = new FileOutputStream("person.obj");
//对象高级流，序列化
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p);
System.out.println("写出完毕!");
oos.close();

反序列化
ObjectInputSteam：
Object readObject()

//从person.obj文件中将对象反序列化回来
FileInputStream fis = new FileInputStream("person.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
System.out.println(p);

transient关键字可以修饰属性，用于在进行对象序列化时忽略不必要的属性，达到对象瘦身的目的

就是现实中你填写身份信息的时候，其中有一项可以忽略不写，这里是这一项不被序列化

字符流

java.io.Reader和Writer则是所有字符流的超类

java.io.Writer所有字符输出流的超类上，定义了写出字符的相关方法
void write(int d)写出一个字符，实际传入的应当是一个char。
void write(char[] data)
void write(char[] data,int offset,int len)
void write(String str) 直接写出一个字符串

int read()

java.io.InputStreamReader和OutputStreamWriter

OutputStreamWriter

FileOutputStream fos = new FileOutputStream("osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
String line = "公平是自己创造的 。";
osw.write(line);//转换流的write(String str)会将写出的字符串转换为字节然后写出
osw.write("哪有一定的公平。");
System.out.println("写出完毕!");
osw.close();

InputStreamReader

FileInputStream fis = new FileInputStream("osw.txt");
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
//循环将文件所有字符读取回来
int d;
while((d = isr.read()) != -1){
System.out.print((char)d);
}
isr.close();

缓冲字符流

java.io.BufferedWriter和BufferedReader
BufferedWriter

//文件输出流(低级流，字节流) 作用:向文件中写出字节
FileOutputStream fos = new FileOutputStream("pw2.txt");
//转换输出流(高级流，字符流) 作用:1衔接字符与字节流的 2:将写出的字符转换为字节
OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
//缓冲字符输出流(高级流，字符流) 作用:块写文本数据加速的(内部有一个8k的char数组)
BufferedWriter bw = new BufferedWriter(osw);
//具有自动行刷新功能(高级流，字符流) 作用:1按行写出字符串(println) 2:自动行刷新
PrintWriter pw = new PrintWriter(bw);

//当我们创建PrintWriter时，构造方法里第一个参数为一个流，那么就支持再传入
//一个boolean值参数表示是否打开自动行刷新功能，传入true则打开。
//此时每当我们调用它的println方法写出一行字符串后就会自动flush()一次。
//注意:print方法和write方法写出字符串时并不会自动flush()!!!!
PrintWriter pw = new PrintWriter(bw,true);

BufferedReader
readLine()
作用:读取一行字符串。连续读取若干字符直到遇到了换行符位置，并将换行符之前的
内容返回。注意:返回的字符串里不包含最后的换行符。
特殊情况:
如果这一行只有一个换行符，那么返回值为空字符串:“”
如果读取到了流的末尾，那么返回值为null。

//文件输入流(低级流，字节流) 作用:从文件中读取字节
FileInputStream fis = new FileInputStream("./src/io/BRDemo.java");
//转换输入流(字符流，高级流) 作用:1衔接字节与字符流 2将读取的字节转换为字符
InputStreamReader isr = new InputStreamReader(fis);
//缓冲字符输入流(字符流，高级流) 作用:1块读字符数据加速 2按行读取字符串
BufferedReader br = new BufferedReader(isr);
String line;
while((line = br.readLine()) != null){
System.out.println(line);
}
br.close();

缓冲字符输出流****java.io.PrintWriter
PrintWriter(File file)
PrintWriter(String filename)