Refactor newTopics to remove nested loops (#4026)

* Refactor newTopics to remove nested loops

Replace O(n²) nested iteration with O(n) map-based lookups for filtering topics
Use topicNameToMapKey to efficiently resolve duplicate topic names
This improves application startup time and scalability when managing
a large number of topics, while preserving the original filtering logic

Resolves: #4025

* Refactor newTopics filtering with removeIf

Replace manual Iterator loop with Collection.removeIf() to improve code
readability and maintainability.

The original implementation used a while loop with Iterator to remove
entries that don't match the createOrModifyTopic predicate. While this
worked, it required more boilerplate code and was less expressive.

The new implementation uses the removeIf method introduced in Java 8,
which directly expresses the filtering operation in a single line. This
reduces method complexity and makes the code more idiomatic.

* Simplify newTopics logic to use List instead of Map

Refactored newTopics() to directly collect NewTopic and NewTopics
beans into a single List<NewTopic>, avoiding unnecessary use of Map
and bean names. TopicForRetryable instances are now removed if a
regular NewTopic with the same name exists. This simplifies the
logic and improves code readability. The final filtering is performed
using removeIf for clarity and performance.

* Refactor topic filtering in KafkaAdmin.newTopics

Merge dual removeIf operations into a single filter condition.
Rename normalNames to regularTopicNames for improved clarity.

This change optimizes performance by reducing the number of
collection iterations and improves code readability by using
clearer naming.

Signed-off-by: Choi Wang Gyu <[email protected]>

Author: cwangg897

spring-kafka/src/main/java/org/springframework/kafka/core/KafkaAdmin.java

@@ -22,12 +22,11 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -323,41 +322,27 @@ private void updateClusterId(Admin adminClient) throws InterruptedException, Exe
 	 */
 	protected Collection<NewTopic> newTopics() {
 		Assert.state(this.applicationContext != null, "'applicationContext' cannot be null");
-		Map<String, NewTopic> newTopicsMap = new HashMap<>(
-				this.applicationContext.getBeansOfType(NewTopic.class, false, false));
-		Map<String, NewTopics> wrappers = this.applicationContext.getBeansOfType(NewTopics.class, false, false);
-		AtomicInteger count = new AtomicInteger();
-		wrappers.forEach((name, newTopics) -> {
-			newTopics.getNewTopics().forEach(nt -> newTopicsMap.put(name + "#" + count.getAndIncrement(), nt));
-		});
-		Map<String, NewTopic> topicsForRetry = newTopicsMap.entrySet().stream()
-				.filter(entry -> entry.getValue() instanceof TopicForRetryable)
-				.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
-		for (Entry<String, NewTopic> entry : topicsForRetry.entrySet()) {
-			Iterator<Entry<String, NewTopic>> iterator = newTopicsMap.entrySet().iterator();
-			boolean remove = false;
-			while (iterator.hasNext()) {
-				Entry<String, NewTopic> nt = iterator.next();
-				// if we have a NewTopic and TopicForRetry with the same name, remove the latter
-				if (nt.getValue().name().equals(entry.getValue().name())
-						&& !(nt.getValue() instanceof TopicForRetryable)) {
-
-					remove = true;
-					break;
-				}
-			}
-			if (remove) {
-				newTopicsMap.remove(entry.getKey());
-			}
-		}
-		Iterator<Entry<String, NewTopic>> iterator = newTopicsMap.entrySet().iterator();
-		while (iterator.hasNext()) {
-			Entry<String, NewTopic> next = iterator.next();
-			if (!this.createOrModifyTopic.test(next.getValue())) {
-				iterator.remove();
-			}
-		}
-		return new ArrayList<>(newTopicsMap.values());
+
+		// Deal with List<NewTopic> directly instead of Map (no need for bean names)
+		List<NewTopic> newTopicsList = new ArrayList<>(
+				this.applicationContext.getBeansOfType(NewTopic.class, false, false).values());
+
+		// Add topics from NewTopics wrappers (no need for bean names either)
+		this.applicationContext.getBeansOfType(NewTopics.class, false, false).values()
+				.forEach(wrapper -> newTopicsList.addAll(wrapper.getNewTopics()));
+
+		// Collect regular topic names to check against TopicForRetryable
+		Set<String> regularTopicNames = newTopicsList.stream()
+				.filter(nt -> !(nt instanceof TopicForRetryable))
+				.map(NewTopic::name)
+				.collect(Collectors.toSet());
+
+		// Apply combined filter: remove TopicForRetryable with same name as regular topic OR topics that don't pass predicate
+		newTopicsList.removeIf(nt ->
+				(nt instanceof TopicForRetryable && regularTopicNames.contains(nt.name())) ||
+				!this.createOrModifyTopic.test(nt));
+
+		return newTopicsList;
 	}
 
 	@Override