文件操作

String root = ServletActionContext.getRequest().getRealPath("/upload");
InputStream is = new FileInputStream(file);
File destFile = new File(root,fileFileName);
OutputStream os = new FileOutputStream(destFile);
byte[] buffer = new byte[400];
int length = 0;
while(-1 != (length = is.read(buff)))
{
os.write(buffer,0,length);

}
is.close();
os.close();  



/**
* 移动文件到指定目录
* @param oldPath String 如：c:/fqf.txt
* @param newPath String 如：d:/fqf.txt
*/
public static void moveFolder(String oldPath, String newPath) {
copyFolder(oldPath, newPath);
delFolder(oldPath);

}

/**
* 复制整个文件夹内容
* @param oldPath String 原文件路径 如：c:/fqf
* @param newPath String 复制后路径 如：f:/fqf/ff
* @return boolean
*/
public static 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();

}

}
/**

* 删除文件夹

* @param filePathAndName String 文件夹路径及名称 如c:/fqf
* @param fileContent String
* @return boolean
*/
public static 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();

}

}
------------------------------------------------
以下是常见的三种java文件拷贝的方法，抛砖引玉，大家都来说说
/**
  * 普通复制
  *
  * @param inFile
  * @param outFile
  * @throws Exception
  */
public static void fileByteCopy(String inFile, String outFile)
   throws Exception {
  long t1 = System.currentTimeMillis();
  FileInputStream in = new FileInputStream(new File(inFile));
  FileOutputStream out = new FileOutputStream(new File(outFile), true);
  byte[] bytes = new byte[1024];
  int i;
  while ((i = in.read(bytes)) != -1) {
   out.write(bytes, 0, i);
  }
  in.close();
  out.close();
  System.out.println("【普通复制】花费时间" + (System.currentTimeMillis() - t1)
    + "豪秒");
}
--------------
public static void fileBufferCopy(String inFile, String outFile)
   throws Exception {
  long t1 = System.currentTimeMillis();
  FileChannel inChannel = new FileInputStream(new File(inFile))
    .getChannel();
  FileChannel ouChannel = new FileOutputStream(new File(outFile))
    .getChannel();
  ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
  int i = 0;
  while (true) {
   buffer.clear();
   if ((i = inChannel.read(buffer)) == -1)
    break;
   buffer.flip();
   ouChannel.write(buffer);
  }
  inChannel.close();
  ouChannel.close();
  System.out.println("【新IO中的基于channel和direct buffer】花费时间"
    + (System.currentTimeMillis() - t1) + "毫秒");
}
-------------------------------------------------------------------------------

     import java.io.File;
import java.util.ArrayList;
public class FileSystem1 {
    private static ArrayList filelist = new ArrayList();
   
    public static void main(String[] args) {
       
        long a = System.currentTimeMillis();
        refreshFileList("c:\\java");
        System.out.println(System.currentTimeMillis() - a);
    }
    public static void refreshFileList(String strPath) {
        File dir = new File(strPath);
        File[] files = dir.listFiles();
       
        if (files == null)
            return;
        for (int i = 0; i < files.length; i++) {
            if (files[i].isDirectory()) {
                refreshFileList(files[i].getAbsolutePath());
            } else {
                String strFileName = files[i].getAbsolutePath().toLowerCase();
                System.out.println("---"+strFileName);
                filelist.add(files[i].getAbsolutePath());                   
            }
        }
    }
}

