Java Api之IO流输入与输出
1输入与输出
|
input |
某个设备或者环境进行数据的输入 |
|
output |
某个设备或者环境进行数据的输出 |
在java中，java将输入输出抽象为流对象（IO流）来解决，我们以文件设备来解释：
|
输入流 |
从文件读取数据或者从键盘输入数据 |
|
输出流 |
向文件写入数据 |
Io流在java中又分为字节流和字符流：
|
字节流 |
所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列 |
|
字符流 |
字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！ |
2、字符流
|
字符输出流超类 |
字符输出流子类 |
|
Writer |
FileWriter |
|
BufferedWriter |
|
字符输入流超类 |
字符输入流子类 |
|
Reader |
FileReader |
|
BufferedReader |
(1) 字符输出流FileWriter
FileWriter的构造方法：
|
FileWriter(File file) |
根据给定的file对象构造一个FileWriter对象 |
|
FileWriter(String filename) |
根据给定的文件名对象构造一个FileWriter对象 |
举例：使用字符流向一个文件输出Hello World！
步骤：
1） 创建文件；
2） 创建输出流对象；
3） 把输出流对象指向文件；
4） 清空缓存。
5） 关闭输出流
package com.file;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileCreate {
public static void main(String[] args) {
//创建file对象
File file=null;
FileWriter fw=null;
try {
//创建文件
file=new File("D:/test/newFile.txt");
file.createNewFile();
//创建文件输出流
fw=new FileWriter(file);
//把内容写入文件
fw.write("Hello World!");
//清空缓存，把内容写入文件
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fw!=null){
try {
//关闭输出流
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
当我们每次使用输出流向文件里写输出数据的时候，写入数据会覆盖文件里原有数据，若是我们想要文件里原有数据不被覆盖，我们可使用FileWrite的追加构造方法：
|
FileWriter(File file,boolean append) |
构造方法的第二个boolean参数用来表示是否追加
|
|
FileWriter(String filename, boolean append) |
例如我们再向上例中Hello World!后追加Hello China！
package com.file;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileCreate {
public static void main(String[] args) {
//创建file对象
File file=null;
FileWriter fw=null;
try {
//创建文件
file=new File("D:/test/newFile.txt");
file.createNewFile();
//创建文件输出流,输出数据将追加在文件中原有数据后面
fw=new FileWriter(file,true);
//把内容写入文件
fw.write("Hello China!");
//清空缓存，把内容写入文件
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fw!=null){
try {
//关闭输出流
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
从上里可以看出，两次输入的数据（Hello World!Hello China!）是在一行，如果我们想让追加后的数据另起一行呢
在输入数据时“\r\n”表示换行，效果如下：
package com.file;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileCreate {
public static void main(String[] args) {
//创建file对象
File file=null;
FileWriter fw=null;
try {
//创建文件
file=new File("D:/test/newFile.txt");
file.createNewFile();
//创建文件输出流,输出数据将追加在文件中原有数据后面
fw=new FileWriter(file,true);
//把内容写入文件,并换行
fw.write("Hello Beijing!\r\n");
//清空缓存，把内容写入文件
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fw!=null){
try {
//关闭输出流
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
在windows系统中“\r\n”表示换行
在Linux系统中“\n”表示换行
在ios系统中“\r”表示换行
FilterWriter的writer方法还有其他写入功能：
|
writer(Char[ ] chuf) |
写入字符数组 |
|
writer(Char[ ] chuf,int offset,int length) |
写入字符数组的某一部分 |
|
writer(int i) |
写入单个字符（int转换为ASCII） |
|
writer(String str) |
写入字符串 |
|
writer(String [ ] str,int offset,int length) |
写入字符串的某一一部分 |
（2）字符输入流FileReader
FileReader的构造方法：
|
FileReader(File file) |
在给定从中读取数据的File的情况下传建一个新的FileReader |
|
FileReader(String fileName) |
在给定从中读取数据的File文件名的情况下传建一个新的FileReader |
举例：使用字符流从一个文件读取数据！
步骤：
1） 创建输入流对象；
2） 把输出流对象指向文件；
3） 读取数据；
4） 关闭输入流。
package com.file;
import java.io.*;
public class FileIO {
public static void main(String[] args) {
//创建FileReader对象
FileReader fr=null;
try {
//把输入流指向需要读取的文件
fr=new FileReader("D:/test/newFile.txt");
//创建字符数组
char[] chars=new char[1024];
int num=-1;
//读取数据，如果读取完毕，则num将返回-1
while ((num=fr.read(chars))!=-1){
//将字符数组中数据转换为字符串并输出到控制台
String str=new String(chars,0,num);
System.out.println(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
} (3)字符输入流之BufferedReade
BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取一个文本行，从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。
BufferedReader提供了readLine()方法来读取一行数据
package com.file;
import java.io.*;
public class FileIO {
public static void main(String[] args) {
//创建FileReader对象
FileReader fr=null;
//BufferedReader
BufferedReader br=null;
try {
//把输入流指向需要读取的文件
fr=new FileReader("D:/test/newFile.txt");
//用BufferedReader包装FileReader
br=new BufferedReader(fr);
//创建字符串
String str=null;
//读取数据，如果读取完毕，则str将返回null
while ((str=br.readLine())!=null){
//将字符串输出到控制台
System.out.println(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
(4)字符输入流之BufferedWriter
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 该类提供了 newLine() 方法，它使用平台自己的行分隔符概念。
package com.file;
import java.io.*;
public class FileCreate {
public static void main(String[] args) {
//创建file对象
File file=null;
FileWriter fw=null;
BufferedWriter bw=null;
try {
//创建文件
file=new File("D:/test/newFile.txt");
if (!file.exists()){
file.createNewFile();
}
//创建文件输出流,输出数据将追加在文件中原有数据后面
fw=new FileWriter(file,true);
//用BufferedWriter包装FileWriter
bw=new BufferedWriter(fw);
//把内容写入文件,并换行
bw.write("Hello Xian!");
bw.newLine();
bw.write("Hello madi");
//清空缓存，把内容写入文件
bw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fw!=null){
try {
//关闭输出流
bw.close();
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3、字节流
(1)字节输出流OutputStream
OutputStream是整个IO包中字节输出流的最大父类，此类是一个抽象类，如果想要使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化。具体事例如下：
package com.file;
import java.io.*;
public class OutputStreamDemo {
public static void main(String[] args) {
//创建文件对象
File file = new File("D:/test/newFile2.txt");
//声明输出流
OutputStream os=null;
try {
//将输出流指向文件对象
os=new FileOutputStream(file);
String str="Hello World";
byte[] bytes=str.getBytes();
//向指定文件输出数据
os.write(bytes);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if(os!=null){
try {
//关闭输出流
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}}}（2）字节输入流InputStream
既然程序可以向文件中写入内容，则就可以通过InputStream从文件中把内容读取进来，
与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，就用FileInputStream来实现。具体事例如下：
package com.file;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class InputStreamDemo {
public static void main(String[] args) {
//构造一个文件输入流对象
InputStream is=null;
try {
//将输入流对象指向文件
is=new FileInputStream("D:/test/newFile2.txt");
byte[] bytes=new byte[1024];
//temp用来存储读入的字节长度
int temp;
//循环读取数据
while ((temp=is.read(bytes))!=-1){
String str=new String(bytes,0,temp);
System.out.print(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (is!=null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
（3）字节输入流之InputStreamReader
InputStreamReader将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码。
构造方法：
|
构造一个默认编码集的InputStreamReader类 |
InputStreamReader isr = new InputStreamReader(InputStream in); |
|
构造一个指定编码集的InputStreamReader类 |
InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName); |
package com.file;
import java.io.*;
public class InputStreamDemo {
public static void main(String[] args) {
//构造一个文件输入流对象
InputStream is=null;
InputStreamReader isr=null;
try {
//将输入流对象指向文件
is=new FileInputStream("D:/test/newFile2.txt");
//用InputStreamReader包装FileInputStream
isr=new InputStreamReader(is);
char[] chars=new char[1024];
//temp用来存储读入的字节长度
int temp;
//循环读取数据
while ((temp = isr.read(chars))!= -1){
String str=new String(chars,0,temp);
System.out.print(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (isr!=null){
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (is!=null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
（4）字节输出流之OutputStreamWriter
OutputStreamWriter将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码。
构造方法：
|
构造一个默认编码集的OutputStreamWriter类 |
OutputStreamWriter osw = new OutputStreamWriter(OutputStream out); |
|
构造一个指定编码集的OutputStreamWriter类 |
OutputStreamWriter osw = new OutputStreamWriter(OutputStream out,String charsetName); |
package com.file;
import java.io.*;
public class OutputStreamDemo {
public static void main(String[] args) {
//创建文件对象
File file = new File("D:/test/newFile2.txt");
//声明输出流
OutputStream os=null;
//声明OutputStreamWriter对象
OutputStreamWriter osw=null;
try {
//将输出流指向文件对象
os=new FileOutputStream(file,true);
//用OutputStreamWriter包装OutputStream
osw=new OutputStreamWriter(os);
String str="\r\nHello China!";
//向指定文件输出数据
osw.write(str);
osw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (osw!=null){
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(os!=null){
try {
//关闭输出流
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
上一篇： Java NIO之Buffer
下一篇： Java使用Jdom读取xml解析实例