Fix sizing of Maps

kilink · kilink · commit 8b937fb7fa16 · 2025-08-12T13:37:26.000-07:00
Fix several instances where Maps were sized incorrectly when the number of
elements to insert is known; specifying the capacity without taking into
account the load factor meant it would always result in a rehash / resize
operation.

To this end, add a simple Maps utility class that handles the capacity
calculation, much like the static HashMap.newHashMap helper that was added in JDK19.
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/ThreadContextTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/ThreadContextTest.java
@@ -22,10 +22,10 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.Map;
 import org.apache.logging.log4j.test.ThreadContextUtilityClass;
 import org.apache.logging.log4j.test.junit.UsingAnyThreadContext;
+import org.apache.logging.log4j.util.internal.Maps;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 
@@ -115,7 +115,7 @@ void testPutAll() {
         assertTrue(ThreadContext.isEmpty());
         assertFalse(ThreadContext.containsKey("key"));
         final int mapSize = 10;
-        final Map<String, String> newMap = new HashMap<>(mapSize);
+        final Map<String, String> newMap = Maps.newHashMap(mapSize);
         for (int i = 1; i <= mapSize; i++) {
             newMap.put("key" + i, "value" + i);
         }
diff --git a/log4j-api-test/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextMapTest.java b/log4j-api-test/src/test/java/org/apache/logging/log4j/spi/DefaultThreadContextMapTest.java
@@ -20,11 +20,11 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
 import org.apache.logging.log4j.test.junit.UsingThreadContextMap;
 import org.apache.logging.log4j.test.spi.ThreadContextMapSuite;
+import org.apache.logging.log4j.util.internal.Maps;
 import org.apache.logging.log4j.util.PropertiesUtil;
 import org.junit.jupiter.api.Test;
 
@@ -56,7 +56,7 @@ void testPutAll() {
         assertTrue(map.isEmpty());
         assertFalse(map.containsKey("key"));
         final int mapSize = 10;
-        final Map<String, String> newMap = new HashMap<>(mapSize);
+        final Map<String, String> newMap = Maps.newHashMap(mapSize);
         for (int i = 1; i <= mapSize; i++) {
             newMap.put("key" + i, "value" + i);
         }
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/CloseableThreadContext.java b/log4j-api/src/main/java/org/apache/logging/log4j/CloseableThreadContext.java
@@ -20,6 +20,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.apache.logging.log4j.util.internal.Maps;
 
 /**
  * Adds entries to the {@link ThreadContext stack or map} and them removes them when the object is closed, e.g. as part
@@ -206,7 +207,7 @@ public void close() {
         }
 
         private void closeMap() {
-            final Map<String, String> valuesToReplace = new HashMap<>(originalValues.size());
+            final Map<String, String> valuesToReplace = Maps.newHashMap(originalValues.size());
             final List<String> keysToRemove = new ArrayList<>(originalValues.size());
             for (final Map.Entry<String, String> entry : originalValues.entrySet()) {
                 final String key = entry.getKey();
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/message/ThreadDumpMessage.java b/log4j-api/src/main/java/org/apache/logging/log4j/message/ThreadDumpMessage.java
@@ -24,12 +24,12 @@
 import java.io.InvalidObjectException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.ServiceLoader;
 import org.apache.logging.log4j.message.ThreadDumpMessage.ThreadInfoFactory;
 import org.apache.logging.log4j.status.StatusLogger;
 import org.apache.logging.log4j.util.Lazy;
+import org.apache.logging.log4j.util.internal.Maps;
 import org.apache.logging.log4j.util.ServiceLoaderUtil;
 import org.apache.logging.log4j.util.StringBuilderFormattable;
 import org.apache.logging.log4j.util.Strings;
@@ -176,7 +176,7 @@ private static class BasicThreadInfoFactory implements ThreadInfoFactory {
         @Override
         public Map<ThreadInformation, StackTraceElement[]> createThreadInfo() {
             final Map<Thread, StackTraceElement[]> map = Thread.getAllStackTraces();
-            final Map<ThreadInformation, StackTraceElement[]> threads = new HashMap<>(map.size());
+            final Map<ThreadInformation, StackTraceElement[]> threads = Maps.newHashMap(map.size());
             for (final Map.Entry<Thread, StackTraceElement[]> entry : map.entrySet()) {
                 threads.put(new BasicThreadInformation(entry.getKey()), entry.getValue());
             }
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/util/SortedArrayStringMap.java b/log4j-api/src/main/java/org/apache/logging/log4j/util/SortedArrayStringMap.java
@@ -21,9 +21,10 @@
 import java.io.Serializable;
 import java.util.Arrays;
 import java.util.ConcurrentModificationException;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
+
+import org.apache.logging.log4j.util.internal.Maps;
 import org.apache.logging.log4j.util.internal.SerializationUtil;
 
 /**
@@ -152,7 +153,7 @@ public boolean containsKey(final String key) {
 
     @Override
     public Map<String, String> toMap() {
-        final Map<String, String> result = new HashMap<>(size());
+        final Map<String, String> result = Maps.newHashMap(size());
         for (int i = 0; i < size(); i++) {
             final Object value = getValueAt(i);
             result.put(getKeyAt(i), value == null ? null : String.valueOf(value));
diff --git a/log4j-api/src/main/java/org/apache/logging/log4j/util/internal/Maps.java b/log4j-api/src/main/java/org/apache/logging/log4j/util/internal/Maps.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.logging.log4j.util.internal;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+
+public final class Maps {
+    private Maps() {}
+
+    /**
+     * Calculate initial capacity from expected size and default load factor (0.75).
+     */
+    private static int calculateCapacity(int numMappings) {
+        return (int) Math.ceil(numMappings / 0.75d);
+    }
+
+    /**
+     * Creates a new, empty HashMap suitable for the expected number of mappings.
+     * The returned map is large enough so that the expected number of mappings can be
+     * added without resizing the map.
+     *
+     * This is essentially a backport of HashMap.newHashMap which was added in JDK19.
+     */
+    public static <K, V> HashMap<K, V> newHashMap(int numMappings) {
+        return new HashMap<>(calculateCapacity(numMappings));
+    }
+
+    /**
+     * Creates a new, empty LinkedHashMap suitable for the expected number of mappings.
+     * The returned map is large enough so that the expected number of mappings can be
+     * added without resizing the map.
+     *
+     * This is essentially a backport of LinkedHashMap.newLinkedHashMap which was added in JDK19.
+     */
+    public static <K, V> LinkedHashMap<K, V> newLinkedHashMap(int numMappings) {
+        return new LinkedHashMap<>(calculateCapacity(numMappings));
+    }
+}
diff --git a/log4j-core-test/src/test/java/org/apache/logging/log4j/core/context/internal/GarbageFreeSortedArrayThreadContextMapTest.java b/log4j-core-test/src/test/java/org/apache/logging/log4j/core/context/internal/GarbageFreeSortedArrayThreadContextMapTest.java
@@ -20,9 +20,10 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
+
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.spi.ThreadContextMap;
 import org.apache.logging.log4j.test.spi.ThreadContextMapSuite;
 import org.apache.logging.log4j.util.PropertiesUtil;
@@ -52,7 +53,7 @@ void testPutAll() {
         assertTrue(map.isEmpty());
         assertFalse(map.containsKey("key"));
         final int mapSize = 10;
-        final Map<String, String> newMap = new HashMap<>(mapSize);
+        final Map<String, String> newMap = Maps.newHashMap(mapSize);
         for (int i = 1; i <= mapSize; i++) {
             newMap.put("key" + i, "value" + i);
         }
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AppenderSet.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AppenderSet.java
@@ -16,7 +16,6 @@
  */
 package org.apache.logging.log4j.core.appender;
 
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.apache.logging.log4j.core.Appender;
@@ -28,6 +27,7 @@
 import org.apache.logging.log4j.core.config.plugins.PluginConfiguration;
 import org.apache.logging.log4j.core.config.plugins.PluginNode;
 import org.apache.logging.log4j.core.config.plugins.validation.constraints.Required;
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.status.StatusLogger;
 
 /**
@@ -60,7 +60,7 @@ public AppenderSet build() {
                 LOGGER.error("No children node in AppenderSet {}", this);
                 return null;
             }
-            final Map<String, Node> map = new HashMap<>(children.size());
+            final Map<String, Node> map = Maps.newHashMap(children.size());
             for (final Node childNode : children) {
                 final String key = childNode.getAttributes().get("name");
                 if (key == null) {
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/rewrite/LoggerNameLevelRewritePolicy.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/rewrite/LoggerNameLevelRewritePolicy.java
@@ -18,7 +18,6 @@
 
 import static org.apache.logging.log4j.util.Strings.toRootUpperCase;
 
-import java.util.HashMap;
 import java.util.Map;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.core.Core;
@@ -29,6 +28,7 @@
 import org.apache.logging.log4j.core.config.plugins.PluginFactory;
 import org.apache.logging.log4j.core.impl.Log4jLogEvent;
 import org.apache.logging.log4j.core.util.KeyValuePair;
+import org.apache.logging.log4j.core.util.internal.Maps;
 
 /**
  * Rewrites log event levels for a given logger name.
@@ -45,11 +45,9 @@ public class LoggerNameLevelRewritePolicy implements RewritePolicy {
     /**
      * Creates a policy to rewrite levels for a given logger name.
      *
-     * @param loggerNamePrefix
-     *        The logger name prefix for events to rewrite; all event logger names that start with this string will be
-     *        rewritten.
-     * @param levelPairs
-     *        The levels to rewrite, the key is the source level, the value the target level.
+     * @param loggerNamePrefix The logger name prefix for events to rewrite; all event logger names that start with this string will be
+     *                         rewritten.
+     * @param levelPairs       The levels to rewrite, the key is the source level, the value the target level.
      * @return a new LoggerNameLevelRewritePolicy
      */
     @PluginFactory
@@ -58,7 +56,7 @@ public static LoggerNameLevelRewritePolicy createPolicy(
             @PluginAttribute("logger") final String loggerNamePrefix,
             @PluginElement("KeyValuePair") final KeyValuePair[] levelPairs) {
         // @formatter:on
-        final Map<Level, Level> newMap = new HashMap<>(levelPairs.length);
+        final Map<Level, Level> newMap = Maps.newHashMap(levelPairs.length);
         for (final KeyValuePair keyValuePair : levelPairs) {
             newMap.put(getLevel(keyValuePair.getKey()), getLevel(keyValuePair.getValue()));
         }
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/rewrite/PropertiesRewritePolicy.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/rewrite/PropertiesRewritePolicy.java
@@ -17,7 +17,6 @@
 package org.apache.logging.log4j.core.appender.rewrite;
 
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.apache.logging.log4j.Logger;
@@ -31,6 +30,7 @@
 import org.apache.logging.log4j.core.config.plugins.PluginFactory;
 import org.apache.logging.log4j.core.impl.ContextDataFactory;
 import org.apache.logging.log4j.core.impl.Log4jLogEvent;
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.status.StatusLogger;
 import org.apache.logging.log4j.util.StringMap;
 
@@ -55,7 +55,7 @@ public final class PropertiesRewritePolicy implements RewritePolicy {
 
     private PropertiesRewritePolicy(final Configuration config, final List<Property> props) {
         this.config = config;
-        this.properties = new HashMap<>(props.size());
+        this.properties = Maps.newHashMap(props.size());
         for (final Property property : props) {
             final Boolean interpolate = Boolean.valueOf(property.getValue().contains("${"));
             properties.put(property, interpolate);
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/filter/MapFilter.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/filter/MapFilter.java
@@ -32,6 +32,7 @@
 import org.apache.logging.log4j.core.config.plugins.PluginElement;
 import org.apache.logging.log4j.core.config.plugins.PluginFactory;
 import org.apache.logging.log4j.core.util.KeyValuePair;
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.message.MapMessage;
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.util.IndexedReadOnlyStringMap;
@@ -286,7 +287,7 @@ protected boolean isAnd() {
     /** @deprecated  use {@link #getStringMap()} instead */
     @Deprecated
     protected Map<String, List<String>> getMap() {
-        final Map<String, List<String>> result = new HashMap<>(map.size());
+        final Map<String, List<String>> result = Maps.newHashMap(map.size());
         map.forEach((key, value) -> result.put(key, (List<String>) value));
         return result;
     }
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/jackson/ListOfMapEntryDeserializer.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/jackson/ListOfMapEntryDeserializer.java
@@ -21,6 +21,8 @@
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import org.apache.logging.log4j.core.util.internal.Maps;
+
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.List;
@@ -46,7 +48,7 @@ public Map<String, String> deserialize(final JsonParser jp, final Deserializatio
                 new TypeReference<List<MapEntry>>() {
                     // empty
                 });
-        final HashMap<String, String> map = new HashMap<>(list.size());
+        final HashMap<String, String> map = Maps.newHashMap(list.size());
         for (final MapEntry mapEntry : list) {
             map.put(mapEntry.getKey(), mapEntry.getValue());
         }
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/AbstractJacksonLayout.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/AbstractJacksonLayout.java
@@ -27,7 +27,6 @@
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.charset.Charset;
-import java.util.LinkedHashMap;
 import java.util.Map;
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.Marker;
@@ -42,6 +41,7 @@
 import org.apache.logging.log4j.core.time.Instant;
 import org.apache.logging.log4j.core.util.KeyValuePair;
 import org.apache.logging.log4j.core.util.StringBuilderWriter;
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.util.ReadOnlyStringMap;
 import org.apache.logging.log4j.util.Strings;
@@ -356,7 +356,7 @@ protected Object wrapLogEvent(final LogEvent event) {
 
     private Map<String, String> resolveAdditionalFields(final LogEvent logEvent) {
         // Note: LinkedHashMap retains order
-        final Map<String, String> additionalFieldsMap = new LinkedHashMap<>(additionalFields.length);
+        final Map<String, String> additionalFieldsMap = Maps.newLinkedHashMap(additionalFields.length);
         final StrSubstitutor strSubstitutor = configuration.getStrSubstitutor();
 
         // Go over each field
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/Rfc5424Layout.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/layout/Rfc5424Layout.java
@@ -51,6 +51,7 @@
 import org.apache.logging.log4j.core.pattern.ThrowablePatternConverter;
 import org.apache.logging.log4j.core.util.NetUtils;
 import org.apache.logging.log4j.core.util.Patterns;
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.message.MessageCollectionMessage;
 import org.apache.logging.log4j.message.StructuredDataCollectionMessage;
@@ -219,7 +220,7 @@ private Rfc5424Layout(
 
     private Map<String, FieldFormatter> createFieldFormatters(
             final LoggerFields[] loggerFields, final Configuration config) {
-        final Map<String, FieldFormatter> sdIdMap = new HashMap<>(loggerFields == null ? 0 : loggerFields.length);
+        final Map<String, FieldFormatter> sdIdMap = Maps.newHashMap(loggerFields == null ? 0 : loggerFields.length);
         if (loggerFields != null) {
             for (final LoggerFields loggerField : loggerFields) {
                 final StructuredDataId key = loggerField.getSdId() == null ? mdcSdId : loggerField.getSdId();
@@ -908,7 +909,7 @@ public FieldFormatter(final Map<String, List<PatternFormatter>> fieldMap, final
         }
 
         public StructuredDataElement format(final LogEvent event) {
-            final Map<String, String> map = new HashMap<>(delegateMap.size());
+            final Map<String, String> map = Maps.newHashMap(delegateMap.size());
 
             for (final Map.Entry<String, List<PatternFormatter>> entry : delegateMap.entrySet()) {
                 final StringBuilder buffer = new StringBuilder();
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/lookup/MapLookup.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/lookup/MapLookup.java
@@ -16,11 +16,11 @@
  */
 package org.apache.logging.log4j.core.lookup;
 
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.apache.logging.log4j.core.LogEvent;
 import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.util.internal.Maps;
 import org.apache.logging.log4j.message.MapMessage;
 import org.apache.logging.log4j.util.Strings;
 
@@ -62,10 +62,6 @@ static Map<String, String> initMap(final String[] srcArgs, final Map<String, Str
         return destMap;
     }
 
-    static HashMap<String, String> newMap(final int initialCapacity) {
-        return new HashMap<>(initialCapacity);
-    }
-
     /**
      * An application's {@code public static main(String[])} method calls this method to make its main arguments
      * available for lookup with the prefix {@code main}.
@@ -102,14 +98,14 @@ static Map<String, String> toMap(final List<String> args) {
             return null;
         }
         final int size = args.size();
-        return initMap(args.toArray(Strings.EMPTY_ARRAY), newMap(size));
+        return initMap(args.toArray(Strings.EMPTY_ARRAY), Maps.newHashMap(size));
     }
 
     static Map<String, String> toMap(final String[] args) {
         if (args == null) {
             return null;
         }
-        return initMap(args, newMap(args.length));
+        return initMap(args, Maps.newHashMap(args.length));
     }
 
     protected Map<String, String> getMap() {
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/lookup/PropertiesLookup.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/lookup/PropertiesLookup.java
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/lookup/StrSubstitutor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/lookup/StrSubstitutor.java
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/message/ExtendedThreadInfoFactory.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/message/ExtendedThreadInfoFactory.java
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/JAnsiTextRenderer.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/pattern/JAnsiTextRenderer.java
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/util/WatchManager.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/util/WatchManager.java
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/util/internal/Maps.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/util/internal/Maps.java
diff --git a/log4j-perf-test/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashStringMap.java b/log4j-perf-test/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashStringMap.java
