海阔天空

手机扫码查看

IO框架

什么是流？
概念：内存与存储设备之间传输数据的通道。
水借助管道传输;数据借助流传输。

流的分类：
按方向【重点】：
输入流：将<存储设备>中的内容读入到<内存>中。
输出流：将<内存>中的内容写入到<存储设备>中。

流的分类：
按单位：
字节流：以字节为单位，可以读写所有数据。
字符流：以字符为单位，只能读写文本数据。

按功能：
节点流：具有实际传输数据的读写功能。
过滤流：在节点流的基础之上增强功能。

字节流：
字节流的父类(抽象类):

InputStream:字节输入流
方法：
public int read(){}
public int read(byte[] b){}
public int read(byte[] b,int off,int len){}

OutputStream:字节输出流
方法：
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b,int off,int len){}

字节节点流

FileInputStream:
public int read(byte[] b)
从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1.

FileOutputStream:
public void write(byte[] b)
一次写多个字节，将b数组中所有字节，写入输出流。

import java.io.FileOutputStream;
public class demos{
    public static void main(String[] args) throws Exception{
        //true为追加，false为不追加
        FileOutputStream fo=new FileOutputStream("F:\\test.txt",true);
        //利用for循环进行将字母写入到文本中
        for(int i=65;i<=75;i++){
            char c=(char)i;
            fo.write(c);
        }
    }
}

import java.io.FileInputStream;
public class demos{
    public static void main(String[] args) throws Exception{
        FileInputStream fi=new FileInputStream("F:\\test.txt");
        //方法一
        //利用where死循环将文本内容输出
        while(true){
            int n = fi.read();
            //读取到末尾则返回-1
            //如果读取到末尾则结束
            if(n==-1) break;
            //打印内容
            System.out.print((char)n);
        }
        System.out.println("===华丽的分割线===");
        //方法二
        //利用数组结构循环输出
        byte[] b=new byte[5];
        while(true){
            int m = fi.read(b);
            if(m==-1)break;
            for(int i=0;i<m;i++){
                System.out.print((char) b[i]+"\t");
            }
            System.out.println();
        }
    }
}

字节过滤流
缓冲流：BufferedOutputStream/BufferedInputStream
提高IO效率，减少访问磁盘的次数；
数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

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

public class demos{
    public static void main(String[] args) throws IOException {
        FileOutputStream fo=new FileOutputStream("F:\\test.txt");
        BufferedOutputStream bo=new BufferedOutputStream(fo);
        for(int i=65;i<=78;i++){
            char c=(char)i;
            bo.write(c);
        }
        bo.flush();
    }
}

import java.io.*;
public class demos{
    public static void main(String[] args) throws IOException {
        FileInputStream fi=new FileInputStream("F:\\test.txt");
        BufferedInputStream bi=new BufferedInputStream(fi);
        byte[] b=new byte[4];
        while(true){
            int in = bi.read(b);
            if(in==-1)break;
            for (int i=0;i<in;i++){
                System.out.print((char)b[i]);
            }
        }
    }
}

字节过滤流
对象流：ObjectOutputStream/ObjectInputStream
增强了缓冲区功能
增强了读写8中基本类型数据和字符串功能
增强了读写对象的功能：
readObject()从流中读取一个对象
writeObject(Object obj)向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化。

对象序列化：
细节：
必须实现Serializable接口。
必须保证其所有属性均可序列化。
transient修饰为临时属性，不参与序列化。
读取到文件末尾的标志：java.io.EOFException

import java.io.*;

