java读取文件，写入文件

Java 中 IO 流

Java 中 IO 流分为几种?

按照流的流向分，可以分为输入流和输出流；

按照操作单元划分，可以划分为字节流和字符流；

按照流的角色划分为节点流和处理流。

Java Io 流共涉及 40 多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧

密的联系， Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。

OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

递归读取文件夹下的文件，代码怎么实现

/**
     * 递归读取文件夹下的 所有文件
     *
     * @param testFileDir 文件名或目录名
     */
    private static void testLoopOutAllFileName(String testFileDir) {
        if (testFileDir == null) {
            //因为new File(null)会空指针异常,所以要判断下
            return;
        }
        File[] testFile = new File(testFileDir).listFiles();
        if (testFile == null) {
            return;
        }
        for (File file : testFile) {
            if (file.isFile()) {
                System.out.println(file.getName());
            } else if (file.isDirectory()) {
                System.out.println("-------file-------" + file.getName());
                testLoopOutAllFileName(file.getPath());
            } else {
                System.out.println("文件读入有误！");
            }
        }
    }

文件操作工具类：

package com.fyg.common.util;

import com.fyg.common.constants;
import lombok.extern.slf4j.Slf4j;
import org.apache.tools.tar.TarEntry;
import org.apache.tools.tar.TarInputStream;

import java.io.*;
import java.nio.charset.Charset;
import java.text.DecimalFormat;
import java.util.*;
import java.util.zip.GZIPInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;


/**
 * 操作文件的辅助类
 *
 * @author liqh
 * @version 1.0
 */
@Slf4j
public class FileUtils extends org.apache.commons.io.FileUtils {

    public static final String B_UNIT = "B";
    public static final String KB_UNIT = "KB";
    public static final String MB_UNIT = "MB";
    public static final String GB_UNIT = "GB";
    public static final DecimalFormat decimalFormat = new DecimalFormat("#.0");

    /**
     * 创建目录
     *
     * @param dir
     * @return
     */
    public static boolean createDirectory(String dir) {
        if (!isExistsDirectory(dir)) {
            File folder = new File(dir);
            return folder.mkdirs();
        }
        return false;
    }


    /**
     * 判断当前目录是否存在
     *
     * @param dir
     * @return true:存在  false：不存在
     */
    public static boolean isExistsDirectory(String dir) {
        File folder = new File(dir);
        if (!folder.exists() && !folder.isDirectory()) {
            return false;
        }
        return true;
    }


    /**
     * 创建新的文件名
     */
    public static String renameToUUID(String fileName) {
        return IDUtils.generateId32() + "." + fileName.substring(fileName.lastIndexOf(".") + 1);
    }

    /**
     * 创建文件
     *
     * @param fileName
     * @return true:创建成功   false:创建失败
     * @throws IOException
     */
    public static boolean createNewFile(String fileName) throws IOException {
        if (!isExistsFile(fileName)) {
            File file = new File(fileName);
            return file.createNewFile();
        }
        return false;
    }


    /**
     * 判断当前文件是否存在
     *
     * @param fileName
     * @return true:存在  false：不存在
     */
    public static boolean isExistsFile(String fileName) {
        File file = new File(fileName);
        return file.exists();
    }


    /**
     * 获取某个文件夹下的所有文件,只包含文件
     *
     * @param dir
     * @return
     */
    public static List<String> getFileList(String dir) {
        List<String> fileNameList = new ArrayList<>();
        File file = new File(dir);
        File[] tempList = file.listFiles();
        for (int i = 0; i < tempList.length; i++) {
            if (tempList[i].isFile()) {
                fileNameList.add(tempList[i].getName());
            }
        }
        return fileNameList;
    }

    /**
     * 获取某个文件夹下的所有文件全路径
     *
     * @param dir
     * @return
     */
    public static List<String> getAllFileAbsolute(String dir) {
        List<String> fileNameList = new ArrayList<>();
        return getAllFileAbsolute(dir, fileNameList);
    }

    /**
     * 获取某个文件夹下的所有文件,包含文件夹和文件
     *
     * @param dir
     * @return
     */
    public static List<String> getAllFileAbsolute(String dir, List<String> fileNameList) {
        File file = new File(dir);
        File[] tempList = file.listFiles();
        for (int i = 0; i < tempList.length; i++) {
            if (tempList[i].isFile()) {
                fileNameList.add(tempList[i].toString());
            } else if (tempList[i].isDirectory()) {
                getAllFileAbsolute(tempList[i].getAbsolutePath(), fileNameList);
            }
        }
        return fileNameList;
    }

