文件操作——读取、写入

package test.org.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
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.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class FileOperation {

	public static final String[] fileBandString = { "图片文件", "jpeg2000", "tiff","psd", "png", "swf", "svg", "jpg", "jpeg", "pcx", "dxf", "wmf","emf", "gif", "bmp", 
																		"压缩文件", "rar", "zip", "7z", "cab", "iso",
																		"音频文件", "mp3", "wave", "aiff", "au", "mpeg", "cd", "mpeg-4","midi", "wma", "realaudio", "vof", "oggvorbis", 
																		"视频文件", "mp4","avi", "mov", "asf", "wmv", "navi", "3gp", "real video", "mkv","flv", "f4v", "rmvb", "webm" };

	public static final List<String> fileBandList = new ArrayList<String>(Arrays.asList(fileBandString));

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		String filePath = "E:\\KuGou\\supplierss_save.jsp";
		filePath = "E:\\KuGou\\lvtu.mp3"; 

		getFilePath(filePath);
	}

	/**
	 * 以行为单位读取文件，常用于读面向行的格式化文件
	 * 
	 * @param filePath
	 * @throws Exception
	 */
	public static void readLineByFileOprea(String filePath) throws Exception {
		File file = new File(filePath);
		//字符 缓冲流
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
		//创建集合，存放读取的数据
		List<String> list = new ArrayList<String>();
		
		String line = null;
		//循环读取文件 直至读取的文件为空
		while ((line = br.readLine()) != null) {
			list.add(line);
		}
		//关闭流
		br.close();
		//调用写操作
		writeLineByFileOpera(filePath, list);
	}

	/**
	 * 以行为单位写入文件，常用于读面向行的格式化文件
	 * @param filePath
	 * @throws Exception
	 */
	public static void writeLineByFileOpera(String filePath, List list)throws Exception {
		String strName = getFileName(filePath);
		File file = new File(strName);

		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)));

		for (Object obj : list) {
			bw.append((String) obj);
			bw.newLine(); // 创建新 的一行
		}
		System.out.println(strName + "  Line   创建完成");
		bw.close();
	}

	/**
	 * 读取文件单个字符 reader inutputSreamReader 字符流 以字符为单位读取文件，常用于读文本，数字等类型的文件
	 * 
	 * @param filePath
	 * @throws Exception
	 */
	public static void readCharByFileOprea(String filePath) throws Exception {
		File file = new File(filePath);

		InputStreamReader isr = new InputStreamReader(
				new FileInputStream(file), "UTF-8");

		List<Integer> list = new ArrayList<Integer>();

		int len = -1;
		while ((len = isr.read()) != -1) {
			list.add(len);
		}
		isr.close();
		writeCharByFileOpera(filePath, list);
	}

	/**
	 * 写入文件单个字符 writer outtputSreamWriter 字符流 以字符为单位写入文件，常用于读文本，数字等类型的文件
	 * @param filePath
	 * @throws Exception
	 */
	public static void writeCharByFileOpera(String filePath, List list)throws Exception {
		String strName = getFileName(filePath);
		File file = new File(strName);

		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream( file ), "UTF-8");

		for (Object obj : list) {
			osw.write((Integer) obj);
		}
		System.out.println(strName + "  Char   创建完成");
		osw.close();
	}

	/**
	 * 读取文件多个字符 reader inutputSreamReader 字符流 以字符为单位读取文件，常用于读文本，数字等类型的文件
	 * @param filePath
	 * @throws Exception
	 */
	public static void readCharsByFileOprea(String filePath) throws Exception {
		File file = new File(filePath);

		Reader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");

		List<Integer> list = new ArrayList<Integer>();

		char[] ch = new char[1024];
		int len = -1;
		while ((len = isr.read(ch)) != -1) {
			list.add(len);
		}
		isr.close();
		writeCharsByFileOpera(filePath, list, ch);
	}

	/**
	 * 写入文件单个字符 writer outtputSreamWriter 字符流
	 * @param filePath
	 * @throws Exception
	 */
	public static void writeCharsByFileOpera(String filePath, List list,char[] ch) throws Exception {
		String strName = getFileName(filePath);
		File file = new File(strName);

		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");

		for (Object obj : list) {
			osw.write((Integer) obj);
			osw.write(ch, 0, (Integer) obj);
		}
		System.out.println(strName + "   chars  创建完成");
		osw.close();
	}

	/**
	 * 读取文件单个字节 inputstream fileInputSream 字节流 常用于读二进制文件，如图片、声音、影像等文件
	 * @param filePath
	 * @throws IOException
	 */
	public static void readByteByFileOpera(String filePath) throws IOException {
	    	
		File file = new File(filePath);
		InputStream fis = null;
		fis = new FileInputStream(file);
		List<Integer> list = new ArrayList<Integer>();

		int len = -1;
		long time = System.currentTimeMillis();
		while ((len = fis.read()) != -1) {
			// 将读取的文件加入到集合中
			list.add(len);
//			//计算读取的长度
//			String st = getReadFilePlan(list.size() ,  file.length());
//			//打印进度
//			System.out.println(st);
		}
		fis.close();
		// 读取文件单个字节
		FileOperation.writeByteByfileOpera(filePath, list, time , file.length());
	}

	/**
	 * 写入文件单个字节 outputStream fileOutputSteram 字节流 常用于写二进制文件，如图片、声音、影像等文件
	 * @param filePath		文件路径
	 * @param list			存放数据的集合
	 * @param time		事件戳
	 * @param fileLength	源文件大小
	 * @throws IOException
	 */
	public static void writeByteByfileOpera(String filePath , List list , long time , long fileLength) throws IOException {
	    	//获取文件名字
	    	String fileName = getFileName(filePath);
	    	//创建文件
        	File file = new File(fileName);
        	//创建字节流对象
        	OutputStream fos = new FileOutputStream(file, true);
        	//将数据写入文件
        	for (Object obj : list) {
        		fos.write((Integer) obj);
//        		//计算写入的进度
//                	String writePlan = getWriteFilePlan( file.length() , fileLength);
//                	//打印进度
//                	System.out.println(writePlan);
        	}
        	long time1 = System.currentTimeMillis();
        	System.out.println(fileName + "Byte  创建完成，耗时：" + (time1 - time) / 1000 + " 秒 ");
        
        	fos.close();
	}

	/**
	 * 读取文件多个字节 inputstream fileInputSream 字节流 常用于读二进制文件，如图片、声音、影像等文件
	 * @param filePath
	 * @throws Exception
	 */
	public static void readBytesByFileOprea(String filePath) throws Exception {
		InputStream fis = new FileInputStream(new File(filePath));
		// 创建集合存储读取的二进制文件
		List list = new ArrayList();
		byte[] b = new byte[5000];
		int len = -1;
		while ((len = fis.read(b)) != -1) {
//		    	System.out.println(new String(b, 0, len));
			list.add(len);
		}
		fis.close();
		// 如果list 为空，return ，不为空
		if (list.size() != 0) {
			writeBytesByFileOprea(filePath, list, b);
		} else {
			System.out.println("文件为空");
			return;
		}
	}

	/**
	 * 写文件多个字节 outputStream fileOutputSteram 字节流 常用于写二进制文件，如图片、声音、影像等文件
	 * @param filePath
	 * @param list
	 * @throws Exception
	 */
	public static void writeBytesByFileOprea(String filePath, List list,byte[] b) throws Exception {
	    	//获取文件名
	    	String fileName = getFileName(filePath);
		// 创建二进制文件写对象 并追加模式
		File file = new File(fileName);
		OutputStream fos = new FileOutputStream(file, true);
		// 遍历循环写操作
		for (Object obj : list) {
			fos.write(b, 0, (Integer) obj);
		}
		System.out.println(fileName + "bytes   创建完成");
		// 关闭流
		fos.close();
	}

	/**
	 * 获取文件的名称和 格式
	 * @param filePath		文件
	 * @return
	 */
	public static String getFileName(String filePath) {
		long date = System.currentTimeMillis();
		// 获取文件格式并转换成小写
		String fileBand = getFileBand(filePath);
		return "D:\\KuGou\\" + date + "." + fileBand;
	}

	// 获取文件格式
	public static String getFileBand(String filePath) {
		String[] str = filePath.split("\\.");
		return str[1];
	}
	/**
	 * 根据不同的文件类型执行不同的方法
	 * @param filePath
	 * @throws Exception
	 */
	public static void getFilePath(String filePath) throws Exception {
		String fileBand = getFileBand(filePath).toLowerCase();
		// 音频文件,视频文件，压缩文件
		if (fileBandList.contains(fileBand)) {
		    	//字节流方法
			readByteByFileOpera(filePath);
		} else {
		    	//字符流方法
			readCharsByFileOprea(filePath);
//			readBytesByFileOprea(filePath);
		}
	}
	/**
	 * 读取文件的进度
	 * @param readFile		读取文件的大小
	 * @param fileLength	源文件的大小
	 * @return
	 */
	public static String getReadFilePlan(long readFile , long fileLength){
	    DecimalFormat df=new DecimalFormat(".##");
	    double bai =readFile *10000 / fileLength;
	    String st = df.format(bai/100);
	    if(bai < 100){
		st = "读取进度："+ "0"+st + "%";
	    }else{
		st = "读取进度："+ st +"%";
	    }
		return st ;
	}
	/**
	 * 读取写入文件的进度
	 * @param writeFile		写入文件的大小
	 * @param fileLength	写入源文件的大小
	 * @return
	 */
	public static String getWriteFilePlan(long writeFile , long fileLength){
	    //格式化  保留两位小数
	    DecimalFormat df=new DecimalFormat(".##");
	    double bai =writeFile *10000 / fileLength;
	    String st = df.format(bai/100);
	    if(bai < 100){
		st = "写入进度："+ "0"+st + "%";
	    }else{
		st = "写入进度："+ st +"%";
	    }
	    return st;
	}

}