【java修改文件名称】

											
import org.slf4j.Logger;											
import org.slf4j.LoggerFactory;											
											
import java.io.*;											
import java.text.DecimalFormat;											
import java.text.Format;											
import java.util.*;											
import java.util.stream.Collectors;											
											
											
public class FileNameChangeMain {											
											
    private static Logger logger = LoggerFactory.getLogger(FileNameChangeMain.class);											
											
    public static void main(String[] args){											
											
        if ((args == null) || (args.length != 1)) {											
            logger.error("Illegal argument count error.");											
        }else {											
			// 取参数
            String filePath = args[0];											
            logger.info("Start! filePath:" + filePath);											
													
            try{											
                String originalPath = filePath.substring(0,filePath.lastIndexOf("\\")+1);		
                //创建一个文件类实例，抽象路径名是 targetPath									
                File targetPath = new File( originalPath + "\\out");											
                File errPath = new File( originalPath + "\\error");						
                //判断抽象路径名指定的路径或者文件是否存在					
                if(!targetPath.exists()){											
                    targetPath.mkdir();											
                }else{											
                    int delRet = deleteFile(String .valueOf(targetPath));											
                    if(delRet != 0){											
                        logger.error("delete out file is error.");											
                        return;											
                    }											
                }											
                if(!errPath.exists()){											
                    errPath.mkdir();											
                }else{											
                    int delRet = deleteFile(String .valueOf(errPath));											
                    if(delRet != 0){											
                        logger.error("delete err file is error.");											
                        return;											
                    }											
                }											
                File fileDir = new File(filePath);											
                if(!fileDir.exists()){											
                    logger.error("origin file is error.");											
                }		
                //取路径下的文件list									
                File[] files = fileDir.listFiles();											
                ArrayList<String> fileList = new ArrayList<>();											
											
                for(File originFile : files){											
                    copyFiles(originFile,targetPath,errPath,fileList);											
                }											
            }catch (Exception e){											
                logger.error("file read error. :" + filePath, e);											
            }											
            logger.info("Finish!");											
        }											
    }											
											
    public static void copyFiles(File originFile, File targetPath, File errPath, ArrayList<String> fileList) throws IOException{											
        logger.info("originFile : "+ originFile.getName());											
        String[] originNames = originFile.getName().split("\\.");							
        //String：字符串常量，字符串长度不可变。字符串变量（Synchronized，即线程安全）。
        //如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，
        //可以调用 StringBuffer 的 toString() 方法。	
        //	使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。
        //所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。		
        StringBuilder  newName = new StringBuilder();											
        String  keyName = "";											
        Format formatName = new DecimalFormat("000");											
        //											
        ArrayList<String> subList = new ArrayList<>();											
        File tagetFile = null;											
        int ret = 0;											
        if(originNames.length > 0){											
            //file name change											
            ret = check(originNames,newName);											
        }											
        if(ret == 0 && !"".equals(newName) ){											
            //查询list中符合条件的元素，对相同名字的文件顺番起名					
            subList = (ArrayList<String>) fileList.stream().filter(v -> v.toString().contains(newName)).collect(Collectors.toList());											
            int maxNum = 0;											
            for(String subName : subList){											
                int subNum = Integer.parseInt(subName.substring(subName.length()-3));											
                if(subNum > maxNum){											
                    maxNum = subNum;											
                }											
            }											
            if(maxNum == 0){											
                keyName = newName + "001";											
            }else {											
                String num = formatName.format(maxNum + 1);											
                keyName = newName + num;											
            }											
            fileList.add(keyName);											
            tagetFile = new File(targetPath,keyName);											
        }else {											
            //error file											
            tagetFile = new File(errPath,originFile.getName());											
        }											
        //创建读入流，从实际存在的文件读数据
        //创建写入流				
        FileInputStream fis = new FileInputStream(originFile);											
        FileOutputStream fos = new FileOutputStream(tagetFile);											
											
        int data;											
        while ((data = fis.read()) != -1) {											
            fos.write(data);											
            fos.flush();											
        }											
        fis.close();											
        fos.close();											
    }											
											
    public static int check(String[] originNames,StringBuilder newName){											
        int ret = 0;											
        switch (originNames.length){											
            case 5:											
                newName.append(originNames[3]);											
                newName.append("_");											
                newName.append(originNames[0]);											
                break;											
            case 7:											
                if("a".equals(originNames[originNames.length -1]) || "s".equals(originNames[originNames.length -1])){											
                    newName.append(originNames[5]);											
                    newName.append("_");											
                    newName.append(originNames[1]);											
                    newName.append(originNames[2]);											
                }else {											
                    logger.error("online filename is Error!");											
                    ret = -1;											
                }											
                break;											
            default:											
                logger.error("File Name Format is Error!");											
                ret = -1;											
                break;											
        }											
											
        return ret;											
    }											
											
    public static int deleteFile(String deletePath){											
        int ret = 0;											
        File file = new File(deletePath);											
        String[] content = file.list();											
        for (String name : content){											
            File temp = new File(deletePath, name);											
            if (temp.isDirectory()) {//判断是否是目录											
                deleteFile(temp.getAbsolutePath());//递归调用，删除目录里的内容											
                temp.delete();//删除空目录											
            } else {											
                if (!temp.delete()) {//直接删除文件											
                    ret = -1;											
                }											
            }											
        }											
        return ret;											
    }											
}