JAVA SE学习day_05: IO与流操作

一、IO与流

以程序为主体，input（输入）是读、获取、使用输入流的过程，output（输出）是写、发送的过程。

JAVA IO 标准的输入与输出

JAVA IO将读和写按照方向划分为:

输入:用于读取
输出:用于写出
区分方向的参照点是程序，从外界获取信息到程序中的方向是输入，反之是输出。
JAVA IO以标准化的方式对外界设备进行读写操作。使得我们读写外界设备的方式
基本是统一的。

输入流与输出流

输入流:java.io.InputStream,它是所有字节输入流的超类，定义了所有字节输入流都必须具备的读取数据的方法。
输出流:java.io.OutputStream,所有字节输出流的超类，定义了写出操作。
流的读写形式是顺序读写模式，即:读写数据只能顺序向后进行，是不能回退的。

节点流与处理流

流除了按照读写方向分类外，还有一种分类就是:节点流与处理流
节点流:数据源明确，是真实连接程序与另一端的"管道"，负责实际读写数据的流读写一定是建立在节点流的基础上进行的。它在行业里也称为:低级流
处理流:不能独立存在，必须连接在其他流上，目的是当数据流经当前流时，可以对数据进行加工处理，简化我们的操作，行业里也称为:高级流

文件流

java.io.FileInputStream和FileOutputStream
文件流是一对低级流，用于读写文件的流。功能上与RandomAccessFile一致，但是文件流是基于JAVA标准的IO，读写是分开的，并且流的读写是顺序读写，只能顺序向后进行读或写操作，是不能回退的。
但是RAF是基于指针的随机读写形式，可以调整指针位置对文件任意位置读写。

二、文件流（输出流，向程序内写入数据）

文件流的两种模式
* 1.覆盖模式
* FileOutputStream（String path）
* FileOutputStream（File file）
* 覆盖模式：在写下构造方法时，如果指定的文件中存在数据则删除当前文件中的所有数据后进行操作
*
* 2.追加模式，对应的构造方法：
* FileOutputStream（String path，boolean append）
* FileOutputStream（File file，boolean append）
* 追加模式：当第二个参数为true，创建文件流时，如果指定文件已经存在，则通过追加当前流写入的内容都会被顺序追加到文件末尾

//1 FileOutputStream fos = new FileOutputStream("./fos.txt");
FileOutputStream fos = new FileOutputStream("./fos.txt",true);
//2
//3File file = new File("./fos.txt");
//FileOutputStream fos = new FileOutputStream(file);/*1and3 String ling = "asdasdasda123@#";byte[]data = ling.getBytes("utf-8");fos.write(data);*/String ling = "asdasdasda123@#";byte[]data = ling.getBytes("utf-8");fos.write(data);//2System.out.println("over");fos.close();

三、输入流（从文件中读取数据）

文件输入流，用于从文件中读取字节

FileInputStream fis = new FileInputStream("./fos.txt");byte[]data = new byte[200];int len = fis.read(data);System.out.println("实际读取到了"+len+"个字节");String str = new String(data,0,len,"utf-8");System.out.println(str);fis.close();

四、缓存流（属于处理流）

java.io.BufferedInputStream和BufferedOutputstream

缓冲流是一种高级流，在流的连接中作用为加快读写效率。无论我们使用块读写还是单字节读写，缓冲流最终都会统一转换为块读写以保证读写效率

package io;import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class CopyDemo2 {public static void main(String[] args) throws IOException {FileInputStream fis = new FileInputStream("image.png");BufferedInputStream bis = new BufferedInputStream(fis);FileOutputStream fos = new FileOutputStream("image77.png");BufferedOutputStream bos = new BufferedOutputStream(fos);int d = 0;long start = System.currentTimeMillis();while((d=bis.read())!=-1){bos.write(d);}long end = System.currentTimeMillis();System.out.println("copy over!usetime:"+(end-start));bis.close();bos.close();}}

缓冲字节输出流写数据的缓冲区问题

