Given an array of desired String in the order of their creation. Since two strings cannot be equal replace it versioning them

Given an array of desired String in the order of their creation. Since two strings cannot be equal , the one which comes later will have an addition to its name in a form of (k), where k is the smallest positive integer such that the obtained name is not used yet.

static String[] fileNaming(String[] names) {
List<String> newNames = new ArrayList<String>();
LinkedHashMap<String, Integer> wordCount = new LinkedHashMap<String, Integer>();
Arrays.asList(names).stream().forEach(x -> {
String str = x;
if (wordCount.containsKey(x)) {
str = x + "(" + String.valueOf(wordCount.get(x)) + ")";
wordCount.merge(x, 1, Integer::sum);
wordCount.merge(str, 1, Integer::sum);
} else {
wordCount.put(x, 1);
}
newNames.add(str);
System.out.println(wordCount);
});
return newNames.toArray(new String[names.length]);
}

Testing this code against two string[]'s

Arrays.toString(fileNaming(new String[] { "doc", "doc",
"image", "doc(1)", "doc" }))
Arrays.toString(
fileNaming(new String[] { "a(1)", "a(6)", "a", "a", "a", "a", "a", "a", "a", "a", "a", "a" }))

The desired output for both of them should be

["doc", "doc(1)", "image", "doc(1)(1)", "doc(2)"].
["a(1)", "a(6)",  "a",  "a(2)",  "a(3)",  "a(4)", "a(5)",  "a(7)",  "a(8)",  "a(9)",  "a(10)", "a(11)"]

With the given code I was able to match the first output correctly. But for the second one I am getting

[a(1), a(6), a, a(1), a(2), a(3), a(4), a(5), a(6), a(7), a(8), a(9)]

Here we can see that a(1) and a(6) are being repeated. For which I have put a check but still no getting the desired output.

The problem is that you aren't checking your new files to see if they are already present. I think it can work like this:

static String[] fileNaming(String[] names) {
List<String> newNames = new ArrayList<String>();
var usedNames = new HashSet<String>();
Arrays.asList(names).stream().forEach(x -> {
int retries = 0;
var uniqueName = x;
while (!usedNames.add(uniqueName)) {
uniqueName = x + "(" + ++retries + ")";
}
newNames.add(uniqueName);
System.out.println(wordCount);
});
return newNames.toArray(new String[names.length]);
}

If you have a lot of copies of the same string, this will be slower than your original code...but it is simpler and it works, so it has that going for it! You could tweak this code to be faster in that case but it probably isn't worth it (unless you know you'll get lots of copies of your strings).

Edit: Oh heck, here's the O(n) version:

static String[] fileNaming(String[] names) {
List<String> newNames = new ArrayList<String>();
var usedNames = new HashSet<String>();
var counts = new HashMap<String, Integer>();
Arrays.asList(names).stream().forEach(x -> {
int retries = counts.getOrDefault(x, 0);
var uniqueName = x;
while (!usedNames.add(uniqueName)) {
uniqueName = x + "(" + ++retries + ")";
}
newNames.add(uniqueName);
counts.put(x, retries);
System.out.println(wordCount);
});
return newNames.toArray(new String[names.length]);
}