《Java 程序设计》— IO接口（II）
文件：
构造方法：
1、File (String <pathname>)
pathname：表示相对路径或绝对路径
例如：
File f1 = new File("D:"+File.separator+"java2");
String s = "java2\\myfirst"; //当前目录的子目录java2\\myfirst
File f2 = new File(s);
2、File (String <parent>, String <child>)
parent：表示所对应的文件或目录的绝对或相对路径
child：表示文件或目录名
例如：
File f3 = new File("java2\\myfirst", "first.java");
3、File (File <parent>, String <child>)
parent：表示一个已经存在的代表某磁盘目录的File对象。
child：表示文件或目录名。
例如：
String sdir = "java2"+File.separator+"myfirst";
String sfile = "first.java";
File Fdir = new File(sdir);
File Ffile = new File(Fdir, sfile);
获取文件或目录属性方法：
public boolean exists();
public boolean isFile();
public boolean is Directory();
public String getName();
public String getPath();
public long length();
public boolean canRead();
public boolean canWrite();
public String[] list(); //列出目录中的文件。将目录下所有文件名保存在字符串数组中返回。
public boolean equals(File f);
文件或目录操作方法：
public boolean renameTo(File newFile);
public void delete();
public boolean mkdir();
public boolean mkdirs();
例如：
import java.io.*;
public class FileOperation
{
public static void main(String args[])
{
try
{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String sdir = "d:\\temp";
String sfile;
File Fdir1 = new File(sdir); //利用相对路径创建File对象，代表目录temp
if(Fdir1.exists() && Fdir1.isDirectory())
{
System.out.println("There is a directory "+sdir+" exists.");
for(int i=0; i<Fdir1.list().length; i++)
{
System.out.println((Fdir1.list())[i]);
}
File Fdir2 = new File("d:\\temp", "temp1");
if(!Fdir2.exists())
{
Fdir2.mkdir();
}
System.out.println();
System.out.println("Now the new list after create a new dir: ");
for(int i=0; i<Fdir1.list().length; i++)
{
System.out.println((Fdir1.list())[i]);
}
}
System.out.println("Enter a file name in this directory: ");
sfile = in.readLine();
File Ffile = new File(Fdir1, sfile);
if(Ffile.isFile())
{
System.out.println("File "+Ffile.getName()+" in Path "+Ffile.getPath()+" is "+Ffile.length()+" in length. " );
}
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
文件输入输出流：
文件输入流类-java.io.FileInputStream
文件输出流类-java.io.FileOutputStream
步骤：1、利用文件名字符串或File对象创建输入输出流对象。
FileInputStream(String FileName) throws FileNotFoundException;
FileInputStream(File f) throws FileNotFoundException;
2、从文件输入输出流中读写数据。
int read() throws IOException; //从输入流中读下一个字节数据。到达文件末尾返回-1。
void write(int b) throws IOException; //向输出流写一个字节的数据。只有低8位被写入文件。
3、关闭文件输入输出流与文件的连接。
close(); //是对它们父类的覆盖。
例如：
java CopyFile first.txt second.txt
将文件first拷贝到second，不管second有没有内容，最终first与second一样。
import java.io.*;
public class CopyFile
{
public static void main(String[] args) throws IOException
{
int i;
FileInputStream fin;
FileOutputStream fout;
try
{
fin=new FileInputStream(args[0]);
}
catch(FileNotFoundException e)
{
System.out.println("Input File Not Found. ");
return;
}
try
{
fout=new FileOutputStream(args[1]);
}
catch(FileNotFoundException e)
{
System.out.println("Error Opening Output File. ");
return;
}
while((i=fin.read())!=-1)
{
fout.write(i);
}
fin.close();
fout.close();
}
}
随机访问文件流：
随机访问文件流类-java.io.RandomAccessFile，实现对文件的随机读写访问。
构造方法：
RandomAccessFile(File file, String mode) throws FileNotFoundException;
RandomAccessFile(String name, String mode) throws FileNotFoundException;
参数mode：指定RandomAccessFile对象可以用何种方式打开和访问文件。（r, rw, rwd, rws）
例如：
File fileName = new File("File.txt");
RandomAccessFile myRAF = new RandomAccessFile(fileName, "rw");
操作文件指针的方法：
1、getFilePointer()方法获取当前文件指针从文件头为基准偏移的字节数。
2、seek()方法从文件头为基准移动文件指针。
void seek(long pos) throws IOException 将文件指针移动到以文件头为基准再偏移pos指定的字节数位置处。在调用seek()后，下一个读写操作将在新位置上发生。
3、skipBytes()将文件指针向前移动指定的字节数。
int skipBytes() 返回实际移动的字节数。
4、length()方法获取文件的字节长度。
public long length()
读文件的方法：
read(), readBoolean(), readChar(), readInt(), readLong(), readFloat(), readDouble(), readLine()和readUTF()等。
写文件的方法：
write(), writeBoolean(), writeChar(), writeInt(),writeLong(), writeFloat(), writeDouble()和writeUTF()等。
void setLength(long len) throws IOException; 该方法将文件的长度修改为len，可以用于加长或缩短一个文件。
例如：
import java.io.*;
public class TextFileLineNo
{
public static void main(String args[]) throws IOException
{
RandomAccessFile f = new RandomAccessFile("TextFileLineNo.java", "r");
long lineNo=0, filePointer=0, length=f.length();
while(filePointer<length)
{
String str = f.readLine();
if(lineNo>=9)
{
System.out.print(++lineNo+":");
System.out.println(str);
}
else
{
System.out.print(" "+ ++lineNo+":");
System.out.println(str);
}
filePointer = f.getFilePointer();
}
}
}
对象串行化：（主要用在远程调用上，RMI就是这个原理）
对象输入流-java.io.ObjectInputStream
对象输出流-java.io.ObjectOutputStream
步骤：
1、定义可以用流处理的类。在类名后缀上implements Serializable。（一个类只有实现了Serializable接口，其对象才能够通过流进行输入输出）
import java.io.*;
class MySer implements Serializable
{
int x, y;
String s;
public MySer(int a, int b, String str)
{
x=a; y=b; s=str;
}
public String toString()
{
return "("+x+", "+y+", "+s+")";
}
}
2、创建节点输入输出流。对象按照流处理后，可以通过这些节点流输入输出到文件、内存、屏幕等。
如：
FileInputStream fi = new FileInputStream("first.dat");
FileOutputStream fo = new FileOutputStream("second.dat");
3、创建对象处理流ObjectInputStream和ObjectOutputStream。将创建的节点输入输出流作为参数传递给对象输入输出流，这样，对象就可以通过节点流进行输入输出了。
如：
ObjectInputStream ois = new ObjectInputStream(fi);
ObjectOutputStream oos = new ObjectOutputStream(fo);
4、从流中读写对象。readObject()方法从输入流中读取对象，该方法返回Object对象。writeObject()方法将对象写入对应的输出流。
mySer obj1 = new mySer(0,0,"Hello");
oos.writeObject(obj1);
mm obj2 = (mySer)ois.readObject();
例如：
MySer 这个类的对象MySer obj = new MySer(0,0,"Hello");被串行化后保存以来，以后调用的时候就可以恢复。
import java.io.*;
class MySer implements Serializable
{
int x, y;
String s;
public MySer(int a, int b, String str)
{
x=a; y=b; s=str;
}
public String toString()
{
return "("+x+", "+y+", "+s+")";
}
}
class TestMySerWrite
{
public static void main(String args[]) throws IOException
{
MySer obj = new MySer(0,0,"Hello");
FileOutputStream fo = new FileOutputStream("my.dat");
ObjectOutputStream oos = new ObjectOutputStream(fo);
oos.writeObject(obj);
}
}
上一篇： rt-thread学习1 - 线程
下一篇： C_位域(位段)