字节流与字符流

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等都是采用字节的方式的保存,那么肯定字节流会比字符流使用的更广泛。
         但是需要说明的是,如果要是想操作中文的话,字符流肯定是最好使的。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值