    /**
     * 获取某个文件夹下的所有文件,包含文件夹和文件
     *
     * @param dir
     * @return
     */
    public static List<String> getAllFileName(String dir, List<String> fileNameList) {
        File file = new File(dir);
        File[] tempList = file.listFiles();
        for (int i = 0; i < tempList.length; i++) {
            if (tempList[i].isFile()) {
                fileNameList.add(tempList[i].getName());
            } else if (tempList[i].isDirectory()) {
                getAllFileName(tempList[i].getAbsolutePath(), fileNameList);
            }
        }
        return fileNameList;
    }

    /**
     * 获取某个文件夹下的所有文件,包含文件夹和文件
     *
     * @param dir
     * @return
     */
    public static List<String> getAllFileName(String dir) {
        List<String> fileNameList = new ArrayList<>();
        return getAllFileName(dir, fileNameList);
    }

    /**
     * 删除文件，可以是单个文件或文件夹
     *
     * @param fileName 待删除的文件名
     * @return 文件删除成功返回true, 否则返回false
     */
    public static boolean deleteFileOrDirectory(String fileName) {
        File file = new File(fileName);
        if (!file.exists()) {
            return false;
        } else {
            if (file.isFile()) {
                return deleteFile(fileName);
            } else {
                return deleteDirectory(fileName);
            }
        }
    }

