IO流

一、File

1、 File类的对象代表着一个文件或一个文件目录

        > 当我们使用绝对路径时，不同的操作系统的路径分隔符不一样，我们可以使用File.separator，代替分隔符

// 构造器
File file = new File("hello.txt");

new File(File parent, String child) 

new File(String parent, String child) 

二、IO流

1、 流的分类： 

        > 按操作的数据单位不同分为： 字节流 、 字符流

        > 按数据流的流向不同分为：输入流，输出流

        > 按流的角色的不同分为：节点流，处理流                                                                                     

                    

2、流的体系结构

            抽象基类                        节点流                                缓冲流

        > InputStream                    FileInputStream                BufferedInputStream    

        > OutputStream                 FileOutputStream             BufferedOutputSteam  

        > Reader                            FileReader                       BufferedReader     

        > Writer                              FileWriter                          BufferWriter 

3、 字符流读入的简单使用

1、 File的实例化
File file = new File("hello.txt");
2、FileReader的实例化
FileReader fr = new FileReader(file);
3、读入的操作
int data = fr.read();  //read() ： 返回读入的一个字符，如果达到文件末尾，返回 -1

while(data != -1) {
    System.out.print((char) data);
    data = fr.read();
}
4、资源的关闭

File file = new File("hello.txt");

FileReader fr = new FileReader(file);

char[] cbuf = new char[1024];
int len;

while((len = fr.read(cbuf)) != -1 ) {
    for (int i ; i < len; i++) {
        System.out.print(cbuf[i]);
    }
}

4、 从内存中写出到硬盘文件里

File file = new File("hello1.txt");

FileWrite fw = new FileWrite(file);

fw.wtite("I have a dream");

fw.close();

说明：File写出懂得时候，如果文件不存在会自动创建

           File构造器中还可以追加一个boolean参数，表示是否在原有文件的基础上进行修改

5、读入和写出的结合

File srcFile = new File("hello.txt");// 

File destFile = new File("hello1.txt");

FileReader fr = new FileReader(srcFile);

FileWtite fw = new FileWrite(destFile);

char[] cbuf = new char[1024];
int len ;

while(( len = fr.read(cbuf) ) != -1) {
    fw.write(cbuf,0,len);
}

fr.close;
fw.close;

6、 实现图片的复制

       字符流是不能读写图片类型的文件的，这时我们就需要使用字节流

FileInputStream fis = new FileInputStream(new File("1.jpg"));

FileOutputStream fos = new FileOutputStream(new File("2.jpg"));

byte[] bbuf = new byte[1024];
int len;

while( ( len = fis.read(bbuf) ) != -1 ) {
    fos.write(bbuf,0,len);
}

fis.close;
fos.close;

7、 缓冲流的使用

FileInputStream fis = new FileInputStream(new File("1.jpg"));

FileOutputeStream fos = new FileOutputSteam("2.jpg");

//缓冲流
BufferInputStream bis = new BufferInputStream(fis);

BufferOutputStream bos = new BufferOutputStream(fos);

byte[] bbuf = new byte[1024];
int len;

while( ( len = bis.read(bbuf) ) != -1 ) {
    bos.write(bbuf, 0 , len);
} 

bis.close;
bos.close;
//fis.close;
//fos.close;
内层可以不关，因为外层关的同时，内层也会关闭

8、 转换流

        InputStreamReader: 将一个字节的输入流转换为字符的输入流

        OutputStreamWriter ：将一个字符的输出流转换为字节的输出流

FileInputStream fis = new FileInputStream(new File("1.txt"));
FileOutputStream fos = new FileOutputStream(new File("2.txt"));

InputStreamReader isr = new InputStreamReader(fis,"utf-8");// utf-8不写的话，使用默认的编码集
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

char[] cbuf = new char[1024];
int len;

while( ( len = isr.read(cbuf) ) != -1 ) {
    osw.write(cbuf,0,len);
}

isr.close();
osw.close();

9、 标准输入、输出流

InputStreamReader isr = new InputStreamReader(System.in);

BufferReader br = new BufferReader(isr);

while(true) {
    System.out.println("输入一个字符");
    String data = br.readLine();

    if( "e".equals(data )) {
        break;
    }

    String upper = data.toUpperCase();
    System.out.println(upper)
}

br.close();

10、 对象流

        > 对象的序列化机制：把存储在内存中的Java对象转换成二进制流，从而允许把这种二进制流持久的保存在磁盘中，或通过网络将这种二进制流传输到另一个网络节点，当其他程序获取到了这些二进制流，就可以恢复成原来的Java对象了

        > 对象流的使用： ObjectInputStream  和  ObjectOutputStream

        > 序列化的过程，使用ObjectOutputStream

ObjectOuputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

oos.writeObject(new String("输出的对象流"));

oos.flush(); // 刷新操作

oos.close();

        > 反序列化的过程， 使用ObjectInputStream

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));

Object obj = ois.readObject();

System.out.print(obj);

ois.close();

注意： 当我们序列化自定义的类时，我们自定义的类需要实现Serializable接口 （一个标识接口），该类中还要提供一个全局常量： serialVersionUID，还必须保证自定义类的内部的属性也是可以序列化的

           被static和transient修饰的成员变量不能被序列化

public class Student implements Serializable {
    private static final long serialVersionUID=7981560250804078637l;
    String name ;
    int age ;

    public Student() {

    }

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

    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 +
                '}';
    }
}