How can I increment the filename if the file already exists?
Here's the code that I am using -
int num = 0;
String save = at.getText().toString() + ".jpg";
File file = new File(myDir, save);
if (file.exists()) {
save = at.getText().toString() + num + ".jpg";
file = new File(myDir, save);
num++;
}
This code works, but only two files are saved, like file.jpg and file2.jpg.
This problem is to always initialize num = 0, so if file exists, it saves file0.jpg and does not check whether file0.jpg exists.
So, to code work. You should check until it is available:
int num = 0;
String save = at.getText().toString() + ".jpg";
File file = new File(myDir, save);
while(file.exists()) {
save = at.getText().toString() + (num++) + ".jpg";
file = new File(myDir, save);
}
Try this:
File file = new File(myDir, at.getText().toString() + ".jpg");
for (int num = 0; file.exists(); num++) {
file = new File(myDir, at.getText().toString() + num + ".jpg");
}
// Now save/use your file here
In addition to the first answer, I made some more changes:
private File getUniqueFileName(String folderName, String searchedFilename) {
int num = 1;
String extension = getExtension(searchedFilename);
String filename = searchedFilename.substring(0, searchedFilename.lastIndexOf("."));
File file = new File(folderName, searchedFilename);
while (file.exists()) {
searchedFilename = filename + "(" + (num++) + ")" + extension;
file = new File(folderName, searchedFilename);
}
return file;
}
int i = 0;
String save = at.getText().toString();
String filename = save +".jpg";
File f = new File(filename);
while (f.exists()) {
i++;
filename =save+ Integer.toString(i)+".jpg";
f = new File(filename);
}
f.createNewFile();
You can avoid the code repetition of some of the answers here by using a do while loop
Here's an example using the newer NIO Path API introduced in Java 7
Path candidate = null;
int counter = 0;
do {
candidate = Paths.get(String.format("%s-%d",
path.toString(), ++counter));
} while (Files.exists(candidate));
Files.createFile(candidate);
Kotlin version:
private fun checkAndRenameIfExists(name: String): File {
var filename = name
val extension = "pdf"
val root = Environment.getExternalStorageDirectory().absolutePath
var file = File(root, "$filename.$extension")
var n = 0
while (file.exists()) {
n += 1
filename = "$name($n)"
file = File(root, appDirectoryName + File.separator + "$filename.$extension")
}
return file
}
Another simple logic solution to get the unique file name under a directory using Apache Commons IO using WildcardFileFilter to match the file name and get the number of exists with the given name and increment the counter.
public static String getUniqueFileName(String directory, String fileName) {
String fName = fileName.substring(0, fileName.lastIndexOf("."));
Collection<File> listFiles = FileUtils.listFiles(new File(directory), new WildcardFileFilter(fName + "*", IOCase.INSENSITIVE), DirectoryFileFilter.DIRECTORY);
if(listFiles.isEmpty()) {
return fName;
}
return fName.concat(" (" + listFiles.size() + ")");
}
This is the solution I use to handle this case. It works for folders as well as for files.
var destination = File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS), "MyFolder")
if (!destination.exists()) {
destination.mkdirs()
} else {
val numberOfFileAlreadyExist =
destination.listFiles().filter { it.name.startsWith("MyFolder") }.size
destination = File(
Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
"MyFolder(${numberOfFileAlreadyExist + 1})"
)
destination.mkdirs()
}
Having needed to solve this problem in my own code, I took Tejas Trivedi's answer, made it work like Windows when you happen to download the same file several times.
// This function will iteratively to find a unique file name to use when given a file: example (###).txt
// More or less how Windows will save a new file when one already exists: 'example.txt' becomes 'example (1).txt'.
// if example.txt already exists
private File getUniqueFileName(File file) {
File originalFile = file;
try {
while (file.exists()) {
String newFileName = file.getName();
String baseName = newFileName.substring(0, newFileName.lastIndexOf("."));
String extension = getExtension(newFileName);
Pattern pattern = Pattern.compile("( \\(\\d+\\))\\."); // Find ' (###).' in the file name, if it exists
Matcher matcher = pattern.matcher(newFileName);
String strDigits = "";
if (matcher.find()) {
baseName = baseName.substring(0, matcher.start(0)); // Remove the (###)
strDigits = matcher.group(0); // Grab the ### we'll want to increment
strDigits = strDigits.substring(strDigits.indexOf("(") + 1, strDigits.lastIndexOf(")")); // Strip off the ' (' and ').' from the match
// Increment the found digit and convert it back to a string
int count = Integer.parseInt(strDigits);
strDigits = Integer.toString(count + 1);
} else {
strDigits = "1"; // If there is no (###) match then start with 1
}
file = new File(file.getParent() + "/" + baseName + " (" + strDigits + ")" + extension); // Put the pieces back together
}
return file;
} catch (Error e) {
return originalFile; // Just overwrite the original file at this point...
}
}
private String getExtension(String name) {
return name.substring(name.lastIndexOf("."));
}
Calling getUniqueFileName(new File('/dir/example.txt') when 'example.txt' already exists while generate a new File targeting '/dir/example (1).txt' if that too exists it'll just keep incrementing number between the parentheses until a unique file is found, if an error happens, it'll just give the original file name.
I hope this helps some one needing to generate a unique file in Java on Android or another platform.
This function returns the exact new file with an increment number for all kind of extensions.
private File getFileName(File file) {
if (file.exists()) {
String newFileName = file.getName();
String simpleName = file.getName().substring(0, newFileName.indexOf("."));
String strDigit = "";
try {
simpleName = (Integer.parseInt(simpleName) + 1 + "");
File newFile = new File(file.getParent() + "/" + simpleName + getExtension(file.getName()));
return getFileName(newFile);
}
catch (Exception e){
}
for (int i=simpleName.length()-1; i>=0; i--) {
if (!Character.isDigit(simpleName.charAt(i))) {
strDigit = simpleName.substring(i + 1);
simpleName = simpleName.substring(0, i+1);
break;
}
}
if (strDigit.length() > 0) {
simpleName = simpleName + (Integer.parseInt(strDigit) + 1);
}
else {
simpleName += "1";
}
File newFile = new File(file.getParent() + "/" + simpleName + getExtension(file.getName()));
return getFileName(newFile);
}
return file;
}
private String getExtension(String name) {
return name.substring(name.lastIndexOf("."));
}
Related
I would like to create a backup backup_autoexec" + value + ".cfg of my file autoexec.cfg if it exists. If there is also already and backup then it should increase the value number. for example backup1, backup2, backup3...
public class Backup {
private int value1 = 0;
private String value;
private File file = new File("autoexec.cfg");
private boolean exists = file.exists();
private Path backup;
private Path auto = Paths.get("autoexec.cfg");
public void kopie() {
if(exists) {
while(exists) {
System.out.println("test");
value1 += 1;
value = String.valueOf(value1);
file = new File("backup_autoexec" + value + ".cfg");
backup = Paths.get("backup_autoexec" + value + ".cfg");
}
try {
Files.move(auto, backup);
}
catch (IOException f) {
f.printStackTrace();
}
}
}
}
atm it will hang into the while loop for ever and I dont know why.
You check the existence only once - for the first file. Here is a minimal working example:
int index = 1;
while (true) {
final String source = "autoexec" + index + ".txt";
if (new File(source).exists()) {
Files.copy(Paths.get(source), Paths.get(path + "\\backup_file" + index + ".txt"));
index++;
} else {
break;
}
}
it should leave the loop if no file could be found with an existing name
I'm trying to load a specific JNLP file from a Java program and get its .jar files. I've downloaded the .pack.gz files (because it uses compressing), but now I can't unpack them. I'm trying it by using the class java.util.jar.Pack200.Unpacker, but it throws an Exception with the following information:
SEVERE: null
java.io.IOException: Corrupted pack file: magic/ver = 1F8B0800/0.0 should be CAFED00D/150.7 OR CAFED00D/160.1 OR CAFED00D/170.1 OR CAFED00D/171.0
at com.sun.java.util.jar.pack.NativeUnpack.start(Native Method)
at com.sun.java.util.jar.pack.NativeUnpack.run(NativeUnpack.java:198)
at com.sun.java.util.jar.pack.NativeUnpack.run(NativeUnpack.java:247)
at com.sun.java.util.jar.pack.UnpackerImpl.unpack(UnpackerImpl.java:138)
at com.sun.java.util.jar.pack.UnpackerImpl.unpack(UnpackerImpl.java:174)
at rmiattack.Util.loadJNLP(Util.java:186)
at rmiattack.RmiAttack.debugFunction(RmiAttack.java:50)
at rmiattack.RmiAttack.main(RmiAttack.java:74)
I've looked for that error and then I tried to unpack the file with the command "unpack200" and it works. Then I tried to find the unpack200 sources in the openjdk project, but I didn't found them. So, could anyone tell me where can I find those sources to know how to use the Unpacker class?
I'm attaching the code I'm using:
public static void loadJNLP(String file, String outDir) throws IOException, ParserConfigurationException, SAXException {
byte[] encoded = Files.readAllBytes(Paths.get(file));
Document document = stringToXML(new String(encoded, Charset.defaultCharset()), false);
System.out.println(document.getElementsByTagName("title").item(0));
String baseURL = document.getElementsByTagName("jnlp").item(0).getAttributes().getNamedItem("codebase").getTextContent();
int i;
NodeList nodeList = document.getElementsByTagName("jar");
Unpacker unpacker = Pack200.newUnpacker();
SortedMap<String,String> properties = unpacker.properties();
properties.entrySet().stream().forEach((entry) -> {
System.out.println(entry.getKey() + " - " + entry.getValue());
});
for (i = 0; i < nodeList.getLength(); i++) {
//This can be threaded
NamedNodeMap attributes = nodeList.item(i).getAttributes();
String fileName = attributes.getNamedItem("href").getTextContent().replace(".jar", "") + "__V" + attributes.getNamedItem("version").getTextContent() + ".jar.pack.gz";
File packedJar = new File(outDir + '/' + fileName); //File path to download packed jar
FileUtils.copyURLToFile(new URL(baseURL + '/' + fileName), packedJar); //Download packed jar
FileOutputStream fileOutputStream = new FileOutputStream(outDir+'/'+attributes.getNamedItem("href").getTextContent()); //Save jar without version
try (JarOutputStream jarOutputStream = new JarOutputStream(fileOutputStream)) {
unpacker.unpack(packedJar, jarOutputStream);
} finally {
fileOutputStream.close();
}
packedJar.delete();
}
System.out.println("Save to " + outDir);
}
The output before the exception is this:
[title: null]
com.sun.java.util.jar.pack.class.format.error - pass
com.sun.java.util.jar.pack.default.timezone - false
com.sun.java.util.jar.pack.disable.native - false
com.sun.java.util.jar.pack.verbose - 0
pack.class.attribute.CompilationID - RUH
pack.class.attribute.SourceID - RUH
pack.code.attribute.CharacterRangeTable - NH[PHPOHIIH]
pack.code.attribute.CoverageTable - NH[PHHII]
pack.deflate.hint - keep
pack.effort - 5
pack.keep.file.order - true
pack.modification.time - keep
pack.segment.limit - -1
pack.unknown.attribute - pass
Thanks in advance.
Edit:
Thanks to #Thorbjoern comment I've solved it. I just had to uncompress files and then unpack them. File code looks like this:
public static void loadJNLP(String file, String outDir) throws IOException, ParserConfigurationException, SAXException {
byte[] encoded = Files.readAllBytes(Paths.get(file));
Document document = stringToXML(new String(encoded, Charset.defaultCharset()), false);
System.out.println(document.getElementsByTagName("title").item(0));
String baseURL = document.getElementsByTagName("jnlp").item(0).getAttributes().getNamedItem("codebase").getTextContent();
int i;
int length;
byte[] buffer = new byte[1024];
NodeList nodeList = document.getElementsByTagName("jar");
Unpacker unpacker = Pack200.newUnpacker();
for (i = 0; i < nodeList.getLength(); i++) {
//This can be threaded
NamedNodeMap attributes = nodeList.item(i).getAttributes();
String fileName = attributes.getNamedItem("href").getTextContent().replace(".jar", "") + "__V" + attributes.getNamedItem("version").getTextContent() + ".jar";
File compressedPackedIn = new File(outDir + '/' + fileName + ".pack.gz"); //File path to download compressed packed jar
FileUtils.copyURLToFile(new URL(baseURL + '/' + fileName + ".pack.gz"), compressedPackedIn); //Download packed jar
FileOutputStream uncompressedPackedOut;
try (GZIPInputStream compressed = new GZIPInputStream(new FileInputStream(outDir + '/' + fileName + ".pack.gz"))) {
uncompressedPackedOut = new FileOutputStream(outDir + '/' + fileName + ".pack");
//http://www.mkyong.com/java/how-to-decompress-file-from-gzip-file/
while ((length = compressed.read(buffer))> 0) {
uncompressedPackedOut.write(buffer, 0, length);
}
}
uncompressedPackedOut.close();
File uncompressedPackedIn = new File(outDir + '/' + fileName + ".pack");
FileOutputStream uncompressedUnpacked = new FileOutputStream(outDir + '/' + fileName);
try (JarOutputStream jarOutputStream = new JarOutputStream(uncompressedUnpacked)) {
unpacker.unpack(uncompressedPackedIn, jarOutputStream);
} finally {
uncompressedUnpacked.close();
}
compressedPackedIn.delete();
uncompressedPackedIn.delete();
}
}
building an Android app i came across the need to do some file copying. I would like a way to get new filenames in the event of a filename allready being used by adding a "(increment)" string in the filename. for example
text.txt ---> text(1).txt
The algorith should account for the following
1) if text.txt exists the new file name should NEVER be text.txt(1)
2) if text(1).txt exists then new filename should be text(2).txt not text(1)(1).txt
3) if text(1)foo.txt exists the new filename should be text(1)foo(1).txt
I've allready done the first but I'm having difficulties with the second. Regular expressions is not my strong suit!(It's not mandatory to use Regex. every approach is welcome) Some help ?
ANSWER:
combining my original code and one of the answers here I ended up with this which works very well for me in all cases regardless of file having an extension or not:
public static File getFinalNewDestinationFile(File destinationFolder, File fileToCopy){
String destFolderPath = destinationFolder.getAbsolutePath()+File.separator;
File newFile = new File(destFolderPath + fileToCopy.getName());
String filename=fileToCopy.getName();
String nameWithoutExtentionOrIncrement;
String extension = getFileExtension(filename);
if(extension!=null){
extension="."+extension;
int extInd = filename.lastIndexOf(extension);
nameWithoutExtentionOrIncrement = new StringBuilder(filename).replace(extInd, extInd+extension.length(),"").toString();
}
else{
extension="";
nameWithoutExtentionOrIncrement = filename;
}
int c=0;
int indexOfClose = nameWithoutExtentionOrIncrement.lastIndexOf(")");
int indexOfOpen = nameWithoutExtentionOrIncrement.lastIndexOf("(");
if(indexOfClose!=-1 && indexOfClose!=-1 && indexOfClose==nameWithoutExtentionOrIncrement.length()-1 && indexOfClose > indexOfOpen && indexOfOpen!=0){
String possibleNumber = nameWithoutExtentionOrIncrement.substring(indexOfOpen+1, indexOfClose);
try{
c = Integer.parseInt(possibleNumber);
nameWithoutExtentionOrIncrement=nameWithoutExtentionOrIncrement.substring(0, indexOfOpen);
}catch(Exception e){c=0;}
}
while(newFile.exists()){
c++;
String path = destFolderPath + nameWithoutExtentionOrIncrement +"(" + Integer.toString(c) + ")" + extension;
newFile = new File(path);
}
return newFile;
}
public static String getFileExtension(String filename) {
if (filename == null) { return null; }
int lastUnixPos = filename.lastIndexOf('/');
int lastWindowsPos = filename.lastIndexOf('\\');
int indexOfLastSeparator = Math.max(lastUnixPos, lastWindowsPos);
int extensionPos = filename.lastIndexOf('.');
int lastSeparator = indexOfLastSeparator;
int indexOfExtension = lastSeparator > extensionPos ? -1 : extensionPos;
int index = indexOfExtension;
if (index == -1) {
return null;
} else {
return filename.substring(index + 1).toLowerCase();
}
}
Using one regex pattern:
final static Pattern PATTERN = Pattern.compile("(.*?)(?:\\((\\d+)\\))?(\\.[^.]*)?");
String getNewName(String filename) {
if (fileExists(filename)) {
Matcher m = PATTERN.matcher(filename);
if (m.matches()) {
String prefix = m.group(1);
String last = m.group(2);
String suffix = m.group(3);
if (suffix == null) suffix = "";
int count = last != null ? Integer.parseInt(last) : 0;
do {
count++;
filename = prefix + "(" + count + ")" + suffix;
} while (fileExists(filename));
}
}
return filename;
}
The regex pattern explanation:
(.*?) a non greedy "match everything" starting at the beginning
(?:\\((\\d+)\\))? a number in parenthesis (optional)
(?:____________) - is a non capturing group
___\\(______\\)_ - matches ( and )
______(\\d+)____ - matches and captures the one or more digits
(\\.[^.]+)? a dot followed by anything but a dot (optional)
Here's one way of doing it:
String fileName;
File file = new File(fileName);
if(file.exists()) {
int dot = fileName.lastIndexOf('.'), open = fileName.lastIndexOf('('), incr;
boolean validNum = false;
if(fileName.charAt(dot-1) == ')' && open != -1){
String n = fileName.substring(open+1, dot-1);
try {
incr = Integer.parseInt(n);
validNum = true;
} catch(NumberFormatException e) {
validNum = false;
}
}
if(validNum) {
String pre = fileName.substring(0, open+1), post = fileName.substring(0, dot-1);
while(new File(pre + ++incr + post).exists());
fileName = pre + incr + post;
} else {
fileName = fileName.substring(0, dot) + "(1)" + fileName.substring(dot);
}
}
I assume a couple of things:
1) A method called fileExists(String fileName) is available. It returns true if a file with the specified name is already present in the file system.
2) There is a constant called FILE_NAME which in your example case is equal to "text".
if (!fileExists(FILE_NAME)) {
//create file with FILE_NAME.txt as name
}
int availableIndex = 1;
while (true) {
if (!fileExists(currentName)) {
//create file with FILE_NAME(availableIndex).txt
break;
}
availableIndex++;
}
I am not very sure about Android but since its a Java program, you may be able to create File object of the directory in which you want to write.
Once you have this you can see the list of file names already present inside it and other related information. Then you can decide the file name as per your above logic.
File dir = new File("<dir-path>");
if(dir.isDirectory()){
String[] files = dir.list();
for(String fileName : files){
<logic for finding filename>
}
}
If all filenames have an extenstion you could do something like this (just an example you will have to change it to work in your case):
public static void main(String[] args)
{
String test = "test(1)foo.txt";
String test1 = "test(1)foo(1).txt";
Pattern pattern = Pattern.compile("((?<=\\()\\d+(?=\\)\\.))");
Matcher matcher = pattern.matcher(test);
String fileOutput = "";
String temp = null;
int newInt = -1;
while(matcher.find())
{
temp = matcher.group(0);
}
if(temp != null)
{
newInt = Integer.parseInt(temp);
newInt++;
fileOutput = test.replaceAll("\\(\\d+\\)(?=\\.(?!.*\\.))", "(" + newInt + ")");
}
else
{
fileOutput = test;
}
System.out.println(fileOutput);
matcher = pattern.matcher(test1);
fileOutput = "";
temp = null;
while(matcher.find())
{
temp = matcher.group(0);
}
if(temp != null)
{
newInt = Integer.parseInt(temp);
newInt++;
fileOutput = test1.replaceAll("\\(\\d+\\)(?=\\.(?!.*\\.))", "(" + newInt + ")");
}
else
{
fileOutput = test1;
}
System.out.println(fileOutput);
}
Output:
test(1)foo.txt
test(1)foo(2).txt
This uses regex to look for a number in the () right before the last ..
Update
replaceAll() changed to handle case where there is a . after the first (1) in test(1).foo(1).txt.
I have been trying to get data in the file but somehow i am not able to get the data in file, any suggestion is highly appreciated.
File is created as per the requirement, but they are empty.I ahve been trying to fix it by trying various things but it doesnt seem to work.
public class Node {
#SuppressWarnings("unchecked")
public static void main(String[] args) {
// handling the argument and placing it in respective variables for
// further use
int fromNode = 0;
int toNode = 0;
String message = null;
int timeAfter = 0;
// Write a message to the respective node after particular time interval
// to the respective node after
// message example node 2 9 "message" 20 & i.e node x node y the message
// and
for (int i = 0; i < args.length; i++) {
fromNode = Integer.parseInt(args[0]);
toNode = Integer.parseInt(args[1]);
message = args[2];
timeAfter = Integer.parseInt(args[3]);
}
System.out.println("from Node :" + fromNode);
System.out.println("to Node :" + toNode);
System.out.println("message :" + message);
System.out.println("time after which :" + timeAfter);
// ******************************************************************
// opening and closing the file for required appending the content to
// those files
try {
String data = message;
File fileTo = new File(File.separator + "Users"
+ File.separator + "Desktop" + File.separator
+ "Files" + File.separator + "to" + toNode + ".txt");
File fileFrom = new File(File.separator + "Users"
+ File.separator + "Desktop" + File.separator
+ "Files" + File.separator + "from" + fromNode + ".txt");
// if file does not exists, then create it
if (!fileTo.exists()) {
fileTo.createNewFile();
}
if (!fileFrom.exists()) {
fileFrom.createNewFile();
}
// true = append file
FileWriter fileWritter = new FileWriter(fileTo.getName(), true);
BufferedWriter bufferWritter = new BufferedWriter(fileWritter);
bufferWritter.write(data);
bufferWritter.flush();
bufferWritter.close();
FileWriter fileWritterfrom = new FileWriter(fileFrom.getName(),
true);
// System.out.println("------>"+data);
BufferedWriter bufferWritterfrom = new BufferedWriter(
fileWritterfrom);
bufferWritterfrom.write(data);
bufferWritterfrom.flush();
bufferWritterfrom.close();
System.out.println("Files have been created");
} catch (IOException e) {
e.printStackTrace();
}
// ******************************************************************
I guess, the files were written, but not at the place you expected. The call fileTo.getName() just gives you the last component of the path. So you wrote to a file with name to<some number>.txt in the current directory.
Try to use just
FileWriter fileWritter = new FileWriter(fileTo, true);
This should write to the file at the full path.
Btw. it is not necessary to create the files first.
The following Java code renames files but it does not rename the way I wanted it to. I want the rename files to start from beginning in the directory to the end per the “part” numbers (not the time it was added in inside a particular directory), but it does not do so. Is there an “if” check I can put, like: if filename.contains(j) then process this?
import java.io.File;
public class RenameFile2 {
public static void main(String[] args) {
String absolutePath1 = "1 to 4";
String absolutePath2 = "6 to 9";
String absolutePath3 = "10 to 99";
String absolutePath4 = "100 to 224";
File dir1 = new File(absolutePath1);
File dir2 = new File(absolutePath2);
File dir3 = new File(absolutePath3);
File dir4 = new File(absolutePath4);
File[] filesInDir1 = dir1.listFiles();
File[] filesInDir2 = dir2.listFiles();
File[] filesInDir3 = dir3.listFiles();
File[] filesInDir4 = dir4.listFiles();
int i1 = 1;
for(File file:filesInDir1) {
String name = file.getName();
String newName = "550 00510 00" + i1 + ".pdf";
String newPath = absolutePath1 + "\\" + newName;
file.renameTo(new File(newPath));
System.out.println(name + " changed to " + newName);
i1++;
}
int i2 = 6;
for(File file:filesInDir2) {
String name = file.getName();
String newName = "550 00510 00" + i2 + ".pdf";
String newPath = absolutePath2 + "\\" + newName;
file.renameTo(new File(newPath));
System.out.println(name + " changed to " + newName);
i2++;
}
int i3 = 10;
for(File file:filesInDir3) {
String name = file.getName();
String newName = "550 00510 0" + i3 + ".pdf";
String newPath = absolutePath3 + "\\" + newName;
file.renameTo(new File(newPath));
System.out.println(name + " changed to " + newName);
i3++;
}
int i4 = 100;
//int j = 99;
for(File file:filesInDir4) {
String name = file.getName();
/* if(name.contains(j))
{
}
*/
String newName = "550 00510 " + i4 + ".pdf";
String newPath = absolutePath4 + "\\" + newName;
file.renameTo(new File(newPath));
System.out.println(name + " changed to " + newName);
i4++;
}
}
}
In the documentation for .listFiles(), it says:
There is no guarantee that the name strings in the resulting array will appear in any specific order; they are not, in particular, guaranteed to appear in alphabetical order.
You need to sort the array in the order you want to process them in a particular order.
Additional notes and suggestions:
String.contains() takes a String as an argument, not an int. You have this code commented out in your question.
Use the constructor for File to produce the new path instead of string concatenation: File newPath = new File(dir1, newName);
You need to sort the files once you list them, the listFiles() does not guarentee any order.
File[] filesInDir1 = dir1.listFiles();
Arrays.sort(filesInDir1);
You may need to implement a Comparator and call Arrays.sort(filesList, comparator) in order to have them custom sorted.
Once you have the files in sorted order, you can apply the rename logic as you wanted.
Another improvement would be, if you want to list only files with a pattern, you can filter while listing.
final String pattern = "regexpattern";
dir1.listFiles(new FilenameFilter(){
public boolean accept( File dir, String name ) {
return name.matches( pattern );
}
});