第十章 IO流2

最新推荐文章于 2021-07-26 14:45:56 发布

X.. R H

最新推荐文章于 2021-07-26 14:45:56 发布

阅读量172

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_47160763/article/details/107441340

版权

JavaSE 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

处理流之一：缓冲流

FileInputStream,FileOutStream,FileReader,FileWriter,这些都是计算机与硬盘之间发生的IO操作，基于硬盘的读写相对较慢，这个速度受到硬盘读写速递的制约，为了提高速度绕过硬盘的限制Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。
根据数据操作单位可以把缓冲流分为：
BufferedInputStream 和 BufferedOutputStream
BufferedReader 和 BufferedWriter
缓冲流就是先把数据缓存到内存里，在内存中做IO此操作，大概比硬盘IO操作快75000倍

缓冲字节流

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

public class Test {
	public static void main(String[] args) {
		try {
			//Test.testBufferedInputStream();
			//Test.testBufferedOutputStream();
			Test.copyFile();
			
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
	
	/**
	 * 缓冲字节输入流
	 * @throws Exception 
	 */
	public static void testBufferedInputStream() throws Exception {
		//文件字节流输入对象
		FileInputStream  in =new FileInputStream("D:\\project\\helloworld\\src\\day13\\tt");
		//缓冲字节输入流 (把文件字节流输入流放到缓冲字节输入流对象)
		BufferedInputStream br =new BufferedInputStream(in);
		
		byte [] b= new byte[10]; //临时存放数据的一个数组
		int len =0;
		while((len=br.read(b))!=-1) {
			System.out.println(new String(b,0,len));
		}
		br.close();
		in.close();
	}
	
	/**
	 * 缓冲字节输出流
	 * @throws Exception 
	 */
	public static void testBufferedOutputStream() throws Exception {
		//创建字节输出流对象
		FileOutputStream out=new FileOutputStream("D:\\project\\helloworld\\src\\day13\\tt1.txt");
		//把字节输出流放到缓冲字节输出流里面
		BufferedOutputStream bo =new BufferedOutputStream(out);
		
		String s="hello world";
		
		bo.write(s.getBytes());//写到内存中
		bo.flush();
		bo.close();
		out.close();
				
	}
	
	/**
	 * 缓冲流实现文件的复制
	 * @throws Exception 
	 */
	
	public static void copyFile() throws Exception {
		//缓冲输入流
		BufferedInputStream br =new BufferedInputStream(new FileInputStream("D:\\project\\helloworld\\src\\day13\\tt1.txt"));
		//缓冲输出流
		BufferedOutputStream bo =new BufferedOutputStream(new FileOutputStream("D:\\project\\helloworld\\src\\day13\\tt2.txt"));
		
		byte [] b=new byte[1024];
		int len =0;
		
		while((len =br.read(b))!=-1) {
			bo.write(b, 0, len);
		}
		bo.flush();
		bo.close();
		br.close();
		
		
	}
	
	
	
}

缓冲字符流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import jdk.jfr.events.FileWriteEvent;

public class Test1 {
	public static void main(String[] args) {
		try {
			//Test1.testBufferedReader();
			//Test1.testBufferedWriter();
			Test1.copyFile();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
	/**
	 * 缓冲字符输入流
	 * @throws Exception 
	 */
	public static void testBufferedReader() throws Exception {
		FileReader r=new FileReader("D:\\project\\helloworld\\src\\day13\\tt");
		BufferedReader br =new BufferedReader(r);
		
		char[] c =new char[100];
		int len =0;
		while ((len=br.read(c))!=-1) {
			System.out.println(new String(c, 0, len));//转换成字符串
			
		}
		br.close();
		r.close();		
	}
	
	/**
	 * 缓冲字符输出流
	 * @throws Exception 
	 */
	
	public static void testBufferedWriter() throws Exception {
		FileWriter w =new FileWriter("D:\\project\\helloworld\\src\\day13\\tt3");
		BufferedWriter bw =new BufferedWriter(w);
		
		String s="hello world";
		bw.write(s);
		bw.flush();
		bw.close();
		w.close();
				
	}
	
	/**
	 * 缓冲字符复制文件  先输入(读取)旧的tt然后在输出到新的tt中
	 * @throws Exception 
	 */
	
	public static void copyFile() throws Exception {
		BufferedReader br =new BufferedReader(new FileReader("D:\\project\\helloworld\\src\\day13\\tt") );
		BufferedWriter bw =new BufferedWriter(new FileWriter("D:\\project\\helloworld\\src\\day13\\tttt"));
		//以上两步是，复制第一行的文件，复制到第二行的路径里
		
		char [] c= new char[100];
		int len =0;
		while((len=br.read(c))!=-1) {
			bw.write(c, 0, len);
		}
		bw.flush();
		bw.close();
		br.close();
		
	}
	
	
}

处理流之二：转换流

所有的文件都是编码格式，对于我们来说，TXT和Java文件一般有三种编码，ISO8859-1，西欧编码，纯粹的英文编码。GBK和UTF-8适用于中文。一般使用UTF-8。
转换流，可以把字节流转换为字符流，当字节流中的数据都是字符的时候，使用转换流转化为字符流处理效率更高

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Test2 {
	public static void main(String[] args) {
		try {
			//Test2.testInputStreamReader();
			Test2.testOutputStreamWriter();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
	
	
	/**
	 * 转换输入流
	 * @throws Exception 
	 */
	
	public static void testInputStreamReader() throws Exception {
		FileInputStream fs =new FileInputStream("D:\\project\\helloworld\\src\\day13\\tt5.txt");
		//字节流转换成字符流
		InputStreamReader in =new InputStreamReader(fs,"GBK");
		
		char [] c =new char[100];
		int len =0;
		while((len=in.read(c))!=-1) {
			System.out.println(new String(c,0,len));		
		}
		in.close();
		fs.close();
	}
	
	
	/**
	 * 转换字节输出流为字符输出流
	 * @throws Exception 
	 */
	public static void testOutputStreamWriter() throws Exception {
		FileOutputStream out =new FileOutputStream("D:\\project\\helloworld\\src\\day13\\tt6.txt");
		OutputStreamWriter of =new OutputStreamWriter(out,"GBK");
		
		of.write("你好");
		of.flush();
		of.close();
		out.close();
		
		
	}
}

处理流之三：标准输入输出流

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test3 {
	public static void main(String[] args) {
		try {
			Test3.testsys();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
	/**
	 * 标准的输入流
	 * @throws Exception
	 */
	
	public static void testsys() throws Exception {
		//创建接受一个键盘输入数据的输入流
		InputStreamReader is =new InputStreamReader(System.in);
		//把输入流放到缓冲流中
		BufferedReader br =new BufferedReader(is);
		
		String str =""; //定义一个临时接受数据的字符串
		
		while ((str=br.readLine())!=null) {
			System.out.println(str);
		}
		br.close();
		is.close();
		
	}
}

练习：把控制台输入的内容写到指定的TXT文件中，当接收到字符串over，就结束程序的运行

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test3 {
	public static void main(String[] args) {
		try {
			
			Test3.writeTXT();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}

	
	//为什么写静态方法，是因为这样调用方法可以直接类名点方法，不用new对象了
	public static void writeTXT() throws Exception {
		InputStreamReader is =new InputStreamReader(System.in);
		
		BufferedReader br =new BufferedReader(is);
		
		BufferedWriter out =new BufferedWriter(new FileWriter("D:\\project\\helloworld\\src\\day13\\tt5.txt"));
		
		String strs ="";
		while ((strs=br.readLine())!=null) {
			if(strs.equals("over")) {
				break;
			}
			
			//读取的每一行写到指定的txt中
			out.write(strs);
		}
		
		out.flush();
		out.close();
		br.close();
		is.close();
	}

练习2：在一个TXT文件中，写一组用户名和密码，通过控制台输入用户名和密码，与TXT文件中的用户名密码做对比，如果一样就在打印登录成功，如果不一致，就打印用户名密码错误

数据流之四打印流

数据流之五数据流

用数据输出流写到文件中的基本数据类型的数据是乱码的，不能直接辨认，需要数据输入流来读取。用数据输入流读取数据输出流写到文件的数据时，要保证和当时写的数据类型一致。

数据流之六对象流

硬盘存的是二进制，需要把对象转化喂一个二进制的字节流，把这个流保存到电脑上。通过网络传输也是转化成字节流进行传输。
用于存储和读取对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

因为要保存对象到硬盘（对象的持久化）和对象的网络传输，就产生了对象的输入输出流。
序列化(Serialize)：用ObjectOutputStream类将一个Java对象写入IO流中
反序列化(Deserialize)：用ObjectInputStream类从IO流中恢复该Java对象
为了让某个类是可序列化的，该类必须实现如下两个接口之一：
Serializable
Externalizable


import java.io.Serializable;

public class Person  implements Serializable{
	/**
	 * 用来表明类的不同版本间的兼容性
	 * 一个表示序列化版本标识符的静态变量
	 */
	private static final long serialVersionUID=1L;
	
	String name;
	int age;
	
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 序列化与反序列化
 * 注意：对象的序列化与反序列化的类严格一致，包名，类名，类机构等等
 * @author xrh
 *
 */
public class Test5 {
	public static void main(String[] args) {
		try {
		//	Test5.testSerialize();
			Test5.testDeserialize();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
	/**
	 * 序列化
	 * @throws Exception 
	 * @throws
	 */
	public static void testSerialize() throws  Exception {
		//定义对象的输出流，把对象的序列化之后的流放到指定的文件中
		ObjectOutputStream out =new ObjectOutputStream(new FileOutputStream("D:\\project\\helloworld\\src\\day13\\tt9.txt"));
		Person p=new Person();
		p.name="张三";
		p.age=12;
		
		out.writeObject(p);
		out.flush();
		out.close();
	}
	/**
	 * 反序列化
	 * @throws Exception 
	 * @throws 
	 */
	public static void testDeserialize() throws  Exception {
		//创建对象输入流对象，从指定的文件中把对象序列化的流读出来
		ObjectInputStream in =new ObjectInputStream(new FileInputStream("D:\\project\\helloworld\\src\\day13\\tt9.txt"));
	
			Object obj=in.readObject();
			Person p =(Person)obj;//强制转化成Person类
			
			System.out.println(p.name);
			System.out.println(p.age);
			
			in.close();
	}

}

RandomAccessFile 类（随机存取流）

RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意地方来读、写文件
支持只访问文件的部分内容
可以向已存在的文件后追加内容
文件中还有换行符 \n

import java.io.FileNotFoundException;
import java.io.RandomAccessFile;

/**
 * 文件的随机读取，程序可以跳到任意地方读写文件
 * @author xrh
 *
 */
public class Test6 {
	public static void main(String[] args) {
		try {
			//Test6.testRandomAccessFileRead();
			Test6.testRandomAccessFileWrite();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
	/**
	 * 随机读文件
	 * @throws Exception 
	 */
	public static void testRandomAccessFileRead() throws Exception {
		
		//RandomAccessFile的构造有两个参数，参数一是读写文件的路径，参数二是访问模式
		//r: 以只读方式打开  rw：打开以便读取和写入（常用）
	      //rwd:打开以便读取和写入；同步文件内容的更新
	     //rws:打开以便读取和写入；同步文件内容和元数据的更新

		RandomAccessFile ra =new RandomAccessFile("D:\\project\\helloworld\\src\\day13\\tttt", "r");
		
		ra.seek(6);//设置读取文件的起始点（字节位置）
		byte [] b=new byte[1024];
		int len =0;
		while ((len=ra.read(b))!=-1) {
			System.out.println(new String(b,0,len));
		}
		ra.close();
	}
	/**
	 * 随机写,在中间写或开头写会覆盖
	 * @throws Exception 
	 */
	
	public static void testRandomAccessFileWrite() throws Exception {
		RandomAccessFile ra =new RandomAccessFile("D:\\project\\helloworld\\src\\day13\\tttt", "rw");
		
		ra.seek(0);//设置写的起始点，0代表从开头写
		//ra.seek(ra.length());//从结尾开始写
		
		ra.write("你好".getBytes());  //不用flush
		ra.close();
	}
	
	
	
}

流的基本应用小节

流是用来处理数据的。
处理数据时，一定要先明确数据源，与数据目的地
数据源可以是文件，可以是键盘。
数据目的地可以是文件、显示器或者其他设备
而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理、转换处理等。
字节流-缓冲流（重点）
输入流InputStream-FileInputStream-BufferedInputStream
输出流OutputStream-FileOutputStream-BufferedOutputStream
字符流-缓冲流（重点）
输入流Reader-FileReader-BufferedReader
输出流Writer-FileWriter-BufferedWriter
转换流
InputSteamReader和OutputStreamWriter
对象流ObjectInputStream和ObjectOutputStream（难点）
序列化
反序列化
随机存取流RandomAccessFile（掌握读取、写入）

X.. R H

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
第十章 IO流2

处理流之一：缓冲流FileInputStream,FileOutStream,FileReader,FileWriter,这些都是计算机与硬盘之间发生的IO操作，基于硬盘的读写相对较慢，这个速度受到硬盘读写速递的制约，为了提高速度绕过硬盘的限制Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。根据数据操作单位可以把缓冲流分为：BufferedInputStream 和 BufferedOutputStreamBufferedReader 和 BufferedWrit
复制链接

扫一扫