Java中的File与IO流(2)

缓冲流

1.字节缓冲流

​BufferedInputStream: 该类实现了输入流的缓冲,为其提供一个内部的缓冲区数组.当我们读取字节时,内部缓冲区将根据所需要读取数据自动填充,一次可以读取多个字节

​BufferedOutputStream: 该类实现缓冲输出流.通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入字节的每个字节导致底层系统的频繁调用.

构造方法

方法名	描述
BufferedInputStream(in)	创建字节缓冲输入流对象并实现字节输入流
BufferedOutputStream(out)	创建字节缓冲输出流对象

public class CopyAviDemo {

	public static void main(String[] args) {
		// 记录开始时间
		long start = System.currentTimeMillis();
		try {
			// 一次读取一个字节
			// method1();
			// method2();

			// 一次读取一个字节数组
			// method3();
			method4();
		} catch (Exception e) {
			e.printStackTrace();
		}
		// 记录结束时间
		long end = System.currentTimeMillis();
		System.out.println("复制所用时间为:" + (end - start));
	}

	private static void method4() {
		// 在JDK1.7之后,可以将流放入try后面的括号中,使用完成后自动关闭
		try (InputStream in = new FileInputStream("E:\\实现购物商城菜单.mp4");
				OutputStream out = new FileOutputStream("E:\\Java\\3.cai.mp4");) {
			// 设置缓存空间
			byte[] bs = new byte[1024];
			// 设置读取长度
			int len;
			while ((len = in.read(bs)) != -1) {
				// 将读取的内容写出到指定文件
				out.write(bs, 0, len);
				out.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void method3() throws Exception {
		// 创建缓冲流
		BufferedInputStream bin = new BufferedInputStream(
				new FileInputStream("E:\\实现购物商城菜单.mp4"));
		BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("E:\\Java\\3.cai.mp4"));
		// 创建外部自定义缓冲数组
		byte[] bs = new byte[1024];
		int len;
		while ((len = bin.read(bs)) != -1) {
			bout.write(bs, 0, len);
		}
		bin.close();
		bout.close();
	}

	// 基本字节流单个字节读取文件
	private static void method2() {
		// 在JDK1.7之后,可以将流放入try后面的括号中,使用完成后自动关闭
		try (InputStream in = new FileInputStream("E:\\实现购物商城菜单.mp4");
				OutputStream out = new FileOutputStream("E:\\Java\\3.cai.mp4");) {
			// 设置读取长度
			int by;
			while ((by = in.read()) != -1) {
				// 将读取的内容写出到指定文件
				out.write(by);
			}
			System.out.println("复制成功!");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 字节缓冲流每次读取一个字节
	private static void method1() throws Exception {
		// 创建缓冲流
		BufferedInputStream bin = new BufferedInputStream(
				new FileInputStream("E:\\实现购物商城菜单.mp4"));
		BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("E:\\Java\\3.cai.mp4"));
		int by;
		while ((by = bin.read()) != -1) {
			bout.write(by);
		}
		bin.close();
		bout.close();
	}

}

2.字符缓冲流

​BufferedWriter: 将文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写出,可以指定缓冲区大小,或者可以使用默认大小,可以用于大多数,字符串的写出

​BufferedReader: 从字符输出流中读取文本,缓冲字符,提供字符,数组和字符串行的高效读取,可以指定缓冲区大小

方法

方法名	描述
BufferedWriter(write)	创建字符缓冲输出流对象
BufferedReader(reader)	创建字符缓冲输入流对象
readLine()	读取一行内容并返回字符串
newLine()	转换下一行

public class CopyDemo {

	public static void main(String[] args) {
		long start  = System.currentTimeMillis();
		try {
			//单个字节
//			method1();
//			method2();
			//使用缓冲流读取一行内容
			method3();
		} catch (Exception e) {
			e.printStackTrace();
		}
		long end = System.currentTimeMillis();
		System.out.println("消耗时间为:"+(end-start));
	}

	private static void method3() throws Exception {
		BufferedReader br = new BufferedReader(new FileReader("E:\\Java\\广州新闻.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\Java\\广州小说.txt"));
		String str;
		//readLine可以直接读取一行字符串
		while((str=br.readLine())!=null) {
			bw.write(str);  //可以直接写出一行
			bw.newLine(); //换行
		} 
		bw.close();
		br.close();
	}

	private static void method2() throws Exception {
		Reader r = new FileReader("E:\\Java\\广州新闻.txt");
		Writer w = new FileWriter("E:\\Java\\广州小说.txt");
		int c;
		while((c=r.read())!=-1) {
			w.write(c);
		}
		r.close();
		w.close();
	}

	//单个字符读取
	private static void method1() throws Exception {
		BufferedReader br = new BufferedReader(new FileReader("E:\\Java\\广州新闻.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\Java\\广州小说.txt"));
		int c;
		while((c=br.read())!=-1) {
			bw.write(c);
		}
		br.close();
		bw.close();
	}
}

打印流

​ 打印流分: 字节打印流PrintStream 字符打印流PrintWriter

​ 打印流的特点:

​ 只负责打印输出数据,不负责读取数据

​ 永远不会抛出IOException

​ 有自己的特有方法

public class PrintStreamDemo {

	public static void main(String[] args) throws Exception {
		//创建对一个打印流对象
		PrintStream out = new PrintStream("E:\\Java\\小说.txt");
		//写出数据
		out.print("helloworld");
		out.print(97);
		//释放资源
		out.close();
	}
}

​ 字符打印流

public class CharPrintDemo {

	public static void main(String[] args) throws Exception {
		// 创建字符打印流对象
//		PrintWriter out = new PrintWriter("E:\\Java\\小说.txt");
//		out.write("今天天气不错,凉快!");
//		out.println();
//		out.print("Hello");
//		out.close();
		//每次调用会被刷新
		PrintWriter out = new PrintWriter(new FileWriter("E:\\Java\\小说.txt"),true);
		out.write("今天天气不错,凉快!");
		out.println();
		out.print("Hello");
		out.close();
	}
}

对象序列化流

概念

​对象序列化流: 就是将对象永久的保存在磁盘中,或者在网络中传输对象

​这种机制就是使用一个字节序列表示一个对象,该字节序列包含: 对象的类型,对象的数据和对象中存储的属性等信息

​字节序列化: 字节序列写到文件中,相当于文件保存一个对象信息

​反序列化: 该字节从文件中共读取回来,还原为对象叫做反序列化

对象序列化流: ObjectOutputStream

​将java对象的原始数据类型和图形写入到OutputStream.可以使我们的ObjectOutputStream读取对象,使用文件保存,在另一个计算机也可以使用

构造方法

​ObjectOutputStream(outStream) 创建一个对象输出流,输出对象到指定文件

​ 方法

​ writeObject(对象) 将对象写入到文件 类型成为Object

注意: 在需要被序列化的类中必须实现Serializable 可序列化接口

public class Student implements Serializable {

	private static final long serialVersionUID = 1L;

	private String name;
	private String sex;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
}

public class ObjectOutDemo {

	public static void main(String[] args) throws Exception {
		//创建序列化流
		ObjectOutputStream oos = new           
            
            	ObjectOutputStream(new FileOutputStream("stu.txt"));
		//准备需要被序列化的对象
		Student stu = new Student();
		stu.setName("张三");
		stu.setSex("男");
		stu.setAge(28);
		//通过对象序列化流将对象输出到文件
		oos.writeObject(stu);
		System.out.println("保存成功");
		oos.close();
	}
}

对象反序列化流: ObjectInputStream

​ObjectInputStream反序列化先前用ObjectOutputStream编写的原始数据和对象,还原为回来的过程

构造方法

​ObjectInputStream(inStream) 创建从指定的InputStream中读取的反序列化流对象

​ 方法

​ readObject() 读取字节序列还原为对象Object

public class ObjectInputDemo {

	public static void main(String[] args) throws Exception {
		//创建反序列化流
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("stu.txt"));
		//读取字节序列化内容为Object对象
		Object obj = ois.readObject();
		Student stu = (Student) obj;
		System.out.println("学生姓名为:"+stu.getName()+", 性别为:"+stu.getSex()+", 年龄为:"+stu.getAge());
		ois.close();
	}
}

以集合的形式序列化对象

public class ListOutStream {

	public static void main(String[] args) throws Exception {
		// 创建输出流对象(序列化)
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("stus.txt"));
		// 创建输入流对象(反序列化)
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("stus.txt"));
		// 准备集合数据
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("张安", "男", 22));
		list.add(new Student("李安", "男", 23));
		list.add(new Student("赵柳", "女", 18));
		list.add(new Student("王辉", "男", 21));
		// 使用序列化流输出对象
		oos.writeObject(list);
		// 当需要使用集合时,将集合返回
		List<Student> list1 = (List<Student>) ois.readObject();
		for (Student stu : list1) {
			System.out.println(stu);
		}
		oos.flush();
		oos.close();
		ois.close();
		addStu(list);
	}

	private static void addStu(List<Student> list) throws Exception {
		// 创建输出流对象(序列化)
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("stus.txt"));
		// 创建输入流对象(反序列化)
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("stus.txt"));
		list.add(new Student("赵慧", "女", 18));
		oos.writeObject(list);

		List<Student> list1 = (List<Student>) ois.readObject();
		for (Student stu : list1) {
			System.out.println(stu);
		}
	}

}

