Java基础 day17----IO框架-CSDN博客

本文链接：https://blog.csdn.net/quansiwen5307/article/details/109264568

1、什么是流

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

2、流的分类

按方向来分：
输入流:把存储设备中的内容读入到内存当中
输出流：把内存中的内容写入到存储设备中

按单位来分
字节流：以字节为单位，可以读写所有数据
字符流:以字符为单位，只能读写文本数据
(一个字符可能有1个字节，也可能是两个字节…)

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

3字节流

字节流的父类(抽象类)

InputStream:字节输入流
OutputStream:字节输出流

文件字节流

FileInputStream:
public int read(byte[] b )//从流中读出多个字节，将读到的内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1

FileOutputStream:
public void write(byte[] b) .//一次写多个字节，将b数组中所有的字节，写入输出流

小案例：
文件的复制
`/**
* 实现文件的复制：
* 思路：先创建一个文件，里面写上内容
* 然后用文件字节输入流读到内存中
* 最后通过文件字节输出流写入到文件中(目标文件)
*/

	FileInputStream fis=new FileInputStream("E:\\bbb.txt");
	FileOutputStream fos=new FileOutputStream("E:\\c.txt");
	byte []b=new byte[20];
	int read=0;
	while((read=fis.read(b))!=-1) {
	//			System.out.println(read);
	//			System.out.println(new String(b,0,read));
		fos.write(b,0,read);
		
	}`

/**
	 * 实现文件的复制(对图片)
	 */
		
		FileInputStream fis=new FileInputStream("C:\\Users\\15163\\Pictures\\1.jpg");
		FileOutputStream fos=new FileOutputStream("E:\\1.jpg");
		
		byte [] b=new byte[1024];
		int count=0;
		while((count=fis.read(b))!=-1) {
			fos.write(b, 0, count);
		}
		System.out.println("执行成功");
		fis.close();
		fos.close();

4.字节缓冲流

缓冲流：BufferedInputStream 或 BufferedOutputStream
优点:
1、提高IO效率，减少访问磁盘的次数
2、数据存储在缓冲区内，flush是将缓存区的内容写入文件中，也可以直接close

小案例`/**
* 利用缓冲流来复制文件（图片）
*/

	FileInputStream fis=new FileInputStream("C:\\Users\\1516\\Pictures\\1.jpg");
	FileOutputStream fos=new FileOutputStream("e:\\1.jpg");
	BufferedInputStream bis=new BufferedInputStream(fis);
	BufferedOutputStream bos=new BufferedOutputStream(fos);
	
	byte []b=new byte[1024];
	int count=0;
	while((count=bis.read(b))!=-1) {
		bos.write(b, 0, count);
		bos.flush();
	}
	System.out.println("执行成功");
	
	bis.close();
	bos.close();`

5、对象流

对象流：ObjectInputStream （反序列化）或 ObjectOutputStream（序列化）
好处：
1、增强了缓冲区功能
2、增强了读写8种基本数据类型和字符串功能【重点】
3、增强了读写对象的功能
readObject() 从流中读取一个对象
writeObject(Object obj) 从流中写入一个对象

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

java.io.NotSerializableException: com.hp.demo.Student
只需要将Student类实现序列化接口即可。序列化接口只是一个标记接口

序列化：（写入）

FileOutputStream fos=new FileOutputStream("e:\\d.class");//文件名的后缀任意
		ObjectOutputStream oos=new ObjectOutputStream(fos);
			//序列化（写入操作）
		Student stu=new Student("张三",20);
		oos.writeObject(stu);
		
		oos.close();
		System.out.println("执行完毕");

反序列化：(读取)

FileInputStream fis=new FileInputStream("e:\\d.class");
		ObjectInputStream ois=new ObjectInputStream(fis);
		
		//反序列化（读取）
		Object oread=ois.readObject();
		System.out.println(oread);//Student [name=张三, age=20]
		
		System.out.println("执行完毕");
		ois.close();

