java读取文件，写入文件

朱雀 2024-03-30 17:26 198阅读 0赞

Java 中 IO 流

Java 中 IO 流分为几种?

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

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

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

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

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

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

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

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

  1. /**
  2.      * 递归读取文件夹下的 所有文件
  3.      *
  4.      * @param testFileDir 文件名或目录名
  5.      */
  6.     private static void testLoopOutAllFileName(String testFileDir) {
  7.         if (testFileDir == null) {
  8.             //因为new File(null)会空指针异常,所以要判断下
  9.             return;
  10.         }
  11.         File[] testFile = new File(testFileDir).listFiles();
  12.         if (testFile == null) {
  13.             return;
  14.         }
  15.         for (File file : testFile) {
  16.             if (file.isFile()) {
  17.                 System.out.println(file.getName());
  18.             } else if (file.isDirectory()) {
  19.                 System.out.println("-------file-------" + file.getName());
  20.                 testLoopOutAllFileName(file.getPath());
  21.             } else {
  22.                 System.out.println("文件读入有误！");
  23.             }
  24.         }
  25.     }

文件操作工具类：

  1. package com.fyg.common.util;
  3. import com.fyg.common.constants;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.tools.tar.TarEntry;
  6. import org.apache.tools.tar.TarInputStream;
  8. import java.io.*;
  9. import java.nio.charset.Charset;
  10. import java.text.DecimalFormat;
  11. import java.util.*;
  12. import java.util.zip.GZIPInputStream;
  13. import java.util.zip.ZipEntry;
  14. import java.util.zip.ZipFile;
  15. import java.util.zip.ZipInputStream;
  18. /**
  19.  * 操作文件的辅助类
  20.  *
  21.  * @author liqh
  22.  * @version 1.0
  23.  */
  24. @Slf4j
  25. public class FileUtils extends org.apache.commons.io.FileUtils {
  27.     public static final String B_UNIT = "B";
  28.     public static final String KB_UNIT = "KB";
  29.     public static final String MB_UNIT = "MB";
  30.     public static final String GB_UNIT = "GB";
  31.     public static final DecimalFormat decimalFormat = new DecimalFormat("#.0");
  33.     /**
  34.      * 创建目录
  35.      *
  36.      * @param dir
  37.      * @return
  38.      */
  39.     public static boolean createDirectory(String dir) {
  40.         if (!isExistsDirectory(dir)) {
  41.             File folder = new File(dir);
  42.             return folder.mkdirs();
  43.         }
  44.         return false;
  45.     }
  48.     /**
  49.      * 判断当前目录是否存在
  50.      *
  51.      * @param dir
  52.      * @return true:存在  false：不存在
  53.      */
  54.     public static boolean isExistsDirectory(String dir) {
  55.         File folder = new File(dir);
  56.         if (!folder.exists() && !folder.isDirectory()) {
  57.             return false;
  58.         }
  59.         return true;
  60.     }
  63.     /**
  64.      * 创建新的文件名
  65.      */
  66.     public static String renameToUUID(String fileName) {
  67.         return IDUtils.generateId32() + "." + fileName.substring(fileName.lastIndexOf(".") + 1);
  68.     }
  70.     /**
  71.      * 创建文件
  72.      *
  73.      * @param fileName
  74.      * @return true:创建成功   false:创建失败
  75.      * @throws IOException
  76.      */
  77.     public static boolean createNewFile(String fileName) throws IOException {
  78.         if (!isExistsFile(fileName)) {
  79.             File file = new File(fileName);
  80.             return file.createNewFile();
  81.         }
  82.         return false;
  83.     }
  86.     /**
  87.      * 判断当前文件是否存在
  88.      *
  89.      * @param fileName
  90.      * @return true:存在  false：不存在
  91.      */
  92.     public static boolean isExistsFile(String fileName) {
  93.         File file = new File(fileName);
  94.         return file.exists();
  95.     }
  98.     /**
  99.      * 获取某个文件夹下的所有文件,只包含文件
  100.      *
  101.      * @param dir
  102.      * @return
  103.      */
  104.     public static List<String> getFileList(String dir) {
  105.         List<String> fileNameList = new ArrayList<>();
  106.         File file = new File(dir);
  107.         File[] tempList = file.listFiles();
  108.         for (int i = 0; i < tempList.length; i++) {
  109.             if (tempList[i].isFile()) {
  110.                 fileNameList.add(tempList[i].getName());
  111.             }
  112.         }
  113.         return fileNameList;
  114.     }
  116.     /**
  117.      * 获取某个文件夹下的所有文件全路径
  118.      *
  119.      * @param dir
  120.      * @return
  121.      */
  122.     public static List<String> getAllFileAbsolute(String dir) {
  123.         List<String> fileNameList = new ArrayList<>();
  124.         return getAllFileAbsolute(dir, fileNameList);
  125.     }
  127.     /**
  128.      * 获取某个文件夹下的所有文件,包含文件夹和文件
  129.      *
  130.      * @param dir
  131.      * @return
  132.      */
  133.     public static List<String> getAllFileAbsolute(String dir, List<String> fileNameList) {
  134.         File file = new File(dir);
  135.         File[] tempList = file.listFiles();
  136.         for (int i = 0; i < tempList.length; i++) {
  137.             if (tempList[i].isFile()) {
  138.                 fileNameList.add(tempList[i].toString());
  139.             } else if (tempList[i].isDirectory()) {
  140.                 getAllFileAbsolute(tempList[i].getAbsolutePath(), fileNameList);
  141.             }
  142.         }
  143.         return fileNameList;
  144.     }
  146.     /**
  147.      * 获取某个文件夹下的所有文件,包含文件夹和文件
  148.      *
  149.      * @param dir
  150.      * @return
  151.      */
  152.     public static List<String> getAllFileName(String dir, List<String> fileNameList) {
  153.         File file = new File(dir);
  154.         File[] tempList = file.listFiles();
  155.         for (int i = 0; i < tempList.length; i++) {
  156.             if (tempList[i].isFile()) {
  157.                 fileNameList.add(tempList[i].getName());
  158.             } else if (tempList[i].isDirectory()) {
  159.                 getAllFileName(tempList[i].getAbsolutePath(), fileNameList);
  160.             }
  161.         }
  162.         return fileNameList;
  163.     }
  165.     /**
  166.      * 获取某个文件夹下的所有文件,包含文件夹和文件
  167.      *
  168.      * @param dir
  169.      * @return
  170.      */
  171.     public static List<String> getAllFileName(String dir) {
  172.         List<String> fileNameList = new ArrayList<>();
  173.         return getAllFileName(dir, fileNameList);
  174.     }
  176.     /**
  177.      * 删除文件，可以是单个文件或文件夹
  178.      *
  179.      * @param fileName 待删除的文件名
  180.      * @return 文件删除成功返回true, 否则返回false
  181.      */
  182.     public static boolean deleteFileOrDirectory(String fileName) {
  183.         File file = new File(fileName);
  184.         if (!file.exists()) {
  185.             return false;
  186.         } else {
  187.             if (file.isFile()) {
  188.                 return deleteFile(fileName);
  189.             } else {
  190.                 return deleteDirectory(fileName);
  191.             }
  192.         }
  193.     }
  195.     /**
  196.      * 删除单个文件
  197.      *
  198.      * @param fileName 被删除文件的文件名
  199.      * @return 单个文件删除成功返回true, 否则返回false
  200.      */
  201.     public static boolean deleteFile(String fileName) {
  202.         File file = new File(fileName);
  203.         if (file.isFile() && file.exists()) {
  204.             file.delete();
  205.             return true;
  206.         } else {
  207.             return false;
  208.         }
  209.     }
  212.     /**
  213.      * 删除目录（文件夹）以及目录下的文件
  214.      *
  215.      * @param dir 被删除目录的文件路径
  216.      * @return 目录删除成功返回true, 否则返回false
  217.      */
  218.     public static boolean deleteDirectory(String dir) {
  219.         //如果dir不以文件分隔符结尾，自动添加文件分隔符   
  220.         if (!dir.endsWith(File.separator)) {
  221.             dir = dir + File.separator;
  222.         }
  223.         File dirFile = new File(dir);
  224.         //如果dir对应的文件不存在，或者不是一个目录，则退出   
  225.         if (!dirFile.exists() || !dirFile.isDirectory()) {
  226.             return false;
  227.         }
  228.         boolean flag = true;
  229.         //删除文件夹下的所有文件(包括子目录)   
  230.         File[] files = dirFile.listFiles();
  231.         for (int i = 0; i < files.length; i++) {
  232.             //删除子文件   
  233.             if (files[i].isFile()) {
  234.                 flag = deleteFile(files[i].getAbsolutePath());
  235.                 if (!flag) {
  236.                     break;
  237.                 }
  238.             }
  239.             //删除子目录   
  240.             else {
  241.                 flag = deleteDirectory(files[i].getAbsolutePath());
  242.                 if (!flag) {
  243.                     break;
  244.                 }
  245.             }
  246.         }
  247.         if (!flag) {
  248.             return false;
  249.         }
  250.         //删除当前目录
  251.         if (dirFile.delete()) {
  252.             return true;
  253.         } else {
  254.             return false;
  255.         }
  256.     }
  259.     /**
  260.      * 用于上传或复制文件
  261.      *
  262.      * @param srcFile 源文件
  263.      * @param tarFile 目标文件
  264.      * @throws IOException
  265.      */
  266.     public static void copyFile(File srcFile, File tarFile) throws IOException {
  267.         InputStream inStream = new FileInputStream(srcFile);
  268.         OutputStream outStream = new FileOutputStream(tarFile);
  269.         byte[] buff = new byte[1024];
  270.         int readed = -1;
  271.         while ((readed = inStream.read(buff)) > 0) {
  272.             outStream.write(buff, 0, readed);
  273.         }
  274.         outStream.flush();
  275.         inStream.close();
  276.         outStream.close();
  277.     }
  280.     /**
  281.      * 文件的移动
  282.      *
  283.      * @param srcFile 源文件
  284.      * @param tarFile 目标文件
  285.      * @return
  286.      */
  287.     public static boolean moveTotherFolders(File srcFile, File tarFile) {
  289.         return srcFile.renameTo(tarFile);
  290.     }
  293.     /**
  294.      * 将文件的byte数组转换成目标文件
  295.      *
  296.      * @param srcByte 源文件数组
  297.      * @param tarFile 目标文件
  298.      * @throws IOException
  299.      */
  300.     public static File convertToFile(byte[] srcByte, File tarFile) throws IOException {
  301.         //将字节转换成文件
  302.         OutputStream outStream = new FileOutputStream(tarFile);
  303.         outStream.write(srcByte);
  304.         outStream.flush();
  305.         outStream.close();
  307.         return tarFile;
  308.     }
  310.     /**
  311.      * 将文件的byte数组转换成目标文件
  312.      *
  313.      * @param inStream 源文件数组
  314.      * @param tarFile  目标文件
  315.      * @throws IOException
  316.      */
  317.     public static File convertToFile(InputStream inStream, File tarFile) throws IOException {
  318.         if (inStream == null) return null;
  320.         //将字节转换成文件
  321.         OutputStream outStream = new FileOutputStream(tarFile);
  323.         byte[] buff = new byte[1024];
  324.         int readed = -1;
  325.         while ((readed = inStream.read(buff)) > 0) {
  326.             outStream.write(buff, 0, readed);
  327.         }
  328.         outStream.flush();
  329.         inStream.close();
  330.         outStream.close();
  332.         return tarFile;
  333.     }
  336.     /**
  337.      * 将文件转换成byte数组的形式
  338.      *
  339.      * @param srcFile 目标文件
  340.      * @return byte数组
  341.      * @throws IOException
  342.      */
  343.     public static byte[] converToByte(File srcFile) throws IOException {
  344.         byte[] content = null;
  346.         //转换成byte数组
  347.         InputStream inStream = new FileInputStream(srcFile);
  348.         if (inStream != null) {
  349.             content = new byte[inStream.available()];
  350.             inStream.read(content);
  351.             inStream.close();
  352.         }
  354.         return content;
  355.     }
  357.     /**
  358.      * 将文件转换成byte数组的形式
  359.      *
  360.      * @param inStream 目标文件
  361.      * @return byte数组
  362.      * @throws IOException
  363.      */
  364.     public static byte[] converToByte(InputStream inStream) throws IOException {
  365.         byte[] content = null;
  366.         //转换成byte数组
  367.         if (inStream != null) {
  368.             content = new byte[inStream.available()];
  369.             inStream.read(content);
  370.             inStream.close();
  371.         }
  372.         return content;
  373.     }
  376.     /**
  377.      * 重命名文件
  378.      *
  379.      * @param fileName
  380.      * @return
  381.      */
  382.     public static File renameFile(String filePath, String fileName) {
  383.         filePath = filePath.endsWith(Constants.System.SLANT) ? filePath : filePath + Constants.System.SLANT;
  384.         String oldFileName = filePath + fileName;
  385.         File oldFile = new File(oldFileName);
  386.         String newFileName = DateUtils.getCurrentTimestamp(DateUtils.DATETIME_17) + fileName;
  387.         String newFilePath = filePath + newFileName;
  388.         File newFile = new File(newFilePath);
  389.         if (oldFile.exists() && oldFile.isFile()) {
  390.             oldFile.renameTo(newFile);
  391.         }
  392.         return newFile;
  393.     }
  396.     /**
  397.      * 重命名文件
  398.      *
  399.      * @param sourFile 源文件
  400.      * @param tarFile  目标文件
  401.      * @return
  402.      */
  403.     public static File renameFile(File sourFile, File tarFile) {
  404.         sourFile.renameTo(tarFile);
  405.         return tarFile;
  406.     }
  409.     /**
  410.      * 多个斜杠转成一个斜杠
  411.      *
  412.      * @param path
  413.      * @return
  414.      */
  415.     public static String transformPath(String path) {
  416.         String regex = "/+";
  417.         String regex1 = "\\+";
  418.         return path.replaceAll(regex, "/").replaceAll(regex1, "/");
  419.     }
  421.     /**
  422.      * 删除超时的文件
  423.      *
  424.      * @param tarFile
  425.      * @param aLong
  426.      */
  427.     public static void deleteTimeoutFiles(File tarFile, Long aLong) {
  428.         File[] files = tarFile.listFiles();
  429.         Arrays.stream(files).forEach(file -> {
  430.             Long ftime = file.lastModified();
  431.             if (ftime < aLong) {
  432.                 deleteFile(file.getAbsolutePath());
  433.             }
  434.         });
  435.     }
  437.     /**
  438.      * 将传入的二进制数组，获取文件头部对应的二进制信息
  439.      *
  440.      * @param src 二进制数组
  441.      * @return 二进制信息
  442.      * @throws Exception
  443.      */
  444.     public static String bytesToHexString(byte[] src) throws Exception {
  445.         StringBuilder stringBuilder = new StringBuilder();
  446.         if (src == null || src.length <= 0) {
  447.             return null;
  448.         }
  449.         for (int i = 0; i < src.length; i++) {
  450.             int v = src[i] & 0xFF;
  451.             String hv = Integer.toHexString(v);
  452.             if (hv.length() < 2) {
  453.                 stringBuilder.append(0);
  454.             }
  455.             stringBuilder.append(hv);
  456.         }
  457.         return stringBuilder.toString();
  458.     }
  461.     /**
  462.      * 根据传入的文件取得对应的文件类型
  463.      *
  464.      * @param file 文件对应的信息
  465.      * @return 文件类型
  466.      */
  467.     public static String[] getFileType(File file) throws Exception {
  468.         return getFileType(getFileContent(file));
  469.     }
  472.     /**
  473.      * 根据传入的文件流取得对应的文件类型
  474.      *
  475.      * @param is 文件流
  476.      * @return 文件类型
  477.      */
  478.     public static String[] getFileType(InputStream is) throws Exception {
  479.         return getFileType(getFileContent(is));
  480.     }
  482.     /**
  483.      * 根据文件字节取得对应的文件类型
  484.      *
  485.      * @param srcByte 文件字节
  486.      * @return 文件类型
  487.      */
  488.     public static String[] getFileType(byte[] srcByte) throws Exception {
  489.         return getFileType(getFileContent(srcByte));
  490.     }
  492.     /**
  493.      * 根据传入的头部二进制信息获取文件类型
  494.      *
  495.      * @param fileContent 头部二进制信息
  496.      * @return 文件类型
  497.      * @throws Exception
  498.      */
  499.     public static String[] getFileType(String fileContent) throws Exception {
  500.         //取得文件头对应的二进制数组
  501.         Map<String, String[]> map = getFileSuffixMap();
  502.         String[] fileType = null;
  503.         //便利文件取得对应的文件类型
  504.         if (fileContent != null) {
  505.             for (String key : map.keySet()) {
  506.                 if (fileContent.toLowerCase().startsWith(key.toLowerCase())) {
  507.                     fileType = map.get(key);
  508.                     break;
  509.                 }
  510.             }
  511.         }
  512.         return fileType;
  513.     }
  515.     /**
  516.      * 根据传入的文件取得文件头部的二进制信息
  517.      *
  518.      * @param file 文件类型
  519.      * @return 二进制信息
  520.      * @throws Exception
  521.      */
  522.     public static String getFileContent(File file) throws Exception {
  523.         return getFileContent(new FileInputStream(file));
  524.     }
  526.     /**
  527.      * 从流中读出前28位字节，再得到文件头信息
  528.      *
  529.      * @param is InputStream对象
  530.      * @return 文件头2进制数组
  531.      * @throws IOException
  532.      */
  533.     public static String getFileContent(InputStream is) throws Exception {
  534.         byte[] b = new byte[28];
  535.         try {
  536.             //取得28位文件头
  537.             is.read(b, 0, 28);
  538.         } catch (Exception e) {
  539.             e.printStackTrace();
  540.         } finally {
  541.             try {
  542.                 if (is != null) is.close();
  543.             } catch (Exception e) {
  544.                 e.printStackTrace();
  545.             }
  546.         }
  548.         return getFileContent(b);
  549.     }
  551.     /**
  552.      * 截取二进制数组的前28位,在获得对应的文件头二进制数组信息
  553.      *
  554.      * @param srcByte 传入的二进制数组
  555.      * @return 文件头二进制数组信息
  556.      * @throws Exception
  557.      */
  558.     private static String getFileContent(byte[] srcByte) throws Exception {
  559.         String content = null;
  560.         if (srcByte != null && srcByte.length > 0) {
  561.             //如果二进制文件的长度大于28位，则截取前28位
  562.             byte[] b = new byte[28];
  563.             if (srcByte.length > 28) System.arraycopy(srcByte, 0, b, 0, 28);
  564.             else b = srcByte;
  565.             //取得后最文件
  566.             content = bytesToHexString(b);
  567.         }
  568.         return content;
  569.     }
  571.     /**
  572.      * 取得文件后缀对应的字符串，前4个组成的文件头
  573.      *
  574.      * @return 文件头对应的后缀
  575.      */
  576.     public static Map<String, String[]> getFileSuffixMap() {
  577.         //设置接收参数对应的MAP
  578.         Map<String, String[]> map = new HashMap<String, String[]>();
  580.         //设置对应的值
  581.         map.put("FFD8FF", new String[]{"JPEG"});
  582.         map.put("89504E47", new String[]{"PNG"});
  583.         map.put("47494638", new String[]{"GIF"});
  584.         map.put("49492A00", new String[]{"TIFF"});
  585.         map.put("424D", new String[]{"BMP"});
  586.         map.put("41433130", new String[]{"DWG"});
  587.         map.put("38425053", new String[]{"PSD"});
  588.         map.put("7B5C727466", new String[]{"RTF"});
  589.         map.put("3C3F786D6C", new String[]{"XML"});
  590.         map.put("68746D6C3E", new String[]{"HTML"});
  591.         map.put("44656C69766572792D646174653A", new String[]{"EML"});
  592.         map.put("CFAD12FEC5FD746F", new String[]{"DBX"});
  593.         map.put("2142444E", new String[]{"PST"});
  594.         map.put("D0CF11E0", new String[]{"XLS", "DOC"});
  595.         map.put("5374616E64617264204A", new String[]{"MDB"});
  596.         map.put("FF575043", new String[]{"WPD"});
  597.         map.put("252150532D41646F6265", new String[]{"EPS"});
  598.         map.put("255044462D312E", new String[]{"PDF"});
  599.         map.put("AC9EBD8F", new String[]{"QDF"});
  600.         map.put("E3828596", new String[]{"PWL"});
  601.         map.put("504B0", new String[]{"XLSX", "ZIP"});
  602.         map.put("52617221", new String[]{"RAR"});
  603.         map.put("57415645", new String[]{"WAV"});
  604.         map.put("41564920", new String[]{"AVI"});
  605.         map.put("2E7261FD", new String[]{"RAM"});
  606.         map.put("2E524D46", new String[]{"RM"});
  607.         map.put("000001BA", new String[]{"MPG"});
  608.         map.put("6D6F6F76", new String[]{"MOV"});
  609.         map.put("3026B2758E66CF11", new String[]{"ASF"});
  610.         map.put("4D546864", new String[]{"MID"});
  611.         map.put("494433", new String[]{"MP3"});
  612.         map.put("61646661647366", new String[]{"TXT"});
  613.         map.put("202f2a2a", new String[]{"TXT"});
  614.         return map;
  615.     }
  618.     /**
  619.      * 解析txt文档
  620.      *
  621.      * @param txtFile txt文件
  622.      * @return
  623.      */
  624.     public static List<List<String>> parseTxt(String txtFile, String separator) {
  625.         if (txtFile == null) {
  626.             return null;
  627.         }
  628.         List<List<String>> data = new ArrayList<List<String>>();
  629.         try {
  630.             BufferedReader buffReader = null;
  631.             FileInputStream fi = new FileInputStream(txtFile);
  632.             String carSet = getTxtFileCharSet(new File(txtFile));
  633.             System.out.println(carSet);
  634.             if ("Unicode".equals(carSet)) {
  635.                 buffReader = new BufferedReader(new InputStreamReader(fi, "UTF-16"));
  636.             } else if ("Unicode big endian".equals(carSet)) {
  637.                 buffReader = new BufferedReader(new InputStreamReader(fi, "UTF-16LE"));
  638.             } else {
  639.                 buffReader = new BufferedReader(new InputStreamReader(fi, "UTF-8"));
  640.             }
  641.             System.out.println(Charset.defaultCharset().name());
  642.             String line = "";
  643.             while (buffReader.ready()) {
  644.                 line = buffReader.readLine();
  645.                 if (StringUtils.isBlank(line)) continue;
  646.                 String[] chars = line.split(separator);
  647.                 List<String> innerData = new ArrayList<String>();
  648.                 for (String charactor : chars) {
  649.                     if (StringUtils.isNotBlank(charactor)) {
  650.                         if ("UTF-8 + BOM".equals(carSet)) {
  651.                             charactor = new String(charactor.getBytes(Charset.defaultCharset().name()), "UTF-8");
  652.                             charactor = charactor.indexOf("?") == 0 ? charactor.substring(1) : charactor;
  653.                         }
  654.                     }
  655.                     innerData.add(charactor);
  656.                 }
  657.                 data.add(innerData);
  658.             }
  659.             if (buffReader != null) {
  660.                 buffReader.close();
  661.                 buffReader = null;
  662.             }
  663.             if (fi != null) {
  664.                 fi.close();
  665.                 fi = null;
  666.             }
  667.         } catch (Exception e) {
  668.             e.printStackTrace();
  669.         }
  670.         return data;
  671.     }
  674.     /**
  675.      * 查看文件编码
  676.      *
  677.      * @param file
  678.      * @return
  679.      */
  680.     public static String getTxtFileCharSet(File file) {
  681.         try {
  682.             return getTxtFileCharSet(new FileInputStream(file));
  683.         } catch (FileNotFoundException e) {
  684.             e.printStackTrace();
  685.             return "";
  686.         }
  687.     }
  689.     /**
  690.      * 查看TXT文件编码
  691.      *
  692.      * @param inputStream
  693.      * @return
  694.      */
  695.     public static String getTxtFileCharSet(InputStream inputStream) {
  696.         String carSet = "ANSI";
  697.         try {
  698.             byte[] fileHead = new byte[3];
  699.             inputStream.read(fileHead);
  700.             if (-17 == fileHead[0] && -69 == fileHead[1] && -65 == fileHead[2]) {
  701.                 carSet = "UTF-8 + BOM";
  702.             } else if (49 == fileHead[0] && 51 == fileHead[1] && 49 == fileHead[2]) {
  703.                 carSet = "UTF-8";
  704.             } else if (-1 == fileHead[0] && -2 == fileHead[1]) {
  705.                 carSet = "Unicode";
  706.             } else if (-2 == fileHead[0] && -1 == fileHead[1]) {
  707.                 carSet = "Unicode big endian";
  708.             }
  709.         } catch (Exception e) {
  710.             e.printStackTrace();
  711.         } finally {
  712.             if (inputStream != null) {
  713.                 try {
  714.                     inputStream.close();
  715.                     inputStream = null;
  716.                 } catch (IOException e) {
  717.                     e.printStackTrace();
  718.                 }
  719.             }
  720.         }
  721.         return carSet;
  722.     }
  725.     /**
  726.      * 写入Txt
  727.      *
  728.      * @param path
  729.      * @param txt
  730.      * @throws IOException
  731.      */
  732.     public static boolean writeFile(String path, String txt) {
  733.         // 相对路径，如果没有则要建立一个新的path文件
  734.         File file = new File(path);
  735.         try {
  736.             // 创建新文件
  737.             createNewFile(file.getAbsolutePath());
  738.             // 字符缓冲输出流：写东西到该文件
  739.             BufferedWriter out = new BufferedWriter(new FileWriter(file));
  740.             // 写东西：\r\n即为换行
  741.             out.write(txt);
  742.             // 把缓存区内容压入文件
  743.             out.flush();
  744.             // 最后关闭流
  745.             out.close();
  746.             //返回成功
  747.             return true;
  748.         } catch (IOException e) {
  749.             e.printStackTrace();
  750.             return false;
  751.         }
  752.     }
  755.     /**
  756.      * 描述： 获取格式化的文件大小
  757.      * 格式为带单位保留一位小数
  758.      *
  759.      * @param size
  760.      * @return
  761.      */
  762.     public static String getFormatSize(double size) {
  763.         String fileSizeString = "";
  764.         if (size < 1024) {
  765.             fileSizeString = decimalFormat.format(size) + B_UNIT;
  766.         } else if (size < 1048576) {
  767.             fileSizeString = decimalFormat.format(size / 1024) + KB_UNIT;
  768.         } else if (size < 1073741824) {
  769.             fileSizeString = decimalFormat.format(size / 1048576) + MB_UNIT;
  770.         } else {
  771.             fileSizeString = decimalFormat.format(size / 1073741824) + GB_UNIT;
  772.         }
  773.         return fileSizeString;
  774.     }
  776.     /**
  777.      * 获取文件大小
  778.      *
  779.      * @param size
  780.      * @return
  781.      */
  782.     public static String getFormatSize(long size) {
  783.         return getFormatSize((double) size);
  784.     }
  786.     /**
  787.      * 传文件全路径，解压gz文件到当前文件夹
  788.      *
  789.      * @param fileUrl
  790.      * @return
  791.      */
  792.     public static String unGzFile(String fileUrl) {
  793.         String errMess="";
  794.         GZIPInputStream in = null;
  795.         try {
  796.             in = new GZIPInputStream(new FileInputStream(fileUrl));
  797.         } catch(FileNotFoundException e) {
  798.             log.info("File not found. " + fileUrl);
  799.             errMess=e.getMessage();
  800.         } catch (IOException e) {
  801.             e.printStackTrace();
  802.             errMess=e.getMessage();
  803.         }
  804.         String gzFileNameAndUrl = getGzFileNameAndUrl(fileUrl);
  806.         FileOutputStream out = null;
  807.         try {
  808.             out = new FileOutputStream(gzFileNameAndUrl);
  809.         } catch (FileNotFoundException e) {
  810.             log.info("Could not write to file. " + gzFileNameAndUrl);
  811.             errMess=e.getMessage();
  812.         }
  813.         log.info("文件路径=========" + gzFileNameAndUrl);
  814.         try {
  815.             byte[] buf = new byte[1024];
  816.             int len;
  817.             while((len = in.read(buf)) > 0) {
  818.                 out.write(buf, 0, len);
  819.             }
  820.             in.close();
  821.             out.close();
  822.             deleteFileOrDirectory(fileUrl);
  823.         } catch (IOException e) {
  824.             e.printStackTrace();
  825.             errMess=e.getMessage();
  826.         }
  827.         return errMess;
  828.     }
  830.     /**
  831.      * 传文件全路径，解压zip文件到当前文件夹
  832.      *
  833.      * @param filePath
  834.      * @return
  835.      */
  836.     public static String unzipFile(String filePath) {
  837.         String errMess="";
  838.         String zipDir = filePath.substring(0,filePath.lastIndexOf("/") + 1);
  839.         String name = "";
  840.         try {
  841.             BufferedOutputStream dest = null;
  842.             BufferedInputStream is = null;
  843.             ZipEntry entry;
  844.             ZipFile zipfile = new ZipFile(filePath, Charset.forName("GBK"));
  846.             Enumeration dir = zipfile.entries();
  847.             while (dir.hasMoreElements()){
  848.                 entry = (ZipEntry) dir.nextElement();
  850.                 if( entry.isDirectory()){
  851.                     name = entry.getName();
  852.                     name = name.substring(0, name.length() - 1);
  853.                     File fileObject = new File(zipDir + name);
  854.                     fileObject.mkdir();
  855.                 }
  856.             }
  858.             Enumeration e = zipfile.entries();
  859.             while (e.hasMoreElements()) {
  860.                 entry = (ZipEntry) e.nextElement();
  861.                 if( entry.isDirectory()){
  862.                     continue;
  863.                 }else{
  864.                     is = new BufferedInputStream(zipfile.getInputStream(entry));
  865.                     int count;
  866.                     byte[] dataByte = new byte[1024];
  867.                     FileOutputStream fos = new FileOutputStream(zipDir+entry.getName());
  868.                     dest = new BufferedOutputStream(fos, 1024);
  869.                     while ((count = is.read(dataByte, 0, 1024)) != -1) {
  870.                         dest.write(dataByte, 0, count);
  871.                     }
  872.                     dest.flush();
  873.                     dest.close();
  874.                     is.close();
  875.                 }
  876.             }
  878.             deleteFileOrDirectory(filePath);
  879.         } catch (Exception e) {
  880.             e.printStackTrace();
  881.             errMess=e.getMessage();
  882.         }
  884.         return errMess;
  885.     }
  887.     /**
  888.      * 传路径，找出当前路径下所有子目录以及文件
  889.      *
  890.      * @param
  891.      * @return
  892.      */
  893.     public static List<String> findUnzipAllFile(File filePath,List<String> filePaths) {
  895.         File[] files = filePath.listFiles();
  896.         if(files == null){
  897.             return filePaths;
  898.         }
  899.         for(File f:files){
  900.             if(f.isDirectory()){
  901.                 filePaths.add(f.getPath());
  902.                 findUnzipAllFile(f,filePaths);
  903.             }else{
  904.                 filePaths.add(f.getPath());
  905.             }
  906.         }
  907.         return filePaths;
  908.     }
  910.     /**
  911.      * 截取文件后缀
  912.      *
  913.      * @param
  914.      * @return
  915.      */
  916.     public static String checkFile(String filePaths) {
  917.         String hzhwjm = "";
  918.         String houZui = "";
  919.         int i =filePaths.lastIndexOf("/");
  920.         if (i > 0 &&  i < filePaths.length() - 1) {
  921.             hzhwjm = filePaths.substring(i + 1);
  922.         }
  923.         int j =hzhwjm.lastIndexOf(".");
  924.         if (j > 0 &&  j < hzhwjm.length() - 1) {
  925.             houZui = hzhwjm.substring( j+ 1);
  926.         }
  927.         if(houZui.equals("gz")||houZui.equals("GZ")){
  928.             if(j>3){
  929.                 if(hzhwjm.substring(j - 3).equals("tar.gz")||hzhwjm.substring(j - 3).equals("TAR.GZ")){
  930.                     houZui=hzhwjm.substring(j - 3);
  931.                 }
  932.             }
  933.         }
  934.         return houZui;
  935.     }
  937.     public static String getGzFileNameAndUrl(String f) {
  938.         String fname = "";
  939.         int i = f.lastIndexOf('.');
  941.         if (i > 0 &&  i < f.length() - 1) {
  942.             fname = f.substring(0,i);
  943.         }
  946.         return fname;
  947.     }
  948.     /**
  949.      * 压缩文件通过文件全路径截取文件名
  950.      *
  951.      * @param
  952.      * @return
  953.      */
  954.     public static String getFileNameByAllUrl(String fileAllUrl) {
  955.         String fName = "";
  956.         int i = fileAllUrl.lastIndexOf('/');
  958.         if (i > 0 &&  i < fileAllUrl.length() - 1) {
  959.             fName = fileAllUrl.substring(i+1);
  960.         }
  961.         return fName;
  963.     }
  964.     /**
  965.      * 压缩文件通过文件全路径截取文件路径
  966.      *
  967.      * @param
  968.      * @return
  969.      */
  970.     public static String getFileUrlByAllUrl(String fileAllUrl) {
  971.         String fUrl = "";
  972.         int i = fileAllUrl.lastIndexOf('/');
  974.         if (i > 0 &&  i < fileAllUrl.length() - 1) {
  975.             fUrl = fileAllUrl.substring(0,i+1);
  976.         }
  977.         return fUrl;
  978.     }
  980.     /**
  981.      * 解压tar.gz 传文件全路径
  982.      * @param filePath
  983.      *
  984.      */
  985.     public static String unTarGz(String filePath) throws IOException{
  986.         String outputDir = filePath.substring(0,filePath.lastIndexOf("/") + 1);
  987.         String errMess="";
  988.         File file = new File(filePath);
  989.         TarInputStream tarIn = null;
  990.         try{
  991.             tarIn = new TarInputStream(new GZIPInputStream(
  992.                     new BufferedInputStream(new FileInputStream(file))),
  993.                     1024 * 2);
  995.             createDirectory(outputDir,null);//创建输出目录
  997.             TarEntry entry = null;
  998.             while( (entry = tarIn.getNextEntry()) != null ){
  1000.                 if(entry.isDirectory()){//是目录
  1001.                     entry.getName();
  1002.                     createDirectory(outputDir,entry.getName());//创建空目录
  1003.                 }else{//是文件
  1004.                     File tmpFile = new File(outputDir + "/" + entry.getName());
  1005.                     createDirectory(tmpFile.getParent() + "/",null);//创建输出目录
  1006.                     OutputStream out = null;
  1007.                     try{
  1008.                         out = new FileOutputStream(tmpFile);
  1009.                         int length = 0;
  1011.                         byte[] b = new byte[2048];
  1013.                         while((length = tarIn.read(b)) != -1){
  1014.                             out.write(b, 0, length);
  1015.                         }
  1017.                     }catch(IOException ex){
  1018.                         errMess=ex.getMessage();
  1019.                         throw ex;
  1020.                     }finally{
  1021.                         if(out!=null)
  1022.                             out.close();
  1023.                     }
  1024.                 }
  1025.             }
  1026.         }catch(IOException ex){
  1027.             errMess=ex.getMessage();
  1028.             throw new IOException("解压归档文件出现异常",ex);
  1029.         } finally{
  1030.             try{
  1031.                 if(tarIn != null){
  1032.                     tarIn.close();
  1033.                 }
  1034.             }catch(IOException ex){
  1035.                 errMess=ex.getMessage();
  1036.                 throw new IOException("关闭tarFile出现异常",ex);
  1037.             }
  1038.         }
  1039.         deleteFileOrDirectory(filePath);
  1040.         return errMess;
  1041.     }
  1043.     /**
  1044.      * 构建目录
  1045.      * @param outputDir
  1046.      * @param subDir
  1047.      */
  1048.     public static void createDirectory(String outputDir,String subDir){
  1049.         File file = new File(outputDir);
  1050.         if(!(subDir == null || subDir.trim().equals(""))){//子目录不为空
  1051.             file = new File(outputDir + "/" + subDir);
  1052.         }
  1053.         if(!file.exists()){
  1054.             if(!file.getParentFile().exists())
  1055.                 file.getParentFile().mkdirs();
  1056.             file.mkdirs();
  1057.         }
  1058.     }
  1060.     /**
  1061.      * 解析txt删除第一行字段
  1062.      * @param fileName
  1063.      *
  1064.      */
  1065.     public static void removeFirstLine(String fileName) throws IOException {
  1067.         RandomAccessFile raf = new RandomAccessFile(fileName, "rw");
  1070.         long writePosition = raf.getFilePointer();
  1072.         raf.readLine();
  1076.         long readPosition = raf.getFilePointer();
  1078.         byte[] buff = new byte[1024];
  1080.         int n;
  1082.         while (-1 != (n = raf.read(buff))) {
  1084.             raf.seek(writePosition);
  1086.             raf.write(buff, 0, n);
  1088.             readPosition += n;
  1090.             writePosition += n;
  1092.             raf.seek(readPosition);
  1094.         }
  1096.         raf.setLength(writePosition);
  1098.         raf.close();
  1100.     }
  1104. }
  1106. package com.fyg.common.constants;
  1108. public final class Constants {
  1110.     /**
  1111.      * code码
  1112.      */
  1113.     public static final class Code {
  1114.         /**
  1115.          * 成功 success
  1116.          */
  1117.         public static final String SUCCESS = "00";
  1118.         /**
  1119.          * 参数不正确
  1120.          */
  1121.         public static final String PARAM_INVALID = "01";
  1123.         /**
  1124.          * 文件下载
  1125.          */
  1126.         public static final String FILE_DOWNLOAD_FILE = "96";
  1128.         /**
  1129.          * 上传文件超过限制
  1130.          */
  1131.         public static final String FILE_UPLOAD_FILE_MAX = "97";
  1132.         /**
  1133.          * 文件上传
  1134.          */
  1135.         public static final String FILE_UPLOAD = "98";
  1136.         /**
  1137.          * 系统异常
  1138.          */
  1139.         public static final String UNKNOW_ERROR = "99";
  1141.         /**
  1142.          * 未登录不通过
  1143.          */
  1144.         public static final String NO_LOGIN = "02";
  1146.         /**
  1147.          * 数据重复
  1148.          */
  1149.         public static final String DATA_REPEAT = "03";
  1150.     }
  1152.     /**
  1153.      * code 码提示信息
  1154.      */
  1155.     public static final class Message {
  1156.         /**
  1157.          * 成功 success（00）
  1158.          */
  1159.         public static final String SUCCESS = "success";
  1160.         /**
  1161.          * 上传文件超过限制
  1162.          */
  1163.         public static final String FILE_UPLOAD_FILE_MAX = "upload file is failed, %s";
  1165.         /**
  1166.          * 下载文件错误
  1167.          */
  1168.         public static final String FILE_DOWNLOAD_FILE = "download file is failed, %s";
  1170.         /**
  1171.          * 文件上传错误（98）
  1172.          */
  1173.         public static final String FILE_UPLOAD = "The file cannot be empty, please contact the administrator!";
  1174.         /**
  1175.          * 错误信息（99）
  1176.          */
  1177.         public static final String UNKNOW_ERROR = "system problem, please contact administrator!";
  1179.         /**
  1180.          * 未登录提示信息（02）
  1181.          */
  1182.         public static final String NO_LOGIN = "未登录或登录已超时，请登录!!!";
  1185.         /**
  1186.          * 数据重复
  1187.          */
  1188.         public static final String DATA_REPEAT = "该数据已存在，请勿重复提交！";
  1190.     }
  1192.     /**
  1193.      * 系统常量
  1194.      */
  1195.     public static final class System {
  1196.         /**
  1197.          * /
  1198.          */
  1199.         public static final String SLANT = "/";
  1200.         /**
  1201.          * \
  1202.          */
  1203.         public static final String UNSLANT = "\\";
  1204.         /**
  1205.          * ,
  1206.          */
  1207.         public static final String COMMA = ",";
  1208.         /**
  1209.          * 空字符串（""）empty
  1210.          */
  1211.         public static final String EMPTY = "";
  1212.         /**
  1213.          * " "
  1214.          */
  1215.         public static final String SPACE = " ";
  1216.         /**
  1217.          * .
  1218.          */
  1219.         public static final String SPOT = ".";
  1220.         /**
  1221.          * :
  1222.          */
  1223.         public static final String COLON = ":";
  1224.         /**
  1225.          * （string *）
  1226.          */
  1227.         public static final String ASTERISK = "*";
  1228.         /**
  1229.          * （string ?）
  1230.          */
  1231.         public static final String ASK = "?";
  1232.         /**
  1233.          * -
  1234.          */
  1235.         public static final String TRANSVERSE = "-";
  1236.         /**
  1237.          * ;
  1238.          */
  1239.         public static final String SEMICOLON = ";";
  1240.         /**
  1241.          * |
  1242.          */
  1243.         public static final String STRAIGHT = "|";
  1244.         /**
  1245.          * _
  1246.          */
  1247.         public static final String UNDERLINE = "_";
  1248.         /**
  1249.          * UTF-8
  1250.          */
  1251.         public static final String UTF8 = "UTF-8";
  1252.         /**
  1253.          * GBK
  1254.          */
  1255.         public static final String GBK = "GBK";
  1256.         /**
  1257.          * ISO-8859-1
  1258.          */
  1259.         public static final String ISO88591 = "ISO-8859-1";
  1260.         /**
  1261.          * url 地址参数连接符（&）
  1262.          */
  1263.         public static final String AND = "&";
  1264.         /**
  1265.          * 等于（=）
  1266.          */
  1267.         public static final String EQUAL = "=";
  1268.         /**
  1269.          * 艾特（@）
  1270.          */
  1271.         public static final String AT = "@";
  1272.     }
  1274.     public static final class ID {
  1275.         /**
  1276.          * 用户ID前缀
  1277.          */
  1278.         public static final String ID_USER = "USER";
  1279.         /**
  1280.          * 角色ID前缀
  1281.          */
  1282.         public static final String ID_ROLE = "ROLE";
  1283.         /**
  1284.          * 菜单ID前缀
  1285.          */
  1286.         public static final String ID_MENU = "MENU";
  1287.         /**
  1288.          * 附件ID前缀
  1289.          */
  1290.         public static final String ID_FILE = "FILE";
  1292.     }
  1294.     public static final class Web {
  1295.         /**
  1296.          * 登录类型（随机码）
  1297.          */
  1298.         public static final String LOGIN_TYPE_CODE = "code";
  1299.         /**
  1300.          * 登录类型（密码）
  1301.          */
  1302.         public static final String LOGIN_TYPE_PASSWORD = "password";
  1303.         /**
  1304.          * 电话
  1305.          */
  1306.         public static final String PHONE = "phone";
  1307.         /**
  1308.          * 邮箱
  1309.          */
  1310.         public static final String EMAIL = "email";
  1312.         /**
  1313.          * web端
  1314.          */
  1315.         private static final String PROJECT = "web";
  1317.         /**
  1318.          * 在线用户
  1319.          */
  1320.         public static final String ONLINE_USER = "online.user";
  1322.         /**
  1323.          * 令牌
  1324.          */
  1325.         public static final String TOKEN = "TOKEN";
  1327.         /**
  1328.          * 用户登录session key
  1329.          */
  1330.         public static final String SESSION_USER = PROJECT + ".manager.session.user";
  1332.     }
  1335.     /**
  1336.      * redis key
  1337.      */
  1338.     public static final class Redis {
  1339.         /**
  1340.          * 所有配置项
  1341.          */
  1342.         public static final String CONFIG_ALL = Web.PROJECT + ":db:config:";
  1343.         /**
  1344.          * 检测是否登录的例外地址配置
  1345.          */
  1346.         public static final String REQUEST_CONFIG = CONFIG_ALL + "page.login.notcheck";
  1348.         /**
  1349.          * 用户
  1350.          */
  1351.         public static final String USER_USER = Web.PROJECT + ":login:user:user:";
  1352.         /**
  1353.          * 用户、角色
  1354.          */
  1355.         public static final String USER_ROLE = Web.PROJECT + ":login:user:role:";
  1357.         /**
  1358.          * 角色
  1359.          */
  1360.         public static final String ROLE_ROLE = Web.PROJECT + ":login:role:role:";
  1362.         /**
  1363.          * 角色、菜单
  1364.          */
  1365.         public static final String ROLE_MENU = Web.PROJECT + ":login:role:menu:";
  1367.         /**
  1368.          * 菜单
  1369.          */
  1370.         public static final String MENU_MENU = Web.PROJECT + ":login:menu:menu:";
  1372.         /**
  1373.          * 组织
  1374.          */
  1375.         public static final String ORGAN_ORGAN = Web.PROJECT + ":login:organ:organ:";
  1377.         /**
  1378.          * 组织、角色
  1379.          */
  1380.         public static final String ORGAN_ROLE = Web.PROJECT + ":login:organ:role:";
  1382.         /**
  1383.          * 令牌
  1384.          */
  1385.         public static final String TOKEN = Web.PROJECT + ":token:";
  1387.     }
  1389.     public static final class OpsLogType {
  1391.         /**
  1392.          * 添加
  1393.          */
  1394.         public static final String ADD = "ADD";
  1396.         /**
  1397.          * 修改
  1398.          */
  1399.         public static final String UPDATE = "UPDATE";
  1401.         /**
  1402.          * 删除
  1403.          */
  1404.         public static final String DELETE = "DELETE";
  1406.         /**
  1407.          * 查询
  1408.          */
  1409.         public static final String SELECT = "SELECT";
  1411.         /**
  1412.          * 设置
  1413.          */
  1414.         public static final String SET = "SET";
  1416.         /**
  1417.          * 重置
  1418.          */
  1419.         public static final String RESET = "RESET";
  1421.         /**
  1422.          * 停用
  1423.          */
  1424.         public static final String STOP = "STOP";
  1426.         /**
  1427.          * 上传
  1428.          */
  1429.         public static final String UPLOAD = "UPLOAD";
  1431.         /**
  1432.          * 下载
  1433.          */
  1434.         public static final String DOWNLOAD = "DOWNLOAD";
  1436.         /**
  1437.          * 登陆
  1438.          */
  1439.         public static final String LOGIN = "LOGIN";
  1441.         /**
  1442.          * 退出
  1443.          */
  1444.         public static final String LOGINOUT = "LOGINOUT";
  1445.     }
  1447. }

在 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。

发表评论

表情：
评论列表 （有 0 条评论，198人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java读取文件，写入文件

    Java 中 IO 流 Java 中 IO 流分为几种? 按照流的流向分，可以分为输入流和输出流； 按照操作单元划分，可以划分为字节流和字符流； 按照流的角色划分为节点

    朱雀朱雀/ 0 赞/ 199 阅读