在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据时要使用输入流读取数据,而当程序需要将一些数据保存起来时,就要使用输出流,可以通过图12-5表示出输入及输出的关系。
![]() |
(点击查看大图)图12-5 输入、输出的关系 |
在java.io包中流的操作主要有字节流、字符流两大类,两类都有输入和输出操作。在字节流中输出数据主要使用OutputStream类完成,输入使用的是InputStream类。在字符流中输出主要是使用Writer类完成,输入主要是使用Reader类完成。
在Java中IO操作也是有相应步骤的,以文件的操作为例,主要的操作流程如下:
(1)使用File类打开一个文件。
(2)通过字节流或字符流的子类指定输出的位置。
(3)进行读/写操作。
(4)关闭输入/输出。
java的IO流分两种流
字节流 InputStream OutputStream
字符流 Reader Writer
他们都是抽象类
具体实现
字节流 FileInputStream FileOutputStream
字符流 FileReader FileWriter
字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件、图片、歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点.
所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列.
字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。
字节流转换成字符流可以用 InputSteamReader OutputStreamWriter
转换成BufferdReader BufferedWriter 他们具有缓冲区
例如:读取文件 从字节流输入到字符流输入
定义一个字节流:
// 定义一个指向D:/TEXT.TXT 的字节流
FileInputStream fileInputStream = new FileInputStream("d:/text.txt");
//字节流转换成InputStreamReader
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
//InputStreamReader 转换成带缓存的bufferedReader
BufferedReader bufferedReader = new BufferedReader(inputSteamReader);
可以把读出来的内容赋值给字符
String ss = new String();
String s;
while((s = bufferedReader.readLine())!=null){
ss += s;
}
例如:写入文件 从字节流输出到字符流输出
FileOutputStream fileOutputStream = new FileOutputStream("d:/text.txt"); //定义一个指向D:/TEXT.TXT文件
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
bufferedWriter.write(s);
bufferedWriter.close();
outputStreamWriter.close();
fileOutputStream.close();
先来看一下流的概念:
在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。
程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。
字节流与字符流
在java.io包中操作文件内容的主要有两大类:字节流、字符流,两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成,输入使的是InputStream,在字符流中输出主要是使用Writer类完成,输入流主要使用Reader类完成。(这四个都是抽象类)
java中提供了专用于输入输出功能的包Java.io,其中包括:
InputStream,OutputStream,Reader,Writer
InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
Reader和 Writer.两个是为字符流(一个字符占两个字节)设计的,主要用来处理字符或字符串.
字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件、图片、歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点
所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列
字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以
字节流是最基本的,所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的 但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的
==================我们还可以看到:============
Reader类的read()方法返回类型为int :作为整数读取的字符(占两个字节共16位),范围在 0 到 65535 之间 (0x00-0xffff),如果已到达流的末尾,则返回 -1
inputStream的read()虽然也返回int,但由于此类是面向字节流的,一个字节占8个位,所以返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节,则返回值 -1。因此对于不能用0-255来表示的值就得用字符流来读取!比如说汉字.
操作流程
在Java中IO操作也是有相应步骤的,以文件操作为例,主要的操作流程如下:
1 使用File类打开一个文件
2 通过字节流或字符流的子类,指定输出的位置
3 进行读/写操作
4 关闭输入/输出
IO操作属于资源操作,一定要记得关闭
字节流
字节流主要是操作byte类型数据,以byte数组为准,主要操作类就是OutputStream、InputStream
字节输出流:OutputStream
OutputStream是整个IO包中字节输出流的最大父类,此类的定义如下:
public abstract class OutputStream extends Object implements Closeable,Flushable
从以上的定义可以发现,此类是一个抽象类,如果想要使用此类的话,则首先必须通过子类实例化对象,那么如果现在要操作的是一个文件,则可以使用:FileOutputStream类。通过向上转型之后,可以为OutputStream实例化
Closeable表示可以关闭的操作,因为程序运行到最后肯定要关闭
Flushable:表示刷新,清空内存中的数据
FileOutputStream类的构造方法如下:
public FileOutputStream(File file)throws FileNotFoundException
写数据:
1 import java.io.File;
2 import java.io.FileOutputStream;
3 import java.io.IOException;
4 import java.io.OutputStream;
5
6 public class Test11 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
10 String str="Hello World";
11 byte[] b=str.getBytes();
12 out.write(b);//因为是字节流,所以要转化成字节数组进行输出
13 out.close();
14 }
15 }
也可以一个字节一个字节进行输出,如下:
1 import java.io.File;
2 import java.io.FileOutputStream;
3 import java.io.IOException;
4 import java.io.OutputStream;
5
6 public class Test11 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
10 String str="Hello World";
11 byte[] b=str.getBytes();
12 for(int i=0;i<b.length;i++){
13 out.write(b[i]);
14 }
15 out.close();
16 }
17 }
以上输出只会进行覆盖,如果要追加的话,请看FileOutputStream类的另一个构造方法:
public FileOutputStream(File file,boolean append)throws FileNotFoundException
在构造方法中,如果将append的值设置为true,则表示在文件的末尾追加内容。
1 import java.io.File;
2 import java.io.FileOutputStream;
3 import java.io.IOException;
4 import java.io.OutputStream;
5
6 public class Test11 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 OutputStream out=new FileOutputStream(f,true);//追加内容
10 String str="\r\nHello World";
11 byte[] b=str.getBytes();
12 for(int i=0;i<b.length;i++){
13 out.write(b[i]);
14 }
15 out.close();
16 }
17 }
文件中换行为:\r\n
字节输入流:InputStream
既然程序可以向文件中写入内容,则就可以通过InputStream从文件中把内容读取进来,首先来看InputStream类的定义:
public abstract class InputStream extends Object implements Closeable
与OutputStream类一样,InputStream本身也是一个抽象类,必须依靠其子类,如果现在是从文件中读取,就用FileInputStream来实现。
观察FileInputStream类的构造方法:
public FileInputStream(File file)throws FileNotFoundException
读文件:
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStream;
5
6 public class Test12 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 InputStream in=new FileInputStream(f);
10 byte[] b=new byte[1024];
11 int len=in.read(b);
12 in.close();
13 System.out.println(new String(b,0,len));
14 }
15 }
但以上方法是有问题的,用不用开辟这么大的一个字节数组,明显是浪费嘛,我们可以根据文件的大小来定义字节数组的大小,File类中的方法:public long length()
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStream;
5
6 public class Test13 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 InputStream in=new FileInputStream(f);
10 byte[] b=new byte[(int) f.length()];
11 in.read(b);
12 in.close();
13 System.out.println(new String(b));
14 }
15 }
我们换种方式,一个字节一个字节读入~
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStream;
5
6 public class Test14 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 InputStream in=new FileInputStream(f);
10 byte[] b=new byte[(int) f.length()];
11 for(int i=0;i<b.length;i++){
12 b[i]=(byte) in.read();
13 }
14 in.close();
15 System.out.println(new String(b));
16 }
17 }
但以上情况只适合知道输入文件的大小,不知道的话用如下方法:
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.IOException;
4 import java.io.InputStream;
5
6 public class Test15 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 InputStream in=new FileInputStream(f);
10 byte[] b=new byte[1024];
11 int temp=0;
12 int len=0;
13 while((temp=in.read())!=-1){//-1为文件读完的标志
14 b[len]=(byte) temp;
15 len++;
16 }
17 in.close();
18 System.out.println(new String(b,0,len));
19 }
20 }
字符流
在程序中一个字符等于两个字节,那么java提供了Reader、Writer两个专门操作字符流的类。
字符输出流:Writer
Writer本身是一个字符流的输出类,此类的定义如下:
public abstract class Writer extends Object implements Appendable,Closeable,Flushable
此类本身也是一个抽象类,如果要使用此类,则肯定要使用其子类,此时如果是向文件中写入内容,所以应该使用FileWriter的子类。
FileWriter类的构造方法定义如下:
public FileWriter(File file)throws IOException
字符流的操作比字节流操作好在一点,就是可以直接输出字符串了,不用再像之前那样进行转换操作了。
写文件:
1 import java.io.File;
2 import java.io.FileWriter;
3 import java.io.IOException;
4 import java.io.Writer;
5
6 public class Test16 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 Writer out=new FileWriter(f);
10 String str="Hello World";
11 out.write(str);
12 out.close();
13 }
14 }
在默认情况下再次输出会覆盖,追加的方法也是在构造函数上加上追加标记
1 import java.io.File;
2 import java.io.FileWriter;
3 import java.io.IOException;
4 import java.io.Writer;
5
6 public class Test17 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 Writer out=new FileWriter(f,true);//追加
10 String str="\r\nHello World";
11 out.write(str);
12 out.close();
13 }
14 }
字符输入流:Reader
Reader是使用字符的方式从文件中取出数据,Reader类的定义如下:
public abstract class Reader extends Objects implements Readable,Closeable
Reader本身也是抽象类,如果现在要从文件中读取内容,则可以直接使用FileReader子类。
FileReader的构造方法定义如下:
public FileReader(File file)throws FileNotFoundException
以字符数组的形式读取出数据:
1 import java.io.File;
2 import java.io.FileReader;
3 import java.io.IOException;
4 import java.io.Reader;
5
6 public class Test18 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 Reader input=new FileReader(f);
10 char[] c=new char[1024];
11 int len=input.read(c);
12 input.close();
13 System.out.println(new String(c,0,len));
14 }
15 }
也可以用循环方式,判断是否读到底:
1 import java.io.File;
2 import java.io.FileReader;
3 import java.io.IOException;
4 import java.io.Reader;
5
6 public class Test19 {
7 public static void main(String[] args) throws IOException {
8 File f = new File("d:" + File.separator+"test.txt");
9 Reader input=new FileReader(f);
10 char[] c=new char[1024];
11 int temp=0;
12 int len=0;
13 while((temp=input.read())!=-1){
14 c[len]=(char) temp;
15 len++;
16 }
17 input.close();
18 System.out.println(new String(c,0,len));
19 }
20 }
字节流与字符流的区别
字节流和字符流使用是非常相似的,那么除了操作代码的不同之外,还有哪些不同呢?
字节流在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,而字符流在操作的时候是使用到缓冲区的
字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不close的情况下输出内容
那开发中究竟用字节流好还是用字符流好呢?
在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的,包括图片也是按字节完成,而字符是只有在内存中才会形成的,所以使用字节的操作是最多的。
如果要java程序实现一个拷贝功能,应该选用字节流进行操作(可能拷贝的是图片),并且采用边读边写的方式(节省内存)。
字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?
实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如图12-6所示。
下面以两个写文件的操作为主进行比较,但是在操作时字节流和字符流的操作完成之后都不关闭输出流。
范例:使用字节流不关闭执行
- package org.lxh.demo12.byteiodemo;
- import java.io.File;
- import java.io.FileOutputStream;
- import java.io.OutputStream;
- public class OutputStreamDemo05 {
- public static void main(String[] args) throws Exception { // 异常抛出, 不处理
- // 第1步:使用File类找到一个文件
- File f = new File("d:" + File.separator + "test.txt"); // 声明File 对象
- // 第2步:通过子类实例化父类对象
- OutputStream out = null;
- // 准备好一个输出的对象
- out = new FileOutputStream(f);
- // 通过对象多态性进行实例化
- // 第3步:进行写操作
- String str = "Hello World!!!";
- // 准备一个字符串
- byte b[] = str.getBytes();
- // 字符串转byte数组
- out.write(b);
- // 将内容输出
- // 第4步:关闭输出流
- // out.close();
- // 此时没有关闭
- }
- }
程序运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/acada23cd5cd436e872948ccaf5c3453.jpeg)
此时没有关闭字节流操作,但是文件中也依然存在了输出的内容,证明字节流是直接操作文件本身的。而下面继续使用字符流完成,再观察效果。
范例:使用字符流不关闭执行
- package org.lxh.demo12.chariodemo;
- import java.io.File;
- import java.io.FileWriter;
- import java.io.Writer;
- public class WriterDemo03 {
- public static void main(String[] args) throws Exception { // 异常抛出, 不处理
- // 第1步:使用File类找到一个文件
- File f = new File("d:" + File.separator + "test.txt");// 声明File 对象
- // 第2步:通过子类实例化父类对象
- Writer out = null;
- // 准备好一个输出的对象
- out = new FileWriter(f);
- // 通过对象多态性进行实例化
- // 第3步:进行写操作
- String str = "Hello World!!!";
- // 准备一个字符串
- out.write(str);
- // 将内容输出
- // 第4步:关闭输出流
- // out.close();
- // 此时没有关闭
- }
- }
程序运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/d51c6fa2e1dd70a6303f4c91de398f96.jpeg)
程序运行后会发现文件中没有任何内容,这是因为字符流操作时使用了缓冲区,而 在关闭字符流时会强制性地将缓冲区中的内容进行输出,但是如果程序没有关闭,则缓冲区中的内容是无法输出的,所以得出结论:字符流使用了缓冲区,而字节流没有使用缓冲区。
提问:什么叫缓冲区?
在很多地方都碰到缓冲区这个名词,那么到底什么是缓冲区?又有什么作用呢?
回答:缓冲区可以简单地理解为一段内存区域。
可以简单地把缓冲区理解为一段特殊的内存。
某些情况下,如果一个程序频繁地操作一个资源(如文件或数据库),则性能会很低,此时为了提升性能,就可以将一部分数据暂时读入到内存的一块区域之中,以后直接从此区域中读取数据即可,因为读取内存速度会比较快,这样可以提升程序的性能。
在字符流的操作中,所有的字符都是在内存中形成的,在输出前会将所有的内容暂时保存在内存之中,所以使用了缓冲区暂存数据。
如果想在不关闭时也可以将字符流的内容全部输出,则可以使用Writer类中的flush()方法完成。
范例:强制性清空缓冲区
- package org.lxh.demo12.chariodemo;
- import java.io.File;
- import java.io.FileWriter;
- import java.io.Writer;
- public class WriterDemo04 {
- public static void main(String[] args) throws Exception { // 异常抛出不处理
- // 第1步:使用File类找到一个文件
- File f = new File("d:" + File.separator + "test.txt");// 声明File
- 对象
- // 第2步:通过子类实例化父类对象
- Writer out = null;
- // 准备好一个输出的对象
- out = new FileWriter(f);
- // 通过对象多态性进行实例化
- // 第3步:进行写操作
- String str = "Hello World!!!";
- // 准备一个字符串
- out.write(str);
- // 将内容输出
- out.flush();
- // 强制性清空缓冲区中的内容
- // 第4步:关闭输出流
- // out.close();
- // 此时没有关闭
- }
- }
程序运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/ced7a878a1a7ad1551c9577ed17ae48f.jpeg)
此时,文件中已经存在了内容,更进一步证明内容是保存在缓冲区的。这一点在读者日后的开发中要特别引起注意。
提问:使用字节流好还是字符流好?
学习完字节流和字符流的基本操作后,已经大概地明白了操作流程的各个区别,那么在开发中是使用字节流好还是字符流好呢?
回答:使用字节流更好。
在回答之前,先为读者讲解这样的一个概念,所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成,所以在开发中,字节流使用较为广泛。
字节流与字符流主要的区别是他们的的处理方式
流分类:
1.Java的字节流
InputStream是所有字节输入流的祖先,而OutputStream是所有字节输出流的祖先。
2.Java的字符流
Reader是所有读取字符串输入流的祖先,而writer是所有输出字符串的祖先。
InputStream,OutputStream,Reader,writer都是抽象类。所以不能直接new
字节流是最基本的,所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的
但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化
这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联
在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的
在从字节流转化为字符流时,实际上就是byte[]转化为String时,
public String(byte bytes[], String charsetName)
有一个关键的参数字符集编码,通常我们都省略了,那系统就用操作系统的lang
而在字符流转化为字节流时,实际上是String转化为byte[]时,
byte[] String.getBytes(String charsetName)
也是一样的道理
至于java.io中还出现了许多其他的流,按主要是为了提高性能和使用方便,
如BufferedInputStream,PipedInputStream等