--------------------------------------------------
import java.io.*;
/**
* 复制文件夹或文件夹
*/
public class CopyDirectory {
    // 源文件夹 
    static String url1 = "f:/photos";
    // 目标文件夹 
    static String url2 = "d:/tempPhotos";
    public static void main(String args[]) throws IOException {
        // 创建目标文件夹 
        (new File(url2)).mkdirs();
        // 获取源文件夹当前下的文件或目录 
        File[] file = (new File(url1)).listFiles();
        for (int i = 0; i < file.length; i++) {
            if (file[i].isFile()) {
                // 复制文件 
                copyFile(file[i],new File(url2+file[i].getName()));
            }
            if (file[i].isDirectory()) {
                // 复制目录 
                String sourceDir=url1+File.separator+file[i].getName();
                String targetDir=url2+File.separator+file[i].getName();
                copyDirectiory(sourceDir, targetDir);
            }
        }
    }
// 复制文件 
public static void copyFile(File sourceFile,File targetFile) 
throws IOException{
        // 新建文件输入流并对它进行缓冲 
        FileInputStream input = new FileInputStream(sourceFile);
        BufferedInputStream inBuff=new BufferedInputStream(input);

        // 新建文件输出流并对它进行缓冲 
        FileOutputStream output = new FileOutputStream(targetFile);
        BufferedOutputStream outBuff=new BufferedOutputStream(output);
        
        // 缓冲数组 
        byte[] b = new byte[1024 * 5];
        int len;
        while ((len =inBuff.read(b)) != -1) {
            outBuff.write(b, 0, len);
        }
        // 刷新此缓冲的输出流 
        outBuff.flush();
        
        //关闭流 
        inBuff.close();
        outBuff.close();
        output.close();
        input.close();
    }
    // 复制文件夹 
    public static void copyDirectiory(String sourceDir, String targetDir)
            throws IOException {
        // 新建目标目录 
        (new File(targetDir)).mkdirs();
        // 获取源文件夹当前下的文件或目录 
        File[] file = (new File(sourceDir)).listFiles();
        for (int i = 0; i < file.length; i++) {
            if (file[i].isFile()) {
                // 源文件 
                File sourceFile=file[i];
                // 目标文件 
               File targetFile=new 
File(new File(targetDir).getAbsolutePath()
+File.separator+file[i].getName());
                copyFile(sourceFile,targetFile);
            }
            if (file[i].isDirectory()) {
                // 准备复制的源文件夹 
                String dir1=sourceDir + "/" + file[i].getName();
                // 准备复制的目标文件夹 
                String dir2=targetDir + "/"+ file[i].getName();
                copyDirectiory(dir1, dir2);
            }
        }
    }
}  

---------------------------------------------------------------------
import java.io.*;

public class FileOperate {
  public FileOperate() {
  }