    /**
     * 删除单个文件
     *
     * @param fileName 被删除文件的文件名
     * @return 单个文件删除成功返回true, 否则返回false
     */
    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        if (file.isFile() && file.exists()) {
            file.delete();
            return true;
        } else {
            return false;
        }
    }


    /**
     * 删除目录（文件夹）以及目录下的文件
     *
     * @param dir 被删除目录的文件路径
     * @return 目录删除成功返回true, 否则返回false
     */
    public static boolean deleteDirectory(String dir) {
        //如果dir不以文件分隔符结尾，自动添加文件分隔符   
        if (!dir.endsWith(File.separator)) {
            dir = dir + File.separator;
        }
        File dirFile = new File(dir);
        //如果dir对应的文件不存在，或者不是一个目录，则退出   
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        //删除文件夹下的所有文件(包括子目录)   
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            //删除子文件   
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            }
            //删除子目录   
            else {
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag) {
                    break;
                }
            }
        }
        if (!flag) {
            return false;
        }
        //删除当前目录
        if (dirFile.delete()) {
            return true;
        } else {
            return false;
        }
    }


    /**
     * 用于上传或复制文件
     *
     * @param srcFile 源文件
     * @param tarFile 目标文件
     * @throws IOException
     */
    public static void copyFile(File srcFile, File tarFile) throws IOException {
        InputStream inStream = new FileInputStream(srcFile);
        OutputStream outStream = new FileOutputStream(tarFile);
        byte[] buff = new byte[1024];
        int readed = -1;
        while ((readed = inStream.read(buff)) > 0) {
            outStream.write(buff, 0, readed);
        }
        outStream.flush();
        inStream.close();
        outStream.close();
    }


    /**
     * 文件的移动
     *
     * @param srcFile 源文件
     * @param tarFile 目标文件
     * @return
     */
    public static boolean moveTotherFolders(File srcFile, File tarFile) {

        return srcFile.renameTo(tarFile);
    }


    /**
     * 将文件的byte数组转换成目标文件
     *
     * @param srcByte 源文件数组
     * @param tarFile 目标文件
     * @throws IOException
     */
    public static File convertToFile(byte[] srcByte, File tarFile) throws IOException {
        //将字节转换成文件
        OutputStream outStream = new FileOutputStream(tarFile);
        outStream.write(srcByte);
        outStream.flush();
        outStream.close();

        return tarFile;
    }

    /**
     * 将文件的byte数组转换成目标文件
     *
     * @param inStream 源文件数组
     * @param tarFile  目标文件
     * @throws IOException
     */
    public static File convertToFile(InputStream inStream, File tarFile) throws IOException {
        if (inStream == null) return null;

        //将字节转换成文件
        OutputStream outStream = new FileOutputStream(tarFile);

        byte[] buff = new byte[1024];
        int readed = -1;
        while ((readed = inStream.read(buff)) > 0) {
            outStream.write(buff, 0, readed);
        }
        outStream.flush();
        inStream.close();
        outStream.close();

        return tarFile;
    }


    /**
     * 将文件转换成byte数组的形式
     *
     * @param srcFile 目标文件
     * @return byte数组
     * @throws IOException
     */
    public static byte[] converToByte(File srcFile) throws IOException {
        byte[] content = null;

        //转换成byte数组
        InputStream inStream = new FileInputStream(srcFile);
        if (inStream != null) {
            content = new byte[inStream.available()];
            inStream.read(content);
            inStream.close();
        }

        return content;
    }

    /**
     * 将文件转换成byte数组的形式
     *
     * @param inStream 目标文件
     * @return byte数组
     * @throws IOException
     */
    public static byte[] converToByte(InputStream inStream) throws IOException {
        byte[] content = null;
        //转换成byte数组
        if (inStream != null) {
            content = new byte[inStream.available()];
            inStream.read(content);
            inStream.close();
        }
        return content;
    }


    /**
     * 重命名文件
     *
     * @param fileName
     * @return
     */
    public static File renameFile(String filePath, String fileName) {
        filePath = filePath.endsWith(Constants.System.SLANT) ? filePath : filePath + Constants.System.SLANT;
        String oldFileName = filePath + fileName;
        File oldFile = new File(oldFileName);
        String newFileName = DateUtils.getCurrentTimestamp(DateUtils.DATETIME_17) + fileName;
        String newFilePath = filePath + newFileName;
        File newFile = new File(newFilePath);
        if (oldFile.exists() && oldFile.isFile()) {
            oldFile.renameTo(newFile);
        }
        return newFile;
    }


    /**
     * 重命名文件
     *
     * @param sourFile 源文件
     * @param tarFile  目标文件
     * @return
     */
    public static File renameFile(File sourFile, File tarFile) {
        sourFile.renameTo(tarFile);
        return tarFile;
    }


    /**
     * 多个斜杠转成一个斜杠
     *
     * @param path
     * @return
     */
    public static String transformPath(String path) {
        String regex = "/+";
        String regex1 = "\\+";
        return path.replaceAll(regex, "/").replaceAll(regex1, "/");
    }

    /**
     * 删除超时的文件
     *
     * @param tarFile
     * @param aLong
     */
    public static void deleteTimeoutFiles(File tarFile, Long aLong) {
        File[] files = tarFile.listFiles();
        Arrays.stream(files).forEach(file -> {
            Long ftime = file.lastModified();
            if (ftime < aLong) {
                deleteFile(file.getAbsolutePath());
            }
        });
    }

    /**
     * 将传入的二进制数组，获取文件头部对应的二进制信息
     *
     * @param src 二进制数组
     * @return 二进制信息
     * @throws Exception
     */
    public static String bytesToHexString(byte[] src) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }


    /**
     * 根据传入的文件取得对应的文件类型
     *
     * @param file 文件对应的信息
     * @return 文件类型
     */
    public static String[] getFileType(File file) throws Exception {
        return getFileType(getFileContent(file));
    }


    /**
     * 根据传入的文件流取得对应的文件类型
     *
     * @param is 文件流
     * @return 文件类型
     */
    public static String[] getFileType(InputStream is) throws Exception {
        return getFileType(getFileContent(is));
    }

    /**
     * 根据文件字节取得对应的文件类型
     *
     * @param srcByte 文件字节
     * @return 文件类型
     */
    public static String[] getFileType(byte[] srcByte) throws Exception {
        return getFileType(getFileContent(srcByte));
    }

    /**
     * 根据传入的头部二进制信息获取文件类型
     *
     * @param fileContent 头部二进制信息
     * @return 文件类型
     * @throws Exception
     */
    public static String[] getFileType(String fileContent) throws Exception {
        //取得文件头对应的二进制数组
        Map<String, String[]> map = getFileSuffixMap();
        String[] fileType = null;
        //便利文件取得对应的文件类型
        if (fileContent != null) {
            for (String key : map.keySet()) {
                if (fileContent.toLowerCase().startsWith(key.toLowerCase())) {
                    fileType = map.get(key);
                    break;
                }
            }
        }
        return fileType;
    }

    /**
     * 根据传入的文件取得文件头部的二进制信息
     *
     * @param file 文件类型
     * @return 二进制信息
     * @throws Exception
     */
    public static String getFileContent(File file) throws Exception {
        return getFileContent(new FileInputStream(file));
    }

    /**
     * 从流中读出前28位字节，再得到文件头信息
     *
     * @param is InputStream对象
     * @return 文件头2进制数组
     * @throws IOException
     */
    public static String getFileContent(InputStream is) throws Exception {
        byte[] b = new byte[28];
        try {
            //取得28位文件头
            is.read(b, 0, 28);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) is.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return getFileContent(b);
    }

    /**
     * 截取二进制数组的前28位,在获得对应的文件头二进制数组信息
     *
     * @param srcByte 传入的二进制数组
     * @return 文件头二进制数组信息
     * @throws Exception
     */
    private static String getFileContent(byte[] srcByte) throws Exception {
        String content = null;
        if (srcByte != null && srcByte.length > 0) {
            //如果二进制文件的长度大于28位，则截取前28位
            byte[] b = new byte[28];
            if (srcByte.length > 28) System.arraycopy(srcByte, 0, b, 0, 28);
            else b = srcByte;
            //取得后最文件
            content = bytesToHexString(b);
        }
        return content;
    }

    /**
     * 取得文件后缀对应的字符串，前4个组成的文件头
     *
     * @return 文件头对应的后缀
     */
    public static Map<String, String[]> getFileSuffixMap() {
        //设置接收参数对应的MAP
        Map<String, String[]> map = new HashMap<String, String[]>();

        //设置对应的值
        map.put("FFD8FF", new String[]{"JPEG"});
        map.put("89504E47", new String[]{"PNG"});
        map.put("47494638", new String[]{"GIF"});
        map.put("49492A00", new String[]{"TIFF"});
        map.put("424D", new String[]{"BMP"});
        map.put("41433130", new String[]{"DWG"});
        map.put("38425053", new String[]{"PSD"});
        map.put("7B5C727466", new String[]{"RTF"});
        map.put("3C3F786D6C", new String[]{"XML"});
        map.put("68746D6C3E", new String[]{"HTML"});
        map.put("44656C69766572792D646174653A", new String[]{"EML"});
        map.put("CFAD12FEC5FD746F", new String[]{"DBX"});
        map.put("2142444E", new String[]{"PST"});
        map.put("D0CF11E0", new String[]{"XLS", "DOC"});
        map.put("5374616E64617264204A", new String[]{"MDB"});
        map.put("FF575043", new String[]{"WPD"});
        map.put("252150532D41646F6265", new String[]{"EPS"});
        map.put("255044462D312E", new String[]{"PDF"});
        map.put("AC9EBD8F", new String[]{"QDF"});
        map.put("E3828596", new String[]{"PWL"});
        map.put("504B0", new String[]{"XLSX", "ZIP"});
        map.put("52617221", new String[]{"RAR"});
        map.put("57415645", new String[]{"WAV"});
        map.put("41564920", new String[]{"AVI"});
        map.put("2E7261FD", new String[]{"RAM"});
        map.put("2E524D46", new String[]{"RM"});
        map.put("000001BA", new String[]{"MPG"});
        map.put("6D6F6F76", new String[]{"MOV"});
        map.put("3026B2758E66CF11", new String[]{"ASF"});
        map.put("4D546864", new String[]{"MID"});
        map.put("494433", new String[]{"MP3"});
        map.put("61646661647366", new String[]{"TXT"});
        map.put("202f2a2a", new String[]{"TXT"});
        return map;
    }


    /**
     * 解析txt文档
     *
     * @param txtFile txt文件
     * @return
     */
    public static List<List<String>> parseTxt(String txtFile, String separator) {
        if (txtFile == null) {
            return null;
        }
        List<List<String>> data = new ArrayList<List<String>>();
        try {
            BufferedReader buffReader = null;
            FileInputStream fi = new FileInputStream(txtFile);
            String carSet = getTxtFileCharSet(new File(txtFile));
            System.out.println(carSet);
            if ("Unicode".equals(carSet)) {
                buffReader = new BufferedReader(new InputStreamReader(fi, "UTF-16"));
            } else if ("Unicode big endian".equals(carSet)) {
                buffReader = new BufferedReader(new InputStreamReader(fi, "UTF-16LE"));
            } else {
                buffReader = new BufferedReader(new InputStreamReader(fi, "UTF-8"));
            }
            System.out.println(Charset.defaultCharset().name());
            String line = "";
            while (buffReader.ready()) {
                line = buffReader.readLine();
                if (StringUtils.isBlank(line)) continue;
                String[] chars = line.split(separator);
                List<String> innerData = new ArrayList<String>();
                for (String charactor : chars) {
                    if (StringUtils.isNotBlank(charactor)) {
                        if ("UTF-8 + BOM".equals(carSet)) {
                            charactor = new String(charactor.getBytes(Charset.defaultCharset().name()), "UTF-8");
                            charactor = charactor.indexOf("?") == 0 ? charactor.substring(1) : charactor;
                        }
                    }
                    innerData.add(charactor);
                }
                data.add(innerData);
            }
            if (buffReader != null) {
                buffReader.close();
                buffReader = null;
            }
            if (fi != null) {
                fi.close();
                fi = null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }


    /**
     * 查看文件编码
     *
     * @param file
     * @return
     */
    public static String getTxtFileCharSet(File file) {
        try {
            return getTxtFileCharSet(new FileInputStream(file));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 查看TXT文件编码
     *
     * @param inputStream
     * @return
     */
    public static String getTxtFileCharSet(InputStream inputStream) {
        String carSet = "ANSI";
        try {
            byte[] fileHead = new byte[3];
            inputStream.read(fileHead);
            if (-17 == fileHead[0] && -69 == fileHead[1] && -65 == fileHead[2]) {
                carSet = "UTF-8 + BOM";
            } else if (49 == fileHead[0] && 51 == fileHead[1] && 49 == fileHead[2]) {
                carSet = "UTF-8";
            } else if (-1 == fileHead[0] && -2 == fileHead[1]) {
                carSet = "Unicode";
            } else if (-2 == fileHead[0] && -1 == fileHead[1]) {
                carSet = "Unicode big endian";
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                    inputStream = null;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return carSet;
    }


    /**
     * 写入Txt
     *
     * @param path
     * @param txt
     * @throws IOException
     */
    public static boolean writeFile(String path, String txt) {
        // 相对路径，如果没有则要建立一个新的path文件
        File file = new File(path);
        try {
            // 创建新文件
            createNewFile(file.getAbsolutePath());
            // 字符缓冲输出流：写东西到该文件
            BufferedWriter out = new BufferedWriter(new FileWriter(file));
            // 写东西：\r\n即为换行
            out.write(txt);
            // 把缓存区内容压入文件
            out.flush();
            // 最后关闭流
            out.close();
            //返回成功
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 描述： 获取格式化的文件大小
     * 格式为带单位保留一位小数
     *
     * @param size
     * @return
     */
    public static String getFormatSize(double size) {
        String fileSizeString = "";
        if (size < 1024) {
            fileSizeString = decimalFormat.format(size) + B_UNIT;
        } else if (size < 1048576) {
            fileSizeString = decimalFormat.format(size / 1024) + KB_UNIT;
        } else if (size < 1073741824) {
            fileSizeString = decimalFormat.format(size / 1048576) + MB_UNIT;
        } else {
            fileSizeString = decimalFormat.format(size / 1073741824) + GB_UNIT;
        }
        return fileSizeString;
    }

    /**
     * 获取文件大小
     *
     * @param size
     * @return
     */
    public static String getFormatSize(long size) {
        return getFormatSize((double) size);
    }

    /**
     * 传文件全路径，解压gz文件到当前文件夹
     *
     * @param fileUrl
     * @return
     */
    public static String unGzFile(String fileUrl) {
        String errMess="";
        GZIPInputStream in = null;
        try {
            in = new GZIPInputStream(new FileInputStream(fileUrl));
        } catch(FileNotFoundException e) {
            log.info("File not found. " + fileUrl);
            errMess=e.getMessage();
        } catch (IOException e) {
            e.printStackTrace();
            errMess=e.getMessage();
        }
        String gzFileNameAndUrl = getGzFileNameAndUrl(fileUrl);

        FileOutputStream out = null;
        try {
            out = new FileOutputStream(gzFileNameAndUrl);
        } catch (FileNotFoundException e) {
            log.info("Could not write to file. " + gzFileNameAndUrl);
            errMess=e.getMessage();
        }
        log.info("文件路径=========" + gzFileNameAndUrl);
        try {
            byte[] buf = new byte[1024];
            int len;
            while((len = in.read(buf)) > 0) {
                out.write(buf, 0, len);
            }
            in.close();
            out.close();
            deleteFileOrDirectory(fileUrl);
        } catch (IOException e) {
            e.printStackTrace();
            errMess=e.getMessage();
        }
        return errMess;
    }

    /**
     * 传文件全路径，解压zip文件到当前文件夹
     *
     * @param filePath
     * @return
     */
    public static String unzipFile(String filePath) {
        String errMess="";
        String zipDir = filePath.substring(0,filePath.lastIndexOf("/") + 1);
        String name = "";
        try {
            BufferedOutputStream dest = null;
            BufferedInputStream is = null;
            ZipEntry entry;
            ZipFile zipfile = new ZipFile(filePath, Charset.forName("GBK"));

            Enumeration dir = zipfile.entries();
            while (dir.hasMoreElements()){
                entry = (ZipEntry) dir.nextElement();

                if( entry.isDirectory()){
                    name = entry.getName();
                    name = name.substring(0, name.length() - 1);
                    File fileObject = new File(zipDir + name);
                    fileObject.mkdir();
                }
            }

            Enumeration e = zipfile.entries();
            while (e.hasMoreElements()) {
                entry = (ZipEntry) e.nextElement();
                if( entry.isDirectory()){
                    continue;
                }else{
                    is = new BufferedInputStream(zipfile.getInputStream(entry));
                    int count;
                    byte[] dataByte = new byte[1024];
                    FileOutputStream fos = new FileOutputStream(zipDir+entry.getName());
                    dest = new BufferedOutputStream(fos, 1024);
                    while ((count = is.read(dataByte, 0, 1024)) != -1) {
                        dest.write(dataByte, 0, count);
                    }
                    dest.flush();
                    dest.close();
                    is.close();
                }
            }

            deleteFileOrDirectory(filePath);
        } catch (Exception e) {
            e.printStackTrace();
            errMess=e.getMessage();
        }

        return errMess;
    }

    /**
     * 传路径，找出当前路径下所有子目录以及文件
     *
     * @param
     * @return
     */
    public static List<String> findUnzipAllFile(File filePath,List<String> filePaths) {

        File[] files = filePath.listFiles();
        if(files == null){
            return filePaths;
        }
        for(File f:files){
            if(f.isDirectory()){
                filePaths.add(f.getPath());
                findUnzipAllFile(f,filePaths);
            }else{
                filePaths.add(f.getPath());
            }
        }
        return filePaths;
    }

    /**
     * 截取文件后缀
     *
     * @param
     * @return
     */
    public static String checkFile(String filePaths) {
        String hzhwjm = "";
        String houZui = "";
        int i =filePaths.lastIndexOf("/");
        if (i > 0 &&  i < filePaths.length() - 1) {
            hzhwjm = filePaths.substring(i + 1);
        }
        int j =hzhwjm.lastIndexOf(".");
        if (j > 0 &&  j < hzhwjm.length() - 1) {
            houZui = hzhwjm.substring( j+ 1);
        }
        if(houZui.equals("gz")||houZui.equals("GZ")){
            if(j>3){
                if(hzhwjm.substring(j - 3).equals("tar.gz")||hzhwjm.substring(j - 3).equals("TAR.GZ")){
                    houZui=hzhwjm.substring(j - 3);
                }
            }
        }
        return houZui;
    }

    public static String getGzFileNameAndUrl(String f) {
        String fname = "";
        int i = f.lastIndexOf('.');

        if (i > 0 &&  i < f.length() - 1) {
            fname = f.substring(0,i);
        }


        return fname;
    }
    /**
     * 压缩文件通过文件全路径截取文件名
     *
     * @param
     * @return
     */
    public static String getFileNameByAllUrl(String fileAllUrl) {
        String fName = "";
        int i = fileAllUrl.lastIndexOf('/');

        if (i > 0 &&  i < fileAllUrl.length() - 1) {
            fName = fileAllUrl.substring(i+1);
        }
        return fName;

    }
    /**
     * 压缩文件通过文件全路径截取文件路径
     *
     * @param
     * @return
     */
    public static String getFileUrlByAllUrl(String fileAllUrl) {
        String fUrl = "";
        int i = fileAllUrl.lastIndexOf('/');

        if (i > 0 &&  i < fileAllUrl.length() - 1) {
            fUrl = fileAllUrl.substring(0,i+1);
        }
        return fUrl;
    }

    /**
     * 解压tar.gz 传文件全路径
     * @param filePath
     *
     */
    public static String unTarGz(String filePath) throws IOException{
        String outputDir = filePath.substring(0,filePath.lastIndexOf("/") + 1);
        String errMess="";
        File file = new File(filePath);
        TarInputStream tarIn = null;
        try{
            tarIn = new TarInputStream(new GZIPInputStream(
                    new BufferedInputStream(new FileInputStream(file))),
                    1024 * 2);

            createDirectory(outputDir,null);//创建输出目录

            TarEntry entry = null;
            while( (entry = tarIn.getNextEntry()) != null ){

                if(entry.isDirectory()){//是目录
                    entry.getName();
                    createDirectory(outputDir,entry.getName());//创建空目录
                }else{//是文件
                    File tmpFile = new File(outputDir + "/" + entry.getName());
                    createDirectory(tmpFile.getParent() + "/",null);//创建输出目录
                    OutputStream out = null;
                    try{
                        out = new FileOutputStream(tmpFile);
                        int length = 0;

                        byte[] b = new byte[2048];

                        while((length = tarIn.read(b)) != -1){
                            out.write(b, 0, length);
                        }

                    }catch(IOException ex){
                        errMess=ex.getMessage();
                        throw ex;
                    }finally{
                        if(out!=null)
                            out.close();
                    }
                }
            }
        }catch(IOException ex){
            errMess=ex.getMessage();
            throw new IOException("解压归档文件出现异常",ex);
        } finally{
            try{
                if(tarIn != null){
                    tarIn.close();
                }
            }catch(IOException ex){
                errMess=ex.getMessage();
                throw new IOException("关闭tarFile出现异常",ex);
            }
        }
        deleteFileOrDirectory(filePath);
        return errMess;
    }

    /**
     * 构建目录
     * @param outputDir
     * @param subDir
     */
    public static void createDirectory(String outputDir,String subDir){
        File file = new File(outputDir);
        if(!(subDir == null || subDir.trim().equals(""))){//子目录不为空
            file = new File(outputDir + "/" + subDir);
        }
        if(!file.exists()){
            if(!file.getParentFile().exists())
                file.getParentFile().mkdirs();
            file.mkdirs();
        }
    }

    /**
     * 解析txt删除第一行字段
     * @param fileName
     *
     */
    public static void removeFirstLine(String fileName) throws IOException {

        RandomAccessFile raf = new RandomAccessFile(fileName, "rw");


        long writePosition = raf.getFilePointer();

        raf.readLine();



        long readPosition = raf.getFilePointer();

        byte[] buff = new byte[1024];

        int n;

        while (-1 != (n = raf.read(buff))) {

            raf.seek(writePosition);

            raf.write(buff, 0, n);

            readPosition += n;

            writePosition += n;

            raf.seek(readPosition);

        }

        raf.setLength(writePosition);

        raf.close();

    }



}

package com.fyg.common.constants;

public final class Constants {

    /**
     * code码
     */
    public static final class Code {
        /**
         * 成功 success
         */
        public static final String SUCCESS = "00";
        /**
         * 参数不正确
         */
        public static final String PARAM_INVALID = "01";

        /**
         * 文件下载
         */
        public static final String FILE_DOWNLOAD_FILE = "96";

        /**
         * 上传文件超过限制
         */
        public static final String FILE_UPLOAD_FILE_MAX = "97";
        /**
         * 文件上传
         */
        public static final String FILE_UPLOAD = "98";
        /**
         * 系统异常
         */
        public static final String UNKNOW_ERROR = "99";

        /**
         * 未登录不通过
         */
        public static final String NO_LOGIN = "02";

        /**
         * 数据重复
         */
        public static final String DATA_REPEAT = "03";
    }

    /**
     * code 码提示信息
     */
    public static final class Message {
        /**
         * 成功 success（00）
         */
        public static final String SUCCESS = "success";
        /**
         * 上传文件超过限制
         */
        public static final String FILE_UPLOAD_FILE_MAX = "upload file is failed, %s";

        /**
         * 下载文件错误
         */
        public static final String FILE_DOWNLOAD_FILE = "download file is failed, %s";

        /**
         * 文件上传错误（98）
         */
        public static final String FILE_UPLOAD = "The file cannot be empty, please contact the administrator!";
        /**
         * 错误信息（99）
         */
        public static final String UNKNOW_ERROR = "system problem, please contact administrator!";

        /**
         * 未登录提示信息（02）
         */
        public static final String NO_LOGIN = "未登录或登录已超时，请登录!!!";


        /**
         * 数据重复
         */
        public static final String DATA_REPEAT = "该数据已存在，请勿重复提交！";

    }

    /**
     * 系统常量
     */
    public static final class System {
        /**
         * /
         */
        public static final String SLANT = "/";
        /**
         * \
         */
        public static final String UNSLANT = "\\";
        /**
         * ,
         */
        public static final String COMMA = ",";
        /**
         * 空字符串（""）empty
         */
        public static final String EMPTY = "";
        /**
         * " "
         */
        public static final String SPACE = " ";
        /**
         * .
         */
        public static final String SPOT = ".";
        /**
         * :
         */
        public static final String COLON = ":";
        /**
         * （string *）
         */
        public static final String ASTERISK = "*";
        /**
         * （string ?）
         */
        public static final String ASK = "?";
        /**
         * -
         */
        public static final String TRANSVERSE = "-";
        /**
         * ;
         */
        public static final String SEMICOLON = ";";
        /**
         * |
         */
        public static final String STRAIGHT = "|";
        /**
         * _
         */
        public static final String UNDERLINE = "_";
        /**
         * UTF-8
         */
        public static final String UTF8 = "UTF-8";
        /**
         * GBK
         */
        public static final String GBK = "GBK";
        /**
         * ISO-8859-1
         */
        public static final String ISO88591 = "ISO-8859-1";
        /**
         * url 地址参数连接符（&）
         */
        public static final String AND = "&";
        /**
         * 等于（=）
         */
        public static final String EQUAL = "=";
        /**
         * 艾特（@）
         */
        public static final String AT = "@";
    }

    public static final class ID {
        /**
         * 用户ID前缀
         */
        public static final String ID_USER = "USER";
        /**
         * 角色ID前缀
         */
        public static final String ID_ROLE = "ROLE";
        /**
         * 菜单ID前缀
         */
        public static final String ID_MENU = "MENU";
        /**
         * 附件ID前缀
         */
        public static final String ID_FILE = "FILE";

    }

    public static final class Web {
        /**
         * 登录类型（随机码）
         */
        public static final String LOGIN_TYPE_CODE = "code";
        /**
         * 登录类型（密码）
         */
        public static final String LOGIN_TYPE_PASSWORD = "password";
        /**
         * 电话
         */
        public static final String PHONE = "phone";
        /**
         * 邮箱
         */
        public static final String EMAIL = "email";

        /**
         * web端
         */
        private static final String PROJECT = "web";

        /**
         * 在线用户
         */
        public static final String ONLINE_USER = "online.user";

        /**
         * 令牌
         */
        public static final String TOKEN = "TOKEN";

        /**
         * 用户登录session key
         */
        public static final String SESSION_USER = PROJECT + ".manager.session.user";

    }


    /**
     * redis key
     */
    public static final class Redis {
        /**
         * 所有配置项
         */
        public static final String CONFIG_ALL = Web.PROJECT + ":db:config:";
        /**
         * 检测是否登录的例外地址配置
         */
        public static final String REQUEST_CONFIG = CONFIG_ALL + "page.login.notcheck";

        /**
         * 用户
         */
        public static final String USER_USER = Web.PROJECT + ":login:user:user:";
        /**
         * 用户、角色
         */
        public static final String USER_ROLE = Web.PROJECT + ":login:user:role:";

        /**
         * 角色
         */
        public static final String ROLE_ROLE = Web.PROJECT + ":login:role:role:";

        /**
         * 角色、菜单
         */
        public static final String ROLE_MENU = Web.PROJECT + ":login:role:menu:";

        /**
         * 菜单
         */
        public static final String MENU_MENU = Web.PROJECT + ":login:menu:menu:";

        /**
         * 组织
         */
        public static final String ORGAN_ORGAN = Web.PROJECT + ":login:organ:organ:";

        /**
         * 组织、角色
         */
        public static final String ORGAN_ROLE = Web.PROJECT + ":login:organ:role:";

        /**
         * 令牌
         */
        public static final String TOKEN = Web.PROJECT + ":token:";

    }

    public static final class OpsLogType {

        /**
         * 添加
         */
        public static final String ADD = "ADD";

        /**
         * 修改
         */
        public static final String UPDATE = "UPDATE";

        /**
         * 删除
         */
        public static final String DELETE = "DELETE";

        /**
         * 查询
         */
        public static final String SELECT = "SELECT";

        /**
         * 设置
         */
        public static final String SET = "SET";

        /**
         * 重置
         */
        public static final String RESET = "RESET";

        /**
         * 停用
         */
        public static final String STOP = "STOP";

        /**
         * 上传
         */
        public static final String UPLOAD = "UPLOAD";

        /**
         * 下载
         */
        public static final String DOWNLOAD = "DOWNLOAD";

        /**
         * 登陆
         */
        public static final String LOGIN = "LOGIN";

        /**
         * 退出
         */
        public static final String LOGINOUT = "LOGINOUT";
    }

}

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。

File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

File 类提供了如下三种形式构造方法。

1. File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文名，则该 File 对象表示的是文件。

2. File(String path, String name)：path 是路径名，name 是文件名。

3. File(File dir, String name)：dir 是路径对象，name 是文件名。

Java IO流是既可以从中读取，也可以写入到其中的数据流。正如这个系列教程之前提到过的，流通常会与数据源、数据流向目的地相关联，比如文件、网络等等。

流和数组不一样，不能通过索引读写数据。在流中，你也不能像数组那样前后移动读取数据，除非使用RandomAccessFile 处理文件。流仅仅只是一个连续的数据流。

某些类似PushbackInputStream 流的实现允许你将数据重新推回到流中，以便重新读取。然而你只能把有限的数据推回流中，并且你不能像操作数组那样随意读取数据。流中的数据只能够顺序访问。

Java IO流通常是基于字节或者基于字符的。字节流通常以“stream”命名，比如InputStream和OutputStream。除了DataInputStream 和DataOutputStream 还能够读写int, long, float和double类型的值以外，其他流在一个操作时间内只能读取或者写入一个原始字节。

字符流通常以“Reader”或者“Writer”命名。字符流能够读写字符(比如Latin1或者Unicode字符)。可以浏览Java Readers and Writers获取更多关于字符流输入输出的信息。

InputStream

java.io.InputStream类是所有Java IO输入流的基类。如果你正在开发一个从流中读取数据的组件，请尝试用InputStream替代任何它的子类(比如FileInputStream)进行开发。这么做能够让你的代码兼容任何类型而非某种确定类型的输入流。

然而仅仅依靠InputStream并不总是可行。如果你需要将读过的数据推回到流中，你必须使用PushbackInputStream，这意味着你的流变量只能是这个类型，否则在代码中就不能调用PushbackInputStream的unread()方法。

通常使用输入流中的read()方法读取数据。read()方法返回一个整数，代表了读取到的字节的内容(译者注：0 ~ 255)。当达到流末尾没有更多数据可以读取的时候，read()方法返回-1。