FileOutputStream fos = new FileOutputStream("raf.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);String str = "1231231231asdasddas";byte[]data = str.getBytes("utf-8");bos.write(data);/*缓冲流在没有装够8kb数据时不运行，这个时候就需要我们引用* void flush()* 强制将缓冲流的缓冲区中已经缓存的数据写出*/bos.flush();System.out.println("over");bos.close();

五、对象流

java.io.ObjectInputStream和ObjectOutputStream
对象流是一对高级流，作用是方便读写任何java对象

package io;import java.io.Serializable;
import java.util.Arrays;/*** 使用当前类测试对象流的对象读写操作* @author 毛**/
public class Person implements Serializable{/*** 序列号*/private static final long serialVersionUID = 1L;
private String name;
private int age;
private String gender;
private transient String[]otherInfo;
/** transient关键字* 当一个属性被修饰后，那么当对象在序列化的过程中，这个属性会被忽略* 忽略不重要的属性可以达到减少内存的占用效果*/public Person(String name, int age, String gender, String[] otherInfo) {super();this.name = name;this.age = age;this.gender = gender;this.otherInfo = otherInfo;
}public String toString(){return name+","+age+","+gender+","+Arrays.toString(otherInfo);}}

5.1 实例写入操作（序列化）

ObjectOutputStream用于对象的序列化
ObjectOutputStream提供了writeObject方法
writeObject方法要求写出的对象所属的类必须实现接口：

Serializable _序列化接口（签名接口，两个中的其一）
否则会抛出异常

在流连接中，对象流的工作是：对象序列化，就是将给定的对象按照其结构转换为一组字节的过程。
然后这组字节再经过文件流写入文件，这个过程称为数据持久化，因为写入文件就是写入磁盘，断电也可保存；

package io;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;public class OOSDemo {public static void main(String[] args) throws IOException {/** 将一个Person实例写入文件person.obj*/String name = "苍老师";int age = 18;String gender="nv";String[]otherInfo = {"是个演员","来自日本"};Person p = new Person(name,age,gender,otherInfo);System.out.println(p);FileOutputStream fos = new FileOutputStream("person.dat");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(p);System.out.println("over");oos.close();}}

5.2 反序列化

ObjectInputStream用于对象的反序列化
ObjectInputStream提供的方法

Object readObject（）
该方法用于进行对象的反序列化，如果读取的字节不是一个对象的时候（字节不是通过对象输出流序列化的），会抛异常；

package io;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;public class OISDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {FileInputStream fis = new FileInputStream("person.dat");ObjectInputStream ois = new ObjectInputStream(fis);Person p = (Person) ois.readObject();System.out.println(p);ois.close();}}

练习

/*5 FileOutputStream fos1 = new FileOutputStream("./fos.txt");String a = "45456456";byte[]date = a.getBytes("utf-8");fos1.write(date);System.out.println("over");fos1.close();*//*4FileOutputStream fos1 = new FileOutputStream("./fos1.txt");String a = "wqeqwwe";byte[]date = a.getBytes();fos1.write(date);System.out.println("over");fos.close();*//*3FileOutputStream fos2 = new FileOutputStream("./fos2.txt");String s="asdas";byte[]date1 = s.getBytes();fos2.write(date1);System.out.println("over");fos2.close();*//*2FileOutputStream fos3 = new FileOutputStream("./fos3.txt");String as = "asdasdasd";byte[]date = as.getBytes();fos3.write(date);System.out.println("over");fos3.close();*//*1FileOutputStream fos4 = new FileOutputStream("./fos4.txt");String asd = "!@#!@#!@#";byte[]date1=asd.getBytes();fos4.write(date1);System.out.println("over");fos4.close();*/

