《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);
	}
}