java IO流 - leileigwl

IO是指Input/Output，即输入和输出。

字节输入流（常用）#

Inputstream是输入流的抽象父类，类里面主要就是read方法与close方法，需要去找子类的实例，实现其方法；

1
public static void main(String[] args) throws IOException {
2
  File file = new File("D:\\project\\java\\execrise\\project 01\\project0.1\\receive.jpg");//传一个路径
3
  InputStream is = new FileInputStream(file);//构建流
4
  int read = is.read();//按字节来读入流
5
  System.out.println(read);//结果：255(ascil码)
6
  is.close();//关闭流
7
}
8
//read方法如果没有读到就返回-1

1
//通过while循环来改善每个字节的读入
2
public static void main(String[] args) throws IOException {
3
    File file = new File("D:\\project\\java\\execrise\\project 01\\project0.1\\receive.jpg");
4
    InputStream is = new FileInputStream(file);
5
    int len ;
6
    while((len =is.read())!=-1){//当到达-1时候就会停止
7
        System.out.println((char)len);
8
    }
9
    is.close();
10
}

字节读入优化（每次读入一个字节效率太低，通过字符数组缓冲）：

1
public static void main(String[] args) throws IOException {
2
    FileInputStream fis = new FileInputStream("D:\\project\\java\\execrise\\project 01\\project0.1\\src\\test.txt");//直接构建文件
3
    byte[] bytes = new byte[1024];//新建一个存储数组
4
    int len = fis.read(bytes);//记录长度
5
    System.out.println(new String(bytes,0,len));
6
}

1
//可以通过while循环来构建，循环去读入
2
while ((len = fis.read(bytes)) != -1) {
3
    System.out.println(new String(bytes, 0, len));
4
}

字节输出流（常用）#

Ouputstream是输入流的抽象父类，类里面主要就是write方法与close方法，需要去找子类的实例，实现其方法；

1
public static void main(String[] args) throws IOException {
2
    FileOutputStream fos = new FileOutputStream("D:\\project\\java\\execrise\\project 01\\project0.1\\src\\text02.txt");//输出路径
3
    fos.write(97);//写入字符
4
    fos.close();//关闭流
5
}

1
public static void main(String[] args) throws IOException {
2
    FileOutputStream fos = new FileOutputStream("D:\\project\\java\\execrise\\project 01\\project0.1\\src\\text02.txt");
3
    byte[] bytes = "你好".getBytes();//通过getBytes()方法获取字符串数组
4
    fos.write(bytes);//按数组的形式写入
5
    fos.close();
6
}
7
//会默认覆盖原来内容，如果想要是追加在字节输出流的参数中传入true，声明追加
8
//new FileOutputStream("",true);

文件拷贝（常用）#

1
public static void main(String[] args) throws IOException {
2
    FileInputStream fis = new FileInputStream("receive.jpg");
3
    FileOutputStream fos = new FileOutputStream("D:\\project\\java\\execrise\\project 01\\project0.1\\receive2.jpg");
4
    int len;
5
    byte[] bytes = new byte[1024];
6
    while((len =fis.read(bytes))!=-1){
7
        fos.write(bytes,0,len);
8
    }
9

10
    fos.close();
11
    fis.close();
12
}

字符流#

Reader和Writer是字符输入输出的抽象父类，还是两个主要方法read,write,close;
FileReader,FileWriter
注：字符流一般就是对纯文本的处理拷贝

1
public static void main(String[] args) throws IOException {
2
    FileReader fr = new FileReader("D:\\project\\java\\execrise\\project 01\\project0.1\\src\\test.txt");
3
    FileWriter wr = new FileWriter("src\\IO_Demo\\text01.txt");
4
    char[] chars= new char[1024];//这里变成了char数组
5
    int len ;
6
    while ((len = fr.read(chars))!=-1){
7
        wr.write(chars,0,len);
8
    }
9
    wr.close();
10
    fr.close();
11
}

功能流#

缓冲流是功能流中的一种，包裹节点流使用
增强节点流的读写效率，提高性能

InputStream--->BufferedInputstream字节输入流缓冲流 OutputStream --->BufferedOutputstream字节输出流缓冲流 Reader--->BufferedReader字符输入缓冲流 Writer--->BufferedWriter字符输出流的缓冲流

只有字符缓冲流有新增功能，readline()->一行一行的读；newline()->换行
因为readline返回值是String类型，所以改成用不等于null判断

