java第21天----转换流，标准流，打印流，序列化流，Properties类

weixin_42478640

于 2018-10-05 11:41:48 发布

阅读量136

点赞数

本文链接：https://blog.csdn.net/weixin_42478640/article/details/82943061

版权

文章目录

昨天知识总结

1.字符缓冲流
2.装饰设计模式
3.适配器设计模式
4.字节流
5.字节缓冲流
6.标准输入流

流

转换流

转换流：本身是字符流
分类：
InputStreamReader：从字节输入流到字符读入流
OutputStreamWriter：从字节输出流到字符写出流
场景：要使用字符缓冲流的readLine（），newLine方法服务于字节流
实例：使用字符缓冲流的readLine（），newLine（）等方法实现在控制台一次读一行数据

	public static void main(String[] args) throws IOException {
		System.out.println();
		//将标准输入流转成字符缓冲读入流
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		//将标准输出流转成字符缓冲写出流
		BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
		
		//读写
		String str= null;
		while((str = bufferedReader.readLine())!=null) {
			bufferedWriter.write(str);
			bufferedWriter.newLine();
			//手动刷新
			bufferedWriter.flush();
			
			//当输入over的时候结束
			if(str.equals("over")) {
				break;
			}
		}
		//关闭流
		bufferedWriter.close();
		bufferedReader.close();

	}

设备之间的传输：
设备分成输入源和输出源，
输入源：给内存提供数据的设备
输出源：从内存接受数据的设备
输入源：键盘
输出源：控制台

	public static void main(String[] args) throws IOException {
	//将键盘作为输入源
		BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(System.in));
		//将文件作为输入源
		BufferedReader bufferedReader2 = new BufferedReader(new FileReader("src\\com\\qianfeng\\test\\Demo1.java"));
		
		//将文件作为输出源
		BufferedWriter bufferedWriter1 = new BufferedWriter(new FileWriter("temp1.txt"));
		//将控制台作为输出源
		BufferedWriter bufferedWriter2 = new BufferedWriter(new OutputStreamWriter(System.out));
		String str = null;
		while((str = bufferedReader1.readLine())!=null) {
			bufferedWriter2.write(str);
			bufferedWriter2.newLine();
			bufferedWriter2.flush();
		}
		bufferedReader1.close();
		bufferedReader2.close();
		bufferedWriter1.close();
		bufferedWriter2.close();
	}

输入源：键盘
输出源：文件

	public static void main(String[] args) throws IOException {
	//将键盘作为输入源
		BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(System.in));
		//将文件作为输入源
		BufferedReader bufferedReader2 = new BufferedReader(new FileReader("src\\com\\qianfeng\\test\\Demo1.java"));
		
		//将文件作为输出源
		BufferedWriter bufferedWriter1 = new BufferedWriter(new FileWriter("temp1.txt"));
		//将控制台作为输出源
		BufferedWriter bufferedWriter2 = new BufferedWriter(new OutputStreamWriter(System.out));
		String str = null;
		while((str = bufferedReader1.readLine())!=null) {
			bufferedWriter1.write(str);
			bufferedWriter1.newLine();
			bufferedWriter1.flush();
		}
		bufferedReader1.close();
		bufferedReader2.close();
		bufferedWriter1.close();
		bufferedWriter2.close();
	}

输入源：文件
输出源：控制台

	public static void main(String[] args) throws IOException {
	//将键盘作为输入源
		BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(System.in));
		//将文件作为输入源
		BufferedReader bufferedReader2 = new BufferedReader(new FileReader("src\\com\\qianfeng\\test\\Demo1.java"));
		
		//将文件作为输出源
		BufferedWriter bufferedWriter1 = new BufferedWriter(new FileWriter("temp1.txt"));
		//将控制台作为输出源
		BufferedWriter bufferedWriter2 = new BufferedWriter(new OutputStreamWriter(System.out));
		String str = null;
		while((str = bufferedReader2.readLine())!=null) {
			bufferedWriter2.write(str);
			bufferedWriter2.newLine();
			bufferedWriter2.flush();
		}
		bufferedReader1.close();
		bufferedReader2.close();
		bufferedWriter1.close();
		bufferedWriter2.close();
	}

