笔记：Java SE之IO流

一. File

1. 凡是与输入、输出相关的类、接口等都定义在java.io包下

2. File是一个类，可以有构造器创建其对象。此对象对应着一个文件（.txt .avi .doc .ppt .mp3 .jpg）或文件目录

3. File类对象是与平台无关的。

4. File中的方法，仅涉及到如何创建、删除、重命名等等。只要涉及文件内容的，File是无能为力的，必须由io流来完成

5. File类的对象常作为io流的具体类的构造器的形参。

6. renameTo(File newName):重命名。file1.renameTo(file2)；file1重命名为file2.要求：file1文件一定存在，file2一定不存在

7. mkDir():创建一个文件目录。只有在上层文件目录存在的情况下，才能返回true

8. mkDirs():创建一个文件目录。若上层文件目录不存在，一并创建

 

二. FileInputStream

//从硬盘存在的一个文件中，读取其内容到程序中。使用FileInputStream
// 要读取的文件一定要存在。否则抛FileNotFoundException
@Test
public void testFileInputStream1() throws Exception {
	// 1.创建一个File类的对象。
	File file = new File("hello.txt");
	// 2.创建一个FileInputStream类的对象
	FileInputStream fis = new FileInputStream(file);
	// 3.调用FileInputStream的方法，实现file文件的读取。
	/*
	 * read():读取文件的一个字节。当执行到文件结尾时，返回-1
	 */
	// int b = fis.read();
	// while(b != -1){
	// System.out.print((char)b);
	// b = fis.read();
	// }
	int b;
	while ((b = fis.read()) != -1) {
		System.out.print((char) b);
	}
	// 4.关闭相应的流
	fis.close();
}

 

三. FileOutStream

//FileOutputStream
@Test
public void testFileOutputStream() {
	// 1.创建一个File对象，表明要写入的文件位置。
	// 输出的物理文件可以不存在，当执行过程中，若不存在，会自动的创建。若存在，会将原有的文件覆盖
	File file = new File("hello2.txt");
	// 2.创建一个FileOutputStream的对象，将file的对象作为形参传递给FileOutputStream的构造器中
	FileOutputStream fos = null;
	try {
		fos = new FileOutputStream(file);
		// 3.写入的操作
		fos.write(new String("I love China！").getBytes());
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		// 4.关闭输出流
		if (fos != null) {
			try {
				fos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

四. FileReader & FileWriter

@Test
public void testFileReaderWriter(){
	//1.输入流对应的文件src一定要存在，否则抛异常。输出流对应的文件dest可以不存在，执行过程中会自动创建
	FileReader fr = null;
	FileWriter fw = null;
	try{
		//不能实现非文本文件的复制
//		File src = new File("C:\\Users\\shkstart\\Desktop\\1.jpg");
//		File dest = new File("C:\\Users\\shkstart\\Desktop\\3.jpg");
		File src = new File("dbcp.txt");
		File dest = new File("dbcp1.txt");
		//2.
		fr = new FileReader(src);
		fw = new FileWriter(dest);
		//3.
		char[] c = new char[24];
		int len;
		while((len = fr.read(c)) != -1){
			fw.write(c, 0, len);
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		if(fw != null){
			try {
				fw.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if(fr != null){
			try {
				fr.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

 

五. BufferedInputStream & BufferedOnputStream

package com.java.IO;

public class TestFileReaderWriter {



}
//使用缓冲流实现文件的复制的方法
public void copyFile(String src,String dest){
	BufferedInputStream bis = null;
	BufferedOutputStream bos = null;
	try {
		//1.提供读入、写出的文件
		File file1 = new File(src);
		File file2 = new File(dest);
		//2.想创建相应的节点流：FileInputStream、FileOutputStream
		FileInputStream fis = new FileInputStream(file1);
		FileOutputStream fos = new FileOutputStream(file2);
		//3.将创建的节点流的对象作为形参传递给缓冲流的构造器中
		bis = new BufferedInputStream(fis);
		bos = new BufferedOutputStream(fos);
		//4.具体的实现文件复制的操作
		byte[] b = new byte[1024];
		int len;
		while((len = bis.read(b)) != -1){
			bos.write(b, 0, len);
			bos.flush();
		}
	}catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally{
		//5.关闭相应的流
		if(bos != null){
			try {
				bos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
		if(bis != null){
			try {
				bis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}
}

 

六.InputStreamReader & OutStreamReader

七. 其它的流

1. 转换流：实现字节流与字符流之间的转换

①. InputStreamReader:输入时，实现字节流到字符流的转换，提高操作的效率（前提是，数据是文本文件）   ===>解码：字节数组--->字符串

②. OutputStreamWriter：输出时，实现字符流到字节流的转换。 ===>编码：  字符串---->字节数组

2. 标准的输入输出流

①. System.in: The "standard" input stream:从键盘输入数据

②. System.out:The "standard" output stream：从显示器输出数据

3. 打印流 (都是输出流)  PrintStream(处理字节)  PrintWriter(处理字符) 

可以使用System.setOut（PrintStream p）重新设置一下输出的位置。  

PrintStream p = new PrintStream(new FileOutputStream("hello.txt"),true);

4. 数据流（处理基本数据类型、String类、字节数组）

DataInputStream  DataOutputStream

5. 对象流(用来处理对象的)

>对象的序列化机制：允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

ObjectInputStream（Object readObject();）   ObjectOutputStream  (void writeObject(Object obj))

如何创建流的对象：ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("person.txt")));

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("person.txt")));

实现序列化机制的对象对应的类的要求：

①. 要求类要实现Serializable接口

②. 同样要求类的所有属性也必须实现Serializable接口

③. 要求给类提供一个序列版本号：private static final long serialVersionUID;

④. 属性声明为static 或transient的，不可以实现序列化

6. 随机存取文件流:RandomAccessFile

①. 既可以充当一个输入流，又可以充当一个输出流：public RandomAccessFile(File file, String mode) 

②. 支持从文件的开头读取、写入。若输出的文件不存在，直接创建。若存在，则是对原有文件内容的覆盖。

③. 支持任意位置的“插入”。

 

个人IO方面学的不太好