IO流(上)

 

IO流：本质就是一套数据传输的机制

inputOutputStream：输入输出流

 

根据数据传输方向：数据往内存中传输 -–-–-–-–-–-– 输入流

数据从内存中向外传输 -–-–-–-–-– 输出流

参照物是内存

 

 

根据数据传输的形式：字节流：以字节存储的数据

字符流：以字符存储的数据

 

IO流的四大基本流：四大基本流对应的类都是抽象类

	字符流	字节流
输出流	Writer	OuterPutStream
输入流	Reader	InputStream

 

根据数据存放或者获取的位置：硬盘，内存，网络，外设设备

硬盘：

　　往一个txt文件中写入数据 ------- 需要有：字符输出流 文件 ----- FileWirter

　　从一个txt文件中获取数据 -------- 字符流输入文件 ----------- FileReader

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
​
public class FileWriterDemo {
    public static void main(String[] args) throws IOException{
        //创建一个字符输出流的对象 
        // 会先检测指定文件是否存在，如果没有。会创建一个新的文件
        //如果已经存在，就会用新的文件进行覆盖
        FileWriter fw =new FileWriter(new File("E:\\a.txt"));
        
        //写数据
        //底层根据缓冲区进行数据传输
        //缓冲区数据转满之后才能进行传输
        //数据没有装满就没有进行传输
        fw.write("Hellow");
        
        //冲刷缓冲区
        //如果数据没有装满，就会滞留在缓冲区
        //冲刷缓冲区就不管数据有没有装满，都会进行数据传输
//      fw.flush();
        
        //关流
        //将文件之间的数据连接（通道）关闭
        //自带冲刷缓冲区
        fw.close();
        
        //强制针对对象变为无用对象，通知系统在某个时间进行回收
        fw=null;
        
    }
}

 

开发时的操作：

　　异常在IO流的处理方式

　　　　1.流对象初始值为null，真正初始化的过程在try块里

　　　　2.在关流之前要保证流对象不为null

　　　　3.不管关流操作是否成功，都要将流对象置为null，变为无用对象等待系统回收，提高内存利用率

　　　　4.关流可能失败，如果关流失败时，自带的冲刷区的操作还没有完成，可能会造成数据滞留在缓冲区，需要进行手动冲刷缓冲区的操作

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
​
public class FileWriterDemo {
    public static void main(String[] args) {
        // 往txt文件中写入数据 ------FileWriter
        // 1.流对象初始化值为null
        FileWriter fw = null;
        try {
            // 2.赋值给流对象
            fw = new FileWriter(new File("D:\\b.txt"));
            
            //4.手动冲刷缓冲区
            fw.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // 一定要关流
            // 关流操作保证流对象不能为null
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    // 3.强制对象为null
                    fw = null;
                }
            }
        }
    }
}

 

JDK1.7开始使用的新写法

允许将对方放入方法中（放在栈中）

import java.io.FileWriter;
​
public class FileWriterDemo {
    public static void main(String[] args) {
        //JDK1.7开始使用的新写法
        //自动含有关流操作
        try(FileWriter fw = new FileWriter("");) {
            fw.write("abds");
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

 

读取数据

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
​
public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象
        FileReader fr = new FileReader(new File("D:\\a.txt"));
        
        //读取数据
        //底层没有缓冲区，默认一个一个读
        //获取一个字符
        //返回值是-1时读取结束
        int i=fr.read();                        //返回的是字符的编码值
        System.out.println((char)i);            //a
        System.out.println((char)fr.read());    //b
        System.out.println((char)fr.read());    //c     
        System.out.println((char)fr.read());    //-1
    }
}
 

 

自定义缓冲区

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
​
public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象
        FileReader fr = new FileReader(new File("D:\\a.txt"));
        
        //自定义缓冲区 ----- 数组
        char[] cs = new char[5];
        //
        int len=-1;
        //循环读取
        //返回的时字符的个数
        while((len=fr.read(cs))!=-1){
            System.out.println(new String(cs,0,len));
        }
    }
}

 

案例：通过字符流，完成文件复制（解决异常问题)

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
​
/*
 * 通过字符流实现文件的复制
 */
public class CopyFileDemo {
    public static void main(String[] args) {
        // 1.流对象的初始化
        FileReader fr = null;
        FileWriter fw = null;
​
        try {
            // 表示真正的初始化
​
            fr = new FileReader(new File("D:\\a.txt"));
            fw = new FileWriter(new File("D:\\b.txt"));
​
            // 自建缓冲区
            char[] cs = new char[1024];
            int len = -1;
            while ((len = fr.read(cs)) != -1) {
​
                fw.write(new String(cs, 0, len));
            }
            // 手动冲刷
            fw.flush();
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            // 关闭流
            // 关闭输入流
            // 保证关闭的时候流不能是null
            if (fw != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    // 强制回收
                    fr = null;
                }
            }
        }
    }
}

 

往一个txt文件写入数据（以字节传输）----- 字节输出流 文件--------- FileOutPutStream

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
/*
 * 通过字符流实现文件的复制
 */
public class FileOutPutStreamDemo {
    public static void main(String[] args) throws IOException {
        //根据路径名来创建一个字节输出流的对象
        //会检测路径是否存在，如果不存在就创建一个新文件
        //如果存在就会覆盖
        //为true表明可以进行数据的追加，默认不追加
        FileOutputStream os = new FileOutputStream("D:\\a.txt",true);
        
        //写出数据----java中大部分的字节流没有缓冲区
        os.write("ABC".getBytes());
        
        //关流
        os.close();
    }
}

 

从一个txt文件中获取数据

import java.io.FileInputStream;
import java.io.IOException;
​
/*
 * 通过字符流实现文件的复制
 */
public class FileInPutStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建了一个字节输入流对象
        FileInputStream is = new FileInputStream("D:\\a.txt");
        
        //自建缓冲区
        byte[] bs = new byte[3];
        int len =-1;
        while((len=is.read(bs))!=-1){
            System.out.println(new String(bs,0,len));
        }
    }
}