标签：
一.文件和目录
1.显示文件的基本信息。
2.显示目录的基本信息。
3.在指定目录下创建单个文件。
4.指定目录下创建多个临时文件。
二、字节流
1.生成ZIP压缩文件
2.解压缩zip文件
3.生成Excel文件
4.读取excel文件
5.生成PDF文件
6.读取PDF文件中的内容
7.利用poi读取Word文件中的内容。
三、字符流
1.追加文件内容
2.读取jar包内容
3文件的加密/解密操作
JAVA加包+++右键项目+BuildPath+Add External Achievees.......
一.文件和目录
1.显示文件的基本信息
package outputintput;
import java.io.File;
public class FileDemo01 {
public static void main(String[] args) {
File file = new File("D:\\temp\\keytoolcmd.txt"); // 根据指定的路径创建一个File对象
System.out.println("文件名为：" + file.getName()); // 获取该File对象的名字
System.out.println("绝对路径为：" + file.getAbsolutePath()); // 获取该File对象的绝对路径
System.out.println("路径为：" + file.getPath()); // 获取该File对象的相对路径
System.out.println("所属磁盘目录为：" + file.getParent()); //获取该File对象的目录
if (!file.exists()) {
file.mkdir();
}
System.out.println("此路径名表示的文件是一个目录吗？：" + file.isDirectory());// 判断该File对象是不是目录
System.out.println("它是处于可读状态吗？：" + file.canRead()); // 判断该File对象是否可读
System.out.println("它是处于可写状态吗？" + file.canWrite()); // 判断该File对象是否可写
System.out.println("该文件长度为：" + file.length() + "字节"); // 获取该File对象中的字符长度
System.out.println("此文件最后修改的时间为：" + file.lastModified());// 获取该File对象最后修改时间
}
}
2.显示目录的基本信息。
package outputintput;
import java.io.File;
import java.io.FilenameFilter;
public class FileDemo02 {
static class MyFilenameFilter implements FilenameFilter {
private String sf = ""; // 定义文件的后缀名
public MyFilenameFilter(String surfix) { // 用构造方法为sf变量赋值
this.sf = surfix;
}
public boolean accept(File dir, String name) { // 重写FilenameFilter接口中的accept方法，判断指定的文件是否在指定的目录中
if (new File(dir, name).isFile()) { // 如果当前的File对象是一个文件，则返回它是否以指定的后缀结束，是返回true
return name.endsWith(sf);
} else {
// 如果是文件夹，则直接返回true
return true;
}
}
}
public static void getAllFiles(String dirName) { // 列出指定目录下所有文件和子目录的路径
// 如果dir不以文件分隔符结尾，自动添加文件分隔符。
if (!dirName.endsWith(File.separator)) {
dirName = dirName + File.separator;
}
File dirFile = new File(dirName);
// 如果dir对应的文件不存在，或者不是一个文件夹，则退出
if (!dirFile.exists() || (!dirFile.isDirectory())) {
System.out.println("失败！找不到指定的目录：" + dirName);
return;
}
// 列出源文件夹下所有文件（包括子目录）
File[] fileArray = dirFile.listFiles();
for (int i = 0; i < fileArray.length; i++) {
if (fileArray[i].isFile()) {
System.out.print(fileArray[i].getAbsolutePath() + " ");
} else if (fileArray[i].isDirectory()) {
System.out.println(fileArray[i].getAbsolutePath() + " ");
FileDemo02.getAllFiles(fileArray[i].getAbsolutePath());
}
if ((i + 1) % 2 == 0)
System.out.println();
}
}
public static void getFilesByFilter(FilenameFilter filter,// 获取在指定目录下符合指定后缀文件名的所有文件
String dir_Path) {
if (!dir_Path.endsWith(File.separator)) {// 如果目录路径不是以文件分隔符结尾则自动添加文件分隔符。
dir_Path = dir_Path + File.separator;
}
File dir_File = new File(dir_Path);
if (!dir_File.exists() || (!dir_File.isDirectory())) {// 如果指定的目录不存在或不是一个目录则返回
System.out.println("失败！找不到指定目录：" + dir_Path);
return;
}
// 列出指定目录下的所有符合过滤器条件的文件（包括子目录）
File[] fileArray = dir_File.listFiles(filter);
for (int i = 0; i < fileArray.length; i++) {
if (fileArray[i].isFile()) {
System.out.println(fileArray[i].getAbsolutePath() + " 是文件!");
} else if (fileArray[i].isDirectory()) {
System.out.println(fileArray[i].getAbsolutePath() + " 是目录!");
FileDemo02.getFilesByFilter(filter, fileArray[i]
.getAbsolutePath());
}
}
}
public static void main(String[] args) {
String dir = "D:\\temp";
System.out.println((dir + "目录下的内容: "));
FileDemo02.getAllFiles(dir);
System.out.println();
System.out.println("符合过滤器条件的文件如下：");
// 新建一个文件名过滤器。参数为".txt"
FilenameFilter myFilenameFilter = new FileDemo02.MyFilenameFilter(
".txt");
FileDemo02.getFilesByFilter(myFilenameFilter, dir);
}
}
3.在指定目录下创建单个文件
package outputintput;
import java.io.File;
import java.io.IOException;
public class FileDemo03 {
// 此方法的主要作用是判断创建文件是否成功，如果成功则返回true否则返回false
public static boolean createFile(String destFileName) {
File file = new File(destFileName); // 根据指定的文件名创建File对象
if (file.exists()) { // 判断该文件是否存在
System.out.println("创建单个文件" + destFileName + "失败，目标文件已存在！");
return false; // 如果存在，则不需创建则返回fasle
}
if (destFileName.endsWith(File.separator)) {// 如果传入的文件名是以文件分隔符结尾的，则说明此File对象是个目录而不是文件
System.out.println("创建单个文件" + destFileName + "失败，目标文件不能为目录！");
return false;// 因为不是文件所以不可能创建成功，则返回false
}
// 判断目标文件所在的目录是否存在
if (!file.getParentFile().exists()) {
// 如果目标文件所在的文件夹不存在，则创建父文件夹
System.out.println("创建" + file.getName() + "所在目录不存在，正在创建！");
if (!file.getParentFile().mkdirs()) {// 判断父文件夹是否存在，如果存在则表示创建成功否则不成功
System.out.println("创建目标文件所在的目录失败！");
return false;
}
}
// 创建目标文件
try {
if (file.createNewFile()) {// 调用createNewFile方法，判断创建指定文件是否成功
System.out.println("创建单个文件" + destFileName + "成功！");
return true;
} else {
System.out.println("创建单个文件" + destFileName + "失败！");
return false;
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建文件" + destFileName + "失败！" + e.getMessage());
return false;
}
}
public static void main(String[] args) {
// 创建目录
String dirName = "D:/temp/aa";
// 创建文件
String fileName = dirName + "/bb/ccFile.txt";
FileDemo03.createFile(fileName);
}
}
4.指定目录下创建多个临时文件。
package outputintput;
import java.io.File;
import java.io.IOException;
public class FileDemo04 {
public static boolean createDirectory(String destDirName) {// 判断目录是否创建成功，成功则返回true，否则返回false
File dir = new File(destDirName);// 创建一个File对象
if (dir.exists()) {// 判断该目录是否存在，存在则返回false
return false;
}
if (!destDirName.endsWith(File.separator)) {// 为了方便获得其目录下的文件的路径，如果该目录路径不是文件分隔符结尾的，则给其加上文件分隔符
destDirName = destDirName + File.separator;
}
// 创建目标目录
if (dir.mkdirs()) {
System.out.println("指定目录不存在,创建目录" + destDirName + "成功！");
return true;
} else {
System.out.println("创建目录" + destDirName + "失败！");
return false;
}
}
public static String createFiles(String fileName, String suffix,
String dirName) {// 根据传入的文件名的前缀和扩展名在指定的目录下创建文件
File tempFile = null;
if (dirName == null) {
try {
// 在默认文件夹下创建临时文件
tempFile = File.createTempFile(fileName, suffix);
// 返回临时文件的路径
return tempFile.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建临时文件失败!" + e.getMessage());
return null;
}
} else {
File dir = new File(dirName);
// 如果临时文件所在目录不存在，首先创建目录
if (!dir.exists()) {
if (FileDemo04.createDirectory(dirName)) {
System.out.println("创建临时文件失败，不能创建临时文件所在的目录！");
return null;
}
}
try {
// 在指定目录下创建指定的文件
tempFile = File.createTempFile(fileName, suffix, dir);
return tempFile.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建临时文件失败!" + e.getMessage());
return null;
}
}
}
public static void main(String[] args) {
String[] surfix = { ".txt", ".jpg", ".doc", ".excel", ".java", ".html",null,"" };
// 创建目录
String dirName = "D:\\temp\\temp1";
FileDemo04.createDirectory(dirName);
// 创建临时文件
String fileName = "temp";
for (int i = 0; i < surfix.length; i++) {
System.out.println("成功创建了临时文件: "
+ FileDemo04.createFiles(fileName, surfix[i], dirName));
}
}
}
二、字节流
1.生成ZIP压缩文件
package outputintput;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
public class StreamDemo11 {
// 压缩文件或者目录，其中：dirPath：压缩的根目录，srcName：
// dirPath目录下的所有文件包名子目录，targetName：压缩后的zip文件
public static void compressAllZip(String dirPath, String srcName,
String targetName) {
if (dirPath == null) {// 判断根目录是否存在
System.out.println("压缩失败" + dirPath + "目录不存在");
return;
}
File baseDir = new File(dirPath);// 判断dirPath是不是目录
if (!baseDir.exists() || (!baseDir.isDirectory())) {
System.out.println("压缩失败" + dirPath + "目录不存在");
return;
}
String basicRootDir = baseDir.getAbsolutePath();
File targetFile = new File(targetName);// 创建zip文件
try {
// 创建一个zip输出流来压缩数据并写入到zip文件
ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
targetFile));
if (srcName.equals("*")) {
// 将baseDir目录下的所有文件压缩到ZIP
StreamDemo11.compressDirToZip(basicRootDir, baseDir, out);
} else {
File file = new File(baseDir, srcName);
if (file.isFile()) {
StreamDemo11.compressFileToZip(basicRootDir, file, out);
} else {
StreamDemo11.compressDirToZip(basicRootDir, file, out);
}
}
out.close();
System.out.println("文件压缩成功，压缩包的文件名为：" + targetName);
} catch (IOException e) {
System.out.println("压缩失败：" + e);
e.printStackTrace();
}
}
// 利用ZipOutputStream对目录的压缩
private static void compressDirToZip(String basicRootDir, File dir,
ZipOutputStream out) {
if (dir.isDirectory()) {
// 列出dir目录下所有文件
File[] files = dir.listFiles();
// 如果是空文件夹
if (files.length == 0) {
ZipEntry entry = new ZipEntry(getFileName(basicRootDir, dir));
// 存储目录信息
try {
out.putNextEntry(entry);
out.closeEntry();
} catch (IOException e) {
e.printStackTrace();
}
return;
}
for (int i = 0; i < files.length; i++) {
if (files[i].isFile()) {
// 如果是文件，调用compressFileToZip方法
StreamDemo11
.compressFileToZip(basicRootDir, files[i], out);
} else {
// 如果是目录，递归调用
StreamDemo11.compressDirToZip(basicRootDir, files[i], out);
}
}
}
}
// 利用ZipOutputStream对文件的压缩
private static void compressFileToZip(String basicRootDir, File file,
ZipOutputStream out) {
FileInputStream in = null;
ZipEntry entry = null;
// 创建复制缓冲区
byte[] buffer = new byte[4096];
int bytes_read;
if (file.isFile()) {
try {
in = new FileInputStream(file); // 创建一个文件输入流
// 根据压缩文件的名字构造一个ZipEntry对象，此类表示zip包中的文件条目
entry = new ZipEntry(getFileName(basicRootDir, file));
out.putNextEntry(entry); // 存储项信息到压缩文件
// 将文件的内容通过字节数组复制到压缩文件中
while ((bytes_read = in.read(buffer)) != -1) {
out.write(buffer, 0, bytes_read);
}
out.closeEntry();
in.close();
System.out
.println("添加文件" + file.getAbsolutePath() + "到ZIP文件中！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 获取等待压缩的文件的文件名，例如：D:\tu\1.jpg获取的文件名为tu\1.jpg
private static String getFileName(String basicRootDir, File file) {
if (!basicRootDir.endsWith(File.separator)) {
basicRootDir += File.separator;
}
String filePath = file.getAbsolutePath();
// 对于目录，必须在entry名字后面加上"/"，表示它将以目录项存储。
if (file.isDirectory()) {
filePath += "/";
}
int index = filePath.indexOf(basicRootDir);
return filePath.substring(index + basicRootDir.length());
}
public static void main(String[] args) {
// 压缩D盘下的tu目录，压缩后的文件是D:/图片.zip
String dirPath = "D:/";
String srcName = "tu/";
String zipFileName = "D:/test/图片.zip";
StreamDemo11.compressAllZip(dirPath, srcName, zipFileName);
}
}
2.解压缩zip文件
package outputintput;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class StreamDemo12 {
public static void main(String[] args) {
// 将刚创建的图片.zip文件解压缩到D盘的temp目录下
String fileName = "D:/test";
String zipName = "D:/test/图片.zip";
StreamDemo12.upzipFile(zipName, fileName);
}
// 将指定的zip文件解压到targetDirName目录下，其中：zipName：zip包的文件名，targetDirName：需解压到的目录
public static void upzipFile(String zipName, String targetDirName) {
if (!targetDirName.endsWith(File.separator)) {
targetDirName += File.separator;
}
try {
// 根据zip文件创建ZipFile对象，此类的作用是从zip文件读取条目。
ZipFile zipFile = new ZipFile(zipName);
ZipEntry zn = null;
String entryName = null;
String targetFileName = null;
byte[] buffer = new byte[4096];
int bytes_read;
// 获取ZIP文件里所有的文件条目的名字
Enumeration entrys = zipFile.entries();
// 循环遍历所有的文件条目的名字
while (entrys.hasMoreElements()) {
zn = (ZipEntry) entrys.nextElement();
// 获得每一条文件的名字
entryName = zn.getName();
targetFileName = targetDirName + entryName;
if (zn.isDirectory()) {
// 如果zn是一个目录，则创建目录
new File(targetFileName).mkdirs();
continue;
} else {
// 如果zn是一个文件，则创建父目录
new File(targetFileName).getParentFile().mkdirs();
}
// 否则创建文件
File targetFile = new File(targetFileName);
System.out.println("正在创建文件：" + targetFile.getAbsolutePath());
// 打开文件输出流
FileOutputStream os = new FileOutputStream(targetFile);
// 从ZipFile对象中打开entry的输入流
InputStream is = zipFile.getInputStream(zn);
while ((bytes_read = is.read(buffer)) != -1) {
os.write(buffer, 0, bytes_read);
}
// 关闭流
os.close();
is.close();
}
System.out.println("解压缩"+zipName+"成功！");
} catch (IOException err) {
System.err.println("解压缩"+zipName+"失败: " + err);
}
}
}
3.生成Excel文件
package outputintput;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.Region;
public class StreamDemo13 {
// 新建一个Excel文件，里面添加5行5列的内容，另外添加一个合并2行5列的大单元格以及一个合并2行1列的5个合并单元格。
public void createExcel(String fileName) {
File file = new File(fileName);// 创建excel文件对象
FileOutputStream fOut = null;
try {
// 创建一个新的HSSFWorkbook对象
HSSFWorkbook workbook = new HSSFWorkbook();
// 创建一个Excel的工作表，可以指定工作表的名字
HSSFSheet sheet = workbook.createSheet("myFirstExcel");
// 创建字体，红色、粗体
HSSFFont font = workbook.createFont();
font.setColor(HSSFFont.COLOR_RED);
font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
HSSFFont font1 = workbook.createFont();
// 创建字体，黑色、非粗体
font1.setColor(HSSFFont.COLOR_NORMAL);
font1.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
// 创建单元格的格式，如居中、左对齐等
HSSFCellStyle cellStyle = workbook.createCellStyle();
cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 水平方向上居中对齐
// 垂直方向上居中对齐
cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
cellStyle.setFont(font); // 设置字体
HSSFCellStyle cellStyle1 = workbook.createCellStyle();
cellStyle1.setAlignment(HSSFCellStyle.ALIGN_LEFT);
cellStyle1.setFont(font1);
// 下面将建立一个4行3列的表。第一行为表头。
int rowNum = 0;// 行标
int colNum = 0;// 列标
// 建立表头信息
HSSFRow row = sheet.createRow((short) rowNum); // 在索引0的位置创建行
HSSFCell cell = null; // 单元格
for (colNum = 0; colNum < 5; colNum++) {
// 在当前行的colNum列上创建单元格
cell = row.createCell((short) colNum);
// 定义单元格为字符类型，也可以指定为日期类型、数字类型
cell.setCellType(HSSFCell.CELL_TYPE_STRING);
// 定义编码方式，为了支持中文，这里使用了ENCODING_UTF_16
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellStyle(cellStyle); // 为单元格设置格式
cell.setCellValue("表头-第" + (colNum + 1) + "列"); // 添加内容至单元格
}
rowNum++;
for (; rowNum < 5; rowNum++) {
// 新建第rowNum行
row = sheet.createRow((short) rowNum);
for (colNum = 0; colNum < 5; colNum++) {
// 在当前行的colNum位置创建单元格
cell = row.createCell((short) colNum);
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellStyle(cellStyle1);
cell.setCellValue("表体-第" + rowNum + "行第" + (colNum + 1)
+ "列");
}
}
// 合并单元格
// 先创建2行5列的单元格，然后将这些单元格合并为2个大单元格
rowNum = 5;
for (; rowNum < 9; rowNum++) {
row = sheet.createRow((short) rowNum);
for (colNum = 0; colNum < 5; colNum++) {
// 在当前行的colNum位置创建单元格
cell = row.createCell((short) colNum);
}
}
// 建立第一个大单元格，高度为2，宽度为2
rowNum = 5;
colNum = 0;
Region region = new Region(rowNum, (short) colNum, (rowNum + 1),
(short) (colNum + 4));
sheet.addMergedRegion(region);
// 获得第一个大单元格
cell = sheet.getRow(rowNum).getCell((short) colNum);
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellStyle(cellStyle);
cell.setCellValue("合并行单元格");
// 建立第二个大单元格，高度为2，宽度为3
rowNum = 7;
for (colNum = 0; colNum < 5; colNum++) {
region = new Region(rowNum, (short) colNum, (rowNum + 1),
(short) (colNum));
sheet.addMergedRegion(region);
// 获得第二个大单元格
cell = sheet.getRow(rowNum).getCell((short) colNum);
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellStyle(cellStyle);
cell.setCellValue("合并列单元格");
}
// 新建一输出文件流
fOut = new FileOutputStream(file);
// 将创建的内容写到指定的Excel文件中
workbook.write(fOut);
fOut.flush();
fOut.close();// 操作结束，关闭文件
System.out.println("Excel文件创建成功！\nExcel文件的存放路径为："
+ file.getAbsolutePath());
} catch (Exception e) {
System.out.println("Excel文件" + file.getAbsolutePath()
+ "创建失败\n其原因为：" + e);
} finally {
if (fOut != null) {
try {
fOut.close();
} catch (IOException e1) {
}
}
}
}
public static void main(String[] args) throws Exception {
StreamDemo13 excel = new StreamDemo13();
String fileName = "D:/temp/new.xls";
excel.createExcel(fileName);
}
}
4.读取excel文件
package outputintput;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
public class StreamDemo14 {
/** 读Excel文件内容 */
public void showExcel(String excelName) {
File file = new File(excelName);
FileInputStream in = null;
try {
// 创建对Excel工作簿文件的引用
in = new FileInputStream(file);
HSSFWorkbook hwb = new HSSFWorkbook(in);
HSSFSheet sheet = hwb.getSheet("myFirstExcel");// 根据指定的名字来引用此Excel中的有效工作表
// 读取Excel 工作表的数据
System.out.println("下面是Excel文件" + file.getAbsolutePath() + "的内容：");
HSSFRow row = null;
HSSFCell cell = null;
int rowNum = 0; // 行标
int colNum = 0; // 列标
for (; rowNum < 9; rowNum++) {
// 获取第rowNum行
row = sheet.getRow((short) rowNum);
for (colNum = 0; colNum < 5; colNum++) {
cell = row.getCell((short) colNum);// 根据当前行的位置来创建一个单元格对象
System.out.print(cell.getStringCellValue() + "\t");// 获取当前单元格中的内容
}
System.out.println(); // 换行
}
in.close();
} catch (Exception e) {
System.out
.println("读取Excel文件" + file.getAbsolutePath() + "失败：" + e);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
public static void main(String[] args) {
StreamDemo14 excel = new StreamDemo14();
String excelName = "D:/temp/new.xls";
excel.showExcel(excelName);
}
}
5.生成PDF文件
package outputintput;
import java.awt.Color;
import java.io.*;
import com.lowagie.text.*;
import com.lowagie.text.pdf.BaseFont;
import com.lowagie.text.pdf.PdfWriter;
public class StreamDemo15 {
// 生成PDF文件中的内容
public void creatPDF(String fileName) {
File file = new File(fileName);
FileOutputStream out = null;
try {
Document document = new Document(PageSize.A4, 50, 50, 50, 50);// 实例化文档对象
out = new FileOutputStream(file);
PdfWriter writer = PdfWriter.getInstance(document, out);// 创建写入器
document.open();// 打开文档准备写入内容
// 设置可以在PDF中输入汉字的字体
BaseFont bfChinese = BaseFont.createFont(
"C:\\WINDOWS\\Fonts\\SIMHEI.TTF", BaseFont.IDENTITY_H,
BaseFont.EMBEDDED);
Font font = new Font(bfChinese, 16, Font.BOLD);
font.setColor(0, 0, 255);
Paragraph paragraph1 = new Paragraph("第7章 IO——输入输出流", font);// 创建段落对象
// 创建了一个章节对象，标题为"第7章 IO——输入输出流"
Chapter chapter1 = new Chapter(paragraph1, 0);
// 将编号级别设为 0 就不会在页面上显示章节编号
chapter1.setNumberDepth(0);
Font font1 = new Font(bfChinese, 14, Font.BOLD);
font1.setColor(255, 0, 0);
Paragraph section1_title1 = new Paragraph("7.1 什么是对象序列化？", font1);// 创建小节对象的标题
Section section1 = chapter1.addSection(section1_title1);// 创建小节对象
Font font2 = new Font(bfChinese, 12, Font.NORMAL);
font2.setColor(0, 0, 0);
Paragraph text = new Paragraph("什么是对象序列化呢？简单的说，就是将对象写入流，\n"
+ "而序列化解体则指从流中获取数据后，重构对象的过程。\n"
+ "Java的对象可以分为可序列化对象和不可序列化对象，\n"
+ "从说明文档中，可以看到只有实现了\"Serializable\"接口的对象才是可序列化对象。", font2);// 创建一个段落
section1.add(text);// 将段落写入小节中
text = new Paragraph("File类主要方法列表", font2);
section1.add(text);
Table table = new Table(2, 5); // 创建表格对象
table.setBorderColor(new Color(220, 255, 100)); // 设置表格边框颜色
// 设置单元格的边距间隔等
table.setPadding(1);
table.setSpacing(1);
table.setBorderWidth(1);
Cell cell = null; // 单元格对象
// 添加表头信息
cell = new Cell(new Paragraph("方法名称", font2));
cell.setHeader(true);
table.addCell(cell);
cell = new Cell(new Paragraph("用法", font2));
cell.setHeader(true);
table.addCell(cell);
table.endHeaders();
// 添加表的内容
table.addCell(new Cell("public Boolean canread()"));
table.addCell(new Cell(new Paragraph("测试这个文件是否可以读?", font2)));
table.addCell(new Cell("public Boolean canwrite()"));
table.addCell(new Cell(new Paragraph("测试这个文件是否可写?", font2)));
table.addCell(new Cell("public Boolean createNewFile()"));
table.addCell(new Cell(new Paragraph(
"看这个文件或目录是否存在,如有此文件则返回false,如果没有这个文件则创建这个类的对象.", font2)));
table.addCell(new Cell("public Boolean delete()"));
table.addCell(new Cell(new Paragraph(
"删除当前对象所指文件。删除成功返回true，否则返回false.", font2)));
section1.add(table); // 将表格对象添加到小节对象中
List list = new List(true, false, 20);// 创建列表
ListItem item = new ListItem("带缓存的字符输出流BufferedWriter类;", font2);// 创建列表项
list.add(item);// 将列表项添加到列表中
item = new ListItem("字符输入流FileReader类和FileWriter类的使用;", font2);
list.add(item);
item = new ListItem("读取带缓存的BufferedReader字符流t.", font2);
list.add(item);
section1.add(list); // 将列表对象添加到小节对象中
// 将章节对象加入到文档中
document.add(chapter1);
// 关闭文档
document.close();
System.out.println("PDF文件生成成功，PDF文件名：" + file.getAbsolutePath());
} catch (DocumentException e) {
System.out.println("PDF文件" + file.getAbsolutePath() + "生成失败！" + e);
e.printStackTrace();
} catch (IOException ee) {
System.out.println("PDF文件" + file.getAbsolutePath() + "生成失败！" + ee);
ee.printStackTrace();
} finally {
if (out != null) {
try {
// 关闭输出文件流
out.close();
} catch (IOException e1) {
}
}
}
}
public static void main(String[] args) {
StreamDemo15 pdf = new StreamDemo15();
String fileName = "D:/temp/myPDF.pdf";
pdf.creatPDF(fileName);
}
}
6.读取PDF文件中的内容
package outputintput;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import org.pdfbox.pdfparser.PDFParser;
import org.pdfbox.pdmodel.PDDocument;
import org.pdfbox.util.PDFTextStripper;
public class StreamDemo18 {
/**
* @param 读取PDF文件
*/
public static void main(String[] args) {
StreamDemo18 pdf = new StreamDemo18();
String pdfName = "D:\\temp\\myPDF.pdf";
pdf.readFileOfPDF(pdfName);
}
// 读取指定的PDF文件的内容，其中：pdfName表示要读取的PDF文件的路径
public void readFileOfPDF(String pdfName) {
File file = new File(pdfName);// 创建一个文件对象
FileInputStream infile = null;
try {
infile = new FileInputStream(pdfName);// 创建一个文件输入流
// 新建一个PDF解析器对象
PDFParser parser = new PDFParser(infile);
// 对PDF文件进行解析
parser.parse();
// 获取解析后得到的PDF文档对象
PDDocument pdfdocument = parser.getPDDocument();
// 新建一个PDF文本剥离器
PDFTextStripper stripper = new PDFTextStripper();
// 从PDF文档对象中剥离文本
String context = stripper.getText(pdfdocument);
System.out.println("PDF文件" + file.getAbsolutePath() + "的文本内容如下：");
System.out.println(context);
} catch (Exception e) {
System.out.println("读取PDF文件" + file.getAbsolutePath() + "失败！"
+ e.getMessage());
} finally {
if (infile != null) {
try {
infile.close();
} catch (IOException e1) {
}
}
}
}
}
7.利用poi读取Word文件中的内容。
package outputintput;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import org.apache.poi.hwpf.extractor.WordExtractor;
public class StreamDemo17 {
/**
* @param 用POI读取word文件中的内容
*/
public static void main(String[] args) {
StreamDemo17 s = new StreamDemo17();
String path = "C:\\fileText.doc";
try {
s.readDocFile(path);
} catch (IOException e) {
System.out.println("读取失败:" + path + "文件不存在" + e.getMessage());
}
}
public void readDocFile(String origFileName) throws IOException {
System.out.println("C:\\fileText.doc中的内容如下：\n");
// 创建文件输入流
FileInputStream in = new FileInputStream(new File(origFileName));
WordExtractor extractor = null;
String text = null;
// 创建WordExtractor
extractor = new WordExtractor(in);
// 对DOC文件进行提取
text = extractor.getText();
System.out.println(text);
}
}
三、字符流
1.追加文件内容
<span style="font-size:14px;">package outputintput;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
public class CharactersDemo03 {
// 使用RandomAccessFile实现文件的追加，其中：fileName表示文件名；content表示要追加的内容
public static void appendMethod_one(String fileName, String content) {
try {
// 按读写方式创建一个随机访问文件流
RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
long fileLength = raf.length();// 获取文件的长度即字节数
// 将写文件指针移到文件尾。
raf.seek(fileLength);
// 按字节的形式将内容写到随机访问文件流中
raf.writeBytes(content);
// 关闭流
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 使用FileWriter实现文件的追加，其中：fileName表示文件名；content表示要追加的内容
public static void appendMethod_two(String fileName, String content) {
try {
// 创建一个FileWriter对象，其中boolean型参数则表示是否以追加形式写文件
FileWriter fw = new FileWriter(fileName, true);
// 追加内容
fw.write(content);
// 关闭文件输出流
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void showFileContent(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {
// 显示行号
System.out.println(line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
public static void main(String[] args) {
String fileName = "D:/temp/append.txt";
String content = "Successful operation!";
System.out.println(fileName + "文件的内容如下：");
CharactersDemo03.showFileContent(fileName); // 显示文件内容
// 按RandomAccessFile的形式追加文件
System.out.println("\n按RandomAccessFile的形式追加文件后的内容如下：");
CharactersDemo03.appendMethod_one(fileName, content);
CharactersDemo03.appendMethod_one(fileName, "\n Game is Over！ \n");
CharactersDemo03.showFileContent(fileName); // 显示文件内容
// 按FileWriter的形式追加文件
System.out.println("\n按FileWriter的形式追加文件后的内容如下：");
CharactersDemo03.appendMethod_two(fileName, content);
CharactersDemo03.appendMethod_two(fileName, "\n Game is Over！ \n");
CharactersDemo03.showFileContent(fileName); // 显示文件内容
}
}
</span>
2.读取jar包内容
<span style="font-size:14px;">package outputintput;
import java.awt.geom.Area;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
public class CharactersDemo05 {
// javaClass表示类文件；filepath表示文件的相对路径
public static void readJar_URL(Class javaClass, String filepath) {
URL url = javaClass.getResource(filepath);// 获取定位资源URL对象
System.out.println("资源的URL: " + url);
try {
InputStream stream = url.openStream();// 打开fileURL对应的文件流
BufferedReader bufferedreader = new BufferedReader(// 创建一个缓冲字符输入流
new InputStreamReader(stream));
String str;
while ((str = bufferedreader.readLine()) != null) {// 从缓冲字符输入流中按行读取信息
System.out.println(str);
}
stream.close();// 关闭流
} catch (IOException ioexception) {
ioexception.printStackTrace();
}
}
// 读Jar包中的资源信息，其中：javaClass表示类文件；filepath表示文件的相对路径
public static void readJar_stream(Class javaClass, String filepath) {
InputStream stream = javaClass.getResourceAsStream(filepath);// 获取该资源输入流的引用
if (stream != null) {
// 创建一个缓冲字符输入流
BufferedReader bufferedreader = new BufferedReader(
new InputStreamReader(stream));
String str;
try {
// 从缓冲字符输入流中按行读取信息
while ((str = bufferedreader.readLine()) != null) {
System.out.println(str);
}
stream.close();
} catch (IOException ioexception) {
ioexception.printStackTrace();
}
}
}
public static void main(String[] args) {
System.out.println("以该class文件的位置为准，以URL的方式读取Jar包信息的内容如下：");
Class javaClass = aa.class;//在该文件的目录下要存在aa.class文件
String filePath = "config0.conf";//filePath的值是要读取的jar包名称
CharactersDemo05.readJar_URL(javaClass, filePath);
System.out.println();
System.out.println("以该class文件的位置为准，以直接获取资源输入流的引用的方式读取Jar包信息的内容如下：");
filePath = "bdc/config1.conf";//filePath的值是要读取的jar包名称
CharactersDemo05.readJar_stream(javaClass, filePath);
System.out.println();
System.out.println("以该jar文件的位置为准，以URL的方式读取Jar包信息的内容如下：：");
filePath = "/jarTest/abc/bdc/config1.conf";//filePath的值是要读取的jar包名称
CharactersDemo05.readJar_URL(javaClass, filePath);
}
}</span><span style="font-size:18px;">
</span>3文件的加密/解密操作
package outputintput;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
public class CharactersDemo06 {
private File file; // 存储文件对象信息
byte[] buf; // 缓冲区，存储文件中的所有数据
RandomAccessFile raf;
public CharactersDemo06(String filename) {
file = new File(filename);
buf = new byte[(int) file.length()];
}
// 按照读写方式打开文件
public void open() throws FileNotFoundException {
raf = new RandomAccessFile(file, "rw");
}
// 关闭文件
public void close() throws IOException {
raf.close();
}
// 对文件进行加密或解密
public void password() throws IOException {
raf.read(buf);// 将文件内容读入到缓冲区中
for (int i = 0; i < buf.length; i++)
buf[i] = (byte) (~buf[i]);// 将缓冲区中的内容按位取反
raf.seek(0);// 将文件指针定位到文件头部
raf.write(buf);// 将缓冲区中的内容写入到文件中
}
// 显示文件的内容
public static void showFileContent(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(file));
String tempString = null;
// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {
// 显示行号
System.out.println(tempString);
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
public static void main(String argv[]) {
CharactersDemo06 oa;
if (argv.length < 1) {
System.out.println("你需要指定待加密的文件名称！");
return;
}
// 下面利用encrypt对象oa对由命令行参数指定的文件进行加密处理
oa = new CharactersDemo06(argv[0]);
try {
oa.open();// 打开文件
oa.password();// 先对指定的文件加密
System.out.println("文件加密成功！加密后的文件内容如下：");
CharactersDemo06.showFileContent(argv[0]);// 显示加密后文件的内容
oa.password();// 再对已经加密的文件解密
oa.close();// 关闭文件
System.out.println("\n文件解密成功！解密后的文件内容如下：");
CharactersDemo06.showFileContent(argv[0]);// 显示解密后文件的内容
} catch (FileNotFoundException e) {
System.out.println("打不开指定文件：" + argv[0]);
} catch (IOException e) {
System.out.println("文件读写出错：" + argv[0]);
}
}
}
标签：
原文地址：http://blog.csdn.net/zhangyufeng0126/article/details/51691059
