7.txt

本书属于《开发专家之 Sun ONE》系列丛书

		//创建顺序输入流
		SequenceInputStream seqInput = new SequenceInputStream(fFilter);
		//创建输出文件对象
		FileOutputStream fOutput = new FileOutputStream(“SourceSum”);
		//每次读取的字符
		int bContent;
		//从文件输入流中读取内容
		while((bContent = seqInput.read())!=-1)
		{
			//写出到文件输出对象
			fOutput.write(nContent);
		}
		//关闭顺序输入流
		seqInput.close();
		//关闭文件输出对象
		fOutput.close();
	}
}
class FileFilter implements Enumeration
{
	File directory;
	String extension;
	String strFileList[];
	Filter filter;
	int nCounter;
	//构造方法
	FileFilter(String strDirectoryName,String extension)
	{
		this.extension = extension;
		//创建目录对象
directory = new File(strDirectoryName);
		if(directory.isDirectory())
		{
			//如果是目录，获取目录中所有文件
			filter = new Filter(extension);
			strFileList = directory.list(filter);
		}	
			else
			{
				//如果不是目录，获取当前文件
				strFileList = new String[1];
				strFileList[0] = strDirectoryName;
			}
			nCounter = 0;
	}
	//判断枚举中十分还有元素的方法
	public Boolean hasMoreElements()
	{
		if(nCounter<strFileList.length)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	//获取枚举中下一元素的方法
	public Object nextElement()
	{
		//如果还有元素
		if( hasMoreElements())
		{
			nCounter++;
			//返回文件输入流对象
			return new FileInputStream(strFileList[nCounter-1]);
		}
		else
			return null;
	}
}



例程7-11
//FilterWalker.Java
import Java.io.*;
import Java.util.*;
class FilterWalker implements Observer
{
    String[] patterns;
    File dir;
        FilterWalker (String dirname, String[] patterns) 
{
        dir = new File(dirname);
        this.patterns = patterns;
        // Start walking the file system.
        FileWalker fw = new FileWalker();
        fw.addObserver(this);
        fw.walk(new File(dirname), false, new FileFilter());
    }
    class FileFilter implements Java.io.FileFilter
{
        // Returns true if filename matches one of the patterns.
        public boolean accept(File file)
{
            if (file.isDirectory()) 
{
                return true;
            }
            String s = file.getName();
            if (patterns.length == 0) {
                return true;
            } else {
                for (int i=0; i<patterns.length; i++) {
                    if (s.endsWith(patterns[i])) {
                        return true;
                    }
                }
            }
            return false;
        }
    }
    // This method is called for each file that the file walker discovers.
    public void update(Observable o, Object arg) {
        System.out.println(arg);
    }
    public static void main(String[] args) {
        if (args.length < 1) {
            System.err.println(
                "Usage: Java Main <directory> [<pattern>...]");
        } else {
            // Retrieve patterns, if any.
            String[] patterns = new String[args.length-1];
            System.arraycopy(args, 1, patterns, 0, patterns.length);
            new Main(args[0], patterns);
        }
    }
}
//FileWalker.Java
import Java.io.*;
import Java.util.*;
import Java.util.zip.*;
class FileWalker extends Observable
{
    void walk(File dir, boolean includeDirectories, FileFilter filter)
{
        if (dir.isDirectory()) {
            if (includeDirectories) {
                setChanged();
                notifyObservers(dir);
            }
            File[] files = dir.listFiles(filter);
            if (files != null) {
                for (int i=0; i<files.length; i++) {
                    walk(files[i], includeDirectories, filter);
                }
            }
        } else {
            setChanged();
            notifyObservers(dir);
        }
    }
}



例程7-12
//DataIOTest.Java
import Java.io.*;
public class DataIOTest
{
    public static void main(String[] args) throws IOException
{
        //创建数据输出流
        DataOutputStream out = new DataOutputStream(new
				   FileOutputStream("content.txt"));
		//初始化输出数据
        double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 };
        int[] units = { 12, 8, 13, 29, 50 };
        String[] descs = {
   "Java T-shirt",
			   "Java Mug",
			   "Duke Juggling Dolls",
			   "Java Pin",
			   "Java Key Chain" 
};
        //数据输出
        for (int i = 0; i < prices.length; i ++)
{
            out.writeDouble(prices[i]);
            out.writeChar('\t');
            out.writeInt(units[i]);
            out.writeChar('\t');
            out.writeChars(descs[i]);
            out.writeChar('\n');
        }
		//关闭数据输出流
        out.close();
        //创建数据输入流
        DataInputStream in = new DataInputStream(
           new	 FileInputStream("content.txt"));

        double price;
        int unit;
        String desc;
        double total = 0.0;
        try 
{
	//利用数据输入流读文件内容
            while (true)
{
                price = in.readDouble();
                in.readChar();       // throws out the tab
                unit = in.readInt();
                in.readChar();       // throws out the tab
                desc = in.readLine();
                System.out.println("You've ordered " +
				    unit + " units of " +
				    desc + " at $" + price);
                total = total + unit * price;
            }
        } 
		//捕获异常
catch (EOFException e)
{
		e.printStackTrace();
        }
        System.out.println("For a TOTAL of: $" + total);
		//关闭数据输入流
        in.close();
    }
}



