文件和IO总结

 

 

文件和IO总结

一、File类
File（String path)：构造放法，参数为文件夹或文件的全路径。还有很多构造方法包括根据文件夹名创建一个文件

File（String  parent，String  child）以一个名为parent字符串作为父目录名，创建一个指向名为child文件对象

boolean exists()方法是判断File文件对象是否存在
否为文件还是文件夹
boolean createNewFile()：根据文件路径（构造方法传入），创建一个文件。
boolean mkdirs()：根据文件路径创建一个或者多个文件夹。
String getPath():得到全路径
String getName():得到文件名字
File[]listFiles():列出目录中的所有文件和文件夹

 

package java0725;

import java.io.File;

public class FileDisplay {

	/**
	 * @param args
	 */
	 

	public int printDir(String dirName) {
		int fileCount = 0;
		try {
			File dirFile = new File(dirName);
			File[] subFile = dirFile.listFiles();
			if (null == subFile || subFile.length == 0) {
				return 0;
			}
			for (int i = 0; i < subFile.length; i++) {
				if (subFile[i].isDirectory()) {
					String subDir = subFile[i].getAbsolutePath();
				 
						System.out.println("目录：" + subDir);
//						MyFrame.ja.append("目录：" + subDir);
//						fileCount += printDir(subDir);
						if(subDir.indexOf(Listener.str02)>=0){
							MyFrame.ja.append("文件：" + subDir);
							fileCount += printDir(subDir);
						}
						
				 
				}
				if (subFile[i].isFile()) {
					
					String fileName = subFile[i].getAbsolutePath();
					 
						System.out.println("文件：" + fileName);
						
						String strin = BaseIO02.readFile2String(fileName);
						if(strin.indexOf(Listener.str02)!=-1){
							MyFrame.ja.append("文件：" + fileName  + "\n");
						}
						fileCount++;
				 
					
				}

			}
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return fileCount;
	}

}

  二．IO体系结构

 1.流的概念 

　　流是字节序列的抽象概念。流和文件的差别：文件是数据的静态存储形式，而流是指数据传输时的形态。文件只是流      的操作对象之一。流按其操作的对象不同可以分为文件流、网络流、内存流、磁带流等。

2.流的分类：

    流按方向分为输入流(InputStream)和输出流(OutputStream):

    流按性质分为：

    基础字节流：⑴InputStream类：程序可以从中连续读取字节的对象叫输入流，在Java中， 用InputStream类来描                述所有输入流的抽象概念。这个类是抽象类。 
　　                ⑵OutputStream类：程序可以向其连续写入字节的对象叫输出流，在Java中，     用OutputStream类               来描述所有输出流的抽象概念。这个类也是抽象类。

 

package java0726;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class BaseIO {

	/**
	 *  程序主方法
	 */
	public static void main(String[] args)throws Exception {
		BaseIO bi = new BaseIO();
		String fileName = "src\\java0726\\BaseIO.java";
		String result = bi.readFile2String(fileName);
		System.out.println(result);
	}
	public String readFile2String(String fileName) throws IOException{
		InputStream ins = new FileInputStream(fileName);
		byte[] contentByte = new byte[ins.available()];
		ins.read(contentByte);
		String s=new String(contentByte);
		return s;
		
		
	}
}

 

 

缓冲字节流:BufferedInputStream/BufferedOutputStream,过滤流是用来包装基础字节流，以提供更好的特性，如提供缓冲           功能的BufferedInputStream/BufferedOutputStream，过滤流并不直接连接数据源。

 

package java0726;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class BaseIO04 {

	/**
	 *  程序主方法
	 */
	public static void main(String[] args)throws Exception {
		BaseIO04 bi = new BaseIO04();
		String srcName = "E:\\学习\\java 资料\\jdk1.6.CHM";
		//要复制的目标文件
		String backName = "D:\\jdk1.6.CHM";
		boolean result = bi.copyFile(srcName,backName);
		System.out.println("复制结果："+result);
		
	}
	/*简单的文件复制
	 * srcName 源文件名
	 * destName 目标文件名
	 * return 是否成功
	 * 
	 */
	public boolean copyFile(String srcFile,String destFile) throws IOException{
		 
		File src = new File(srcFile);
		File dest = new File(destFile);

		
		//创建从源文件的输入流
		
		InputStream ins = new FileInputStream(src);
		//构建缓冲流
		BufferedInputStream bis =new BufferedInputStream(ins);
		
		//缓冲输出对象流
		OutputStream out = new FileOutputStream(dest);
		//构建缓冲流
		BufferedOutputStream bos = new BufferedOutputStream(out);
		
		int i=-1;
		long start = System.currentTimeMillis();
		while((i=ins.read())!=-1){
			 bos.write(i);
		}
		long timeCost = System.currentTimeMillis()-start;
		System.out.println("用时(单位：秒)："+timeCost/1000);
		ins.close();
		//清空输出流的缓存
		out.flush();
		out.close();
		return true;
	}	
}
//用时(单位：秒)：120
//复制结果：true

 基于具体数据类型的流：DataInputStream/DataOutputStream

 

 基于对象的读写流：ObjectInputStream/ObjectOutputStream

                      对象输入输出流需要对对象的输入输出类进行序列化，继承Serilizable接口，如果需要反序列化则需要进行Externalizable接口. transient关键字是提供成员变量不考虑此成员变量。

 

package java0726;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import org.omg.CORBA.DataOutputStream;

public class BaseIO06 {

	/**
	 *  程序主方法
	 */
	public static void main(String[] args)throws Exception {
		BaseIO06 bi = new BaseIO06();
		//要写入的文件名
		 bi.dataTypeStream();
		
	}
	public void  dataTypeStream() throws Exception{
		
		String fileName = "src\\java0726\\BaseIO05.data";
		FileOutputStream fos = new FileOutputStream(fileName);
		java.io.DataOutputStream dos = new java.io.DataOutputStream(fos);
		//按类型写入
		dos.writeBoolean(true);
		dos.writeByte((byte)123);
		dos.writeChar('J');
		dos.writeDouble(3.1415926);
		dos.writeFloat(2.7182f);
		dos.writeInt(123456789);
//		dos.writeLong(9988875475859607567L);
		dos.writeShort((short)11223);
		//按类型读取
		java.io.DataInputStream dis  = new java.io.DataInputStream(new FileInputStream(fileName));
		System.out.println("\t"+dis.readBoolean());
		System.out.println("\t"+dis.readByte());
		System.out.println("\t"+dis.readChar());
		System.out.println("\t"+dis.readDouble());
		System.out.println("\t"+dis.readFloat());
		System.out.println("\t"+dis.readInt());
		System.out.println("\t"+dis.readShort());
	}	
}