请选择 进入手机版 | 继续访问电脑版

热点推荐

查看: 62|回复: 0

【Java工具类】java文件操作工具类工具类

[复制链接]
  • TA的每日心情
    开心
    15 小时前
  • 签到天数: 133 天

    [LV.7]常住居民III

    4347

    主题

    4357

    帖子

    1万

    积分

    管理员

    Rank: 9Rank: 9Rank: 9

    积分
    16743
    发表于 2019-10-4 00:14:01 | 显示全部楼层 |阅读模式
    Java吧[java8.com]整理 java文件操作


    Java源码:
    1. import com.foriseland.fjf.lang.DateUtil;
    2. import org.apache.commons.io.FileUtils;
    3. import org.slf4j.Logger;
    4. import org.slf4j.LoggerFactory;
    5. import org.springframework.util.Base64Utils;
    6. import java.io.*;
    7. import java.util.ArrayList;
    8. import java.util.List;
    9. /**
    10. * @version V1.0
    11. * @ClassName FileUtil
    12. * @author itmrchen
    13. * @date 2019/10/04 20:58
    14. */
    15. public class FileUtil {
    16.     private static Logger logger = LoggerFactory.getLogger(FileUtil.class);
    17.     /**
    18.      * 获得指定文件的byte数组
    19.      */
    20.     public static byte[] getBytes(String filePath){
    21.         byte[] buffer = null;
    22.         try {
    23.             File file = new File(filePath);
    24.             FileInputStream fis = new FileInputStream(file);
    25.             ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
    26.             byte[] b = new byte[1000];
    27.             int n;
    28.             while ((n = fis.read(b)) != -1) {
    29.                 bos.write(b, 0, n);
    30.             }
    31.             fis.close();
    32.             bos.close();
    33.             buffer = bos.toByteArray();
    34.         } catch (FileNotFoundException e) {
    35.             e.printStackTrace();
    36.         } catch (IOException e) {
    37.             e.printStackTrace();
    38.         }
    39.         return buffer;
    40.     }
    41.     /**
    42.      * 根据byte数组,生成文件
    43.      */
    44.     public static void getFile(byte[] bfile, String filePath,String fileName) {
    45.         BufferedOutputStream bos = null;
    46.         FileOutputStream fos = null;
    47.         File file = null;
    48.         try {
    49.             File dir = new File(filePath);
    50.             if(!dir.exists()){//判断文件目录是否存在
    51.                 dir.mkdirs();
    52.             }
    53.             file = new File(filePath+"\"+fileName);
    54.             fos = new FileOutputStream(file);
    55.             bos = new BufferedOutputStream(fos);
    56.             bos.write(bfile);
    57.         } catch (Exception e) {
    58.             e.printStackTrace();
    59.         } finally {
    60.             if (bos != null) {
    61.                 try {
    62.                     bos.close();
    63.                 } catch (IOException e1) {
    64.                     e1.printStackTrace();
    65.                 }
    66.             }
    67.             if (fos != null) {
    68.                 try {
    69.                     fos.close();
    70.                 } catch (IOException e1) {
    71.                     e1.printStackTrace();
    72.                 }
    73.             }
    74.         }
    75.     }
    76.     /**
    77.      * byte[] 转InputStream
    78.      */
    79.     public static final InputStream byte2Input(byte[] buf) {
    80.         return new ByteArrayInputStream(buf);
    81.     }
    82.     /**
    83.      * InputStream 转 byte[]
    84.      * @param inStream
    85.      * @return
    86.      * @throws IOException
    87.      */
    88.     public static final byte[] input2byte(InputStream inStream)
    89.             throws IOException {
    90.         ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
    91.         byte[] buff = new byte[100];
    92.         int rc = 0;
    93.         while ((rc = inStream.read(buff, 0, 100)) > 0) {
    94.             swapStream.write(buff, 0, rc);
    95.         }
    96.         byte[] in2b = swapStream.toByteArray();
    97.         return in2b;
    98.     }
    99.     /**
    100.      * byte[] 转 InputStreamReader
    101.      */
    102.     public static final InputStreamReader byte2Reader(byte[] buf) {
    103.         InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(buf));
    104.         return isr;
    105.     }
    106.     /**
    107.      * 删除文件
    108.      *
    109.      * @param pathname
    110.      *          文件名(包括路径)
    111.      */
    112.     public static void deleteFile(String pathname){
    113.         File file = new File(pathname);
    114.         if(file.isFile() && file.exists()){
    115.             file.delete();
    116.         }
    117.         else{
    118.             logger.error("File["+ pathname +"] not exists!");
    119.         }
    120.     }
    121.     /**
    122.      * 删除文件树
    123.      *
    124.      * @param dirpath
    125.      *          文件夹路径
    126.      */
    127.     public static void deleteFileTree(String dirpath) throws IOException {
    128.         File dir = new File(dirpath);
    129.         FileUtils.deleteDirectory(dir);
    130.     }
    131.     /**
    132.      * 获取文件扩展名
    133.      *
    134.      * @param fileName
    135.      *            文件名
    136.      * @return
    137.      */
    138.     public static String getExtention(String fileName) {
    139.         int pos = fileName.lastIndexOf(".");
    140.         return fileName.substring(pos);
    141.     }
    142.     /**
    143.      * 获取文件分隔符
    144.      *
    145.      * @return
    146.      */
    147.     public static String getFileSeparator() {
    148.         return File.separator;
    149.     }
    150.     /**
    151.      * 获取相对路径
    152.      *
    153.      * @param params
    154.      *          按参数先后位置得到相对路径
    155.      * @return
    156.      */
    157.     public static String getRelativePath(String... params){
    158.         if(null != params){
    159.             String path = "";
    160.             for(String str : params){
    161.                 path = path + getFileSeparator() + str;
    162.             }
    163.             return path;
    164.         }
    165.         return null;
    166.     }
    167.     /**
    168.      * 把一个字符串写到指定文件中
    169.      * @param str  要写入文件中的字符串内容
    170.      * @param path 文件夹路径
    171.      * @param fileName 文件名称
    172.      */
    173.     public static void writeStringToFile(String str,String path,String fileName) throws IOException {
    174.         File fileDir = new File(path);
    175.         if(!fileDir.exists()){
    176.             fileDir.mkdirs();
    177.         }
    178.         File file = new File(path+fileName);
    179.         if(!file.exists()){
    180.             file.createNewFile();
    181.         }
    182.         FileWriter fw = new FileWriter(file,true);
    183.         fw.write(str);
    184.         fw.flush();
    185.         fw.close();
    186.     }
    187.     /**
    188.      * 在某个文件中追加内容
    189.      * @param fileName
    190.      * @param content
    191.      */
    192.     public static void appendStringToFile(String fileName, String content) {
    193.         try {
    194.             //判断文件是否存在
    195.             File file = new File(fileName);
    196.             judeFileExists(file);
    197.             // 打开一个随机访问文件流,按读写方式
    198.             RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
    199.             // 文件长度,字节数
    200.             long fileLength = randomFile.length();
    201.             // 将写文件指针移到文件尾。
    202.             randomFile.seek(fileLength);
    203.             randomFile.write((content + "\r\n").getBytes());
    204.             randomFile.close();
    205.         } catch (IOException e) {
    206.             e.printStackTrace();
    207.         }
    208.     }
    209.     // 判断文件是否存在,如果不存在则创建
    210.     public static void judeFileExists(File file) {
    211.         if (file.exists()) {
    212.         } else {
    213.             try {
    214.                 file.createNewFile();
    215.             } catch (Exception e) {
    216.                 e.printStackTrace();
    217.             }
    218.         }
    219.     }
    220.     // 判断文件夹是否存在,如果不存在则创建
    221.     public static void judeDirExists(File file) {
    222.         if (file.exists()) {
    223.             if (file.isDirectory()) {
    224.                 System.out.println("dir exists");
    225.             } else {
    226.                 System.out.println("the same name file exists, can not create dir");
    227.             }
    228.         } else {
    229.             System.out.println("dir not exists, create it ...");
    230.             file.mkdir();
    231.         }
    232.     }
    233. }
    复制代码


    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    快速回复 返回顶部 返回列表