例程7-13
// DataIOException.Java
import Java.io.*;
class DataIOException
{
	public static void main(String args[])
	{
		//利用文件输入流创建数据输入流
		DataInputStream dis = new DataInputStream(
						New FileInputStream(“DataIOException.Java”));
		byte b;
		try
		{
			//读文件的内容并打印出来
			while(true)
			{
				b = dis.readByte();
				System.out.println((char)b);
				System.out.flush();
			}
		}
		//捕获文件结束异常
		catch(EOFException e1)
		{
			System.out.println(e1);
		}
		//捕获文件不存在异常
		catch(FileNotFoundException e2)
		{
			System.out.println(e2);
		}
		//捕获文件输入输出异常
		catch(IOException e3)
		{
			System.out.println(e3);
		}
		//处理其他异常
		catch(Throwable anything)
		{
			System.out.println(anything);
		}
	}
}



例程7-14
//BufferedInputDemo.Java
class BufferedInputDemo
{
	public static void main(String args[])
	{
		//创建与文件输入流对应的缓冲区输入流
		BufferedInputStream bis = new BufferedInputStream(
						new FileInputStream(“BufferedInputDemo.Java”));
		int b;
		try
		{
			//从缓冲区输入流中读数据
			while((b=bis.read())!=-1)
			{
				System.out.println((char)b);
			}
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
	}
}



例程7-15
//LineNumberDemo.Java
class LineNumerDemo
{
	public static void main(String args[])
	{
		//定义数据输入流
		DataInputStream dis;
		//定义文件输入流
		FileInputStream fis;
		//定义缓冲区输入流
		BufferedInputStream bis;
		//定义行号输入流
		LineNumberInputStream lnis;
		String strLine;
		
		Try
		{
			//创建文件输入流对象，与实际文件相连
			fis = new FileInputStream(“LineNumberDemo.Java”);
			//根据文件输入流对象创建缓冲区输入流
			bis = new BufferedInputStream(fis);
			//根据缓冲区输入流对象创建行号输入流
			lnis = new LineNumberStream(bis);
			//根据行号输入流创建数据输入流
			dis = new DataInputStream(lnis);
			//从数据输入流中读数据
			while((strLine=dis.readLine())!=null)
			{
				//从行号输入流中取得行号
				int nLineNumber = lis.getLineNumber();
				//打印出行号和当前行内容
				System.out.println(nLineNumer+”:”+strLine);
			}
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			//关闭数据输入流
			dis.close();
		}
	}
}



例程7-16
//FileCopy.Java
//自定义异常
class FileCopyException extends IOException
{
	public FileCopyException(String msg)
	{
		//调用父类的构造函数
		super(msg);
	}
}
//FileCopy类
public class FileCopy
{
	public static void copy(String sourcename,String destname) 
throw IOException
	{
		//创建源文件对象
		File sourcefile = new File(sourcename);
		//创建目标文件对象
		File destfile   = new File(destname);
		//定义文件输入流
		FileInputStream   source= null;
		//定义文件输出流
		FileOutputStream  dest = null;
		byte[] buffer;
		int    readbytes;
		try
		{
			//判断文件十分存在、是否为普通文件
	if(!sourcefile.exists() || !sourcefile.isFile())
				throw new FileCopyException("No such file:"+sourcename+"\n");
			//判断是否具有写权限
			if(!sourcefile.canRead())
				throw new FileCopyException(sourcename+"cann’t be read\n");
			//判断目标文件存在
			if(destfile.exists())
			{
				//目标文件是普通文件
				if(destfile.isFile())
				{
					//定义数据输入流
					DataInputStream in = new DataInputStream(System.in);
					String response;
					if(!destfile.canWrite())throw new
 FileCopyException(destname+"does not can write\n");
					System.out.println("Overwrite (Yes/No) ?");
					System.out.flush();
					//读取输入内容
					response = System.in.readline();
				}
				else
				{
					System.out.println(“不能对目录进行读写”);
				}
			}
			else
			{
				System.out.println(“指定的文件不存在”);
			}
			//创建文件输入对象
			source = new FileInputStream(sourcefile);
			//创建文件输出对象
			destination = new FileOutputStream(destfile);
			buffer = new byte[1024];
			//文件输出
			for(;;)
			{
				readbytes = source.read(buffer);
				if(readbytes==-1)break;
				destination.write(buffer,0,readbytes);
			}
		}
		finally
		{
			if(source!=null)
			{
				try
				{
					source.close();
				}
				catch(IOException e){};
			}
			if(destination!=null)
			{
				try
				{
					destination.close();
				}
				catch(IOException e){};
			}
		}
	}
	public static void main(String args[])
	{
		if(args.length!=2)
			System.out.println("Java FileCopy <SourceFile> <DestFile>");
		else
		{
			try
			{
				copy(args[0],args[1]);
			}
			catch(IOException e)
			{
				System.out.println(e.getMessage());
			}
		}
	}
	
	private static File parent(File f)
	{
		String dirname = f.getParent();
			if(f.isAbsolute())
				return new File(File.seperator);
			else
				return new File(System.getProperty("user.dir"));
	}