IO流

什么是流

• 概念：内存与存储设备之间传输数据的通道
• 水借助管道传输，数据借助流传输

流的分类

• 按方向【重点】：

  • 输入流：将存<储设备>中的内容读入到<内存>中。
  • 输出流：将<内存>中的内容写入到<存储设备中>。

• 按单位：

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

• 按功能

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

字节流

• 字节流的父类（抽象类）；
  • Input Stream：字节输入流
  • Output Stream：字节输出流

文件字节流

• File Input Stream：
  • public int read(byte[] b) //从流中读取多个子节，将读到内容存入b数组，返回实际读到的字节数：如果达到文件的尾部，则返回-1。
• File Output Stream：
  • public void write（byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流

package com.xu_1;

import java.io.FileInputStream;

/**
 * 演示File Input Stream的使用
 * 文件字节输入流
 * @author 【徐先生】
 *
 */
public class Demo01 {
	public static void main(String[] args) throws Exception{
//		1创建FileInputStream,并指定文件路径
		FileInputStream fis = new FileInputStream("C:\\Desktop\\MarkDown\\basic\\javaSE一\\初识JAVA.md");
//		2读取文件
//		fis.read()
//		int data=0;
//		while((data=fis.read())!=-1) {
//			System.out.println((char)data);
//		}
//		关闭
//		fis.close();
//		System.out.println("执行完毕");
//		2.2一次读取多个字节
		byte[] buf = new byte[1024];
		int count = 0;
		while((count=fis.read(buf))!=-1) {
			System.out.println(new String(buf,0,count));
		}
		
//		3关闭
		fis.close();
		System.out.println("执行完毕");
		
	}
}

package com.xu_1;

import java.io.FileOutputStream;

/**
 * 演示文件字节输出流的使用
 * File Output Stream
 * @author 【徐先生】
 *
 */
public class Demo02 {

	public static void main(String[] args) throws Exception{
//		1创建文件字节输出流对象
		FileOutputStream fos = new FileOutputStream("D:\\bbb.txt",true);
//		2写入文件
//		fos.write(97);
//		fos.write('b');
//		fos.write('c');
		
		String s1 = "helloWorld";
		fos.write(s1.getBytes());
//		3关闭
		fos.close();
		System.out.println("执行完毕");
	}
}

package com.xu_1;

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

/**
 * 使用文件字节流实现文件的复制
 * @author 【徐先生】
 *
 */
public class Demo03 {
	public static void main(String[] args) throws Exception{
//		1创建流
//		1.1文件字节输入流
		FileInputStream fis = new FileInputStream("D:\\Sketchpad.png");
//		1.2文件字节输出流
		FileOutputStream fos = new FileOutputStream("D:\\001.jpg");
//		2一边读一边写
		byte[] buf = new byte[1024];
		int count = 0;
		while ((count=fis.read(buf))!=-1) {
			fos.write(buf,0,count);
			
		}
//		3关闭
		fis.close();
		fos.close();
		System.out.println("执行完毕");
	}
}

字节缓冲流

• 缓冲流：BufferedInput Stream/BufferedOutput Stream
  • 提高IO效率，减少访问磁盘的次数；
  • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

package com.xu_1;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 * @author 【徐先生】
 *
 */
public class Demo04 {
	public static void main(String[] args) throws Exception{
//		1创建BufferedInputStream
		FileInputStream fis = new FileInputStream("D:\\aaa.txt");
		BufferedInputStream bis = new BufferedInputStream(fis);
//		2读取
		byte[] bytes = new byte[1024];
		int count = 0;
		while((count=bis.read(bytes))!=-1) {
			System.out.println(new String(bytes,0,count));
		}
		
//		3关闭
		bis.close();
		System.out.println("执行完毕");
	}

}

package com.xu_1;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/**
 * 使用字节缓冲流写入
 * @author 【徐先生】
 *
 */
