7、I/O流

 一、流的概念：流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。I/O就即用于处理设备之间的数据传输。

　　1、流的分类：

　　　　a）、按操作数据单位分类：字节流、字符流。

　　　　b）、按流向分类：输入流、输出流。

　　　　c）、按照功能分类：节点流、处理流。

　　

　　　　字节流的抽象基类：InputStream、OutputStream
　　　　字符流的抽象基类：Reader、Writer

二、字符流：Reader、Writer

　　1、FileWriter：

public class IOTest {

    /**
     * 需求：往一个文本文件里写入一些字符、字符串
     * 1、创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖。
     * 2、调用write方法，将字符串写入到流(内存)中
     * 3、调用flush方法刷新缓冲中的数据，将数据刷到目的地中
     * 4、close方法：关闭流资源，但是关闭之前会刷新一次内存中的缓冲数据，将数据刷新到目的地中
     * 
     * 注意：close和flush的区别：flush刷新后流可以继续使用;close刷新后会关闭流
     */
    public static void main(String[] args) {
        Writer writer = null;
        try{
            /* true:代表打开已存在的文件。如果指定的文件不存在，就会创建新的文件
             *     如果指定的文件已存在，不会创建新的文件，会在原有数据的基础上追加新的数据*/ 
            writer = new FileWriter("E:\qqq.txt", true);
            writer.append('a'); //将指定字符添加到此 writer
            writer.append("123qwerewqr");//将指定字符序列添加到此 writer。
            writer.append("--abcdesafd", 0, 4);// 包含头，不包含尾 将指定字符序列的子序列添加到此 writer.Appendable  即将"--abcdesafd"的第0-3位上的字符添加到write上
            char[] ch = new char[]{'A', 'Q', 'W', 'T'};
            writer.write(ch);//写入数组
            writer.write(ch, 1, 2);//写入数组的一部分
            writer.write("adsfkwe
字符流写入示例");// 记事本里要换行使用

            
            writer.flush();// 调用flush方法刷新缓冲中的数据，将数据刷到目的地中
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try {
                if(writer != null){
                    writer.close();// 在关闭流资源之前，会先调用flush方法，然后再关闭
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

运行后可在相应的txt文件中看到下面的类容：

a123qwerewqr--abAQWTQWadsfkwe
字符流写入示例

　　2、FileRead：

　　　　a）、一个一个的读：

public class IOTest {
    /**
     * 1、创建一个fileReader对象，和指定的文件想关联，要保证文件已经存在，如果不存在会报FileNotFoundException错误
     * 2、调用读取流的read方法，一次读一个字节，并且会自动往下读。
     * 3、调用close方法关闭资源
     */
    
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("E://qqq.txt");
            System.out.println((char)fr.read()); //这个地方一定要加强转，否则显示的将是ASCLL码的值
            //读取文件中所有的字符
            while(fr.ready()){  //如果保证下一个 read() 不阻塞输入
                System.out.print((char)fr.read());
            }
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　　　b）、用数组来一次性提取文件中的类容：

public class IOTest {
    /**
     * 1、创建一个fileReader对象，和指定的文件想关联，要保证文件已经存在，如果不存在会报FileNotFoundException错误
     * 2、调用读取流的read方法，一次读一个字节，并且会自动往下读。
     * 3、调用close方法关闭资源
     */
    
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("E://qqq.txt");
            char[] buff = new char[4];
            int num1 = fr.read(buff);// 将字符读入至buff数组里，返回的是读取的字符数
            System.out.println(num1 + "	" + String.valueOf(buff));
            
            int num2 = fr.read(buff);
            System.out.println(num2 + "	" + String.valueOf(buff));
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
显示结果为：
4    a123
4    qwer
*/

 三、字符流的缓冲区：缓冲区提高了流的操作效率。但必须注意在创建缓冲区之前必须要先有流的对象。

　　1、BufferedWriter

public class IOTest {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter("E:\qqq.txt");// 创建一个字符流的输出对象
            bw = new BufferedWriter(fw);// 创建一个缓冲区字符流，将字符流对象作为参数传递给构造方法
            bw.write("asdflkj;l123123");// 通过 write方法将内容写入缓冲区里
            bw.write("asdflkj;l123123");
            bw.newLine();//写入一个行分隔符。
            bw.write("asflkj;l123123");
            bw.newLine();
            bw.write("asdflkj;l123123");
            bw.flush();// 通过flush方法将缓冲区里的内容写入至目标文件里
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            try{
                if(bw != null){
                    bw.close();// 会关闭与之相关的字符流对象
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    /*
     在qqq.txt文件中输出结果为：
     asdflkj;l123123asdflkj;l123123
     asflkj;l123123
     asdflkj;l123123
     * */
}

　　2、BufferedReader

public class IOTest {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            // 创建一个字符输入流对象
            fr = new FileReader("E:\qqq.txt");
            // 创建一个缓冲字符输入流，将字符输入流对象作为参数传递给构造方法
            br = new BufferedReader(fr);
            String str = "";
            while((str = br.readLine()) != null){ //readLine():读取一个文本行
                System.out.println(str);
            }
        }catch (Exception e) {
            e.printStackTrace();
        } finally{
            try{
                if(br != null){
                    br.close();// 关闭与之相关的字符流
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

四、字节流：InputStream、OutputStream

　　1、FileInputStream

public class IOTest {
    /**
     * 读取a.jpg这幅图片中的数据在后台显示
     */
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
            fis = new FileInputStream("E:\a.jpg");
            byte[] buff = new byte[1024];
            int len = 0;
            while((len = fis.read(buff)) != -1){
                for(int i = 0; i < len; i++){
                    System.out.print(buff[i]);
                }
                System.out.println();
            }
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null){
                    fis.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

　　2、FileOutputStream

public class IOTest {
    /*
     * 向qqq.txt文件中写入一个一组数据
     */
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream("E:\qqq.txt");
            byte[] b1 = new byte[]{122, 97, 99, 65, 90};
            fos.write(b1);// 通过write方法写入一个字节数组
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fos != null){
                    fos.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

　　3、通过字节流及字节流缓冲区复制一个图片

public class IOTest {
    /*将E盘中的a.jpg图片复制为b.jpg
     * 
     */
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            fis = new FileInputStream("E:\b.jpg");
            fos = new FileOutputStream("E:\c.jpg");
            byte[] buff = new byte[1024];
            int len = 0;
            while((len = fis.read(buff)) != -1){
                for(int i = 0; i < len; i++){
                    fos.write(buff[i]);
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(fis != null)fis.close();
            }catch(Exception e){e.printStackTrace();}
            try{
                if(fos != null)fos.close();
            }catch(Exception e){e.printStackTrace();}
        }
    }
}

五、读取键盘录入：

public class IOTest {
    /*
     * 读取键盘值
     */
    public static void main(String[] args) throws IOException {
        //获取到读取键盘录入的流对象。类型是InputStream 
        InputStream is = System.in;
        while(true){
            int num1 = is.read();// 返回的是一个ASCLL码的值
            System.out.println((char)num1);
        }

    }
}

六、File：将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。separator：与系统有关的默认名称分隔符。

　　1、对文件的一些常见操作的举例：

public class IOTest {

    public static void main(String[] args) throws IOException {
        /*
         * 实验的空目录或者说是起始目录为E:\99
         */
        File file = new File("E:\99\a.txt");
        File file1 = new File("E:\99\aa");
        File file2 = new File("E:\99\bb\cc");
        File file3 = new File("E:\99\qqq.txt");
        /*
         * 创建文件或这是一个文件夹
         */
        //创建一个"a.txt"文件，创建成功则返回true
        System.out.println("createNewFile():" + file.createNewFile()); 
        //创建一个名字为"aa"的文件夹
        System.out.println("createNewFile():" + file1.mkdir()); 
        // 创建多级目录即在E:\99目录下先创建一个bb文件夹，再在bb文件夹下新建一个cc文件夹
        System.out.println("mkdirs():" + file2.mkdirs());
        
        /*
         * 删除一个文件或者删除一个文件夹
         */
        System.out.println("delete():" + file.delete());
        System.out.println("delete():" + file1.delete());
        System.out.println("delete():" + file2.delete());
        /*
         * 判断
         */
        //测试此抽象路径名表示的文件或目录是否存在
        System.out.println("exists()：" + file.exists());
        //测试此抽象路径名表示的文件是否是一个目录。
        System.out.println("isDirectory()：" + file.isDirectory());
        //测试此抽象路径名表示的文件是否是一个标准文件。
        System.out.println("isFile():" + file.isFile());
        // 测试此抽象路径名指定的文件是否是一个隐藏文件。
        System.out.println("isHidden():" + file.isHidden());
        /*
         * 获取信息
         */
        //返回由此抽象路径名表示的文件或目录的名称。
        System.out.println("getName():" + file3.getName());
        //返回此抽象路径名父目录的路径名字符串,如果此路径名没有指定父目录，则返回 null。
        System.out.println("getParent():" + file3.getParent());
        //将此抽象路径名转换为一个路径名字符串。
        System.out.println("getPath():" + file3.getPath());
        //返回此抽象路径名的绝对路径名字符串。
        System.out.println("getAbsolutePath()：" + file3.getAbsolutePath());
    }
}