Java文件操作类封装

最新推荐文章于 2023-06-24 18:29:51 发布
最新推荐文章于 2023-06-24 18:29:51 发布
阅读量402 收藏
点赞数
分类专栏： java 工具类 文章标签： java
package com.wiker;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
 
 
/**
  * @author Wiker Yong Email:<a href="mailto:wikeryong@gmail.com">wikeryong@gmail.com</a>
  * @date 2013-11-8 下午6:21:45
  * @version 1.0-SNAPSHOT
  */
@SuppressWarnings ( "resource" )
public class FileUtils {
     
     /**
      * 获取文件MD5值
      *
      * @param file
      * @return
      */
     public static String getMd5ByFile(File file) {
         String value = null ;
         FileInputStream in = null ;
         try {
             in = new FileInputStream(file);
             MappedByteBuffer byteBuffer = in.getChannel().map(FileChannel.MapMode.READ_ONLY, 0 ,
                     file.length());
             MessageDigest md5 = MessageDigest.getInstance( "MD5" );
             md5.update(byteBuffer);
             BigInteger bi = new BigInteger( 1 , md5.digest());
             value = bi.toString( 16 );
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             if ( null != in) {
                 try {
                     in.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return value;
     }
     
     /**
      * 获取文件大小
      *
      * @param file
      * @return
      */
     public static long getFileLength(File file)
             throws IOException {
         FileInputStream fis = null ;
         fis = new FileInputStream(file);
         return fis.available();
     }
     
     /**
      * 读取文件到二进制
      *
      * @author WikerYong Email:<a href="#">yw_312@foxmail.com</a>
      * @version 2012-3-23 上午11:47:06
      * @param file
      * @return
      * @throws IOException
      */
     public static byte [] getBytesFromFile(File file)
             throws IOException {
         InputStream is = new FileInputStream(file);
         
         long length = file.length();
         
         if (length > Integer.MAX_VALUE) {
             // File is too large
         }
         
         byte [] bytes = new byte [( int ) length];
         
         // Read in the bytes
         int offset = 0 ;
         int numRead = 0 ;
         while (offset < bytes.length
                 && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0 ) {
             offset += numRead;
         }
         
         // Ensure all the bytes have been read in
         if (offset < bytes.length) {
             throw new IOException( "不能读取文件: " + file.getName());
         }
         
         is.close();
         return bytes;
     }
     
     /**
      * 获取标准文件大小，如30KB，15.5MB
      *
      * @param file
      * @return
      * @throws IOException
      */
     public static String getFileSize(File file)
             throws IOException {
         long size = getFileLength(file);
         DecimalFormat df = new DecimalFormat( "###.##" );
         float f;
         if (size < 1024 * 1024 ) {
             f = ( float ) (( float ) size / ( float ) 1024 );
             return (df.format( new Float(f).doubleValue()) + " KB" );
         } else {
             f = ( float ) (( float ) size / ( float ) ( 1024 * 1024 ));
             return (df.format( new Float(f).doubleValue()) + " MB" );
         }
         
     }
     
     /**
      * 复制文件
      *
      * @param f1
      *            源文件
      * @param f2
      *            目标文件
      * @throws Exception
      */
     public static void copyFile(File f1, File f2)
             throws Exception {
         int length = 2097152 ;
         FileInputStream in = new FileInputStream(f1);
         FileOutputStream out = new FileOutputStream(f2);
         FileChannel inC = in.getChannel();
         FileChannel outC = out.getChannel();
         ByteBuffer b = null ;
         while ( true ) {
             if (inC.position() == inC.size()) {
                 inC.close();
                 outC.close();
             }
             if ((inC.size() - inC.position()) < length) {
                 length = ( int ) (inC.size() - inC.position());
             } else
                 length = 2097152 ;
             b = ByteBuffer.allocateDirect(length);
             inC.read(b);
             b.flip();
             outC.write(b);
             outC.force( false );
         }
     }
     
     /**
      * 检查文件是否存在
      *
      * @param fileName
      * @return
      * @throws IOException
      */
     public static boolean existFile(String fileName)
             throws IOException {
         File file = new File(fileName);
         if (!file.exists()) {
             throw new IOException( "文件未找到:" + fileName);
         }
         return file.exists();
     }
     
     /**
      * 删除文件
      *
      * @param fileName
      */
     public static void deleteFile(String fileName)
             throws IOException {
         File file = new File(fileName);
         if (!file.exists()) {
             throw new IOException( "文件未找到:" + fileName);
         }
         file.delete();
     }
     
     /**
      * 读取文件到字符串
      *
      * @param fileName
      * @return
      * @throws IOException
      */
     public static String readFile(String fileName)
             throws IOException {
         File file = new File(fileName);
         if (!file.exists()) {
             throw new IOException( "文件未找到:" + fileName);
         }
         
         BufferedReader in = new BufferedReader( new FileReader(file));
         StringBuffer sb = new StringBuffer();
         String str = "" ;
         while ((str = in.readLine()) != null ) {
             sb.append(str);
         }
         in.close();
         return sb.toString();
     }
     
     /**
      * 获取目录所有所有文件和文件夹
      *
      * @param fileName
      * @return
      * @throws IOException
      */
     public static List<File> listFiles(String fileName)
             throws IOException {
         File file = new File(fileName);
         if (!file.exists()) {
             throw new IOException( "文件未找到:" + fileName);
         }
         return Arrays.asList(file.listFiles());
     }
     
     /**
      * 创建目录
      *
      * @param dir
      */
     public static void mkdir(String dir) {
         String dirTemp = dir;
         File dirPath = new File(dirTemp);
         if (!dirPath.exists()) {
             dirPath.mkdir();
         }
     }
     
     /**
      * 新建文件
      *
      * @param fileName
      *            String 包含路径的文件名 如:E:\phsftp\src\123.txt
      * @param content
      *            String 文件内容
      */
     public static void createNewFile(String fileName, String content)
             throws IOException {
         String fileNameTemp = fileName;
         File filePath = new File(fileNameTemp);
         if (!filePath.exists()) {
             filePath.createNewFile();
         }
         FileWriter fw = new FileWriter(filePath);
         PrintWriter pw = new PrintWriter(fw);
         String strContent = content;
         pw.println(strContent);
         pw.flush();
         pw.close();
         fw.close();
         
     }
     
     /**
      * 删除文件夹
      *
      * @param folderPath
      *            文件夹路径
      */
     public static void delFolder(String folderPath) {
         // 删除文件夹里面所有内容
         delAllFile(folderPath);
         String filePath = folderPath;
         java.io.File myFilePath = new java.io.File(filePath);
         // 删除空文件夹
         myFilePath.delete();
     }
     
     /**
      * 删除文件夹里面的所有文件
      *
      * @param path
      *            文件夹路径
      */
     public static void delAllFile(String path) {
         File file = new File(path);
         if (!file.exists()) {
             return ;
         }
         if (!file.isDirectory()) {
             return ;
         }
         String[] childFiles = file.list();
         File temp = null ;
         for ( int i = 0 ; i < childFiles.length; i++) {
             // File.separator与系统有关的默认名称分隔符
             // 在UNIX系统上，此字段的值为'/'；在Microsoft Windows系统上，它为 '\'。
             if (path.endsWith(File.separator)) {
                 temp = new File(path + childFiles[i]);
             } else {
                 temp = new File(path + File.separator + childFiles[i]);
             }
             if (temp.isFile()) {
                 temp.delete();
             }
             if (temp.isDirectory()) {
                 delAllFile(path + File.separatorChar + childFiles[i]); // 先删除文件夹里面的文件
                 delFolder(path + File.separatorChar + childFiles[i]); // 再删除空文件夹
             }
         }
     }
     
     /**
      * 复制单个文件，传统方式
      *
      * @param srcFile
      *            包含路径的源文件 如：E:/phsftp/src/abc.txt
      * @param dirDest
      *            目标文件目录；若文件目录不存在则自动创建 如：E:/phsftp/dest
      * @throws IOException
      */
     public static void copyFile(String srcFile, String dirDest)
             throws IOException {
         FileInputStream in = new FileInputStream(srcFile);
         mkdir(dirDest);
         FileOutputStream out = new FileOutputStream(dirDest + "/" + new File(srcFile).getName());
         int len;
         byte buffer[] = new byte [ 1024 ];
         while ((len = in.read(buffer)) != - 1 ) {
             out.write(buffer, 0 , len);
         }
         out.flush();
         out.close();
         in.close();
     }
     
     /**
      * 复制文件夹
      *
      * @param oldPath
      *            String 源文件夹路径 如：E:/phsftp/src
      * @param newPath
      *            String 目标文件夹路径 如：E:/phsftp/dest
      * @return boolean
      */
     public static void copyFolder(String oldPath, String newPath)
             throws IOException {
         // 如果文件夹不存在 则新建文件夹
         mkdir(newPath);
         File file = new File(oldPath);
         String[] files = file.list();
         File temp = null ;
         for ( int i = 0 ; i < files.length; i++) {
             if (oldPath.endsWith(File.separator)) {
                 temp = new File(oldPath + files[i]);
             } else {
                 temp = new File(oldPath + File.separator + files[i]);
             }
             
             if (temp.isFile()) {
                 FileInputStream input = new FileInputStream(temp);
                 FileOutputStream output = new FileOutputStream(newPath + "/"
                         + (temp.getName()).toString());
                 byte [] buffer = new byte [ 1024 * 2 ];
                 int len;
                 while ((len = input.read(buffer)) != - 1 ) {
                     output.write(buffer, 0 , len);
                 }
                 output.flush();
                 output.close();
                 input.close();
             }
             if (temp.isDirectory()) { // 如果是子文件夹
                 copyFolder(oldPath + "/" + files[i], newPath + "/" + files[i]);
             }
         }
     }
     
     /**
      * 移动文件到指定目录
      *
      * @param oldPath
      *            包含路径的文件名 如：E:/phsftp/src/ljq.txt
      * @param newPath
      *            目标文件目录 如：E:/phsftp/dest
      */
     public static void moveFile(String oldPath, String newPath)
             throws IOException {
         copyFile(oldPath, newPath);
         deleteFile(oldPath);
     }
     
     /**
      * 移动文件到指定目录，不会删除文件夹
      *
      * @param oldPath
      *            源文件目录 如：E:/phsftp/src
      * @param newPath
      *            目标文件目录 如：E:/phsftp/dest
      */
     public static void moveFiles(String oldPath, String newPath)
             throws IOException {
         copyFolder(oldPath, newPath);
         delAllFile(oldPath);
     }
     
     /**
      * 移动文件到指定目录，会删除文件夹
      *
      * @param oldPath
      *            源文件目录 如：E:/phsftp/src
      * @param newPath
      *            目标文件目录 如：E:/phsftp/dest
      */
     public static void moveFolder(String oldPath, String newPath)
             throws IOException {
         copyFolder(oldPath, newPath);
         delFolder(oldPath);
     }
     
     /**
      * 解压zip文件
      * 说明:本程序通过ZipOutputStream和ZipInputStream实现了zip压缩和解压功能.
      * 问题:由于java.util.zip包并不支持汉字,当zip文件中有名字为中文的文件时,
      * 就会出现异常:"Exception  in thread "main " java.lang.IllegalArgumentException 
      * at java.util.zip.ZipInputStream.getUTF8String(ZipInputStream.java:285)
      * @param srcDir
      *            解压前存放的目录
      * @param destDir
      *            解压后存放的目录
      * @throws Exception
      */
     public static void unZip(String srcDir, String destDir)
             throws IOException {
         int leng = 0 ;
         byte [] b = new byte [ 1024 * 2 ];
         /** 获取zip格式的文件 **/
         File[] zipFiles = new ExtensionFileFilter( "zip" ).getFiles(srcDir);
         if (zipFiles != null && ! "" .equals(zipFiles)) {
             for ( int i = 0 ; i < zipFiles.length; i++) {
                 File file = zipFiles[i];
                 /** 解压的输入流 * */
                 ZipInputStream zis = new ZipInputStream( new FileInputStream(file));
                 ZipEntry entry = null ;
                 while ((entry = zis.getNextEntry()) != null ) {
                     File destFile = null ;
                     if (destDir.endsWith(File.separator)) {
                         destFile = new File(destDir + entry.getName());
                     } else {
                         destFile = new File(destDir + File.separator + entry.getName());
                     }
                     /** 把解压包中的文件拷贝到目标目录 * */
                     FileOutputStream fos = new FileOutputStream(destFile);
                     while ((leng = zis.read(b)) != - 1 ) {
                         fos.write(b, 0 , leng);
                     }
                     fos.close();
                 }
                 zis.close();
             }
         }
     }
     
     /**
      * 压缩文件
      * 说明:本程序通过ZipOutputStream和ZipInputStream实现了zip压缩和解压功能.
      * 问题:由于java.util.zip包并不支持汉字,当zip文件中有名字为中文的文件时,
      * 就会出现异常:"Exception  in thread "main " java.lang.IllegalArgumentException 
      * at java.util.zip.ZipInputStream.getUTF8String(ZipInputStream.java:285)
      * @param srcDir
      *            压缩前存放的目录
      * @param destDir
      *            压缩后存放的目录
      * @throws Exception
      */
     public static void zip(String srcDir, String destDir)
             throws IOException {
         String tempFileName = null ;
         byte [] buf = new byte [ 1024 * 2 ];
         int len;
         // 获取要压缩的文件
         File[] files = new File(srcDir).listFiles();
         if (files != null ) {
             for (File file : files) {
                 if (file.isFile()) {
                     FileInputStream fis = new FileInputStream(file);
                     BufferedInputStream bis = new BufferedInputStream(fis);
                     if (destDir.endsWith(File.separator)) {
                         tempFileName = destDir + file.getName() + ".zip" ;
                     } else {
                         tempFileName = destDir + File.separator + file.getName() + ".zip" ;
                     }
                     FileOutputStream fos = new FileOutputStream(tempFileName);
                     BufferedOutputStream bos = new BufferedOutputStream(fos);
                     ZipOutputStream zos = new ZipOutputStream(bos); // 压缩包
                     
                     ZipEntry ze = new ZipEntry(file.getName()); // 压缩包文件名
                     zos.putNextEntry(ze); // 写入新的ZIP文件条目并将流定位到条目数据的开始处
                     
                     while ((len = bis.read(buf)) != - 1 ) {
                         zos.write(buf, 0 , len);
                         zos.flush();
                     }
                     bis.close();
                     zos.close();
                     
                 }
             }
         }
     }
     
     /**
      * 读取数据
      *
      * @param inSream
      * @param charsetName
      * @return
      * @throws Exception
      */
     public static String readData(InputStream inSream, String charsetName)
             throws IOException {
         ByteArrayOutputStream outStream = new ByteArrayOutputStream();
         byte [] buffer = new byte [ 1024 ];
         int len = - 1 ;
         while ((len = inSream.read(buffer)) != - 1 ) {
             outStream.write(buffer, 0 , len);
         }
         byte [] data = outStream.toByteArray();
         outStream.close();
         inSream.close();
         return new String(data, charsetName);
     }
     
     /**
      * 一行一行读取文件，适合字符读取，若读取中文字符时会出现乱码
      *
      * @param path
      * @return
      * @throws Exception
      */
     public static Set<String> readFileLine(String path)
             throws IOException {
         Set<String> datas = new HashSet<String>();
         FileReader fr = new FileReader(path);
         BufferedReader br = new BufferedReader(fr);
         String line = null ;
         while ((line = br.readLine()) != null ) {
             datas.add(line);
         }
         br.close();
         fr.close();
         return datas;
     }
     
     public static void main(String[] args) {
         try {
             unZip( "c:/test" , "c:/test" );
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
     
}
 
 
class ExtensionFileFilter
         implements FileFilter {
     
     private String extension;
     
     public ExtensionFileFilter(String extension) {
         this .extension = extension;
     }
     
     public File[] getFiles(String srcDir) throws IOException {
         return (File[]) FileUtils.listFiles(srcDir).toArray();
     }
     
     public boolean accept(File file) {
         if (file.isDirectory()) {
             return false ;
         }
         
         String name = file.getName();
         // find the last
         int idx = name.lastIndexOf( "." );
         if (idx == - 1 ) {
             return false ;
         } else if (idx == name.length() - 1 ) {
             return false ;
         } else {
             return this .extension.equals(name.substring(idx + 1 ));
         }
     }
     
}
伱坏小子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java文件操作类封装
08-31
读取、删除、写文件、文本追加、复制文件、复制文件夹及其下面文件，读取目录下所有文件等操作
JAVA文件操作封装工具类
dly120219891208的专栏
06-26 788
在开发中经常会用到文件操作类，这里封装一下，以便大家参考
java代码封装_java语言中封装类代码示例
weixin_35834687的博客
02-15 749
在面向对象程序设计方法中，封装(Encapsulation)是指一种将抽象性函式接口的实现细节部分包装‘隐藏起来的方法。数据被保护在内部，隐藏内部实现细节，对外提供接口与外部交互。使用封装的步骤将类的所有属性使用关键字private去修饰，把它们变成私有的，不允许外部类直接访问生成或者提供公共的setter/getter方法去操作这些被隐藏起来的属性在类自己的 setter/getter方法中加入...
【JAVA】文件储存——File
haoyu__的博客
05-14 3964
【File类】 【概述】：是文件和目录路径名的抽象表示 【特点】： 文件和目录可以通过File封装成对象 File封装的对象仅仅是一个路径名。它可以是存在的，也可以是不存在的。 【构造方法】： File​(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File​(String parent, String child)：从父路径名字符串和子路径名字符串创建新的File实例 File​(File parent, String child)：从父
java操作文本封装类
沙琪玛的技术专栏
04-19 100
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; ...
Java——文件操作
最新发布
Java学不会的博客
06-24 2903
File类在包java.io.File下，代表操作系统的文件对象（文件、文件夹File类提供了：定位文件，获取文件本身的信息、删除文件、创建文件（文件夹）等功能File类创建对象名称说明根据文件路径创建对象从父路径名字符串和子路径名字字符串创建文件对象根据父路径对应文件对象和子路径名字字符串创建对象File对象可以定位文件和文件夹File封装的对象仅仅是一个路径名，这个路径可以是存在的，也可以是不存在的Demo。
Java文件操作封装类
07-31
Java文件操作封装类
java常用工具类封装
09-14
"java常用工具类封装"是指将常见的功能如线程管理、数据解析、第三方库集成等进行封装，以提高代码的可重用性和可维护性。下面我们将深入探讨这些知识点： 1. **线程池**： Java中的线程池是由`java.util....
java 文件操作类
11-03
在实际开发中，为了提高代码的可读性和可维护性，开发者通常会封装一套文件操作的工具类，如`FileUtil`。`FileUtil`类可能包含上述`File`类方法的便捷调用，还可能提供更高级的功能，如文件的读写、复制、移动、...
java文件操作工具类实现复制文件和文件合并
09-04
Java文件操作工具类是开发者在处理文件操作时经常会创建的一类辅助类，它封装了一些常见的文件操作功能，如复制文件、合并文件等。在提供的代码示例中，我们看到一个名为`FileReaderUtil`的工具类，这个类包含了两个...
用java写的一个文件操作类包
03-01
jar包 博文链接：https://wakin2003.iteye.com/blog/242473
java文件操作（超详细！）
weixin_51976923的博客
11-02 2614
java文件操作，近2万字，全面且详细过一遍java文件流！学不会你来捶我！
Java 文件操作
lfm1010123的博客
07-20 1255
详细介绍了 File 类、InputStream 类、OutputStream 类
Java文件操作类
04-29 269
1 继承JavaCore的File类，封装为统一文件概念的类。 1 package waf.file; 2 3 import java.io.*; 4 5 6 /** 7 * 8 * @author waf.wang 9 * 10 */ 11 public class File extends java.io.File 12 { 13...
文件操作（Java）
weixin_53212110的博客
01-31 615
关于文件操作
【Java 基础语法】Java 的文件操作
吞吞吐吐大魔王的博客
09-03 1527
Java 中通过类来对一个文件（包括目录）进行抽象的描述。不过有 File 对象，并不代表对应的文件真实存在。
Java File类（文件操作类）详解
jijiangpeng的博客
07-11 1672
在操作文件之前必须创建一个指向文件的链接或者实例化一个文件对象，也可以指定一个不存在的文件从而创建它。Java 中的 File 类是文件和目录路径名的抽象形式。使用 File 类可以获取文件本身的一些信息，例如文件所在的目录、文件长度、文件读写权限等。本节将对 File 类进行详细介绍。 File 类简介 在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象。Fil...
Java文件操作基础
zhaolk的博客
04-16 462
文件操作的基本方法
Java文件操作
冯同学的博客
11-16 2915
Java文件操作
Mongdb对java 的工具类封装
05-19
以下是一些常用的Java工具类封装： 1. MongoClient：MongoDB的Java驱动程序中的主要类，用于连接MongoDB服务器并访问数据库。 2. MongoDatabase：MongoDB的Java驱动程序中的类，用于访问数据库中的集合。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值