JavaSE IO、NIO

File的基本属性

String filePath = "test.txt";
File file = new File(filePath);
file.exists();			//文件是否存在
file.isFile();			//file对象指向的是否是一个文件
file.isDirectory(); 		//file对象指向的是否是一个目录（文件夹）
file.getName();			//获取file的文件名
file.getAbsolutePath();	//获取file的绝对路径
file.length();			//文件内容长度

File的基本操作

file.delete();//删除文件

//获取文件夹下的所有文件目录
String[] list = new File("test").list();//必须要有目录结构
System.out.println(list.length);	//获取目录长度
for(int i=0; i<list.length; i++) 
	System.out.println(list[i]);

//查看指定目录下存在指定名字的文件或目录
final String directory = "aaa";
String[] list = new File("test").list(new FilenameFilter() {
	@Override
	public boolean accept(File dir, String name) {
		return name.endsWith(directory);
	}
});
System.out.println(list.length);	//获取目录长度
for(int i=0; i<list.length; i++) 
	System.out.println(list[i]);

//创建一个文件
try {
	if(!file.exists()) 
		file.createNewFile();		//创建文件
} catch (IOException e) {
	e.printStackTrace();
}

IO的概念

输入流InputStream:把网络、磁盘的数据写入程序

输出流OutputStream：把程序的数据写入网络、磁盘

IO按传输分类

1.  字节流

2.  字符流

实例：文件操作Demo

// 在aaa下创建一个文件
String filename = "test.txt";
String filepath = "test/aaa/";
File file = new File(filepath + filename);

if (!file.exists()) {
	try {
		file.createNewFile();
	} catch (IOException e) {
		e.printStackTrace();
	}
}
	
BufferedWriter writer = null;
try {
	writer = new BufferedWriter(new FileWriter(file));
	
	//向文件写入内容
	writer.write("I'm a txt file...");
		
	//清除输出流
	 writer.flush();
} catch (IOException e1) {
	e1.printStackTrace();
} finally {
	try {
		writer.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

InputStream input = null;
OutputStream output = null;
try {
	// 读入文件数据
	input = new FileInputStream(file);
		
	// 指定每次传输的数量
	byte[] data = new byte[1024];

	// 指定新文件路径
	String newPath = "test/bbb/";
	File newFile = new File(newPath + filename);

	// 定义输出流
	output = new FileOutputStream(newFile);

	// 循环输出数据
	int length = 0;
	while ((length = input.read(data)) != -1) {
		output.write(data, 0, length);
	}
			
	output.flush();

} catch (FileNotFoundException e) {
	e.printStackTrace();
} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		input.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
	try {
		output.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

序列化与反序列化

//1.实体类实现序列化接口
public class Person implements Serializable {}
//2.序列化
File file = new File("test" + File.separator + "person.ser");
//创建输出流
OutputStream output = new FileOutputStream(file);
//OutputStream转化为ObjectOutputStream流才能进行序列化
ObjectOutputStream obStream = new ObjectOutputStream(output);		
//创建实体类
Person person = new Person("root", "123456");	
obStream.writeObject(person);		
/*
 * 反序列化
File file = new File("test" + File.separator + "person.ser");
InputStream input = new FileInputStream(file);
ObjectInputStream oiStream = new ObjectInputStream(input);
Person person = (Person) oiStream.readObject();
System.out.println(person);
*/

NIO

// 在java的NIO中，负责数据的存取，缓冲区的底层实现就是数组，用于存储不同的数据类型

String str = "abcde";
// 定义一个指定大小的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
/**
 * 缓冲区的三个核心属性
 * 1.capacity()：获取缓冲区容量，表示缓冲区最大存储数据的容量，一旦声明不能更改
 * 2.limit()：界限，缓冲区可以操作的数据的大小（limit后的数据不能进行读写）
 * 3.position()：位置，表示缓冲区正在操作数据的位置 4.
 */
System.out.println(buffer.capacity());
System.out.println(buffer.limit());
System.out.println(buffer.position());
/**
 * 缓冲区的两个核心方法 1.put()：存入缓冲区数据 2.get()：获取缓冲区数据
 */
buffer.put(str.getBytes());

// 将缓冲区切换成读取数据的模式才能读取
buffer.flip();
byte[] data = new byte[buffer.limit()];
System.out.println(buffer.get(data));
		
// rewind():重复读数据
buffer.rewind();
System.out.println(buffer.get(data));

//clear()：清空缓冲区
buffer.clear();