爪哇的学习（io流）

 file类

 它是文件和目录路径名的抽象表示

文件和目录是可以通过File封装成对象的

对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以 是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

File类的构造方法

public static void main(String[] args) {
		//	File f = new File("123.txt");
		
		//	File的separator用来实现跨平台的路径字符串
		System.out.println(File.separator);
		
		System.out.println(new File("aa\\bb\\123.txt"));
		
		//	这是一种更好的实现，因为使用了File的separator实现跨平台操作
		System.out.println(new File("aa" + File.separator + "bb" + File.separator + "123.txt"));
	}

}

 创建目录和删除目录与文件

public static void main(String[] args) {
		//File f = new File("aaa" + File.separator + "bbb" + File.separator + "123.txt");
		File f = new File("111\\222\\333\\444");

		//	如果文件不存在
		if(!f.exists()) {
			try {
				//	使用file对象的createNewFile()方法来创建该文件
				System.out.println("this is if.");
				//	mkdir()用来创建目录，前提是父路径存在，如果存在则成功创建，并返回为true，
				//	如果父路径不存在，则不能创建，并返回false
				//System.out.println(f.mkdir());
				
				//	mkdirs()用来创建目录，即使父路径不存在，也可以层级创建目录后创建最后的目录
				System.out.println(f.mkdirs());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}else {
			System.out.println("this is else.");
			//	delete()可以用来删除文件
			System.out.println(f.delete());;
		}
	}

}

 File类判断和获取功能

public class FileDemo04 {
public static void main(String[] args) {
//创建一个File对象
File f = new File("myFile\\java.txt");
// public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
// public boolean isFile()：测试此抽象路径名表示的File是否为文件
// public boolean exists()：测试此抽象路径名表示的File是否存在
System.out.println(f.isDirectory());
System.out.println(f.isFile());
System.out.println(f.exists());
// public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
// public String getPath()：将此抽象路径名转换为路径名字符串
// public String getName()：返回由此抽象路径名表示的文件或目录的名称
System.out.println(f.getAbsolutePath());
System.out.println(f.getPath());
System.out.println(f.getName());
System.out.println("--------");
// public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数
组
// public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象
数组
File f2 = new File("E:\\itcast");
String[] strArray = f2.list();
for(String str : strArray) {
System.out.println(str);
}
System.out.println("--------");
File[] fileArray = f2.listFiles();
for(File file : fileArray) {
// System.out.println(file);
// System.out.println(file.getName());
if(file.isFile()) {
System.out.println(file.getName());
}
}
}

 file的递归

判断一个文件是不是以.java结尾

public static void main(String[] args) {
		File f = new File("C:\\java2107\\code\\Days22IO\\111");
		
		listMyFile(f);
		System.out.println("===============");
		listMyFile(f, ".txt");
	}
	
	/**
	 * 以递归的方式来实现遍历指定目录下指定格式的文件并打印
	 * @param f
	 */
	public static void listMyFile(File f) {
		if(f.isFile()) {		//	f是一个文件，则判断是不是以java结尾
			if(f.toString().endsWith(".java")) {
				System.out.println(f);
			}
		}else {
			File[] files = f.listFiles();
			
			for (File ff : files) {
				listMyFile(ff);
			}
		}
	}
	
	/**
	 * 以递归的方式来实现遍历指定目录下指定格式的文件并打印
	 * @param f
	 */
	public static void listMyFile(File f, String surfix) {
		if(f.isFile()) {		//	f是一个文件，则判断是不是以java结尾
			if(f.toString().endsWith(surfix)) {
				System.out.println(f);
			}
		}else {
			File[] files = f.listFiles();
			
			for (File ff : files) {
				listMyFile(ff, surfix);
			}
		}
	}
}

 

什么是流？

内存与存储设备之间传输数据的通道

流的分类

按方向

• 输入流：

• 将<存储设备>中的内容读入到<内存>中。

• 输出流：

• 将<内存>中的内容写入到<存储设备>中

按单位 

• 字节流：以字节为单位，可以读写所有数据
• 字符流：以字符为单位，只能读写文本数据

 按功能

• 节点流：具有实际传输数据的读写功能
• 过滤流：在节点流的基础之上增强功能

 字节流

https://pic.downk.cc/item/5f9d7ecb1cd1bbb86bce7018.png

字符流 

 https://pic.downk.cc/item/5f9ef3151cd1bbb86b28470e.png

 

 字节缓冲流介绍

lBufferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写 入字节，而不必为写入的每个字节导致底层系统的调用

lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过 字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

 同理

字符缓冲流介绍

BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可 以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途 BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓 冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

 对象流

ObjectOutputStream/ObjectInputStream

• 增加了缓冲区功能。
• 增强了读写8种基本数据类型和字符串功能。
• 增强了读写对象的功能

 student对象

package com.james.file;

import java.io.Serializable;

public class Student implements Serializable {

	int sid;
	String name;
	double score;
	
	public Student() {
	}

	public Student(int sid, String name, double score) {
		super();
		this.sid = sid;
		this.name = name;
		this.score = score;
	}

	@Override
	public String toString() {
		return "Student [sid=" + sid + ", name=" + name + ", score=" + score + "]";
	}
}

写

package com.james.file;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class TestObjectStream01 {

	public static void main(String[] args) {
		Student s = new Student(9527, "zhouxingxing", 100);
		
		System.out.println(s);
		
		File f = new File("stu.txt");
		
		ObjectOutputStream oos = null;
		FileOutputStream out = null;
		
		try {
			out = new FileOutputStream(f);
			oos = new ObjectOutputStream(out);
			
			oos.writeObject(s);
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(oos != null) {
					oos.close();
					oos = null;
				}
				if(out != null) {
					out.close();
					out = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		System.out.println("write done.");
	}
}

读

package com.james.file;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class TestObjectStream02 {

	public static void main(String[] args) {
		
		File f = new File("stu.txt");
		
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		
		try {
			//	分别构建FileInputStream对象和ObjectInputStream对象
			//		ObjectInputStream对象能够将文件中的对象读取出来进行使用
			fis = new FileInputStream(f);
			ois = new ObjectInputStream(fis);
			
			//	调用ObjectInputStream对象的readObject（）方法读取之前存放好的对象
			Object obj = ois.readObject();
			
			//	一旦对象写入后就被提升为Object，如果想要具体的子类类型，必须要强转
			Student ss = (Student) obj;
			System.out.println(obj);
			System.out.println(ss.name);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}finally {
			try {
				if(ois != null) {
					ois.close();
					ois = null;
				}
				if(fis != null) {
					fis.close();
					fis = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

注意事项：必须序列化对象

补充一个特殊的文件流

RandomAccessFile

写

package com.james.file;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class TestRandomAccessFile {

	public static void main(String[] args) {
		RandomAccessFile raf = null;
		try {
			//	创建RandomAccessFile对象，包含两个参数：
			//		1.	文件名
			//		2.	操作该文件的模式
			//			r w d s
			raf = new RandomAccessFile("raf.txt", "rw");
			
			//	通过RandomAccessFile对象的getFilePointer()方法可以获取文件指针的值
			System.out.println(raf.getFilePointer());
			
			//	RandomAccessFile的write（）方法可以将字节数组写入
			raf.write("helloworld".getBytes());
			
			System.out.println(raf.getFilePointer());
			
			//	RandomAccessFile的writeInt（）可以将整数写入
			raf.writeInt(100000);
			
			System.out.println(raf.getFilePointer());
			
			//	RandomAccessFile的write可以直接写如数组本身
			raf.write(100);
			
			System.out.println(raf.getFilePointer());
			
			//	RandomAccessFile的writeBoolean（flag）可以将boolean类型的值写入
			raf.writeBoolean(false);
			
			System.out.println(raf.getFilePointer());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				raf.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

读

package com.james.file;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class TestRandomAccessFile02 {

	public static void main(String[] args) {
		RandomAccessFile raf = null;
		try {
			//	创建RandomAccessFile对象，包含两个参数：
			//		1.	文件名
			//		2.	操作该文件的模式
			//			r w d s
			//		当前以只读方式对于该文件进行读取
			raf = new RandomAccessFile("raf.txt", "r");
			
//			byte[] b = new byte[10];
//			
//			raf.read(b);
//			
//			System.out.println(new String(b));
			
			
			System.out.println(raf.getFilePointer());
			raf.skipBytes(10);
			System.out.println(raf.getFilePointer());
			
			int myInt = raf.readInt();
			
			System.out.println(myInt);
			
			System.out.println(raf.getFilePointer());
			
			int myInt2 = raf.read();
			
			System.out.println(myInt2);
			
			boolean myBoolean = raf.readBoolean();
			
			System.out.println(myBoolean);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				raf.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}