输入源：文件
输出源：文件

	public static void main(String[] args) throws IOException {
	//将键盘作为输入源
		BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(System.in));
		//将文件作为输入源
		BufferedReader bufferedReader2 = new BufferedReader(new FileReader("src\\com\\qianfeng\\test\\Demo1.java"));
		
		//将文件作为输出源
		BufferedWriter bufferedWriter1 = new BufferedWriter(new FileWriter("temp1.txt"));
		//将控制台作为输出源
		BufferedWriter bufferedWriter2 = new BufferedWriter(new OutputStreamWriter(System.out));
		String str = null;
		while((str = bufferedReader2.readLine())!=null) {
			bufferedWriter1.write(str);
			bufferedWriter1.newLine();
			bufferedWriter1.flush();
		}
		bufferedReader1.close();
		bufferedReader2.close();
		bufferedWriter1.close();
		bufferedWriter2.close();
	}

更换标准流输入源，输出源

更换输入源，输出源
注意：这里是临时更换，只能在当前的程序中使用更换后的输入输出源，如果在其他的程序中会自定变回原来的键盘/控制台
实例：从键盘到控制台，更换成从文件到文件

public static void main(String[] args) throws IOException {
		//更换输入源--从键盘到文件
		System.setIn(new FileInputStream("src/com/qianfeng/test/Demo1.java"));
		//更换输出源--从控制台到文件
		System.setOut(new PrintStream("temp2.txt"));
		
		BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bufferedWriter2 = new BufferedWriter(new OutputStreamWriter(System.out));
		
		String data = null;
		while((data = bufferedReader1.readLine())!=null){
			bufferedWriter2.write(data);
			bufferedWriter2.newLine();
			bufferedWriter2.flush();
		}
		
		bufferedReader1.close();
		bufferedWriter2.close();
	}

打印流

打印流：除了拥有输出流的特点之外，还有打印的功能，比如println，print的方法。
分成两种
- 字节打印流：PrintStream
- 字符打印流：PrintWriter

字节打印流：

可以直接关联的设备（传入的参数）
- 1.File类型的文件
- 2.字符串类型的文件
- 3.字节输出流

public static void main(String[] args) throws IOException {
//		 * 1.File类型的文件
		//PrintStream printStream = new PrintStream(new File("D:\\eclipse-workspace\\BigData1715N20\\src\\com\\qianfeng\\test\\Demo1.java"));
		
//		 * 2.字符串类型的文件
		//PrintStream printStream = new PrintStream("temp3.txt");//对于当前的文件，如果不存在，会自动创建
		
//		 * 3.字节输出流
		PrintStream printStream1 = new PrintStream(new FileOutputStream("temp3.txt"));
		
		//讲解print方法的原理
		printStream1.write(97);//00000000 00000000 00000000 00000000 01100001	在打印的时候，将前面三个字节砍掉了，得到了a	
		printStream1.write(353);//00000000 00000000 00000000 00000001 01100001	在打印的时候，将前面的三个字符砍掉了，得到了a
		
		printStream1.print(353);
		//先将353转成字符串，再转成字节数组
		printStream1.write(String.valueOf(353).getBytes());
		
		printStream1.close();
	}

字符打印流：

可以直接关联的设备（传入的参数）
1.File类型的文件
2.字符串类型的文件
3.字节输出流
4.字符写出流

public static void main(String[] args) throws IOException {
		System.out.println();
		//实例：将数据从键盘接收传到控制台
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		
		//创建字符打印流
		PrintWriter printWriter = new PrintWriter(System.out);
		
		String data = null;
		while((data = bufferedReader.readLine())!=null) {
			printWriter.println(data);
			printWriter.flush();
		}
		
		printWriter.close();
		bufferedReader.close();
	}

序列化流

序列化流：将短期存储的数据实现长期存储的过程
- 短期存储：数据存放在内存中，随着程序的关闭而释放，----对象，数组，集合，变量
- 长期存储：数据存放在磁盘中，即使程序关闭，数据仍然存在----文件
序列化：将数据从内存存入磁盘，可以实现数据的持久化存储。
逆序列化：将数据从磁盘传回内存，
进行序列化的步骤：----以对象的序列化为实例
- 1.创建一个类
  - 这个类的对象进行序列化必须实现Serializable接口，
  - 类通过实现接口，启动序列化功能，未实现此接口的类无法实现序列化或逆序列化，
  - 如果没有实现，会报异常NotSerializableException
  - 注意点：可序列化对象的内部的元素要都支持序列化。
- 2.使用对应的流，将对象存入磁盘----序列化----ObjectOutputStream
- 3.使用对应的流将数据从磁盘中取出放回内存----逆序列化----ObjectInputStream
- 4.关闭流
注意：序列化流在工作时也要关联的输入流输出流

