IO流

1.字节流

1）字节输出流

java.io.OutputStream

：字节输出流顶层父类， 这个抽象类是表示字节输出流的所有类的超类。输出流接收输出字节并将其发送到某个接收器。

成员方法：

void write(int b) 将指定的字节写入此输出流。写出的字节会被解码为对应的字符数据。一次只能写出一个字节数据，如果超出一个字节，只能写出最后的8个二进制数据。
void write?(byte[] b) 将数组中的所有数据写到指定的接收器。
void write?(byte[] b, int off, int len) 将数组中的指定范围的数据写到指定的接收器。
int off：写出数据的起始下标 ， int len:写出的字节个数
void close?() 关闭此输出流并释放与此流相关联的任何系统资源。

java.io.FileOutputStream

：文件字节输出流

构造方法：如果文件路径不存在，则抛出异常，如果文件路径存在，但是文件不存在，则创建文件。

FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。

​ String name： 需要写入数据的文件路径。

FileOutputStream(File file) 创建文件输出以写入由指定的File对象表示的文件。

​ File file ：需要写入数据的文件对象。

FileOutputStream(String name, boolean append) 创建文件的输出流以指定的名称的写入文件。

FileOutputStream(File file,boolean append)创建文件输出流以指定的File对象文件写入。

​ boolean append：默认为false，指定为true时可实现数据的追加。

public static void  Func(){
    FileOutputStream fos=new FileOutputStream(File file);
        fos.write();
        fos.close();
}

2）字节输入流

java.io.InputStream

: 字节输入流顶级父类

成员方法：

void close?() 关闭此输入流并释放与流相关联的任何系统资源。
int read?() 从输入流读取一个字节数据。'返回的是读取的字符编码值，如果返回-1表示文件读取完成。
int read?(byte[] b) 从输入流中读取一些字节数，并将它们存储到缓冲器阵列 b 。
int read?(byte[] b, int off, int len) 从输入流读取最多 len个字节的数据到字节数组。

java.io.FileInputStream

： 文件字节输入流， 从文件中读取数据。

构造方法: 文件一定要存在。
FileInputStream(File file) 创建字节输入流对象，指定需要读取的文件对象。
FileInputStream(String name) 创建字节输入流对象，指定需要读取的文件路径。

public static void  Func(){
    FileIntputStream fos=new FileIntputStream(File file);
        fos.read();
        fos.close();
}

2.字符流

1）字符输出输入流

字符流: 字节流 + 编码表 操作的一定是字符数组。

java.io.Writer

: 字符流顶层父类

字符输出流: Writer
FileWriter: 给目标文件中写入字符数据。

构造方法:
FileWriter(File file) 给一个File对象构造一个FileWriter对象。
FileWriter(File file, boolean append) 给一个File对象构造一个FileWriter对象。
FileWriter(String fileName) 构造一个给定文件名的FileWriter对象。
FileWriter(String fileName, boolean append) 构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。

public static void  Funs(){
    FileWriter fw=new FileWriter(File file);
    fw.writer();
}

java.io.Reader

：字符流输入流顶层父类

字符输入流: Reader
FileReader: 从目标文件中读取字符数据

成员方法：

int read() 读一个字符 。
int read(char[] cbuf) 将字符读入数组。
int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。
void close() 关闭流并释放与之相关联的任何系统资源。

public static void Func(){
    FileReader fd=new FileReader(File file);
    fd.reader();
}

3.转换流

1）字节转字符输入流

实现字符和字节数据之间的转换（编码、解码）。数据最终都是以字节的形式保存在文件中。

java.io.InputStreamReader

: 从字节流到字符流的桥梁：它读取字节，并使用指定的charset将其解码为字符。

​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
'字节转字符输入流，没有字符转字节输入流。