/*5FileInputStream fis1 = new FileInputStream("./fos1.txt");byte[]date = new byte[200];int l = fis1.read(date);System.out.println("实际读取到了"+l+"个字节");String s = new String(date,0,l,"utf-8");System.out.println(s);fis1.close();*//*4FileInputStream fis2 = new FileInputStream("./fos2.txt");byte[]date = new byte[300];int l = fis2.read(date);System.out.println("实际读取到了"+l+"个字节");String sa = new String(date,0,l,"utf-8");System.out.println(sa);fis2.close();*//*3FileInputStream fis3 = new FileInputStream("./fos3.txt");byte[]date = new byte[400];int l=fis3.read(date);System.out.println("实际读取到了"+l+"个字节");String saa  = new String(date,0,l,"utf-8");System.out.println(saa);fis3.close();*//*2FileInputStream fis4 = new FileInputStream("./fos4.txt");byte[]date = new byte[200];int l = fis4.read(date);System.out.println("实际读取到了"+l+"个字节");String sa = new String(date,0,l,"utf-8");System.out.println(sa);fis4.close();/*/*1FileInputStream fis5 = new FileInputStream("./fos5.txt");byte[]date = new byte[200];int l = fis5.read(date);System.out.println("实际读取到了"+l+"个字节");String as = new String(date,0,l,"utf-8");System.out.println(as);fis5.close();*/

     /*5FileInputStream fis1 = new FileInputStream("image.png");BufferedInputStream bis1 = new BufferedInputStream(fis1);FileOutputStream fos1 = new FileOutputStream("image1.png");BufferedOutputStream bos1 = new BufferedOutputStream(fos1);int a=0;while((a=bis.read())!=-1){bos1.write(a);}System.out.println("over");bis1.close();bos1.close();*//*4 FileInputStream fis2 = new FileInputStream("image.png");FileOutputStream fos2 = new FileOutputStream("image2.png");BufferedInputStream bis2 = new BufferedInputStream(fis2);BufferedOutputStream bos2 = new BufferedOutputStream(fos2);int b = 0;while((b=bis2.read())!=-1){bos2.write(b);}System.out.println("over");bis2.close();bos2.close();*//*3FileInputStream fis3 = new FileInputStream("image.png");FileOutputStream fos3 = new FileOutputStream("image3.png");BufferedInputStream bis3 = new BufferedInputStream(fis3);BufferedOutputStream bos3 = new BufferedOutputStream(fos3);int s = 0;while((s = bis3.read())!=-1){bos3.write(s);}System.out.println("over");bis3.close();bos3.close();*//*2FileInputStream fis4 = new FileInputStream("ias.mp4");FileOutputStream fos4 = new FileOutputStream("ias1.mp4");BufferedInputStream bis4 = new BufferedInputStream(fis4);BufferedOutputStream bos4 = new BufferedOutputStream(fos4);int as = 0;while((as = bis4.read())!=-1){bos4.write(as);}System.out.println("over");bis4.close();bos4.close();*//*1FileInputStream fis0 = new FileInputStream("123.dat");FileOutputStream fos0 = new FileOutputStream("1234.dat");BufferedInputStream bis0 = new BufferedInputStream(fis0);BufferedOutputStream bos0 = new BufferedOutputStream(fos0);int dd = 0;while((dd = bis0.read())!=-1){bos0.write(dd);}System.out.println("over");bis0.close();bos0.close();*/

/*5FileOutputStream fos1 = new FileOutputStream("raf.txt");BufferedOutputStream bos1 = new BufferedOutputStream(fos1);String s = "sadasdsad";byte[]date = s.getBytes("utf-8");bos1.write(date);bos1.flush();System.out.println("over");bos1.close();*//*4FileOutputStream fos2 = new FileOutputStream("raf1.txt");BufferedOutputStream bos2 = new BufferedOutputStream(fos2);String sa = "!@#$@#$";byte[]data1 = sa.getBytes("utf-8");bos2.write(data1);bos2.flush();System.out.println("over");bos2.close();*//*3FileOutputStream fos3 = new FileOutputStream("raf2.txt");BufferedOutputStream bos3 = new BufferedOutputStream(fos3);String as = "dsasdasdas";byte[]date = as.getBytes("utf-8");bos3.write(date);bos3.flush();System.out.println("over");bos3.close();*//*2FileOutputStream fos4 = new FileOutputStream("raf3.txt");BufferedOutputStream bos4 = new BufferedOutputStream(fos4);String sa = "asddsa231123";byte[]data2 = sa.getBytes("utf-8");bos4.write(data2);bos4.flush();System.out.println("over");bos4.close();*//*1FileOutputStream fos0 = new FileOutputStream("raf0.txt");BufferedOutputStream bos5 = new BufferedOutputStream(fos0);String ds = "asasdasd";byte[]date1 = ds.getBytes("utf-8");bos5.write(date1);bos5.flush();System.out.println("over");bos5.close();*/