public class Dmeo05 {
	public static void main(String[] args) throws Exception{
//		创建字节输出流
		FileOutputStream fot = new FileOutputStream("D:\\aaa.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fot);
//		String string ="12344556566677";
//		bos.write(string.getBytes());
//		写入文件
		for(int i=0;i<10;i++) {
			bos.write("helloworld\r\n".getBytes());//写入8k缓冲区
			bos.flush();//刷新到硬盘
		}
//		关闭
		bos.close();
	}
}

package com.xu_1;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo06 {
	public static void main(String[] args) throws Exception{
		FileInputStream fis = new FileInputStream("D:\\001.jpg");
		BufferedInputStream bis = new BufferedInputStream(fis);
		FileOutputStream fos = new FileOutputStream("D:\\002.jpg");
		int count= 0;
		while((count=bis.read())!=-1) {
			fos.write(count);
		}
//			关闭
		bis.close();
		fos.close();
		
	}
}

对象流

• 对象流：ObjectOutputStream/ObjectInputStream
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能readObject()从流中读取一个对象
  • writeObject(Object obj)向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化。

package com.xu_1;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 要求，序列化必须要实现Serializable接口
 * @author 【徐先生】
 *
 */
public class Demo07 {
	public static void main(String[] args) throws Exception{
//		1.创建对象流
		FileOutputStream fos =new FileOutputStream("D:\\stu.bin");
		ObjectOutputStream oos =new ObjectOutputStream(fos);
		
//		2.序列化（写入操作）
		Student zhangsan= new Student("张三","20");
		oos.writeObject(zhangsan);
//		3.关闭
		oos.close();
		System.out.println("序列化完毕");
	}
}

package com.xu_1;

import java.io.FileInputStream;

import java.io.ObjectInputStream;

/**
 * 使用Object InputStream实现反序列化（读取重构成对象）
 * @author 【徐先生】
 *
 */
public class Demo08 {
	public static void main(String[] args) throws Exception {
//		1.创建对象流
		FileInputStream fis = new FileInputStream("D:\\stu.bin");
		ObjectInputStream ois = new ObjectInputStream(fis);
		
//		2.读取(反序列化）
		Student s = (Student)ois.readObject();
		System.out.println(s);
//		3.关闭
		ois.close();
		
		System.out.println("执行完毕");
		
	}
}

package com.xu_1;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
/**
 * 使用ObjectOutputStream实现对象的序列化
 * 1.要求，序列化必须要实现Serializable接口
 * 2.序列化类中对象属性要求实现Serializable接口
 * 3.序列化版本号ID，保证序列化的类和你反序列化的类是同一个类
 * 4.使用transient（瞬间的）修饰属性，这个属性不能序列化
 * 5.静态属性不能序列化
 * 6.序列化多个对象，可以借助集合实现
 * @author 【徐先生】
 *
 */
public class Demo07 {
	public static void main(String[] args) throws Exception{
//		1.创建对象流
		FileOutputStream fos =new FileOutputStream("D:\\stu.bin");
		ObjectOutputStream oos =new ObjectOutputStream(fos);
		
//		2.序列化（写入操作）
		Student zhangsan= new Student("张三","20");
		Student lisi = new Student("李四","19");
		ArrayList<Student> list = new ArrayList<>();
		list.add(zhangsan);
		list.add(lisi);
		oos.writeObject(list);
		oos.writeObject(list);
//		3.关闭
		oos.close();
		System.out.println("序列化完毕");
	}
}
package com.xu_1;

import java.io.Serializable;

/**
 * 学术类
 * @author 【徐先生】
 *
 */
public class Student implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 100L;
	/**
	 * 序列化版本号ID，保证序列化的类和你反序列化的类是同一个类
	 */
	