构造方法:
InputStreamReader?(InputStream in) 创建一个使用默认字符集的InputStreamReader。
InputStreamReader?(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。

public static void Func(){
    InputStream  is=new InputStream(new FileInputStream("路径"));
    InputStreamReader isr=new InputStreamReader(is);
    isr.reader();
    isr.close();
    is.close();
}

2）字符转字节输出流

java.io.OutputStreamWriter

:是从字符流到字节流的桥梁：使用指定的charset将写入的字符编码为字节。
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
'字符转字节输出流，没有字节转字符输出流
构造方法:
OutputStreamWriter?(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
OutputStreamWriter?(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。

流的关闭问题: 先开后关， 如果流之间有依赖的关系，先关闭被依赖的流。

public static void Func(){
    OutputStream  os=new OutputStream(new FileOutputStream("路径"));
    OutputStreamWriter osw=new OutputStreamWrotero(os);
    osw.writer();
    osw.close();
    os.close();
}

4.缓冲流

缓冲流: 高效率，读写的效率特别高。

1）字节输出缓冲流

java.io.BufferedOutputStream

： 字节输出缓冲流
构造方法:
BufferedOutputStream?(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream?(OutputStream out, int size) 创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。

public class BufferedCopy {
    public static void main(String[] args) throws IOException {
        copy02();
    }
    // 使用高效率复制文件
    public static void copy02() throws IOException {
        long time = System.currentTimeMillis();
        // 创建高效率输入输出流对象
        BufferedInputStream bis = new BufferedInputStream( new FileInputStream("d:\\demo\\1.avi"));
        BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("d:\\demo\\2.avi"));
        // 声明变量
        int len = 0;
        // 声明数组
        byte[] bytes = new byte[1024];
        // 复制
        while ( (len = bis.read(bytes) ) != -1 ) {
            bos.write(bytes,0,len);
        }
        // 关流
        bos.close();
        bis.close();

        System.out.println( "tiem = " + (System.currentTimeMillis() - time) );
    }
}

2）字节输入缓冲流

java.io.BufferedInputStream

： 字节输入缓冲流
构造方法:
BufferedInputStream?(InputStream in) 创建一个 BufferedInputStream并保存其参数，输入流 in供以后使用。
BufferedInputStream?(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream ，并保存其参数，输入流 in供以后使用。

public class BufferedCopy {
    public static void main(String[] args) throws IOException {
        copy02();
    }
    // 使用高效率复制文件
    public static void copy02() throws IOException {
        long time = System.currentTimeMillis();
        // 创建高效率输入输出流对象
        BufferedInputStream bis = new BufferedInputStream( new FileInputStream("d:\\demo\\1.avi"));
        BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("d:\\demo\\2.avi"));
        // 声明变量
        int len = 0;
        // 声明数组
        byte[] bytes = new byte[1024];
        // 复制
        while ( (len = bis.read(bytes) ) != -1 ) {
            bos.write(bytes,0,len);
        }
        // 关流
        bos.close();
        bis.close();

        System.out.println( "tiem = " + (System.currentTimeMillis() - time) );
    }
}

3）字符输入缓冲流

java.io.BufferedWriter

： 字符输出缓冲流
构造方法：
BufferedWriter?(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter?(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。

特有的成员方法:
void newLine?() 写一行行分隔符。

public class BufferedLine {
    public static void main(String[] args) throws IOException {
        // 创建字符输出缓冲流
        BufferedWriter bw = new BufferedWriter( new FileWriter("d:\\demo\\bw.txt"));*/
        // 写出数据
        bw.write("床前明月光");
        // 写出换行
        bw.newLine();
        bw.write("疑是地上霜");
        ///
        // 声明变量 保存读取到的一行数据
        String line = null;
        while ( ( line = br.readLine()) != null ) {
            System.out.println(line);
        }
        // 关流
        bw.close();
    }
}

4）字符输出缓冲流

java.io.BufferedReader

： 字符输入缓冲流
构造方法：
BufferedReader?(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader?(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
特有的成员方法:
String readLine?() 读一行文字。'撒多浪费TMD就对NND了撒发

 public static void main(String[] args) throws IOException {

        // 创建字符输入缓冲流

        BufferedReader br = new BufferedReader( new FileReader("d:\demo\bw.txt"));

        // 声明变量 保存读取到的一行数据

        String line = null;

        while ( ( line = br.readLine()) != null ) {

            System.out.println(line);

        }

        // 关流

        br.close();
}

5)属性集

java.util.Properties

Properties类表示一组持久的属性。 public class BufferedLine {

}Properties可以保存到流中或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串。
'要求 key 和 value 都是String类型数据

成员方法:
setProperty?(String key, String value) 调用 Hashtable方法 put 。
String getProperty?(String key) 使用此属性列表中指定的键搜索属性。 get(Object key)
Set stringPropertyNames?() 获取key值的set视图。相当于 keySet()方法
将集合中的数据写到指定的文件中:
void store?(OutputStream out, String comments)
void store?(Writer writer, String comments)
将文件中的数据读取到程序中:
void load?(InputStream inStream)
void load?(Reader reader)

public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        // 创建属性集对象
        Properties prop = new Properties();
        // 给属性集中保存数据
        prop.setProperty("东邪", "黄药师");
        prop.setProperty("xidu", "ouyangfeng");
        prop.setProperty("男滴", "段皇爷");
        prop.setProperty("北丐", "洪七公");
        prop.setProperty("中神通", "王重阳");
        prop.setProperty("中神通", "磊哥");
        System.out.println("prop = " + prop);

6）键盘录入

键盘录入: 通过键盘将数据录入到程序中。 操作系统 System.in: 基于获取输入流，读取键盘录入的数据
// 获取系统的输入流，读取键盘录入的数据
InputStream in = System.in;
// 将字节流转换为字符流
InputStreamReader isr = new InputStreamReader( in );
// 缓冲流读取一行键盘录入的数据
BufferedReader br = new BufferedReader( isr );
br.readLine(); // 回车结束 null

​ BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
’ 输入流，有模板代码读取，但是需要通过if指定一个结束的语句。

5.序列化与反序列化流

序列化和反序列化流 : 对象的数据读写（将对象写到文件中，也可以将写到文件中的对象读取到程序中）
序列化 : 将对象写到本地文件中。
反序列化 : 将本地文件中的对象读取到程序中。

1）序列化类

java.io.ObjectOutputStream

： 序列化类
构造方法:
ObjectOutputStream?(OutputStream out) 创建一个写入指定的OutputStream的ObjectOutputStream。
成员方法:
void writeObject?(Object obj) 将指定的对象写入ObjectOutputStream。

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        readObject();
    }
    // 反序列化
    public static void readObject() throws IOException, ClassNotFoundException {
        // 创建反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\demo\\oos.txt"));
        // 调用方法 反序列化
        ArrayList<String> list = (ArrayList<String>)ois.readObject();
        // 遍历集合
        for (String s : list) {
            System.out.println("s = " + s);
        }
        // 关流
        ois.close();
    }

2）反序列化类

java.io.ObjectInputStream

:反序列化类
构造方法：
ObjectInputStream?(InputStream in) 创建从指定的InputStream读取的ObjectInputStream。
成员方法:
Object readObject?() 从ObjectInputStream读取一个对象。

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writerObject();
    }
    // 序列化
    private static void writerObject() throws IOException {
        // 创建序列化对象
        ObjectOutputStream oos = new ObjectOutputStream(new 
        FileOutputStream("d:\\demo\\oos.txt")); 
        // 创建集合，将需要序列化的数据保存到集合中
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"ww","www","222");
        // 写出对象
        oos.writeObject( list );
        // 关流
        oos.close();
    }
}

3）序列化接口

java.io.Serializable

: 序列化接口，标记型接口。只有实现了此接口的类对象才能被序列化。
当类实现了 Serializable 接口之后 ，会根据类中的代码计算出一个串行版本号变量 static final serialVersionUID。
对象被序列化时会绑定UID变量，要求反序列化时对象绑定的UID变量要一致。 如果不一致抛出异常。
在类中自定义一个UID变量的值 = ;
如果某个成员变量不希望被序列化则使用 transient 瞬态关键字修饰即可。

public class Student implements Serializable {
    // 版本号固定
    static final long serialVersionUID = 2379243874927349L;
    // transient 瞬态关键字
    private transient String name;
    private int age;
    private char sex;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

6.随机流

1)随机流

java.io.RandomAccessFile

: 随机流，它是将操作的文件当做一个大型的byte数组。
构造方法:
RandomAccessFile?(String name, String mode) 创建随机访问文件流，以从中指定名称的文件读取，并可选择写入文件。
String name:读写的文件路径 ， String mode： "r"只读 "rw"读写
void seek?(long pos) 设置文件指针偏移，从该文件的开头测量，发生下一次读取或写入。

public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        RandomAccessFile raf = new RandomAccessFile("d:\\demo\\a.txt","rw");
        // 设置读取的起始下标
        /*raf.seek(1);
        int read = raf.read();
        System.out.println("read = " + read);
        */
        raf.write(97);
        // 关流
        raf.close();
    }
}