JAVA笔记整理（十），JAVA中的IO

IO流

IO（input，output）流用来处理设备之间的数据传输。

按照操作数据分为字节流（InputStream，OutputStream）和字符流（Reader，Writer）。

按照流向分为输入流（InputStream，Reader）和输出流（OutputStream，Writer）。

字符流

字符流的基类为Writer和Reader，从该这两个类中派生出一系列的子方法，下面以常用的FileWriter和FileReader来演示字符流的读和写。

字符流的读

使用FileReader需要注意的点：

• 该类使用read()方法来读取文件内容
• read()方法可以读取单个字符，也将字符读入到数组中，如果是读取到数组中，返回的是读取到的字符数
• read()方法如果读取到文件末尾，会返回-1
• 如果将字符读取到数组中，通常会将数组设置为1024的整数倍
• 读取完成后，需要使用close()方法关闭流

读取单个字符

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 
 * FileRead读取单个字符来读取文件
 * 
 * @author
 *
 */
public class FileReaderDemo {

    public static void main(String[] args) {
        FileReader fr = null; // 创建一个FileReader对象
        try {
            fr = new FileReader("E:/新建文件夹/demo.txt"); // 实例化FileReader对象，并传入要读取的文件
            int ch;
            while ((ch = fr.read()) != -1) { // 判断是否到大文件末尾，如果没有，则一直循环
                System.out.print((char) ch); // 输出读取到的内容
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) { // 关闭流之前先判断该流是否已经实例化
                try {
                    fr.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
            }
        }
    }
}

将字符读入到数组中

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.CharBuffer;

/**
 * 将文件读取到字符数组中
 * 
 * @author 
 *
 */
public class FileReaderDemo2 {

    public static void main(String[] args) {
        FileReader fr = null; // 创建一个FileReader对象
        try {
            fr = new FileReader("E:/新建文件夹/demo.txt"); // 实例化FileReader对象，并传入要读取的文件
            char[] chArr = new char[1024]; // 声明数组，用来存放读取的字符，通常会将数组设置为1024的整数倍
            int index = 0;
            while ((index = fr.read(chArr)) != -1) { // 判断是否到大文件末尾，如果没有，则一直循环
                System.out.print(chArr);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) { // 关闭流之前先判断该流是否已经实例化
                try {
                    fr.close();
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
            }
        }
    }
}

字符流的写

使用FileWriter需要注意的点

• 该类使用write()方法来将内容写入到文件中
• write()方法可以写入字符串、字符串的一部分、单个字符、字符数组、字符数组的一部分
• 该类的构造方法中加入参数true，表示是则将数据写入文件末尾处，而不是写入文件开始处
• 需要使用flush()方法来刷新缓存区，在刷新之前，数据是存放在内存中，并没有写入到文件中
• 写入完成后，需要关闭该流，关闭之前，会自动刷新缓存区

import java.io.FileWriter;
import java.io.IOException;

/**
 * FileWriter写入文件
 * 
 * @author
 *
 */
public class FileWriterDemo {
    public static void main(String[] args) {

        FileWriter fw = null;

        try {
            fw = new FileWriter("E:/新建文件夹/demo.txt", true);// 创建一个FileWriter对象，该对象一旦初始化就必须明确要被操作的文件。
            char[] charArray = { '1', 'a', '2', 'b', '3', 'c' };// 向建立的文件中写入数据，但是现在还没有写入到文件中，而是存在缓存区（内存）里。
            fw.write(charArray); // 将数组内容写入
            fw.flush();// 刷新缓存，将内容写入到文件中
            fw.write(charArray, 0, 3); // 将部分数组内容写入
            fw.write('d'); // 写入单个字符
            fw.write("hello world");// 写入字符串
            fw.write("HELLOWORLD", 0, 3);// 写入部分字符串
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close(); // 关闭流，关闭之前，刷新缓存，将内容存入文件中
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

缓冲字符流

普通的输入输出流都是直接对文件操作进行读写，直接读取字节转换成字符并且返回，直接将字符转换成字节写入文件，这样频繁的操作文件效率很低，所以Java提供了缓冲字符流，先将文件读取或者写入到一个缓冲区中（缓冲区大小可自定义可默认，一般默认即可），待到缓冲区满了或者flush或者关闭流时候，再对文件进行操作，提高了读写效率。

使用缓冲字符流需要注意的点：

• 缓冲区的原理是以数组形式对数据流进行封装，缓冲满了或者刷新缓冲区，再对文件进行操作。
• 可以使用readLine方法来读取一行数据
• 可以使用newLine来写入一个行分隔符
• 关闭缓冲区就是关闭流对象

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 使用缓冲字符流复制文件
 * @author 
 *
 */
public class BufferedCopy {
    public static void main(String[] args) {
        BufferedCopy bc = new BufferedCopy();
        bc.copy("D:\\1.txt", "D:\\2.txt");
    }

    public void copy(String fileName, String newFileName) {

        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            fr = new FileReader(fileName); // 实例化FileReader对象，传入要copy的文件
            br = new BufferedReader(fr); // 实例化BufferedReader对象，将FileReader对象作为参数传入
            bw = new BufferedWriter(new FileWriter(newFileName)); // 实例化FileReader对象，并作为参数传入BufferedWriter实例中
            String line = null;
            while (true) {
                if ((line = br.readLine()) != null) { // 使用readLine方法读取一个文本行
                    bw.write(line); // 将读取到的内容写入到文件中
                    bw.newLine(); // 再写一个行分隔符
                    bw.flush(); // 刷新缓冲区
                } else {
                    break; // readLine方法如果读取到文章末尾，会返回null，如果返回null，则跳出循环
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流

我们除了要操作文本之外，还需要操作图片，视频等等，这时候就需要字节流。

字节流的基类是InputStream和OutputStream。

字符流和字节流的操作方式基本类似，不同在于在字符流中数组是字符数组，而字节流中数组是字节数组。

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 字节流复制图片
 * 
 * @author
 *
 */
public class CopyPic {
    public static void main(String[] args) {
        CopyPic cp = new CopyPic();
        cp.copy("D:\\1.jpg", "D:\\2.jpg");
    }

    public void copy(String pic, String newPic) {
        FileOutputStream fos = null; // 定义字节输出流
        FileInputStream fis = null; // 定义字节输入流
        try {
            fis = new FileInputStream(pic);// 初始化字节输出流
            fos = new FileOutputStream(newPic);// 初始化字节输入流

            byte[] arr = new byte[1024]; // 定义缓存数组
            int status = 0; // 定义标识，用来存储读取到的字节数

            while ((status = fis.read(arr)) != -1) {
                fos.write(arr, 0, status); // 写入到文件中
                fos.flush(); // 刷新缓存区
            }

        } catch (Exception e) {
            if (fis != null) {
                try {
                    fis.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }

            if (fos != null) {
                try {
                    fos.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        }
    }
}