IO流的操作：转换流，数据流，对象刘，缓冲流。

总结：
（1）IO流的分类
-->方向，输入流 (InputStream,Reader)与输出流 (OutputStream, Writer)
-->处理单元，字节流(InputStream,OutputStream)和字符流(Reader,Writer)
-->是否直接与设备相连
节点流 :FileInputStream ,FileOutputStream, FileReader,FileWriter
处理流 :
(1)转换流 InputStreamReader, OutputStreamWriter
(2)数据流 DataInputStream ,DataOutputStream
(3)对象流 ObjectInputStream , ObjectOutputStream
(4)缓冲流 BufferedReader ,BufferedWriter

（2）字节输入流 read() 0-255 ,read(byte[] buf)
字符输入流 read() 0-65535, read(char [] c)
缓冲输入流 readLine()

字节输出流 write(int b) ,write(byte [] buf)
字符输出流 write(String str)
缓冲输出流 newLine()，换行

（3）对象流，打不死就行会
自定义类，实现Serializable接口
添加UID
　　　　　　　不希望序列化属性加 transient关键字

20.1转换流
-->转换输出流 OutputStreamWriter 符转节
public OutputStreamWriter( OutputStream os, String charset){
}

(1)OutputStream可以为 FileOutputStream 说明目的的是文件
(2)OutputStream 可以为 System.out，说明目的的是显示器

package com.bjsxt.out;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;

public class TestWriter {
        public static void main(String[] args) throws IOException {
                //(1)创建对象  转换流的对象
                //Writer w=new OutputStreamWriter(new FileOutputStream("D:\\a.txt"), "utf-8");
                Writer w=new OutputStreamWriter(System.out, "gbk");
                //(2)写数据
                w.write("今天有点冷.....");
                
                
        //	w.flush();//刷新缓存
                w.write("还可以吧，不太冷");
                //w.flush();
                w.write("该我啥事!!!");
                //w.flush();
                
                //(3)关闭
                w.close();

        }
}

按照是否直接与（磁盘，内存等）设备相连，分节点和处理流
(1)流的构造方法中直接是数据源或目的地--》节点流
FileInputStream("D:\\a.txt") 数据源
FileOutputStream("D:\\a.txt")目的地
FileReader("D:\\a.txt") 数据源
FileWriter("D:\\a.txt") 目的地

(2)流的构造方法中使用了其它的流对象-->处理流
[1]转换流
OutputStreamWriter（OutputStream os ,String charset）
InputStreamReader(InputStream is,String charset)

--->转换输入流 InputStreamReader 节转符

package com.bjsxt.out;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;


public class TestReader {
        public static void main(String[] args) throws IOException {
                //(1)搭桥
                Reader r=new InputStreamReader(new FileInputStream("D:\\a.txt"),"utf-8");
                //(2)读
                char [] ch=new char[1024];
                int length=0;//读到的字符的个数
                while((length=r.read(ch))!=-1){
                        System.out.println(new String(ch,0,length));
                }
                r.close();
                
        }
}

20.2数据流
用于处理java的基本数据类型和String
用于读写java的基本数据类型数据和String类型的数据

-->DataOutputStream writeInt(..) ,writeBoolean(...),writeChar(..),writeUTF(....)
-->DataInputStream readInt() ,readBoolean(), readChar(),readUTF()

20.3对象流
用于处理java的基本数据类型和引用数据类型 ,建议使用它去处理引用数据类型
-->ObjectOutputStream writeObject(Object obj)
用于将对象，以byte的形式写进文件，称为序列化

要求自定义类，必须实现 Serializable 接口，只有实现了该接口的类，才具备序列化的能力如下代码，要求Person类必须实现 Serializable接口

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class TestObjectOutputStream {
        public static void main(String[] args) throws IOException {
                
                //(1)创建对象流对象
                ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
                //(2)写对象
                //oos.writeObject(new String("你好"));//向上类型转换 相当于 Object  obj=new String("hello");
                oos.writeObject(new Person("张胡", 20));
                //(3)关闭
                oos.close();
                
        }
}

-->ObjectInputStream 读对象 readObject ()
将byte读取还原成对象, 称为反序列化

package com.bjsxt.object;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class TestObjectInputStream {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
                //(1)Objectin
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:\\a.txt"));
                //(2)读对象
                Person p=(Person)ois.readObject();//向下类型转换
        
                //(3)关闭
                ois.close();
                System.out.println(p.getName()+"\t"+p.getAge());
        }
}

如果不希望某个属性被序列化，那么这个属性需要加上transient 关键字

public class Person implements Serializable {
        private String name;
        private transient int age;  //age的值将不会被序列化
....
}

只要序列化(写对象)与反序列化(读对象)的UID相同，无论属性怎么变化，都认为是操作的是同一个实体类

20.4缓冲流

用于提高读写效率

案例:从标准的输入设备获取数据源，将其存储到文件，然后再从文件中读取，要求提高读写效率，使用字符流

package com.bjsxt.dao;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;

public class TestBuffer {
        public static void main(String[] args) throws IOException {
                //(1)从输入设备上读取
                InputStream is=System.in;  //字节
                //InputStream is=new FileInputStream("D:\\a.txt");
                //(2)转换流，字节转字符
                Reader isr=new InputStreamReader(is,"gbk");//将键盘获取的字节转换为字符
                //(3)提高读取效率
                BufferedReader br=new BufferedReader(isr);
                /**BufferedReader br2=new BufferedReader(new InputStreamReader(System.in, "utf-8"));*/
                //创建缓冲输出流对象,作用是提高输出效率
                BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\a.txt"),"gbk"));
                //(4)读取
                //StringBuilder sb=new StringBuilder();//用于存储读到的字符串
                String line=null;//用于存储每次读到的一行字符串
                while((line=br.readLine())!=null){
                        if ("bye".equals(line)) {
                                break;
                        }
                        bw.write(line);
                        bw.newLine();  //换行
                        //sb.append(line);
                        //sb.append("\r\n");//写进文件中换行
                }
                
                
                /**将读到的数据写进文件*/
                //关闭顺序，要求倒着关，先关的后关，
                bw.close();
                br.close();
                        
                
        }
}

（3）对象流，打不死就得会
自定义类，实现Serializable接口
添加UID
　　　　　不希望序列化属性加 transient关键字

IO流的操作：转换流，数据流，对象刘，缓冲流。

猜你喜欢