	private String name;
	private transient String age;
    package com.xu_1;

import java.io.FileInputStream;

import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
 * 使用Object InputStream实现反序列化（读取重构成对象）
 * @author 【徐先生】
 *
 */
public class Demo08 {
	public static void main(String[] args) throws Exception {
//		1.创建对象流
		FileInputStream fis = new FileInputStream("D:\\stu.bin");
		ObjectInputStream ois = new ObjectInputStream(fis);
		
//		2.读取(反序列化）
//		Student s = (Student)ois.readObject();
//		Student s2 = (Student)ois.readObject();
		@SuppressWarnings("unchecked")
		ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
		System.out.println(list);
//		System.out.println(s);
//		System.out.println(s2);
//		3.关闭
		ois.close();
		
		System.out.println("执行完毕");
		
	}
}

字符编码

• ISO-8859-1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
• UTF-8 针对Unicode码表的可变长度字符编码
• GB2312 简体中文
• GBK 简体中文、扩充
• BIG5 ，台湾，繁体中文
  • 当编码方式和解码方式不同的时候会出现乱码

字符流

• reader()
• wreter()

文件字符流

• File Reader：
  • public int read(char[] c) //从流中读取多个字符，将读到内容存入c 数组，返回实际读到的字符数；如果到达文件尾部，则返回-1.
• File Writer：
  • public void write（String str）//一次写多个字符，将b数组中所有字符，写入输出流。

package com.xu_2;

import java.io.FileReader;

/**
 * 使用File Reader读取文件
 * @author 【徐先生】
 *
 */
public class Demo02 {
	public static void main(String[] args) throws Exception{
//		创建File Reader 文件字符流输入
		FileReader fr = new FileReader("D:\\hello.txt");
		int count=0;
		while((count=fr.read())!=-1) {
			System.out.println((char)count);
		}
		
//		关闭
		fr.close();
	}
}

package com.xu_2;

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 * 
 * @author 【徐先生】
 *
 */
public class Demo03 {
	public static void main(String[] args) throws Exception {
//		创建File Writer对象
		FileWriter fw = new FileWriter("D:\\write.txt");
//		写入
		for(int i=0; i<10;i++) {
			fw.write("java是世界上最好的语言\r\n");
			fw.flush();
		}
		
		String data = "java是世界上最好的语言";
		fw.write(data);
//		关闭
		fw.close();
		System.out.println("执行完毕");
	}
}

package com.xu_2;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用File Reader和File Writer复制文本文件，不能复制图片或二进制文件
 * @author 【徐先生】
 *
 */
public class Demo04 {
	public static void main(String[] args) throws Exception{
//		创建File Reader File Writer
		FileReader fr =new FileReader("D:\\write.txt");
		FileWriter fw = new FileWriter("D:\\hello.txt");
		
		int data=0;
		while((data=fr.read())!=-1) {
			fw.write(data);
			fw.flush();
		}
//		关闭
		fr.close();
		fw.close();
		System.out.println("执行完毕");
	}
}

字符缓冲流

• 缓冲流：BufferedReader/BufferedWriter
  • 高效读写
  • 支持输入换行符
  • 可一次写一行、读一行。

package com.xu_2;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓冲流来读取文件 BufferedWriter
 * 
 * @author 【徐先生】
 *
 */
public class Democrats {
	public static void main(String[] args) throws Exception{
		// 创建缓冲流
		FileReader fr = new FileReader("D:\\write.txt");
		BufferedReader br = new BufferedReader(fr);
		
//		读取文件
//		char[] bs = new char[1024];
//		int count=0;
//		while((count=br.read(bs))!=-1) {
//			System.out.print(new String(bs,0,count));
//		}
//		第二种读取方法，一行一行的读取
		String line = null;
		while((line=br.readLine())!=null) {
			System.out.println(line);
		}
		
//		关闭
		br.close();
	}
}

package com.xu_2;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 演示BufferedWriter的使用
 * @author 【徐先生】
 *
 */
public class Demo07 {
	public static void main(String[] args) throws Exception{
//		1创建BufferedWriter对象
		FileWriter fw = new FileWriter("D:\\buffer.txt");
		BufferedWriter bw = new BufferedWriter(fw);
//		写入
		for(int i=0;i<10;i++) {
			bw.write("索尼大法好");
			bw.newLine();
			bw.flush();
		}
//		关闭
		bw.close();
	}
}

打印流

• PrintWriter:
  • 封装了print（）/println（）方法，支持写入后换行。
  • 支持数据原样打印

package com.xu_2;

import java.io.PrintWriter;

/**
 * 演示PrintWriter的使用
 * @author 【徐先生】
 *
 */
public class Demo08 {
	public static void main(String[] args) throws Exception{
//		1创建打印流
		PrintWriter pw = new PrintWriter("D:\\print.txt");
//		打印
		pw.println(97);
		pw.println(true);
		pw.println(3.14);
		
//		关闭
		pw.close();
	}
}

转换流

• 桥转换流：Input Stream Reader/Output Stream Writer