序列化

//序列化
	public static void fun1() throws IOException {
		//创建序列化流并关联文件
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("temp4.txt"));
		//实现序列化
		//序列化后的内容不能直接查看，要想查看必须逆序列化
		objectOutputStream.writeObject(new Person("bingbing",20));
		//关闭流
		objectOutputStream.close();
	
	}
class Person implements Serializable{
	/**
	*相当于这个类的ID，逆序列化比较的是字节码文件的名字还有ID，如果没有对应的ID或字节码文件，就无法逆序列化
	 * generated:由编译器自动生成的吗，后面加L标识long型数据
	 */
	private static final long serialVersionUID = -8537344700990412769L;
	/**
	 * default:默认的方式，可以有用户自己指定，默认值是1
	 */
//	private static final long serialVersionUID = 1L;
	String name;
	int age;
	int height;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "person [name=" + name + ", age=" + age +", height = "+height +"]";
	}
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}

逆序列化

	//逆序列化
	public static void fun2() throws FileNotFoundException, IOException, ClassNotFoundException {
		//创建逆序列化流并关联文件
		ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("temp4.txt"));
		//实现逆序列化--读
		
		Person person = (Person)inputStream.readObject();
		System.out.println(person);
//		Object object = inputStream.readObject();
//		System.out.println(object);
		//关闭流
		inputStream.close(); 
	}
class Person implements Serializable{
	/**相当于这个类的ID，逆序列化比较的是字节码文件的名字还有ID，如果没有对应的ID或字节码文件，就无法逆序列化
	 * generated:由编译器自动生成的吗，后面加L标识long型数据
	 */
	private static final long serialVersionUID = -8537344700990412769L;
	/**
	 * default:默认的方式，可以有用户自己指定，默认值是1
	 */
//	private static final long serialVersionUID = 1L;
	String name;
	int age;
	int height;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "person [name=" + name + ", age=" + age +", height = "+height +"]";
	}
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}

Properties类

Properties这是一个类，可以理解成是一个Map集合，存储的是属性，属性以键值对的形式存在。键值对内部的键值必须是String，不需要泛型
为什么要在这里讲Properties？
因为他的操作与流的关系非常的紧密
优点：
- 1.以键值对的形式存值，
- 2.内部封装了大量的方法，比如：load，store，list等，方便操作

基本操作

//1.基本的操作
	public static void function1() {
		//创建Properties对象
		Properties properties = new Properties();
		
		//存值
		properties.setProperty("01", "java");
		properties.setProperty("02", "python");
		properties.setProperty("01", "ok");
		
		//取值
		properties.getProperty("01");
		System.out.println(properties.getProperty("01"));
		
		//获取所有的key
		Set<String> set = properties.stringPropertyNames();
		for (String string : set) {
			System.out.println("Key"+string+"  = value"+properties.getProperty(string));
		}

获取系统属性

//2.如何通过Properties获取系统的属性
	public static void function2() {
		Properties properties = System.getProperties();
		
		Set<String> set = properties.stringPropertyNames();
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println("Key:"+string+"  = value:"+properties.getProperty(string));
		}

Properties的实际应用

    public static void function3() throws IOException {
		//创建属性集合对象
		Properties properties = new Properties();
		//创建输入流
		FileReader fileReader = new FileReader("temp2.txt");
		
		//将temp2.txt的内容加载到属性集合对象中
		properties.load(fileReader);
		
		//打印到控制台
		//注意：要想打印的是正确的形式，必须保证TXT文件本身是键值对的形式存在
		properties.list(System.out);
		
		//更改内容
		properties.setProperty("01","bingbingbang");
		
		//将内容重新写回磁盘---借助输出流 
		FileWriter fileWriter  = new FileWriter("temp2.txt");
		properties.store(fileWriter,"bingbingchoule");
		
		fileWriter.close();
		fileReader.close();
	}

weixin_42478640

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java第21天----转换流，标准流，打印流，序列化流，Properties类

文章目录昨天知识总结流转换流更换标准流输入源，输出源打印流字节打印流：字符打印流：序列化流序列化逆序列化Properties类基本操作获取系统属性Properties的实际应用昨天知识总结1.字符缓冲流2.装饰设计模式3.适配器设计模式4.字节流5.字节缓冲流6.标准输入流流转换流转换流：本身是字符流分类：InputStreamReader：从字节输入流到字符读入流...
复制链接

扫一扫