package io;import java.io.Serializable;
import java.util.Arrays;/*** 使用当前类测试对象流的对象读写操作* @author 毛**/
public class Person implements Serializable{/*** 序列号*/private static final long serialVersionUID = 1L;
private String name;
private int age;
private String gender;
private transient String[]otherInfo;
/** transient关键字* 当一个属性被修饰后，那么当对象在序列化的过程中，这个属性会被忽略* 忽略不重要的属性可以达到减少内存的占用效果*/public Person(String name, int age, String gender, String[] otherInfo) {super();this.name = name;this.age = age;this.gender = gender;this.otherInfo = otherInfo;
}public String toString(){return name+","+age+","+gender+","+Arrays.toString(otherInfo);}}

     /*5String name = "苍老师";int age = 18;String gender="nv";String[]otherInfo = {"是个演员","来自日本"};Person p = new Person(name,age,gender,otherInfo);FileOutputStream fos = new FileOutputStream("person.dat");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(p);System.out.println("over");oos.close();*//*4String name1 = "苍老师";int age1 = 18;String gender1="nv";String[]otherInfo1 = {"是个演员","来自日本"};Person p1 = new Person(name1,age1,gender1,otherInfo1);FileOutputStream fos1 = new FileOutputStream("person.dat");ObjectOutputStream oos1 = new ObjectOutputStream(fos1);oos1.writeObject(p1);System.out.println("over");oos1.close();*//*3String name2 = "苍老师";int age2 = 18;String gender2="nv";String[]otherInfo2 = {"是个演员","来自日本"};Person p2 = new Person(name2,age2,gender2,otherInfo2);FileOutputStream fos2 = new FileOutputStream("person.dat");ObjectOutputStream oos2 = new ObjectOutputStream(fos2);oos2.writeObject(p2);System.out.println("over");oos2.close();*//*2String name3 = "苍老师";int age3 = 18;String gender3="nv";String[]otherInfo3 = {"是个演员","来自日本"};Person p3 = new Person(name3,age3,gender3,otherInfo3);FileOutputStream fos3 = new FileOutputStream("person.dat");ObjectOutputStream oos3 = new ObjectOutputStream(fos3);oos3.writeObject(p3);System.out.println("over");oos3.close();*//*1String name4 = "苍老师";int age4 = 18;String gender4="nv";String[]otherInfo4 = {"是个演员","来自日本"};Person p4 = new Person(name4,age4,gender4,otherInfo4);FileOutputStream fos4 = new FileOutputStream("person.dat");ObjectOutputStream oos4 = new ObjectOutputStream(fos4);oos4.writeObject(p4);System.out.println("over");oos4.close();*/

/*5FileInputStream fis1 = new FileInputStream("person.dat");ObjectInputStream ois1 = new ObjectInputStream(fis1);Person p1 = (Person)ois1.readObject();System.out.println(p1);ois1.close();*//*4FileInputStream fis2 = new FileInputStream("person.dat");ObjectInputStream ois2 = new ObjectInputStream(fis2);Person p2 = (Person)ois2.readObject();System.out.println(p2);ois2.close();*//*3FileInputStream fis3 = new FileInputStream("person.dat");ObjectInputStream ois3 = new ObjectInputStream(fis3);Person p3 = (Person)ois3.readObject();System.out.println(p3);ois3.close();*//*2FileInputStream fis4 = new FileInputStream("person.dat");ObjectInputStream ois4 = new ObjectInputStream(fis4);Person p4 = (Person)ois4.readObject();System.out.println(p4);ois4.close();*//*1FileInputStream fis0 = new FileInputStream("person.dat");ObjectInputStream ois0 = new ObjectInputStream(fis0);Person p0 = (Person)ois0.readObject();System.out.println(p0);ois0.close();*/