  • 可以将字节流转换为字符流。
  • 可设置字符编码的编码方式。

package com.xu_2;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * 使用Input Stream Reader读取文件，指定使用的编码
 * @author 【徐先生】
 *
 */
public class Demo09 {
	public static void main(String[] args) throws Exception{
//		1.创建Input Stream Reader对象
		FileInputStream fis = new FileInputStream("D:\\write.txt");
		InputStreamReader isr = new InputStreamReader(fis,"gbk");
//		读取文件
		int data=0;
		while((data=isr.read())!=-1) {
			System.out.print((char)data);
		}
//		关闭
		isr.close();
	}
}

package com.xu_2;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWriter写入文件，使用指定编码
 * @author 【徐先生】
 *
 */
public class Demo10 {
	public static void main(String[] args) throws Exception{
//		1创建OutputStreamWriter
		FileOutputStream fos = new FileOutputStream("D:\\info.txt");
		OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
//		2写入
		for(int i=0;i<10;i++) {
			osw.write("我爱北京，我爱故乡\r\n");
		}
//		关闭
		osw.close();
	}
}

File类

• 概念：代表物理盘符中的一个文件或者文件夹。
• 方法：
  • createNewFile()//创建一个新文件
  • mkdir()//创建一个新目录
  • delete()//删除文件或空目录
  • exists()//判断File对象所代表的对象是否存在
  • getAbsolutePath()//获取文件的绝对路径
  • getName()//取得名字
  • getParent()//获取文件/目录所在的目录
  • isDirectory()//是否是目录
  • isFile()//是否是文件
  • length()//获得文件的长度
  • listFiles()//列出目录中的所有内容
  • renameTo()//修改文件名为

package com.xu_3;

import java.io.File;
import java.util.Date;

/**
 * File类的使用 (1)分隔符 (2)文件操作 (3)文件夹操作
 * 
 * @author 【徐先生】
 *
 */
public class Demo01 {
	public static void main(String[] args) throws Exception {
		fileOpe();
	}

	public static void separator() {
		System.out.println("路径分隔符" + File.pathSeparator);
		System.out.println("名称分隔符" + File.pathSeparator);

	}

	// 2文件操作
	public static void fileOpe() throws Exception {
		// 创建文件
		File file = new File("D:\\file.txt");
		// System.out.println(file);
		if (!file.exists()) {
			boolean b = file.createNewFile();
			System.out.println("创建结果" + b);
		}

		// 删除文件
//		System.out.println(file.delete());

		// 使用JVM来删除
//		 file.deleteOnExit();
//		 Thread.sleep(5000);
		// 获取文件的绝对路径
		System.out.println("获取文件的绝对路径：" + file.getAbsolutePath());
		System.out.println("获取路径"+file.getName());
		System.out.println("获取路径"+file.getPath());
		System.out.println("获取父目录"+file.getParent());
		System.out.println("获取文件长度："+file.length());
		System.out.println("文件创建时间"+new Date(file.lastModified()));
//		判断
		System.out.println("是否可写："+file.canWrite());
		System.out.println("是否是文件："+file.isFile());
		System.out.println("是否隐藏"+file.isHidden());
	
	}

}

package com.xu_3;

import java.io.File;
import java.util.Date;

//	3文件夹操作
	public static void directoryOpe() throws Exception {
//		1创建文件夹
		File dir = new File("D:\\aa\\bb\\cc");
		System.out.println(dir.toString());
		if (!dir.exists()) {
//			dir.mkdir();只能创建单级目录
			System.out.println("创建结果："+dir.mkdirs());//创建多级目录
		}
//		2删除文件夹
//		System.out.println("删除文件夹"+dir.delete());
//		使用JVM删除
//		dir.deleteOnExit();
//		Thread.sleep(5000);
//		3获取文件夹信息
		System.out.println("获取绝对路径"+dir.getAbsolutePath());
		System.out.println("获取路径"+dir.getPath());
		System.out.println("获取文件夹名称"+dir.getName());
		System.out.println("获取父目录"+dir.getParent());
		System.out.println("获取文件创建时间"+ new Date(dir.lastModified()));
//		4判断
		System.out.println("是否是文件夹："+dir.isDirectory());
		System.out.println("是否隐藏"+dir.isHidden());
//		5遍历文件夹
		File dir2 = new File("D:\\图片");
		String[] files = dir2.list();
		System.out.println("-----------------------");
		for (String string : files) {
			System.out.println(string);
		}
	}
}

