JAVA IO 学习总结

【1】 JAVA IO流的定义：

Java的输入／输出的功能采用了流的 机制来实现输入／输出，所谓流，就是数据的有序排列，而流可以是从某个源出来，到某个目的地去的。由流的方向，可以分成输入流和输出流，一个程序从输入流读取数据向输出流写数据。而由流的处理数据类型不同可以分为字节流和字符流。

【2】 IO流的分类：（1）根据流的方向：输入流和输出流；（2）根据流处理的数据类型分为：字节流和字符流；（3）根据流的角色分为：节点流和处理流。

【3】 File类： （1）创建方法：1.boolean createNewFile() 不存在返回true 存在返回false；
2.boolean mkdir() 创建目录；（创建目录，但是如果父目录不存在，就无法创建）
3.boolean mkdirs() 创建多级目录；（创建目录，如果没有父目录，就连父目录一起创建）
（2）删除方法：1.boolean delete() 删除此抽象路径名表示的文件或目录；
2.boolean deleteOnExit()在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
（3）判断方法：1.boolean canExecute()判断文件是否可执行
2.boolean canRead()判断文件是否可读
3.boolean canWrite() 判断文件是否可写
4.boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
5.boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
（4）获取方法：1.String getName() 返回由此抽象路径名表示的文件或目录的名称。
2.String getPath() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
3.String[] list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
4.String[] list(FilenameFilter filter) 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

package com.zrj.io;

import java.io.File;

public class FileListTest {

	public static void main(String[] args) {
		File root = new File("C:/Users/Administrator/Desktop20141224我们的模拟数据库v0.1") ;
		FileListTest fileListTest = new FileListTest() ;
		fileListTest.list(root) ;
		
	}
	//属性：计数器
	int count ;
	
	 // 遍历出我们的子文件
	 
	public void list(File parent){	
		count+=1 ;
		//获取给定目录的所有下一级子文件
		File[] files = parent.listFiles() ;  
		//遍历下一级子文件
		for(File file:files){		
			for(int i=0;i<count;i++){
				System.out.print(" ") ;
			}
			System.out.println(file.getName()) ;
			list(file);		
			count-=1 ;
		}
		return ;					
	}

}

【4】 字节流（字节输入流：InputStream；字节输出流：OutPutStream）:
（1） FileInputStream ：从文件系统中的某个文件中获得输入字节。
常用方法：
1．int available()
返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
2．void close()
关闭此文件输入流并释放与此流有关的所有系统资源。
3．protected void finalize()
确保在不再引用文件输入流时调用其 close 方法。
4．FileChannel getChannel()
返回与此文件输入流有关的唯一 FileChannel 对象。
5．FileDescriptor getFD()
返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。
6．int read()
从此输入流中读取一个数据字节。
7．int read(byte[] b)
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
8．int read(byte[] b, int off, int len)
从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
9．long skip(long n)
从输入流中跳过并丢弃 n 个字节的数据。
（2） FileOutputStream: 用于写入诸如图像数据之类的原始字节的流:
常用方法：
1.void close()
关闭此文件输出流并释放与此流有关的所有系统资源。
2.protected void finalize()
清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。
3.FileChannel getChannel()
返回与此文件输出流有关的唯一 FileChannel 对象。
4.FileDescriptor getFD()
返回与此流有关的文件描述符。
5.void write(byte[] b)
将 b.length 个字节从指定 byte 数组写入此文件输出流中。
6.void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
7.void write(int b)

将指定字节写入此文件输出流。

（3） BufferedInputStream：继承FileInputStream是一个带有缓冲区域的InputStrea
常用方法：
int available()
返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。
void close()
关闭此输入流并释放与该流关联的所有系统资源。
void mark(int readlimit)
参见 InputStream 的 mark 方法的常规协定。
boolean markSupported()
测试此输入流是否支持 mark 和 reset 方法。
int read()
参见 InputStream 的 read 方法的常规协定。
int read(byte[] b, int off, int len)
从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
void reset()
参见 InputStream 的 reset 方法的常规协定。
long skip(long n)
参见 InputStream 的 skip 方法的常规协定。

（4） BufferedOutputStream：继承于FileOutputStream是一个带有缓冲区域的FileOutputStream
常用方法：
void flush()
刷新此缓冲的输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
void write(int b)
将指定的字节写入此缓冲的输出流。