序列化和反序列化的注意事项
（1）序列化类必须要实现Serializable接口
（2）序列化类中的属性也要求实现序列化接口
（3）private static final long serialVersionUID = 1L;这个表示的是序列化版本号ID，作用是保证序列化和反序列化是同一个类
（4）使用transient(瞬间的，瞬时的)修饰的属性不能被序列化
（5）静态属性不能被序列化
（6）序列化多个对象，可借助集合来实现（如原先传入的是对象，这时候传入的是集合，集合里有很多这样的对象）

6、字符流

字符流的父类（抽象类）：
Reader:字符输入流
public int read(){} 、 public int read(char[] c){}、public int read(char[] b,int off,int len){}
Writer:字符输出流
public void write(int n){}、public void write(String str){}、public void write(char[] c){}

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

/**
		 * 使用文件字符流来复制文件（只能复制文本文件，不能复制二进制文件或图片）
		 */
		
		FileReader fr=new FileReader("e:\\d1.txt");
		FileWriter fw=new FileWriter("e:\\d2.txt");
		
		
		char[] cbuf=new char[10];
		int count=0;
		while((count=fr.read(cbuf))!=-1) {
			fw.write(cbuf, 0, count);
			fw.flush();
		}
		fr.close();
		fw.close();

字符缓冲流：BufferedReader 或BufferedWriter
好处：
1、高效读写
2、支持输入换行符
3、可一次写一行、读一行

/**
	 * 使用字符缓冲流读取文件
	 * BufferedReader
	 */
		
		FileReader fr=new FileReader("e:\\d1.txt");
		BufferedReader br=new BufferedReader(fr);
		
		String line=null;
		while((line=br.readLine())!=null) {
			System.out.println(line);
		}
		
		br.close();

/**
		 * 使用BufferedWriter的使用
		 */

		FileWriter fw=new FileWriter("e:\\a.txt");
		BufferedWriter bw=new BufferedWriter(fw);
		
		for(int i=0;i<10;i++) {
			bw.write("好好学习呀");
			bw.newLine();//换行
		}
		
		
		bw.close();

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

/**
		 * 使用PrintWriter
		 */
		
		PrintWriter pw=new PrintWriter("e:\\abc.txt");
		
		char c='a';
		pw.print(true);
		pw.print(97);
		pw.print(c);
		
		pw.close();

转换流:InputStreamReader 或 OutputStreamWriter
好处：
1、可将字节流转换为字符流
2、可设置字符的编码方式

/**
		 * 转换流InputStreamReader的使用
		 */
		
		FileInputStream fis=new FileInputStream("e:\\d1.txt");
		InputStreamReader isr=new InputStreamReader(fis, "UTF-8");

		/*
		 * int count=0; while((count=isr.read())!=-1) { System.out.print((char)count); }
		 */
		
		int count=0;
		char [] c=new char[1024];
		while((count=isr.read(c))!=-1) {
			System.out.println(new String(c, 0, count));
		}
		isr.close();

	/**
		 * 使用OutputStreamWriter写入文件，并设置编码
		 */
		
		FileOutputStream fos=new FileOutputStream("e:\\abc.txt");
		OutputStreamWriter osw=new OutputStreamWriter(fos, "utf-8");
		
		for(int i=0;i<10;i++) {
			osw.write("我爱我的家乡，delete one word");
			
			
		}
		osw.close();

7.File类

概念:代表物理盘符中的一个文件或者文件夹

方法：
1、createNewFile()//创建一个新的文件
2、mkdir()//创建一个新的目录
3、delete()//删除空文件或空目录
4、exists()//判断File对象是否存在
5、getAbsolutePath()//获取文件的绝对路径
6、getName()//取得名字
7、getParent()//获取文件/目录所在得目录
8、isDirectory()//是否是目录
9、isFile()//是否是文件
10、length()//获取文件得长度
11、listFiles()//列出目录中所有得内容
12、renameTo()//修改文件名为


		File file=new File("g:\\file.txt");
		
		if(!file.exists()) {
			
			//1.创建文件
			file.createNewFile();
		}
		
		//2.删除文件