FileFilter接口

• public interface FileFilter

  • boolean accept(File pathname)

• 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类,对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中。

package com.xu_3;
import java.io.FileFilter;
//		5遍历文件夹
		File dir2 = new File("D:\\图片");
		String[] files = dir2.list();
		System.out.println("-----------------------");
		for (String string : files) {
			System.out.println(string);
		}
		System.out.println("---------FileFilter接口的使用-------------");
		File[] files2 = dir2.listFiles(new FileFilter() {
			
			@Override
			public boolean accept(File pathname) {
				if(pathname.getName().endsWith(".jpg")) {
					return true;
				}
				return false;
			}
			
		});
		for (File file  : files2) {
			System.out.println(file .getName());
		}
	}

}

递归遍历和递归删除

package com.xu_3;

import java.io.File;

/**
 * 案例1遍历文件夹
 * @author 【徐先生】
 *
 */
public class ListDemo {
	public static void main(String[] args) {
		listDir(new File("D:\\图片"));
		deleteDir(new File("D:\\图片"));
	}
	public static void listDir(File dir) {
		File[] files = dir.listFiles();
		if (files !=null&&files.length>0) {
			for (File file : files) {
				if (file.isDirectory()) {
					listDir(file);
				}else {
					System.out.println(file.getAbsolutePath());
				}
			}
		}
	}
//	案例2:递归删除文件夹
	public static void deleteDir(File dir) {
		File[] files = dir.listFiles();
		if (files!=null&&files.length>0) {
			for (File file : files) {
				if (file .isDirectory()) {
					deleteDir(file);
				}else {
//					删除文件
					System.out.println(file.getAbsolutePath()+"删除"+file.delete());
				}
			}
		}
		System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
	}
}

Properties集合

• Properties：属性集合

• 特点：

  • 1. 存储属性名和属性值
    2. 属性名和属性值都是字符串类型
    3. 没有泛型
    4. 和流有关

package com.xu_3;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;
import java.util.Set;

/**
 * 演示Properties集合的使用
 * @author 【徐先生】
 *
 */
public class Demo02 {
	public static void main(String[] args) throws Exception {
//		1创建集合
		Properties properties = new Properties();
//		2添加数据
		properties .setProperty("username", "zhangsan");
		properties .setProperty("age", "20");
		System.out.println(properties .toString());
//		3遍历
//		3.1keyset
		 for (Object string : properties .keySet()) {
			System.out.println(string+"-------"+properties .get(string));
		}
		 
//		3.2entryset
		 for (Object string : properties .entrySet()) {
			System.out.println(string);
		}
//		3.3stringPropertyNames
		 Set<String> pronames = properties .stringPropertyNames();
		 for (String pro : pronames) {
			System.out.println(pro+"--------"+properties .getProperty(pro));
		}
//		 4和流有关的方法
		 1.list方法
//		 PrintWriter pW = new PrintWriter("D:\\print.txt");
//		 properties .list(pW);
//		 pW.close();
//		2. store方法
		 FileOutputStream fos = new FileOutputStream("D:\\store.properties");
		 properties .store(fos, "注释");
		 fos.close();
//		 3.load方法 加载
		 Properties properties2 = new Properties();
		 FileInputStream fis = new FileInputStream("D:\\store.properties");
		 properties2.load(fis);
		 fis.close();
		 System.out.println(properties2.toString());
	}
}

总结

• 流的概念：
  • 内存与存储设备之间传输数据的通道。
• 流的分类：
  • 输入流、输出流、字节流、字符流、节点流、过滤流
• 序列化、反序列化：
  • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口
• File对象：
  • 代表物理盘符中的一个文件或者文件夹。