1
public static void main(String[] args) throws IOException {
2
    BufferedReader br = new BufferedReader(new FileReader("src\\test.txt"));//包裹节点流
3
    BufferedWriter bw = new BufferedWriter(new FileWriter("src\\test02.txt"));//包裹节点流
4
    String msg =null;
5
    while((msg=br.readLine())!=null){
6
        bw.write(msg);
7
        bw.newLine();//换行
8
    }
9
    bw.close();
10
    br.close();
11
}

转换流#

转换流–>功能流

InputStreamReader:是从字节流到字符流的桥接器：只能从字节到字符，不能从字符到字节

作用：

乱码问题。设置编码格式
流的转换

构造器：

InputStreamReader(Inputstream in)创建一个使用默认字符集的InputStreamReader,
InputStreamReader(InputStream in,String charsetName)创建一个使用指定charset,解决乱码

1
public static void main(String[] args) throws IOException {
2
    BufferedReader br = new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream("src\\test.txt")), "gbk"));
3
    //先读入文件，buffer流优化，通过转换流将字节流转换成字符流，然后再buffer流优化
4
    //同时设置了读入的字符编码gbk
5
    BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream("src\\test02.txt")), "gbk"));
6
    String msg =null;
7
    while((msg=br.readLine())!=null){
8
        wr.write(msg);
9
    }
10
    wr.flush();
11
    wr.close();
12
    br.close();
13
}

基本数据类型流#

基本数据类型流|Data流（节点流）：基本数据类型+String

是字节流功能流的一种
功能：能够是节点流具有传输基本数据类型+数据的能力
DataInputstream 基本数据类型输入流
DataOputputstream 基本数据类型输出流

1
//输出
2
public static void WriteDate(String desc) throws IOException {
3
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("src\\text02.txt"));
4
    int a =1;
5
    boolean flag =false;
6
    char ch ='a';
7
    String str ="你好";
8
    dos.writeInt(a);//写入int类型
9
    dos.writeBoolean(flag);//写入bool类型
10
    dos.writeChar(ch);//写入字符类型
11
    dos.writeUTF(str);//写入字符串类型
12
    dos.close();
13
}

1
//输出
2
public static void ReadDate(String src) throws IOException {
3
    DataInputStream dis = new DataInputStream(new FileInputStream("src\\text.txt"));
4
    //要与上面的写入对应，先写入先读，否则会识别不出
5
    int a = dis.readInt();
6
    boolean flag = dis.readBoolean();
7
    char ch  = dis.readChar();
8
    String str = dis.readUTF();
9

10
    dis.close();
11
}

对象流#

对象流|Object流：所有类型+对象类型

ObjectInputstream对象字节输入流|反序列化输入流 OjbectOutputstream对象字节输出流|序列化输出流
序列化：java对象类型的信息状态转换成为一个可存储，可传输的信息状态的过程反序列化：将已经储存的那个信息状态还原

1
//序列化一个int数组
2
public static void Obj_Output(String desc) throws IOException {
3
    ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(desc)));
4
    int []arr = {1,2,3,4};
5
    oos.writeObject(arr);
6
    oos.flush();
7
    oos.close();
8
}
9
//反序列化这个int数组
10
public static void  Obj_Input(String src) throws IOException, ClassNotFoundException {
11
    ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(src)));
12
    int []a = (int[]) ois.readObject();
13
    System.out.println(Arrays.toString(a));
14
    ois.close();
15
}

如果想要序列化自己定义的类，需要implement Serializable接口，没有什么实质性的用处，就是标志可序列化

1
{
2
    private String name;
3
    private int id;
4
}
5
public static void Obj_Output(String desc) throws IOException {
6
    ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(desc)));
7
    Stu xixi = new Stu("xixi", 10);
8
    oos.writeObject(xixi);
9
    oos.flush();
10
    oos.close();
11
}
12
public static void Obj_Output(String desc) throws IOException {
13
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(desc)));
14
        Stu xixi = new Stu("xixi", 10);
15
        oos.writeObject(xixi);
16
        oos.flush();
17
        oos.close();
18
}

注：

如果想要一个属性不需要被序列化，那么要在这个属性前面添加transient关键字
static修饰的成员不会被序列化
父类实现了序列化接口，子类所有的内容都能序列化
子类实现了序列化接口，子类只能序列化自己的内容，不能序列化父类中继承的内容