岁月无痕: 四月 2007

Java文件操作详解(转载)
发布时间：2007-04-06 10:17
输入输出流
在Java中，我们把能够读取一个字节序列的对象称作一个输入流;而我们把够写一个字节序列称作一个输出流。它们分别由抽象类
InputStream和OutputStream类表示。因为面向字节的流不方便用来处理存储为Unicode（每个字符使用两个字节)的信息。所以Java
引入了用来处理Unicode字符的类层次，这些类派生自抽象类Reader和Writer，它们用于读写双字节的Unicode字符，而不是单字节字符。
Java.io包简介
JDK标准帮助文档是这样解释Java.io包的，通过数据流、序列和文件系统为系统提供输入输出。
InputStream类和OutputStream类
InputStream类是所有输入数据流的父类，它是一个抽象类，定义了所有输入数据流都具有的共通特性。
java.io.InputStream的方法如下：
public abstract read()throws IOException
读取一个字节并返回该字节，如果到输入源的末则返回-1。一个具体的输入流类需要重载此方法，以提供有用的功能。例如：在FileInputStream类中，该方法从一个文件读取一个字节。
public int read(byte[] b)throws IOException
把数据读入到一个字节数据中，并返回实际读取的字节数目。如果遇到流末则返回-1，该方法最多读取b.length个字节。
public abstract int read(byte[] b,int off,int len)throws IOException
把数据读入到一个字节数组中并返回实际读取的字节数目。如果遇到流的末尾则的返回-1。其中参数off表示第一个字节在b中的位置，len表示读取的最大字节数。
public long skip(long n)throws IOException
略过N个字节不读取，会返回实际略过的字节数目。因为数据流中剩下的数据可能不到N 个字节那么多，所以此时返回值会小于N。
public int available()throws IOException
read方法(包括后面要讲的OutputStream类的Write方法)都能够阴塞一个线程，直到字节被实际读取或写入。这意味着如果一个流不能立即被读或被写
/*
* Created on 2005-3-10
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.FileInputStream;;
/**
* @author zhangqinglin
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class Files
{
public static void main(String[] args) throws IOException
{
Files f = new Files();
// System.out.println(f.readFile("f:\\LinkFile.java"));
f.fileIsNull("D:\\java\\","ejb");
//f.readLineFile("D:\\java\\","TestFile.txt");
// System.out.println(f.fileIsNull("f:\\","122.txt"));
//f.readFolderByFile("F:\\Login"); //不区分大小写
// System.out.println(f.createAndDeleteFolder("ss","f:\\"));
// System.out.println(f.createAndDeleteFile("f:\\ss\\","TestFile.dat"));
//f.createAndDeleteFolder("1","D:\\java\\");
String[] ss = new String[50]; //定义对象数组
for(int i=0;i<ss.length;i++)
{
ss = "信息技术和互联网(计算机软硬件,通讯) "+i;
}
f.writeFile("D:\\java\\","TestFile.txt",ss);
}
/**
* 文件的写入
* @param filePath(文件路径)
* @param fileName(文件名)
* @param args[]
* @throws IOException
*/
public void writeFile(String filePath,String fileName,String[] args) throws IOException
{
FileWriter fw = new FileWriter(filePath+fileName);
PrintWriter out=new PrintWriter(fw);
for(int i=0;i<args.length;i++)
{
out.write(args);
out.println();
//out.flush();
}
System.out.println("写入成功！");
fw.close();
out.close();
}
/**
* 文件的写入
* @param filePath(文件路径)
* @param fileName(文件名)
* @param args
* @throws IOException
*/
public void writeFile(String filePath,String fileName,String args) throws IOException
{
FileWriter fw = new FileWriter(filePath+fileName);
fw.write(args);
fw.close();
}
/**
* 创建与删除文件
* @param filePath
* @param fileName
* @return 创建成功返回true
* @throws IOException
*/
public boolean createAndDeleteFile(String filePath,String fileName) throws IOException
{
boolean result = false;
File file = new File(filePath,fileName);
if(file.exists()){
if(file.isFile())
{
file.delete();
result = true;
System.out.println("文件已经删除！");
}
else
{
     System.out.println("对不起,该路径为目录！");
}
}
else
{
file.createNewFile(); //jdk5.0的新方法
result = true;
System.out.println("文件已经创建！");
}
return result;
}
/**
* 创建和删除目录
* @param folderName
* @param filePath
* @return 删除成功返回true
*/
public boolean createAndDeleteFolder(String folderName,String filePath)
{
boolean result = false;
try
{
File file = new File(filePath+folderName);
if(file.exists())
{
if(file.isDirectory()){
file.delete();
System.out.println("目录已经存在，已删除!");
result = true;
}
else{
System.out.println("对不起,该路径为文件！");
}
}
else
{
file.mkdir();
System.out.println("目录不存在，已经建立!");
result = true;
}
}
catch(Exception ex)
{
result = false;
System.out.println("CreateAndDeleteFolder is error:"+ex);
}
return result;
}
/**
* 输出目录中的所有文件及目录名字
* @param filePath
*/
public void readFolderByFile(String filePath)
{
File file = new File(filePath);
File[] tempFile = file.listFiles();
for(int i = 0;i<tempFile.length;i++)
{
if(tempFile.isFile())
{
System.out.println("File : "+tempFile.getName());
}
if(tempFile.isDirectory())
{
System.out.println("Directory : "+tempFile.getName());
}
}
}
/**
* 检查文件中是否为一个空
* @param filePath
* @param fileName
* @return 为空返回true
* @throws IOException
*/
public boolean fileIsNull(String filePath,String fileName) throws IOException
{
boolean result = false;
FileReader fr = new FileReader(filePath+fileName);
if(fr.read() == -1)
{
result = true;
System.out.println(fileName+" 文件中没有数据!");
}
else
{
System.out.println(fileName+" 文件中有数据!");
}
fr.close();
return result;
}
/**
* 读取文件中的所有内容
* @param filePath
* @param fileName
* @throws IOException
*/
public void readAllFile(String filePath,String fileName) throws IOException
{
FileReader fr = new FileReader(filePath+fileName);
//PrintWriter pr=new PrintWriter(fr);
//pr.print
int count = fr.read();
while(count != -1)
{
System.out.print((char)count);
count = fr.read();
//System.out.println();
if(count == 13)
{
fr.skip(1);
System.out.print("跳过!");
}
}
System.out.println();
fr.close();
}
/**
* 一行一行的读取文件中的数据
* @param filePath
* @param fileName
* @throws IOException
*/
public void readLineFile(String filePath,String fileName) throws IOException
{
FileReader fr = new FileReader(filePath+fileName);
BufferedReader br = new BufferedReader(fr);
String line = br.readLine();
while(line != null)
{
System.out.println(line);
line = br.readLine();
}
br.close();
fr.close();
}
}
/***************************以下是常用的文件操作方法******************************/
/**
       * @see 新建目录
       * @param folderPath String 如 c:/fqf
       * @return boolean
       */
     public void newFolder(String folderPath)
{
         try {
             String filePath = folderPath;
             filePath = filePath.toString();
             java.io.File myFilePath = new java.io.File(filePath);
             if (!myFilePath.exists())
              {
                 myFilePath.mkdir();
             }
         }
         catch (Exception e)
         {
             System.out.println("新建目录操作出错");
             e.printStackTrace();
         }
     }
     /**
       * @see 新建文件
       * @param filePathAndName String 文件路径及名称如c:/fqf.txt
       * @param fileContent String 文件内容
       * @return boolean
       */
     public void newFile(String filePathAndName, String fileContent) {
         try {
             String filePath = filePathAndName;
             filePath = filePath.toString();
             File myFilePath = new File(filePath);
             if (!myFilePath.exists()) {
                 myFilePath.createNewFile();
             }
             FileWriter resultFile = new FileWriter(myFilePath);
             PrintWriter myFile = new PrintWriter(resultFile);
             String strContent = fileContent;
             myFile.println(strContent);
             resultFile.close();
         }
         catch (Exception e) {
             System.out.println("新建文件操作出错");
             e.printStackTrace();
         }
     }
     /**
       * @see 删除文件
       * @param filePathAndName String 文件路径及名称如c:/fqf.txt
       * @param fileContent String
       * @return boolean
       */
     public void delFile(String filePathAndName) {
         try {
             String filePath = filePathAndName;
             filePath = filePath.toString();
             java.io.File myDelFile = new java.io.File(filePath);
             myDelFile.delete();
             System.out.println(myDelFile + "\\文件存在，已删除。");
         }
         catch (Exception e) {
             System.out.println("删除文件操作出错");
             e.printStackTrace();
         }
     }
     /**
       * @see 删除文件夹
       * @param filePathAndName String 文件夹路径及名称如c:/fqf
       * @param fileContent String
       * @return boolean
       */
     public void delFolder(String folderPath) {
         try {
             delAllFile(folderPath); //删除完里面所有内容
             String filePath = folderPath;
             filePath = filePath.toString();
             java.io.File myFilePath = new java.io.File(filePath);
             myFilePath.delete(); //删除空文件夹
         }
         catch (Exception e) {
             System.out.println("删除文件夹操作出错");
             e.printStackTrace();
         }
     }
     /**
       * @see 删除文件夹里面的所有文件
       * @param path String 文件夹路径如 c:/fqf
       */
     public void delAllFile(String path) {
         File file = new File(path);
         if (!file.exists()) {
             return;
         }
         if (!file.isDirectory()) {
             return;
         }
         String[] tempList = file.list();
         File temp = null;
         for (int i = 0; i < tempList.length; i++) {
             if (path.endsWith(File.separator)) {
                 temp = new File(path + tempList[i]);
             }
             else {
                 temp = new File(path + File.separator + tempList[i]);
             }
             if (temp.isFile()) {
                 temp.delete();
             }
             if (temp.isDirectory()) {
                 delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
                 delFolder(path+"/"+ tempList[i]);//再删除空文件夹
             }
         }
     }
     /**
       * @see 复制单个文件
       * @param oldPath String 原文件路径如：c:/fqf.txt
       * @param newPath String 复制后路径如：f:/fqf.txt
       * @return boolean
       */
     public void copyFile(String oldPath, String newPath) {
         try {
             int bytesum = 0;
             int byteread = 0;
             File oldfile = new File(oldPath);
             if (oldfile.exists()) { //文件存在时
                 InputStream inStream = new FileInputStream(oldPath); //读入原文件
                 FileOutputStream fs = new FileOutputStream(newPath);
                 byte[] buffer = new byte[1444];
                 //int length = 0;
                 while ( (byteread = inStream.read(buffer)) != -1) {
                     bytesum += byteread; //字节数文件大小
                     System.out.println(bytesum);
                     fs.write(buffer, 0, byteread);
                 }
                 inStream.close();
             }
         }
         catch (Exception e) {
             System.out.println("复制单个文件操作出错");
             e.printStackTrace();
         }
     }
     /**
       * @see 复制整个文件夹内容
       * @param oldPath String 原文件路径如：c:/fqf
       * @param newPath String 复制后路径如：f:/fqf/ff
       * @return boolean
       */
     public void copyFolder(String oldPath, String newPath) {
         try {
             (new File(newPath)).mkdirs(); //如果文件夹不存在则建立新文件夹
             File a=new File(oldPath);
             String[] file=a.list();
             File temp=null;
             for (int i = 0; i < file.length; i++) {
                 if(oldPath.endsWith(File.separator)){
                     temp=new File(oldPath+file[i]);
                 }
                 else{
                     temp=new File(oldPath+File.separator+file[i]);
                 }
                 if(temp.isFile()){
                     FileInputStream input = new FileInputStream(temp);
                     FileOutputStream output = new FileOutputStream(newPath + "/" +
                             (temp.getName()).toString());
                     byte[] b = new byte[1024 * 5];
                     int len;
                     while ( (len = input.read(b)) != -1) {
                         output.write(b, 0, len);
                     }
                     output.flush();
                     output.close();
                     input.close();
                 }
                 if(temp.isDirectory()){//如果是子文件夹
                     copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
                 }
             }
         }
         catch (Exception e) {
             System.out.println("复制整个文件夹内容操作出错");
             e.printStackTrace();
         }
     }
     /**
       * @see 移动文件到指定目录
       * @param oldPath String 如：c:/fqf.txt
       * @param newPath String 如：d:/fqf.txt
       */
     public void moveFile(String oldPath, String newPath) {
         copyFile(oldPath, newPath);
         delFile(oldPath);
     }
     /**
       * 移动文件到指定目录
       * @param oldPath String 如：c:/fqf.txt
       * @param newPath String 如：d:/fqf.txt
       */
     public void moveFolder(String oldPath, String newPath) {
         copyFolder(oldPath, newPath);
         delFolder(oldPath);
     }
     /**
      * @see 获得系统根目录绝对路径
      * @return String
      *
      */
     public String getPath(){
String sysPath = this.getClass().getResource("/").getPath();
       //对路径进行修改
sysPath = sysPath.substring(1, sysPath.length() - 16);
return sysPath;
     }

2007年4月7日星期六

Java文件操作详解(转载)