I/O流技术使用

最新推荐文章于 2024-07-24 11:16:49 发布

骚Java

最新推荐文章于 2024-07-24 11:16:49 发布

阅读量149

点赞数 2

分类专栏： Java小知识

Java小知识专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一.说明

(一).File类

1.说明：用于描述一个文件夹或者文件。

2.用途：通过Flie对象，我们可以读取文件或者文件夹的属性数据

(二).I/O流技术：【Input Output】

1.I/O流分类：

如果按照数据的流向划分:
- a.输出流
- b.输入流
如果按照处理单位:
- a.字节流:字节流读取的都是文件中二进制数据，读取到的数据都不会经过任何做处理
- b.字符流:字符读取的数据时是以字符为单位的，字符流也是读取文件中二进制数据，不过会把这些二进制数据转换成我们能识别的字符【字符流 = 字节流 + 解码】

2.I/O解决问题：解决设备与设备的之间数据的传输问题【内存 —> 硬盘硬盘 —> 内存】

3.用途:读取文件的内容数据

(三).输入流类

1.InputStream类：所有输入字节流的基类抽象类 [读字节] (是FileinputStream的父类)

2.FileInputStream类：读取文件数据的输入字节流

3.Reader类：所有读字符输入流父类抽象类(是InputStreamReader的父类)

4.InputStreamReader 类:关联字节到字符的桥梁，他是负责在I/O 过程中处理读取字节到字符的转换

(四).输出流类

1.OutputSteam类：所有写字节输出流的基类抽象类(是FileOutputSream的父类)

2.FileOutputStream类：写数据到文件的输出字节流

3.Writer类：所有写字符输出流的父类抽象类(是OutputStreamWriter的父类)【注：只能操作文本,不能操作(图片，音频，视频)】

4.OutputStreamWriter 类：关联字符到字节的桥梁，他是负责在I/O过程中处理写字符到字节的转换

二.使用I/O流技术的使用

1.字节流读读和写步骤：

找到目标文件
建立数据输入【输出】通道
读取【写入】文件中的数据
关闭资源

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.log4j.Logger;
import org.junit.Test;


/**
 * <h1> ClassName: IOTest </h1>
 * <h1> Function: IO技术的使用</h1>
 * @version 创建日期：2019年5月18日 下午8:49:41
 * @author LST
 */
public class IOTest {
	
	Logger logger = Logger.getLogger(IOTest.class);
	
	public String writePathName = "F:\\write.txt";
	public String readPathName = "F:\\read.txt";
	
	/** 写 */
	@Test
	public void writeOutputStream() {
		try {
			// 1.找到目标文件
			File outFile = new File(writePathName);
			if(!outFile.exists()) { // 判断文件或是文件夹是否存在
				outFile.createNewFile(); // 不存在则创建文件
			}
			// 2.建立数据输入的通道
			OutputStream outputStream = new FileOutputStream(outFile);
			// 3.文件写入数据
			String con = "根据字节流来写入内容";
			outputStream.write(con.getBytes());
			// 4.关闭资源 实际上就是释放资源。 【如果不关闭的话，对该文件进行其他的操作时，是不允许的】
			outputStream.close();
		} catch (IOException e) {
			logger.error("异常");
			e.printStackTrace();  
		}
	}
	
