Java可直接使用的工具类 - CharStreamUtil (NIO处理字符字节流)

使用Java7的try()关闭流

package sugar.utils.stream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.nio.charset.Charset;

//其中，以Stream结尾的为字节流，
//以Writer或者Reader结尾的为字符流。
//所有的输入流都是抽象类IuputStream（字节输入流）
//或者抽象类Reader（字符输入流）的子类，
//所有的输出流都是抽象类OutputStream(字节输出流)
//或者抽象类Writer(字符输出流)的子类。
//字符流能实现的功能字节流都能实现，
//反之不一定。如：图片，视频等二进制文件，只能使用字节流读写。
public class CharStreamUtil {

	public static void main(String[] args) throws IOException {
		//1
//		randomInsert("source/random.txt" , 45 , "插入的内容\r\n");
		//2
//		randomReadWrite("source/random.txt" , 3 , "AABB\r\n");
		//3
//		String str = buffReadTextFile("source/random.txt");
//		System.out.println(str);
		//4
		//GBK转UTF-8
		encode2enc("source/GBK.txt", "GBK", "source/encodeUTF-8.txt","UTF8");
	}

	// 测试阶段
	public static void readTextFile() {
		FileInputStream fis = null;
		InputStreamReader inReader = null;
		BufferedReader bufReader = null;
		BufferedWriter bufWriter = null;
		try {
			//
			// FileInputStream 节点流 直接从文件创建 不依赖与其它的流对象
			fis = new FileInputStream("source/test_utf8.txt");
			inReader = new InputStreamReader(fis, "UTF8");
			// 缓冲字符输入流
			bufReader = new BufferedReader(inReader);
			//
			bufWriter = new BufferedWriter(new FileWriter("source/text_3.txt"));
			//
			String input = null;
			// 每读一行进行一次写入动作
			// 当读到文件字符 end停止循环!!!!
			while (!(input = bufReader.readLine()).equals("end")) {

				bufWriter.write(input);
				// 写入
				bufWriter.newLine();
			}

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {

				// 关闭流,注意关闭的顺序
				bufReader.close();
				bufWriter.close();
				inReader.close();
				fis.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

		// ****
		// 注意原文件 test_utf8.txt 最后一行必须是end
		// 且end不会被写入新文件中
	}

	
	
	
	/**
	 * 字符转码
	 * @param fileName
	 * @param inEncode  "UTF8" "GBK" 等
	 * @param targetFile
	 * @param outEncode
	 */
	public static void encode2enc(String fileName,String inEncode, String targetFile,String targetEncode) {
		// Java7 新增 try后面加的括号
				// 括号里面是必须显式关闭的物理资源，如数据库连接、网络连接、磁盘文件
				// 在try语句结束时自动关闭该资源，不需要finally 判断关闭了
		try (
			 // FileInputStream 节点流 直接从文件创建 不依赖与其它的流对象
			 FileInputStream fis = new FileInputStream(fileName);
			 InputStreamReader inReader = new InputStreamReader(fis, inEncode);
				// 缓冲字符输入流
				BufferedReader bufReader = new BufferedReader(inReader);
				//不能转码
//				BufferedWriter bufWriter = new BufferedWriter(new FileWriter(targetFile));
				FileOutputStream fos = new FileOutputStream(targetFile);
				OutputStreamWriter outWriter = new OutputStreamWriter(fos,targetEncode);
				BufferedWriter bufWriter = new BufferedWriter(new FileWriter(targetFile));
				){
			String line = null;
			//逐行读取
			while ((line = bufReader.readLine()) != null) {
				bufWriter.write(line);
				// 写入
				bufWriter.newLine();
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
	
	/**
	 * 读取文本文件
	 * @param fileName
	 * @return  文本内容
	 */
	public static String buffReadTextFile(String fileName) {
		// Java7 新增 try后面加的括号
		// 括号里面是必须显式关闭的物理资源，如数据库连接、网络连接、磁盘文件
		// 在try语句结束时自动关闭该资源，不需要finally 判断关闭了
		StringBuilder strBuilder = new StringBuilder();
		try ( // 创建输入流对象
				BufferedReader br = new BufferedReader(new FileReader(fileName));// 文件不存在会抛出java.io.FileNotFoundException

		) {
			// 文本文件复制
//			        char [] chs=new char[1024];
//			        int len=0;
//			       
//			        while((len=br.read(chs))!=-1) {
			//返回的是null 
//			        	strBuilder.append(br.readLine());
//			        }
			
			String line = null;
			//逐行读取
			while ((line = br.readLine()) != null) {
				strBuilder.append(line);
			}

		} catch (Exception e) {
			// TODO: handle exception
		}

		return strBuilder.toString();
	}

	/**
	 * 复制一个文本文件到另一个文件
	 * @param fileName
	 * @param targetFile
	 */
	public static void buffCopyTextFile(String fileName, String targetFile) {
		// Java7 新增 try后面加的括号
		// 括号里面是必须显式关闭的物理资源，如数据库连接、网络连接、磁盘文件
		// 在try语句结束时自动关闭该资源，不需要finally 判断关闭了
		try ( // 创建输入流对象
				BufferedReader br = new BufferedReader(new FileReader(fileName)); // 文件不存在会抛出java.io.FileNotFoundException
				// 创建输出流对象
				BufferedWriter bw = new BufferedWriter(new FileWriter(targetFile));) {
			// 文本文件复制
			char[] chs = new char[1024];
			int len = 0;
			while ((len = br.read(chs)) != -1) {
				bw.write(chs, 0, len);
			}

		} catch (Exception e) {
			// TODO: handle exception
		}
	}

	/**
	 * 随机存储在文件最后添加字符串
	 * 
	 * @param fileName
	 * @param position
	 * @param appendContent
	 */
	public static void randomAppend(String fileName, long position, String appendContent) {
		// Java7 新增 try后面加的括号
		// 括号里面是必须显式关闭的物理资源，如数据库连接、网络连接、磁盘文件
		// 在try语句结束时自动关闭该资源，不需要finally 判断关闭了
		try (
				// 以读、写方式打开一个RandomAccessFile对象
				RandomAccessFile raf = new RandomAccessFile(fileName, "rw")) {
			// 将记录指针移动到文件的最后
			raf.seek(raf.length());
			raf.write(appendContent.getBytes());
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}

	/**
	 * 随机存储写入指定位置
	 * 
	 * @param fileName
	 * @param position
	 * @param insertContent
	 */
	public static void randomReadWrite(String fileName, long position, String insertContent) {

		File tmp = null;
		try {
			tmp = File.createTempFile("tmp", null);
			tmp.deleteOnExit();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		// Java7 新增 try后面加的括号
		// 括号里面是必须显式关闭的物理资源，如数据库连接、网络连接、磁盘文件
		// 在try语句结束时自动关闭该资源，不需要finally 判断关闭了
		try (RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
				// 使用临时文件来保存插入点后的数据
				FileOutputStream tmpOut = new FileOutputStream(tmp);
				FileInputStream tmpIn = new FileInputStream(tmp)) {
			raf.seek(position);
			// ------下面代码将插入点后的内容读入临时文件中保存------
			byte[] bbuf = new byte[64];
			// 用于保存实际读取的字节数
			int hasRead = 0;
			// 使用循环方式读取插入点后的数据
			while ((hasRead = raf.read(bbuf)) > 0) {
				// 将读取的数据写入临时文件
				tmpOut.write(bbuf, 0, hasRead);
			}
			// ----------下面代码插入内容----------
			// 把文件记录指针重新定位到position位置
			raf.seek(position);
			// 追加需要插入的内容
			raf.write(insertContent.getBytes());
			// 追加临时文件中的内容
			while ((hasRead = tmpIn.read(bbuf)) > 0) {
				raf.write(bbuf, 0, hasRead);
			}

		} catch (Exception e) {

		}

	}

	
}