package com.zrj.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class InputStreamTest {
	
	public static void main(String[] args) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			//读文件
			fis = new FileInputStream("D:/JavaIo/java.txt");
			//创建一个数组用于保存数据
			byte[] bytes = new byte[100];
			//读取文件中的数据
			fis.read(bytes);
			//创建一个文件的对象
			File file = new File("D:/JavaIo2/java.txt");
//			file.mkdirs();
			//创建新文件
			file.createNewFile();
			
			 fos = new FileOutputStream(file);
			//写入数据
			fos.write(bytes);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
				// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
				try {
					if(fis != null)
					fis.close();
					if(fos!=null)
						fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

</pre><pre name="code" class="java">

package com.zrj.FileRead;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class BufferedStreamTest {
	public static void main(String[] args) {
		try {
			//创建对象bis
			BufferedInputStream bis = new BufferedInputStream (new FileInputStream("../FileReader/src/com/zrj/FileRead/FileList2Test.java"));
			try {
				//
				if(bis.available()>0) {
					//判断是否支持mark()和reset()方法
					if(bis.markSupported()) {
						System.out.print((char)bis.read()) ;
						//做第一个标记
						bis.mark(0) ;
						for(int i=0;i<10;i++) {
							System.out.print((char)bis.read());
						}
						//从原先标记处取数据
						bis.reset();
						System.out.println();
						System.out.print((char)bis.read());
						System.out.print((char)bis.read());
						System.out.print((char)bis.read());
					}
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

（5）DataInputStream &DataOutputStream：
数据输入（出）流允许应用程序以与机器无关方式从底层输入（出）流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。有时没有必要存储整个对象的信息，而只是要存储一个对象的成员数据，成员数据的类型假设都是Java的基本数据类型，这样的需求不必使用到与Object输入、输出相关的流对象，可以使用DataInputStream、DataOutputStream来写入或读出数据.

</pre><pre name="code" class="java">

（6）ObjectInputStream和ObjectOutputStream ：用于存储和读取对象的输入输出流类，不难想象，我们只要把对象中的所有成员变量都存储起来，就等于保存了这个对象，我们只要读取到一个对象中原来保存的所有成员变量的取值，就等于读取到了一个对象。PS：ObjectInputStream与ObjectOutputStream类所读写的对象必须实现了Serializable接口。

package com.zrj.data;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectOutputStreamTest {
	public static void main(String[] args) throws IOException {
		ObjectOutputStream oos = null;
		try {
			// 1.创建ObjectOutputStream
			oos = new ObjectOutputStream(new FileOutputStream(
					"/DataStream/src/com/zrj/data/Cat.obj"));

			// 2.使用ObjectOutputStream将一个对象写入文件
			Cat cat = new Cat("xiaoT");
			cat.size = 100;
			cat.age = 5;
			oos.writeObject(cat);

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (oos != null) {
				oos.flush();
				oos.close();
			}
		}
	}

}

class Cat implements Serializable {
	static final long serialVersionUID = 1L ;
	String name;
	static int size = 10;
	/**
	 * 临时变量（transient），他在序列化时，将不会被序列化
	 * */
	transient int age = 1;

	/***/
	public Cat(String name) {
		this.name = name;
	}

	/**
	 * DIY写对象
	 * */
	private void writeObject(java.io.ObjectOutputStream out) throws IOException {
		System.out.println("writeObject") ;
		//调用默认写法，写入对象
		out.defaultWriteObject() ;
		//我们自行添加一个对临时变量的输出
		out.writeInt(age) ;
	}

	/**
	 * DIY读对象
	 * */
	private void readObject(java.io.ObjectInputStream in) throws IOException,
			ClassNotFoundException {
		System.out.println("readObject") ;
		//读取数据
		this.name = (String)in.readObject() ;
		//读取DIY写入的临时变量
		this.age = in.readInt() ;
		
	}

}

package com.zrj.data;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamTest {
	public static void main(String[] args) {
		//
		ObjectInputStream ois ;
		try{
			//创建ObjectInputStream对象
			ois = new ObjectInputStream(new FileInputStream("../DataStream/src/com/zrj/data/Cat.obj")) ;
			//从文件读取对象
			Cat cat = (Cat)ois.readObject() ;
			//我们可以序列化类的对象，以及他的成员属性，但是如果是被静态修饰的，将无法被序列化。
			//所以反序列化时，也无法拿到。
			System.out.println(cat.name+"  "+cat.size+"  "+cat.age) ;
		}catch(Exception e){
			e.printStackTrace() ;
		}
	}

}