输入和输出是所有应用中所必需的组成部分,通过IO可以读取输入数据以及存储数据到外部设备上。Java中的输入和输出是通过java.io来支持的。下面是本人在学习中的归纳和体会。
1. File类和文件过滤器
顾名思义,File类中是有关文件的操作。这里必须明确,文件还包括目录。通过文件或目录路径的字符串作为参数,根据传入的是目录路径还是文件名路径可以分别初始化不同的File对象。在File对象中封装了对文件的操作,例如新建文件,删除文件和重命名等方法。但是它并不能访问文件本身的内容,这需要输入输出流来完成。下面是有关File类的代码。
publicclassFileTest
{
publicstaticvoidmain(String[] args)throwsIOException
{
//以当前路径来创建一个File对象
File file =newFile(".");
//直接获取文件名,输出一点
System.out.println(file.getName());
//获取相对路径的父路径可能出错,下面代码输出null
System.out.println(file.getParent());
//获取绝对路径
System.out.println(file.getAbsoluteFile());
//获取上一级路径
System.out.println(file.getAbsoluteFile().getParent());
//在当前路径下创建一个临时文件
File tmpFile = File.createTempFile("aaa",".txt", file);
//指定当JVM退出时删除该文件
tmpFile.deleteOnExit();
//以系统当前时间作为新文件名来创建新文件
File newFile =newFile(System.currentTimeMillis() +"");
System.out.println("newFile对象是否存在:"+ newFile.exists());
//以指定newFile对象来创建一个文件
newFile.createNewFile();
//以newFile对象来创建一个目录,因为newFile已经存在,
//所以下面方法返回false,即无法创建该目录
newFile.mkdir();
//使用list方法来列出当前路径下的所有文件和路径
String[] fileList = file.list();
System.out.println("======当前路径下所有文件和路径如下=====");
for(String fileName : fileList)
{
System.out.println(fileName);
}
//listRoots静态方法列出所有的磁盘根路径。
File[] roots = File.listRoots();
System.out.println("======系统所有根路径如下=====");
for(File root : roots)
{
System.out.println(root);
}
}
}
在上面的代码中,使用list()方法可以返回目录下所有文件的路径和名称。使用文件过滤器,可以根据自己的需要选择返回的文件类型。通过一个实现了FilenameFilter接口的类对象作为list()方法的参数,就可以实现文件过滤的作用。过滤的规则在重写FilenameFilter中的accept()方法中定义。代码如下:
publicclassFilenameFilterTest
{
publicstaticvoidmain(String[] args)
{
File file =newFile(".");
String[] nameList = file.list(newMyFilenameFilter());
for(String name : nameList)
{
System.out.println(name);
}
}
}
//实现自己的FilenameFilter实现类
classMyFilenameFilterimplementsFilenameFilter
{
publicbooleanaccept(File dir, String name)
{
//如果文件名以.java结尾,或者文件对应一个路径,返回true
returnname.endsWith(".java")
||newFile(name).isDirectory();
}
}
2. 输入输出流
在Java中,从不同角度定义了输入输出流的分类。以内存作为流的方向基点,可将其分为输入流和输出流,流向内存的成为输入流,流出内存的成为输出流。从数据操作的最小单元来分类,可将其分为字节流和字符流。根据抽象程度分类,可将其分为节点流和处理流,处理流是连接到实际物理节点的节点流的封装,这样既可以不必去关注节点的来源(文件或者数组),用统一的方法去操作,又可以使用更加方面的方法来实现操作。
在学习中,本人对于输入输出流的总结归纳:
A. 字节流和字符流其实并没有本质的区别,无非是它们二者的操作单元不同。字节流的基类为InputStream和OutputStream,字符流的基类为Reader和Writer。它们所提供的读写方法一样,区别在于参数,需要对应流类型。
B. 输入流中的read系列方法是从输入流中读取数据的操作。空参数将返回所读取的字节(字符)。read方法中可以传入数组参数,数组的类型必须和流的数据类型相匹配,相当于一个竹筒,一次可读取最多等于数组容量的数据,并将所读数据装进数组中。
C. 输出流中的write系列方法是向输出流中写入数据的操作。方法中的参数可以是整型或字符型变量,也可以传入数组参数,数组的类型必须和流的数据类型相匹配,相当于一个竹筒,一次可写入最多等于数组容量的数据。特别地,字符型输出流的write方法可以传入字符串。
D. InputStream和OutputStream,Reader和Writer这四个类作为Java中输入输出流的抽象基类,并不能直接被初始化使用。Java中提供了一些继承了它们的类,用于实现具体的某种流操作。如:
a.File前缀系列的类(如FileInputStream),用于对文件类进行流操作,使用文件名作为构造函数的参数;示例代码如下:
输出类:
publicclassFileOutputStreamTest
{
publicstaticvoidmain(String[] args)throwsIOException
{
FileInputStream fis =null;
FileOutputStream fos =null;
try
{
//创建字节输入流
fis =newFileInputStream("FileOutputStreamTest.java");
//创建字节输入流
fos =newFileOutputStream("newFile.txt");
byte[] bbuf =newbyte[32];
inthasRead =0;
//循环从输入流中取出数据
while((hasRead = fis.read(bbuf)) >0)
{
//每读取一次,即写入文件输出流,读了多少,就写多少。
fos.write(bbuf ,0, hasRead);
}
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
finally
{
//使用finally块来关闭文件输入流
if(fis !=null)
{
fis.close();
}
//使用finally块来关闭文件输出流
if(fos !=null)
{
fos.close();
}
}
}
}
输入类:
publicclassFileInputStreamTest
{
publicstaticvoidmain(String[] args)throwsIOException
{
//创建字节输入流
FileInputStream fis =newFileInputStream("FileInputStreamTest.java");
//创建一个长度为1024的“竹筒”
byte[] bbuf =newbyte[1024];
//用于保存实际读取的字节数
inthasRead =0;
//使用循环来重复“取水”过程
while((hasRead = fis.read(bbuf)) >0)
{
//取出“竹筒”中水滴(字节),将字节数组转换成字符串输入!
System.out.print(newString(bbuf ,0, hasRead ));
}
fis.close();
}
}
b. 数组前缀系列类(如ByteArrayInputSteam),用于对数组进行流操作,使用数组对象作为构造函数的参数;
c. 转换流InputStreamReader将字节输入流转换为字符输入流;InputStreamReader将字节输出流转换为字符输出流,代码如下:
publicclassKeyinTest
{
publicstaticvoidmain(String[] args)
{
BufferedReader br =null;
try
{
//将Sytem.in对象转换成Reader对象
InputStreamReader reader =newInputStreamReader(System.in);
//将普通Reader包装成BufferedReader
br =newBufferedReader(reader);
String buffer =null;
//采用循环方式来一行一行的读取
while((buffer = br.readLine()) !=null)
{
//如果读取的字符串为"exit",程序退出
if(buffer.equals("exit"))
{
System.exit(1);
}
//打印读取的内容
System.out.println("输入内容为:"+ buffer);
}
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
//关闭输入流
finally
{
try
{
br.close();
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
}
}
}
d. 字符流的子类有String前缀(StringReader和StringWriter)系列类可以对字符串进行操作,代码如下:
publicclassStringNodeTest
{
publicstaticvoidmain(String[] args)
{
String src ="从明天起,做一个幸福的人\n"
+"喂马,劈柴,周游世界\n"
+"从明天起,关心粮食和蔬菜\n"
+"我有一所房子,面朝大海,春暖花开\n"
+"从明天起,和每一个亲人通信\n"
+"告诉他们我的幸福\n";
StringReader sr =newStringReader(src);
char[] buffer =newchar[32];
inthasRead =0;
try
{
//采用循环读取的访问读取字符串
while((hasRead = sr.read(buffer)) >0)
{
System.out.print(newString(buffer ,0, hasRead));
}
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
finally
{
sr.close();
}
//创建StringWriter时,实际上以一个StringBuffer作为输出节点
//下面指定的20就是StringBuffer的初始长度
StringWriter sw =newStringWriter(20);
//调用StringWriter的方法执行输出
sw.write("我远离了大海,\n");
sw.write("看不到春暖花开,\n");
sw.write("我只有一只小龟,\n");
sw.write("一样可以闻到馥郁花香\n");
System.out.println("------下面是sw的字符串节点里的内容------:");
//使用toString方法返回StringWriter的字符串节点的内容
System.out.println(sw.toString());
}
}
d.推回输入流PushbackInputStream和PushbackReader带有一个推回缓冲区,使用unread(数组)方法可以将一个字节/字符数组推回到推回缓冲区中。推回输入流也有read方法,使用read方法读取输入流时,首先从输入缓冲区中读取,读完之后才从输入流中读。代码如下:
publicclassPushbackTest
{
publicstaticvoidmain(String[] args)
{
PushbackReader pr =null;
try
{
//创建一个PushbackReader对象,指定推回缓冲区的长度为64
pr =newPushbackReader(newFileReader("PushbackTest.java") ,64);
char[] buf =newchar[32];
//用以保存上次读取的字符串内容
String lastContent ="";
inthasRead =0;
//循环读取文件内容
while((hasRead = pr.read(buf)) >0)
{
//将读取的内容转换成字符串
String content =newString(buf ,0, hasRead);
inttargetIndex =0;
//将上次读取的字符串和本次读取的字符串拼起来,查看是否包含目标字符串
//如果包含目标字符串
if((targetIndex = (lastContent + content).indexOf("new PushbackReader")) >0)
{
//将本次内容和上次内容一起推回缓冲区
pr.unread((lastContent + content).toCharArray());
//再次读取指定长度的内容(就是目标字符串之前的内容)
pr.read(buf ,0, targetIndex);
//打印读取的内容
System.out.print(newString(buf ,0,targetIndex));
System.exit(0);
}
else
{
//打印上次读取的内容
System.out.print(lastContent);
//将本次内容设为上次读取的内容
lastContent = content;
}
}
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
finally
{
try
{
if(pr !=null)
pr.close();
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
}
}
}
E. 在Java虚拟机中可以通过exec方法执行其他的应用程序,并返回Proess对象。利用该对象的getErrorStream、getInputStream和getOutputStream方法可以分别获得子进程的错误流,输出流和输入流(方向是以程序角度为基点)。
F. RandomAccessFile类提供对文件的随机访问,程序可以直接跳转到文件的任何地方来读取数据。它内部提供了与字节流同法相同的读写方法,另外又加入了自由定位文件记录指针的方法seek。在读写操作时以字节为单位。在构造函数中还需加入一个mode参数由于制定读写权限。
G. 需要注意Scanner对象的使用。Scanner对象用于捕获输入,并将输入内容转换为字符串。
//使用System.in创建Scanner对象,用于获取标准输入
Scanner sc =newScanner(System.in);
PrintStream ps =newPrintStream(
newFileOutputStream("out.txt"));
//增加下面一行将只把回车作为分隔符
sc.useDelimiter("\n");
//判断是否还有下一个输入项
while(sc.hasNext())
{
//输出输入项
ps.println("键盘输入的内容是:"+ sc.next());
}
ps.close();
对于初学者来说一个容易忽略的地方是,需要区别节点流和处理流构造方法中参数的意义。节点流中,构造方法参数是要读取或者输出地物理节点,是“目的地”或者“始发地”,而处理流的构造函数参数是所要包装的处理流对象,包装之后的操作实际上是间接操作节点流,并未对被包装的节点流本身属性做修改。采用处理流包装后,可以不用管节点流的数据类型,而根据处理流的性质传递在节点流中不能传递的内容,例如Obj;同时还可以增加一些便于操作的方法,比如缓冲区。