  /**
   * 新建目录
   * @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();
    }
  }

  /**
   * 新建文件
   * @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();

    }

  }

  /**
   * 删除文件
   * @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();

    }
    catch (Exception e) {
      System.out.println("删除文件操作出错");
      e.printStackTrace();

    }

  }

  /**
   * 删除文件夹
   * @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();

    }

  }

  /**
   * 删除文件夹里面的所有文件
   * @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]);//再删除空文件夹
      }
    }
  }

  /**
   * 复制单个文件
   * @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;
        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();

    }

  }

  /**
   * 复制整个文件夹内容
   * @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();

    }

  }

  /**
   * 移动文件到指定目录
   * @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);

  }
}



java中删除目录事先要删除目录下的文件或子目录。用递归就可以实现。这是我第一个用到算法作的程序，哎看来没白学。
public void del(String filepath) throws IOException{
File f = new File(filepath);//定义文件路径      
if(f.exists() && f.isDirectory()){//判断是文件还是目录
    if(f.listFiles().length==0){//若目录下没有文件则直接删除
        f.delete();
    }else{//若有则把文件放进数组，并判断是否有下级目录
        File delFile[]=f.listFiles();
        int i =f.listFiles().length;
        for(int j=0;j<i;j++){
            if (delFile[j].isDirectory()){                                                del (delFile[j].getAbsolutePath());//递归调用del方法并取得子目录路径
            }
            delFile[j].delete();//删除文件
        }
    }
    del(filepath);//递归调用
}

}   


删除一个非空目录并不是简单地创建一个文件对象，然后再调用delete()就可以完成的。要在平台无关的方式下安全地删除一个非空目录，你还需要一个算法。该算法首先删除文件，然后再从目录树的底部由下至上地删除其中所有的目录。

只要简单地在目录中循环查找文件，再调用delete就可以清除目录中的所有文件：

static public void emptyDirectory(File directory) {
   File[ ] entries = directory.listFiles( );
   for(int i=0; i<entries.length; i++) {
       entries[i].delete( );
   }
}
这个简单的方法也可以用来删除整个目录结构。当在循环中遇到一个目录时它就递归调用deleteDirectory，而且它也会检查传入的参数是否是一个真正的目录。最后，它将删除作为参数传入的整个目录。
static public void deleteDirectory(File dir) throws IOException {
   if( (dir == null) || !dir.isDirectory) {
       throw new IllegalArgumentException(

                 "Argument "+dir+" is not a directory. "
             );
   }

   File[ ] entries = dir.listFiles( );
   int sz = entries.length;

   for(int i=0; i<sz; i++) {
       if(entries[i].isDirectory( )) {
           deleteDirectory(entries[i]);
       } else {
           entries[i].delete( );
       }
   }

  dir.delete();
}

-------------------------
http://www.open-open.com/jsoup/parse-body-fragment.htm

评论

4 楼 rooi 2011-12-30  

@echo off
　　　　　　echo 正在清除系统垃圾文件，请稍等......
　　　　　　del /f /s /q %systemdrive%\*.tmp
　　　　　　del /f /s /q %systemdrive%\*._mp
　　　　　　del /f /s /q %systemdrive%\*.log
　　　　　　del /f /s /q %systemdrive%\*.gid
　　　　　　del /f /s /q %systemdrive%\*.chk
　　　　　　del /f /s /q %systemdrive%\*.old
　　　　　　del /f /s /q %systemdrive%\recycled\*.*
　　　　　　del /f /s /q %windir%\*.bak
　　　　　　del /f /s /q %windir%\prefetch\*.*
　　　　　　rd /s /q %windir%\temp & md %windir%\temp
　　　　　　del /f /q %userprofile%\cookies\*.*
　　　　　　del /f /q %userprofile%\recent\*.*
　　　　　　del /f /s /q "%userprofile%\Local Settings\Temporary Internet Files\*.*"
　　　　　　del /f /s /q "%userprofile%\Local Settings\Temp\*.*"
　　　　　　del /f /s /q "%userprofile%\recent\*.*"
　　　　　　echo 清除系统LJ完成！
　　　　　　echo. & pause

3 楼 rooi 2011-12-07  

在菜单飞秋FeiQ图标那里点右键，选择菜单中的属性，在属性栏的快捷方式中快捷键那里设置快捷方式为无（方式是随便按个键，然后取消即可）

2 楼 rooi 2011-12-06  

首先任务栏上的输入法图标上点右键选择设置。

然后选择键设置，第一个“在不同的输入语言之间切换”先勾选“切换输入语言”下面选择左手ALT。取消右边“切换键盘布局”前的勾。

然后进入“中文（简体）输入法 - 输入法/非输入法切换”，取消“启用按键顺序”前的勾。一路都确定后推出设置。

再次进入设置，进入“在不同的输入语言之间切换”，把右边那个"切换键盘布局"打上勾。确定后退出。

解决了无法使用ctrl+shift以及ctrl+space切换输入法的问题

1 楼 idomon3 2011-08-29  

InputStream is = request.getInputStream();
   BufferedReader br = new BufferedReader(new InputStreamReader(is));
   String buffer = null;
   while((buffer = br.readLine())!=null){
   if(buffer.endsWith("--") && buffer.startsWith("----------------")){
   break;
   }
   if(buffer.startsWith("-----------------")){
   if(br.readLine().indexOf("filename")>1){
   br.readLine();
   br.readLine();
   File file = new File(request.getRealPath("/")+System.currentTimeMillis());
   PrintStream ps = new PrintStream(new FileOutputStream(file));
   String content =null;
   while((content = br.readLine())!=null)
   {
   if(content.startsWith("--------------"))
   {
   break;
   }
   ps.println(content);
   }
   ps.flush();
   ps.close();
  
   }
   }
   }