Java学习系列(十)Java面向对象之I/O流(上)

IO流

我们知道应用程序运行时数据是保存在内存中的，但由于内存中的数据不可持久保存(如断电或程序退出时数据会丢失)，因此需要一种手段将数据写入硬盘或读入内存。面向IO流编程就是一种很好的选择。IO：Input/Output 完成输入输出，所谓输入：是指将外部存储器把数据读入内存，而输出：是指将内存中的数据写入外部存储器(如硬盘、磁盘、U盘)中。

File：代表磁盘上的文件或目录。它的特征是只能盘问磁盘上的文件和目录，但无法访问文件内容，必须使用IO流。

举例说明1(遍历根目录)：

publicclassFileTest{
publicstaticvoidmain(String[]args){
//列出系统中所有的根目录
File[]roots=File.listRoots();
for(Fileroot:roots){
System.out.println(root);
}
//下面是相对路径,生成的mydir文件和src同一目录;
//注意只有从根目录开始的路径才是绝对路径
FilemyFile=newFile("mydir");
if(!myFile.exists()){
//创建相应目录
myFile.mkdir();
}
}
}

举例说明2(遍历某个磁盘上的所有文件)：

/**
*@authorlhy
*@description递归遍历某个磁盘下的所有目录及其子目录
*/
publicclassFileTest{
publicstaticvoidmain(String[]args){
Filef=newFile("f:/");
myList(f);
}


publicstaticvoidmyList(Filedir){
System.out.println(dir+"目录下包含的目录和子文件有：");
//返回当前目录所包含的目录和子文件
File[]files=dir.listFiles();
for(Filefile:files){
System.out.println(""+file);
//如果file是目录,继续列出该目录下的所有文件
if(file.isDirectory()){
myList(file);
}
}
}
}

举例说明3(过滤文件):

publicclassFileTest{
publicstaticvoidmain(String[]args){
Filef=newFile("f:/");
File[]files=f.listFiles(newFileFilter(){
@Override
publicbooleanaccept(Filepathname){
try{
//getCanonicalPath()规范路径名是绝对路径名，并且是惟一的。
if(pathname.getCanonicalPath().endsWith(".txt")){
returntrue;
}
}catch(IOExceptione){
e.printStackTrace();
}
returnfalse;
}
});
for(Filefile:files){
System.out.println(file);
}
}
}

IO流的分类(如果要访问文件内容，必须使用IO流)：
a）按流的方向来分(从程序所在内存的角度来看)：分为输入流、输出流。输入流是指将外部输入读入当前程序所在内存；而输出流是指将当前程序所在的内存的数据输出到外部。
b）按流处理的数据来分：分为字节流、字符流。字节流处理的数据单元是字节，适应性广、能共强大；而字符流处理的数据单元是字符，通常来说它主要用于处理文本文件，而且它在处理文本文件时比字节流更方便。
c）按流的角色来分：分为节点流、包装流(处理流/过滤流)。节点流直接和一个IO的物理节点(磁盘上的文件、键盘、网络等)关联；而包装流以节点为基础，经包装之后得到的流。

【流的概念模型】
输入流：只要你得到一个输入流对象，你就相当于得到一根“水管”，每个水滴就代表数据单元(字节/字符)。
输出流：只要你得到一个输出流对象，你也相当于得到一根“水管”，水管中无水滴。

下面讲下IO里面常用的几个类。

FileInputStream类的使用：

publicclassTest{
publicstaticvoidmain(String[]args){
//准备水桶,可以装“1024”个水滴(数据单元)
byte[]bt=newbyte[1024];
FileInputStreamfis=null;
try{
fis=newFileInputStream("f:/Test.java");
inthasRead=-1;
while((hasRead=fis.read(bt))>0){
System.out.println(newString(bt,0,hasRead));
}
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
fis.close();
}catch(IOExceptionex){
ex.printStackTrace();
}
}
}
}

FileOutputStream类的使用：

publicclassTest{
publicstaticvoidmain(String[]args){
FileOutputStreamfos=null;
try{
fos=newFileOutputStream(newFile("f:/1.txt"));
fos.write("Java学习系列(十)Java面向对象之I/O流".getBytes());
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
fos.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}

文件的复制：

publicclassTest{
publicstaticvoidmain(String[]args){
FileOutputStreamfos=null;
FileInputStreamfis=null;
try{
fis=newFileInputStream(newFile("f:/Test.java"));
fos=newFileOutputStream(newFile("f:/Copy.java"));
inthasRead=-1;
//作為水桶
byte[]buff=newbyte[1024];
while((hasRead=fis.read(buff))>0){
fos.write(buff,0,hasRead);
}
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
fis.close();
fos.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}

ByteArrayOutputStream的使用：

publicclassTest{
publicstaticvoidmain(String[]args){
ByteArrayOutputStreambos=newByteArrayOutputStream();
Stringstr="你好,世界！";
try{
bos.write(str.getBytes());
System.out.println(newString(bos.toByteArray()));
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
bos.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}

缓冲流：我们知道外部存储器的速度要比内存速度慢，所以外部存储器的读写与内存的读写是不同步的。注意：流用完了，别忘了调用flush(把缓冲中的内容刷入实际的节点)或者调用close()也可-系统会在关闭之前，自动刷缓冲。

节点流与缓冲流的联系：
节点流：直接与IO节点关联，--IO节点很多：键盘、网络、文件、磁带....
过滤流：建立在节点流的基础之上。

好处：消除底层节点之间的差异。使用过滤流的方法执行IO更加便捷。

PrintStream的使用：

publicclassTest{
publicstaticvoidmain(String[]args){
PrintStreamps=null;
try{
//过滤流
ps=newPrintStream(newFileOutputStream("f:/1.txt"));
ps.println("春");
ps.println("夏");
ps.println("冬");
ps.println("冬");
}catch(FileNotFoundExceptione){
e.printStackTrace();
}
}
}

重定向标准输入输出。
System.setOut(new PrintStream("out.txt"));//将标准输出重定向到指定的输出流 -->out.txt

将字节流装换为字符流(使用BufferedReader可以每次读一行)：

publicclassTest{
publicstaticvoidmain(String[]args){
BufferedReaderbr=null;
try{
br=newBufferedReader(newInputStreamReader(newFileInputStream(
"f:/Test.txt")));
StringhasLine=null;
while((hasLine=br.readLine())!=null){
System.out.println(hasLine);
}
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
br.close();
}catch(Exceptione2){
}
}
}
}

【规律】除DataInputStream和DataOuputStream(这两个类后面会讲)这两个特殊的过滤流外，其它所有以Stream结尾的都是字节流，所有以Reader/Writer结尾的结尾的都是字符流。还有两个类：InputStreamReader、OutputStreamWriter是转换类，负责将字节流转换成字符流。

结束语

由于IO流的的内容比较多，所以打算分两次讲。