	/** 读 */
	@Test
	public void readInputStream() {
		try {
			// 1.找到目标文件
			File inFile = new File(writePathName);
			// 2.建立数据输入通道
			InputStream inputStream = new FileInputStream(inFile);
			// 3.读取文件中的数据
			// 存储读取到的数据缓冲数组的长度一般是1024的倍数，因为与计算机的处理单位。理论上缓冲数组越大，效率越高【相当超市中的购物车】
			// 建立缓冲数组配合循环读取文件的数据。
			// 保存每次读取到的字节个数。
			byte []bs = new byte[1024]; 
			int len = 0; //声明该变量用于存储读取到的数据
			while ((len = inputStream.read(bs)) != -1) { // read方法如果读取到了文件的末尾，那么会返回-1表示。
				System.out.println("读写到的内容是：" + (new String(bs, 0, len)));
			}
			// 关闭资源 实际上就是释放资源。 【如果不关闭的话，对该文件进行其他的操作时，是不允许的】
			inputStream.close();
		} catch (IOException e) {
			e.printStackTrace();  
		}
	}
	/** 读和写 */
	@Test
	public void readAndWriteStream() {
		try {
			// 读
			File inFile = new File(readPathName);
			File outFile = new File(writePathName);
			InputStream inputStream = new FileInputStream(inFile); // 读
			OutputStream outputStream = new FileOutputStream(outFile); // 写
			byte []bs = new byte[1024];
			int len = 0;
			while ((len = inputStream.read(bs)) != -1) {
				outputStream.write(bs, 0, len);
			}
			inputStream.close();
			outputStream.close();
		} catch (FileNotFoundException e) {
			logger.error("找不到该文件");
			e.printStackTrace();  
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

2.字符流读读和写步骤：【跟字节流差不多】

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

import org.apache.log4j.Logger;
import org.junit.Test;


/**
 * <h1> ClassName: IOTest </h1>
 * <h1> Function: IO技术的使用</h1>
 * @version 创建日期：2019年5月18日 下午8:49:41
 * @author LST
 */
public class IOTest2 {
	
	Logger logger = Logger.getLogger(IOTest2.class);
	
	public String writePathName = "F:\\write.txt";
	public String readPathName = "F:\\read.txt";
	
	/** 写 */
	@Test
	public void write() {
		try {
			// 1.找到目标文件
			File outFile = new File(writePathName);
			if(!outFile.exists()) { // 判断文件或是文件夹是否存在
				outFile.createNewFile(); // 不存在则创建文件
			}
			// 2.建立数据输入的通道
			OutputStream outputStream = new FileOutputStream(outFile);
			Writer writer = new OutputStreamWriter(outputStream, "UTF-8"); // // 指定编码【不指定的话默认找系统的编码】
			// 3.文件写入数据
			String con = "根据字符流来写入内容";
			writer.write(con);
			// 4.关闭资源 实际上就是释放资源。 【如果不关闭的话，对该文件进行其他的操作时，是不允许的】
			writer.close();
		} catch (IOException e) {
			logger.error("异常");
			e.printStackTrace();  
		}
	}
	
	/** 读 */
	@Test
	public void read() {
		try {
			// 1.找到目标文件
			File inFile = new File(writePathName);
			// 2.建立数据输入通道
			InputStream inputStream = new FileInputStream(inFile);
			Reader reader = new InputStreamReader(inputStream, "UTF-8");
			// 3.读取文件中的数据
			// 存储读取到的数据缓冲数组的长度一般是1024的倍数，因为与计算机的处理单位。理论上缓冲数组越大，效率越高【相当超市中的购物车】
			// 建立缓冲数组配合循环读取文件的数据。
			// 保存每次读取到的字节个数。
			char []cs = new char[1024]; 
			StringBuffer buffer = new StringBuffer();
			int len = 0; //声明该变量用于存储读取到的数据
			while ((len = reader.read(cs)) != -1) { // read方法如果读取到了文件的末尾，那么会返回-1表示。
				System.out.println("读写到的内容是：" + buffer.append(cs, 0, len));
			}
			// 关闭资源 实际上就是释放资源。 【如果不关闭的话，对该文件进行其他的操作时，是不允许的】
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();  
		}
	}
	
	/** 读和写 */
	@Test
	public void readAndWrite() {
		try {
			// 读
			File inFile = new File(readPathName);
			File outFile = new File(writePathName);
			InputStream inputStream = new FileInputStream(inFile); // 读
			Reader reader = new InputStreamReader(inputStream, "UTF-8");
			OutputStream outputStream = new FileOutputStream(outFile); // 写
			Writer writer = new OutputStreamWriter(outputStream, "UTF-8");
			char []cs = new char[1024];
			int len = 0;
			while ((len = reader.read(cs)) != -1) {
				writer.write(cs, 0, len);
			}
			reader.close();
			writer.close();
		} catch (FileNotFoundException e) {
			logger.error("找不到该文件");
			e.printStackTrace();  
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}