//		file.delete();
		
		//2.1使用jvm退出时删除
//		file.deleteOnExit();
		
		//3.获取文件的信息
		//3.1获取文件的绝对路径
//		System.out.println(file.getAbsolutePath());
		//3.2获取名称
//		System.out.println(file.getName());
		//3.3获取父目录
//		System.out.println(file.getParent());
		//3.4获取文件的长度
//		System.out.println(file.length());
		//3.5文件的创建时间
//		System.out.println(new Date(file.lastModified()));
		
		//4判断文件
		//4.1是否可读
		System.out.println(file.canRead());
		//4.2是否可写
		System.out.println(file.canWrite());
		//4.3是否是文件
		System.out.println(file.isFile());
		//4.4是否是目录
		System.out.println(file.isDirectory());
		//4.5是否是隐藏的
		System.out.println(file.isHidden());

//1.创建文件夹
//		File dir=new File("g:\\aaa\\bbb\\ccc");
//		if(!dir.exists()) {
//			dir.mkdirs();//创建多级目录
//		}
		
		//2.删除文件夹
		//2.1直接删除
//		dir.delete();//注意只能删除空目录
		//2.2使用jvm来进行删除
//		dir.deleteOnExit();
		
//		//3.获取文件夹信息
//		//3.1获取绝对路径
//		System.out.println(dir.getAbsoluteFile());
//		//3.2获取路径
//		System.out.println(dir.getPath());
//		//3.3获取文件夹的名称
//		System.out.println(dir.getName());//最里层文件夹的名称
//		//3.4获取父目录
//		System.out.println(dir.getParent());
//		//3.5获取创建时间
//		System.out.println(new Date(dir.lastModified()));
//		
//		//4.判断
//		System.out.println(dir.isDirectory());
//		System.out.println(dir.isHidden());
		
		//5.遍历
		//5.1获取文件夹的图片
		File dir1=new File("C:\\Users\\cc\\Pictures\\Saved Pictures");
		String [] s=dir1.list();
		for (String string : s) {
			System.out.println(string);
		}

8FileFilter接口

File dir1=new File("C:\\Users\\cc\\Pictures\\Saved Pictures");
	File[] f=dir1.listFiles(new FileFilter() {
			
			@Override
			public boolean accept(File pathname) {
				
				if(pathname.getName().endsWith(".jpg")) {
					return true;
				}
				return false;
			}
		});
		
		for (File file : f) {
			System.out.println(file);
		}

9.Properties

Properties：属性集合(继承HashTable)
特点：
（1）存储属性名和属性值(key:value)
（2）属性名和属性值都是字符串类型
（3）没有泛型
（4）和流有关

//1.创建一个集合
		Properties properties=new Properties();
		
		//2.添加数据
		properties.setProperty("username", "张三");
		properties.setProperty("age", "20");
		System.out.println(properties);
		
		//3.遍历
		Set<Object> keySet = properties.keySet();
		for (Object object : keySet) {
			System.out.println(object+"\t"+properties.getProperty((String) object));
		}
		System.out.println("====================");
		
		Set<Entry<Object, Object>> entrySet = properties.entrySet();
		for (Entry<Object, Object> entry : entrySet) {
			System.out.println(entry);
		}
		System.out.println("====================");
		Set<String> sp = properties.stringPropertyNames();
		for (String string : sp) {
			System.out.println(string+"\t"+properties.getProperty(string));
		}
		
		//4和流有关的方法
		
		//4.1把properties中的数据打印到file.txt中
//		FileOutputStream fos=new FileOutputStream("g:\\file.txt");
//		PrintWriter pw=new PrintWriter(fos);
//		properties.list(pw);
//		pw.close();
		
		//4.2保存
//		PrintWriter pw1=new PrintWriter("g:\\file1.txt");
//		properties.store(pw1, "保存在该");
//		pw1.close();
		
		//4.3加载(重要)
		properties.load(new FileReader(new File("g:\\file1.txt")));
		System.out.println(properties.getProperty("username"));