Properties集合

​ Properties作为Map集合使用

​ 是一个Map体系的集合1

​ properties可以保存到流中,可以从流中读取数据

​ 属性列表中每个键对应一个字符串

Properties的基本使用

public class PropertiesDemo {
	//Map操作方式
	public static void main(String[] args) {
		//创建属性集合对象,Map操作方式
		Properties pro = new Properties();
		//存储元素
		pro.put("driver", "com.mysql.jdbc.Driver");
		pro.put("name", "root");
		
		//遍历集合
		for (Object key : pro.keySet()) {
			System.out.println("key:"+key+"======值:"+pro.get(key));
		}
	}
}

Properties和IO流结合使用(应用)

​ 步骤: 1.在项目中创建properties属性文件

​ 2.在属性文件中 属性=值 的配置

​ 3.使用流的方式读取文件为流

​ 4.使用properties的load方法,将流中的属性加载到Properties对象中

​ 5.获取属性

​ 6.关闭资源

#在src文件夹下创建jdbc.properties文件

###驱动
#driver=com.mysql.jdbc.Driver
#name=root
#password=12345


driver=org.oracle.jdbc.Driver
name=sccot
password=12345

代码读取属性文件

public class PropertiesDemo {
	public static void main(String[] args) throws Exception {
		//创建属性集合对象
		Properties pro = new Properties();
		//创建流读取文件为流
		//PropertiesDemo.class.getClassLoader()  获取到当前类所在
		//getResourceAsStream 从当前类所在资源文件夹中读取文件并转换为Stream
		InputStream in = PropertiesDemo.class.getClassLoader().getResourceAsStream("jdbc.properties");
		//将流加载到properties
		pro.load(in);
		//从属性集合中拿出内容
		System.out.println("驱动为:"+pro.getProperty("driver")+", 账户:"+pro.getProperty("name")+", 密码:"+pro.getProperty("password"));
		in.close();
	}
}

向属性文件中输出内容

public class PropertiesDemo2 {
	public static void main(String[] args) throws Exception {
		//创建属性集合对象
		Properties pro = new Properties();
		pro.setProperty("重庆", "火锅,重庆小面,重庆轻轨,重庆串串");
		pro.setProperty("广东", "穿拖鞋的房东,牛肉丸,龙眼,荔枝");
		//通过字符流输出
		Writer out = new FileWriter("src\\jdbc.properties");
		pro.store(out, null);
		out.close();
	}
}