字节流与字符流

File类本身是与文件操作有关，但是如果要想操作内容则必须使用字节流或字符流完成，但是不管是使用何种的输入输出流，其基本的操作原理是一样的（以文件流为准）
                   1、使用File类找到一个文件
                   2、通过字节流或字符流的子类进行对象的实例化
                   3、进行读或写的操作
                   4、关闭字节或字符流
由于流的操作属于资源操作，所以在操作的最后一定要关闭以释放资源。
操作流有以下几个：
                   · 字节流：OutputStream、InputStream
                   · 字符流：Writer、Reader

字节输出流 OutputStream

         字节输出流使用的是OutputStream，此类定义如下：
public abstract class OutputStream extends Object implements Closeable, Flushable
         本类是一个抽象类，根据面向对象的概念，要通过子类进行对象的实例化操作。
         在此类中定义了如下的几个常用方法：
                   · 关闭流：public void close() throws IOException
                   · 写一组数据：public void write(byte[] b) throws IOException
                   · 写一个数据：public void write(int b) throws IOException
         但是要想为OutputStream实例化，且进行文件操作的话，就要使用FileOutputStream子类。
                   · 构造：public FileOutputStream(File file) throws FileNotFoundException
范例：使用字节流进行输出，输出“Hello World”。

package org.lxh.outputstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        // 1、通过File找到一个文件
        File file = new File("d:" + File.separator + "temp.txt");
        // 2、实例化OutputStream对象
        OutputStream out = new FileOutputStream(file);
        String info = "Hello World!!!"; // 要输出的字符串
        byte data[] = info.getBytes(); // 将字符串变为字节数组
        out.write(data); // 输出内容
        out.close();
    }
}

现在已经可以向文件中输出内容了，但是此时程序每执行一次，实际上都会输出，但是属于覆盖的操作，如果要想在文件的尾部追加的话，则必须观察FileOutputStream类的另外一个构造：

                  · 追加：public FileOutputStream(File file,boolean append) throws FileNotFoundException
如果需要在追加的上面加入换行的话，使用“\r\n”。

package org.lxh.outputstreamdemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class OutputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        // 1、通过File找到一个文件
        File file = new File("d:" + File.separator + "temp.txt");
        // 2、实例化OutputStream对象
        OutputStream out = new FileOutputStream(file, true); // 追加
        String info = "\r\nHello World!!!"; // 要输出的字符串
        byte data[] = info.getBytes(); // 将字符串变为字节数组
        out.write(data); // 输出内容
        out.close();
    }
}

字节输入流 InputStream

         程序中可以使用OutputStream进行输出的操作，也可以使用InputStream完成输入的操作，此类定义如下：
public abstract class InputStream extends Object implements Closeable
此类依然是一个抽象类，肯定要使用子类完成，如果是文件输入，使用FileInputStream类。
         InputStream类中定义的方法如下：
                   · 关闭：public void close() throws IOException
                   · 读取一个字节：public abstract int read() throws IOException
                   · 读取一组内容：public int read(byte[] b) throws IOException
如果要读，则肯定需要一个数组，数组肯定要首先开辟好大小，用于接收内容。但是，与OutputStream类似，要读取就要观察FileInputStream类的构造方法：
                   · 构造：public FileInputStream(File file) throws FileNotFoundException

package org.lxh.inputstreamdemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        File file = new File("d:" + File.separator + "temp.txt");
        InputStream input = new FileInputStream(file);
        byte data[] = new byte[1024]; // 开辟一个空间
        int len = input.read(data); // 接收输入流的内容
        System.out.println("内容是：（" + new String(data, 0, len) + "）");
    }
}

以上的代码属于一次性全部读取，但是在InputStream类中也可以每次读取一个字节。

public class InputStreamDemo02 {
    public static void main(String[] args) throws Exception {
        File file = new File("d:" + File.separator + "temp.txt");
        InputStream input = new FileInputStream(file);
        byte data[] = new byte[1024]; // 开辟一个空间
        int len = 0; // 记录读取的长度
        int temp = 0;
        do {
            temp = input.read(); // 读取一个字节
            if (temp != -1) { // 如果不为-1表示内容可以增加
                data[len++] = (byte) temp; // 保存在字节数组中
            }
        } while (temp != -1); // 如果不是-1表示还有内容可以读
        System.out.println("内容是：（" + new String(data, 0, len) + "）");
    }
}
//但是以上的读取方式在开发中会变成另外一种代码形式：
        int temp = 0;
        while ((temp = input.read()) != -1) {
            data[len++] = (byte) temp;
        }
//以上的程序的语句形式为以后使用的重点。

字符输出流Writer

         Writer属于字符输出流，Writer类也是一个抽象类，既然要操作文件，肯定使用FileWriter。

package org.lxh.writerdemo;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class WriterDemo01 {
    public static void main(String[] args) throws Exception {
        File file = new File("d:" + File.separator + "temp.txt");
        Writer out = new FileWriter(file);
        out.write("Hello World"); // 直接输出字符串
        out.close() ;
    }
}

字符输入流Reader

         Reader也肯定是一个抽象类，要输入文件使用FileReader。

package org.lxh.readerdemo;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class ReaderDemo01 {
    public static void main(String[] args) throws Exception {
        File file = new File("d:" + File.separator + "temp.txt");
        Reader read = new FileReader(file);
        char data[] = new char[1024];
        int len = read.read(data);
        System.out.println(new String(data, 0, len));
    }
}

字节流和字符流的区别
         字节流和字符流在使用上的代码结构都是非常类似的，但是其内部本身也是有区别的，因为在进行字符流操作的时候会使用到缓冲区，而字节流操作的时候是不会使用到缓冲区的。
         在输出的时候，OutputStream类即使最后没有关闭内容也可以输出。但是如果是Writer的话，则如果不关闭，最后一条内容是无法输出的，因为所有的内容都是保存在了缓冲区之中，每当调用了close()方法就意味着清空缓冲区了。那么可以证明字符流确实使用了缓冲区：
                   · 字节流：程序 à 文件
                   · 字符流：程序 à 缓冲区 à 文件
         如果现在字符流即使不关闭也可以完成输出的话，则必须强制性清空缓冲区：
· 方法：public void flush() throws IOException
         两者相比，肯定使用字节流更加的方便，而且在程序中像图片、MP3等都是采用字节的方式的保存，那么肯定字节流会比字符流使用的更广泛。
         但是需要说明的是，如果要是想操作中文的话，字符流肯定是最好使的。