java_IO 读写文件,操作文件,控制台输入输出

这次是要写一些IO相关的,包括

读写文件:字节流,字符流,整行读等

操作文件:以模拟复制文件,罗列根目录下所有文件的例子说明常用文件操作

控制台输入输出:普通输入输出和快速输入输出

直接代码,说明看注释和方法名称:

import java.io.BufferedReader;
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.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.io.Writer;
import java.util.Scanner;

public class FileTest {
	public static void main(String[] args) throws IOException {
		String fileName = "D:/test.txt";
		String newFileName = "D:/testCopy.txt";
		String root = "D:\\Web\\新建文件夹";
		// readFileByBytes(fileName);
		// readFileByChars(fileName);
		// readFileByLines(fileName);
		// readFileByRandomAccess(fileName);
		// appendByRandomAccessFile(fileName, "abcde");
		// appendByFileWrite(fileName, "我");
		// writeFileByChars(fileName, "你好");
		// writeFileByBytes(fileName, "111");
		// copyFile(fileName, newFileName);
		// listFileAndFolder(root);
		consoleInputAndOutput();
	}

	/**
	 * 以子节为单位读取文件,常用于读二进制文件,如图片,声音等文件
	 * 
	 * @param fileName
	 *            文件名
	 */
	public static void readFileByBytes(String fileName) {
		File file = new File(fileName);
		InputStream in = null;
		byte[] data = new byte[(int) file.length()];
		int len = 0;
		try {
			System.out.println("以子节为单位读取文件内容,一次读一个字节");
			in = new FileInputStream(file);
			int read;
			while ((read = in.read()) != -1) {
				data[len++] = (byte) read;
				// 单个输出,非汉字正确输出.转换成字符输出
				System.out.write(read);
			}
			String result = new String(data, 0, len);
			// 非汉字时正常输出
			System.out.println("result:" + result);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (null != in) {
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 字符流读文件
	 * 
	 * @param fileName
	 *            文件名
	 */
	public static void readFileByChars(String fileName) {
		File file = new File(fileName);
		Reader reader = null;
		try {
			// 设置编码,可以读取汉字
			reader = new InputStreamReader(new FileInputStream(file), "GBK");
			int read;
			byte[] data = new byte[(int) file.length()];
			int len = 0;
			while ((read = reader.read()) != -1) {
				data[len++] = (byte) read;
				// 对于windows,\r\n两个字符表示一个换行
				// 分开显示时换行两次
				if ((char) read != '\r') {
					System.out.println((char) read);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != reader) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 整行读取文件
	 * 
	 * @param fileName
	 *            文件名
	 */
	public static void readFileByLines(String fileName) {
		File file = new File(fileName);
		BufferedReader reader = null;
		try {
			System.out.println("读一整行:");
			// 读取非汉字可用
			// reader = new BufferedReader(new FileReader(file));
			// 读汉字可用
			reader = new BufferedReader(new InputStreamReader(
					new FileInputStream(file), "GBK"));
			String str;
			int line = 0;
			while (null != (str = reader.readLine())) {
				System.out.println("line " + line + ": " + str);
				line++;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (null != reader) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 随机读取文件
	 * 
	 * @param fileName
	 *            文件名称
	 */
	public static void readFileByRandomAccess(String fileName) {
		RandomAccessFile randomFile = null;
		try {
			System.out.println("随机读取文件:");
			// r为只读,w为只写,rw读写
			randomFile = new RandomAccessFile(fileName, "r");
			// 设置读取位置
			randomFile.seek(0);
			// 读取到的数据
			byte[] bytes = new byte[10];
			int len = 0;
			// 读取数据,非汉字
			while ((len = randomFile.read(bytes)) != -1) {
				System.out.write(bytes, 0, len);
			}
			// 文件指针位置
			System.out.println(randomFile.getFilePointer());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (null != randomFile) {
				try {
					randomFile.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * 在文件末尾追加数据
	 * 
	 * @param fileName
	 *            文件名
	 * @param content
	 *            追加的数据
	 */
	public static void appendByRandomAccessFile(String fileName, String content) {
		RandomAccessFile randomFile = null;
		try {
			// 以读写方式打开
			randomFile = new RandomAccessFile(fileName, "rw");
			// 获取文件长度
			long len = randomFile.length();
			// 移动文件指针到文件末
			randomFile.seek(len);
			randomFile.writeBytes(content);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (null != randomFile) {
				try {
					randomFile.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		System.out.println("randomAccessFile追加操作完成");
	}

	/**
	 * 已FileWrite方式追加文本
	 * 
	 * @param fileName
	 *            文件名
	 * @param content
	 *            追加内容
	 */
	public static void appendByFileWrite(String fileName, String content) {
		FileWriter writer = null;
		try {
			// 打开一个写文件器,构造函数中的第二个参数true表示以追加形式写文件
			writer = new FileWriter(fileName, true);
			writer.write(content);
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (null != writer) {
				try {
					writer.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		System.out.println("FileWriter追加操作完成");
	}

	/**
	 * 字符写文件
	 * 
	 * @param fileName
	 *            文件名
	 * @param content
	 *            写入内容
	 */
	public static void writeFileByChars(String fileName, String content) {
		File file = new File(fileName);
		Writer writer = null;
		try {
			// 设置编码,可以写汉字
			writer = new OutputStreamWriter(new FileOutputStream(file), "GBK");
			// 写入数据
			writer.append(content);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != writer) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println("字符流写入操作完成");
	}

	/**
	 * 已字节流写内容到文件
	 * 
	 * @param fileName
	 *            文件名
	 * @param content
	 *            写入内容
	 */
	public static void writeFileByBytes(String fileName, String content) {
		File file = new File(fileName);
		OutputStream out = null;
		try {
			System.out.println("以子节为单位写文件");
			out = new FileOutputStream(file);
			byte[] bytes = content.getBytes();
			out.write(bytes, 0, bytes.length);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (null != out) {
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println("字节流写入操作完成");
	}

	/**
	 * 拷贝文件,包括文本文件,图片等
	 * 
	 * @param fileName
	 *            待拷贝文件
	 * @param newFileName
	 *            拷贝结果文件
	 */
	public static void copyFile(String fileName, String newFileName) {
		System.out.println("文件拷贝开始 。。。。。。。。。");
		File file = new File(fileName);
		File newFile = new File(newFileName);
		if (!file.exists()) {
			System.out.println("待拷贝文件不存在");
			return;
		}
		// 拷贝结果文件已存在,就删除
		if (newFile.exists()) {
			newFile.delete();
		}
		// 创建新的拷贝结果文件
		try {
			newFile.createNewFile();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 字节流
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(file);
			out = new FileOutputStream(newFile);
			byte[] data = new byte[(int) file.length()];
			int len = 0;
			int read = -1;
			System.out.println("文件大小:" + file.length());
			// 读取数据
			while ((read = in.read()) != -1) {
				data[len++] = (byte) read;
			}
			// 写入数据
			out.write(data);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (null != in) {
				try {
					in.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		System.out.println("文件拷贝结束 。。。。。。。。。");
	}

	/**
	 * 罗列根目录下所有文件和文件夹,dfs
	 * 
	 * @param root
	 *            根目录
	 */
	public static void listFileAndFolder(String root) {
		File file = new File(root);
		if (!file.exists()) {
			System.out.println("跟目录不存在");
			return;
		}
		// 是文件
		if (file.isFile()) {
			System.out.println("文件名:" + file.getName() + ",文件路径:"
					+ file.getAbsolutePath() + ",文件大小:" + file.length());
			return;
		}
		// 是文件夹
		if (file.isDirectory()) {
			System.out.println("文件夹名:" + file.getName() + ",文件夹路径:"
					+ file.getAbsolutePath() + ",文件夹大小:" + file.length());
			// 获取文件夹下所有文件和文件夹对象
			File[] files = file.listFiles();
			// 获取文件夹下所有文件和文件夹名称
			String[] list = file.list();
			System.out.print(file.getName() + "文件夹下包含:");
			if (null != list) {
				for (int i = 0; i < list.length; i++) {
					if (i == 0) {
						System.out.print(list[i]);
					} else {
						System.out.println("," + list[i]);
					}
				}
				System.out.println();
			}
			for (int i = 0; i < files.length; i++) {
				listFileAndFolder(files[i].getAbsolutePath());
			}
		}
	}

	/**
	 * 控制台上输入和输出 --分普通输入输出和快速输入输出 --快速输入输出是为acm竞赛这样的追求效率的使用,普通情况下普通输入输出就够了
	 */
	public static void consoleInputAndOutput() {
		// 普通输出定义
		Scanner cin = new Scanner(System.in);
		// 快速输入定义
		Reader reader = new InputStreamReader(System.in);
		Writer writer = new OutputStreamWriter(System.out);
		try {
			// 普通输入输出
			Integer num = cin.nextInt();
			System.out.println(num);
			// 快速输入输出
			int read = getInt(reader);// 调用函数输入数字
			// 输出数字的时候,write会将数字转换成字符,即输出97的时候会输出a;所以需要转换成字符串
			writer.write(Integer.toString(read));
			writer.flush();// 强制将内存中的数据输出到控制台上
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (null != reader) {
				try {
					reader.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (null != writer) {
				try {
					writer.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (null != cin) {
				cin.close();
			}
		}
	}

	/**
	 * 获取键盘输入的整数
	 * 
	 * @return 输入的整数
	 */
	public static int getInt(Reader reader) {
		int read;
		int res = 0;
		boolean isNegative = false;// 是不是负数
		try {
			while ((read = reader.read()) != -1) {
				if ((char) read == '-') {
					res = 0;
					isNegative = true;
					break;
				} else if (isNumber((char) read)) {
					res = read - '0';
					break;
				}
			}
			while ((read = reader.read()) != -1) {
				char ch = (char) read;
				if (isNumber(ch)) {
					res = res * 10 + (read - '0');
				} else {
					break;
				}
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (isNegative == true) {
			res = -1 * res;
		}
		return res;
	}

	/**
	 * 判断字符是不是数字
	 * 
	 * @param ch
	 *            字符
	 * @return 判断结果
	 */
	public static boolean isNumber(char ch) {
		if (ch <= '9' && ch >= '0') {
			return true;
		}
		return false;
	}
}


你可能感兴趣的:(java_IO)