public class demos{
    public static void main(String[] args) throws Exception {
        FileOutputStream fo=new FileOutputStream("F:\\Object.txt");
        BufferedOutputStream bo=new BufferedOutputStream(fo);
        ObjectOutputStream oo=new ObjectOutputStream(bo);
        oo.writeObject(new Student("张三",22,99D,new Address()));
        oo.writeObject(new Student("李四",18,95D,new Address()));
        oo.writeObject(new Student("王二麻",27,92D,new Address()));
        oo.close();
        FileInputStream fi=new FileInputStream("F:\\Object.txt");
        BufferedInputStream bi=new BufferedInputStream(fi);
        ObjectInputStream oi=new ObjectInputStream(bi);
        while(true){
            try{
                Object o = oi.readObject();
                System.out.println(o);
            }catch (EOFException e){break;}
        }
    }
}
class Student implements Serializable{
    String name;
    Integer age;
    Double score;
    transient Address addr;//临时属性，不参与序列化
    public Student(String name, Integer age, Double score,Address addr) {
        this.name = name;
        this.age = age;
        this.score = score;
        this.addr=addr;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
class Address{
    String address;
    String zipCode;
}

    String zipCode;
}

字符编码
ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
UTF-8针对Unicode的可变长度字符编码
GB2312简体中文
GBK简体中文，扩充
BIG5 台湾，繁体中文
当编码方式和解码方式不一致时，会出现乱码。

import java.io.UnsupportedEncodingException;
public class demos{
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s="你好世界";
        byte[] s2 = s.getBytes("GBK");
        for(int i=0;i<s2.length;i++){
            System.out.println(s2[i]);
        }
        System.out.println("===");
        byte[] s3 = s.getBytes("UTF8");
        for(int i=0;i<s3.length;i++){
            System.out.println(s3[i]);
        }
        System.out.println("===");
        byte[] s4 = s.getBytes("GB2312");
        for(int i=0;i<s4.length;i++){
            System.out.println(s4[i]);
        }
    }
}

字符流
字符流的父类(抽象类)

Reader：字符输入流
方法：
public int read(){}
public int read(char[] c){}
pubic int read(char[] b,int off,int len){}

Writer：字符输出流
方法：
public void write(int n){}
public void write(String str){}
pubic void write(char[] c){}

import java.io.*;

public class demos{
    public static void main(String[] args) throws Exception{
        Writer w=new FileWriter("F:\\test.txt");
        for(char c='A';c<='Z';c++){
            w.write(c);
        }
        w.close();
        Reader r=new FileReader("F:\\test.txt");
        while(true){
            int read = r.read();
            if(read==-1)break;
            System.out.print((char)read);
        }
        System.out.println();
    }
}

字符节点流

FileWriter:
public void write(String str)//一次写多个字符，将b数组中所有字符，写入输入流。

FileReader:
public int read(char[] c)//从流中读取多个字符，将读到内容存入到c数组，返回实际读到的字符数，如果达到文件的末尾，则返回-1。

字符过滤流
缓冲流：BufferedWriter/BufferedReader
支持输入换行符。
可一次写一行，读一行。
PrintWriter:
封装了print()/println()方法，支持写入后换行。

Writer w=new FileWriter("F:\\test.txt");
BufferedWriter bf=new BufferedWriter(w);
for(char c='A';c<='Z';c++){
    bf.write(c);
}
bf.newLine();
bf.write("换行了吗");
bf.close();
Reader r=new FileReader("F:\\test.txt");
BufferedReader br=new BufferedReader(r);
while(true){
    String s = br.readLine();
    if(s==null)break;
    System.out.println(s);
}
PrintWriter p=new PrintWriter("F:\\test.txt");
BufferedWriter bf2=new BufferedWriter(p);
for(char c='A';c<='Z';c++){
    p.print(c);
}
bf2.close();
Reader r2=new FileReader("F:\\test.txt");
BufferedReader br2=new BufferedReader(r2);
while(true){
    String s = br2.readLine();
    if(s==null)break;
    System.out.println(s);
}

字符节点流
桥转换流：InputStreamReader/OutputStreamWriter
可将字节流转换为字符流。
可设置字符的编码方式。

OutputStream os=new FileOutputStream("F:\\test2.txt");
OutputStreamWriter osw=new OutputStreamWriter(os);
BufferedWriter bfw=new BufferedWriter(osw);
for(int c=65;c<=88;c++){
    bfw.write(c);
}
bfw.close();
InputStream is=new FileInputStream("F:\\test2.txt");
InputStreamReader isr=new InputStreamReader(is);
BufferedReader bfr=new BufferedReader(isr);
while(true){
    String s = bfr.readLine();
    if(s==null)break;
    System.out.println(s);
}

使用步骤
创建节点流
创建过滤流，设置字符编码集
封装过滤流
读写数据
关闭流