Better initial sizing of HashMaps

`HashMap` has default load factor of 0.75. It is often not enough to
specify desired initial capacity in order for the map to not resize.

This commit adds a helper method to create `HashMap` that will not
resize.

Author: lutovich

driver/src/main/java/org/neo4j/driver/internal/Bookmark.java

@@ -19,7 +19,6 @@
 package org.neo4j.driver.internal;
 
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Objects;
@@ -28,6 +27,7 @@
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.singleton;
+import static org.neo4j.driver.internal.util.Iterables.newHashMapWithSize;
 import static org.neo4j.driver.v1.Values.value;
 
 public final class Bookmark
@@ -93,7 +93,7 @@ public Map<String,Value> asBeginTransactionParameters()
         // {bookmarks: ["one", "two", "max"]} for backwards compatibility reasons. Old servers can only accept single
         // bookmark that is why driver has to parse and compare given list of bookmarks. This functionality will
         // eventually be removed.
-        Map<String,Value> parameters = new HashMap<>( 4 );
+        Map<String,Value> parameters = newHashMapWithSize( 2 );
         parameters.put( BOOKMARK_KEY, value( maxValue ) );
         parameters.put( BOOKMARKS_KEY, value( values ) );
         return parameters;

driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java

@@ -21,7 +21,7 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
+import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -73,8 +73,6 @@ public class PackStreamMessageFormatV1 implements MessageFormat
 
     public static final int NODE_FIELDS = 3;
 
-    private static final Map<String,Value> EMPTY_STRING_VALUE_MAP = new HashMap<>( 0 );
-
     @Override
     public MessageFormat.Writer newWriter( PackOutput output, boolean byteArraySupportEnabled )
     {
@@ -543,7 +541,7 @@ private InternalNode unpackNode() throws IOException
                 labels.add( unpacker.unpackString() );
             }
             int numProps = (int) unpacker.unpackMapHeader();
-            Map<String,Value> props = new HashMap<>();
+            Map<String,Value> props = Iterables.newHashMapWithSize( numProps );
             for ( int j = 0; j < numProps; j++ )
             {
                 String key = unpacker.unpackString();
@@ -636,9 +634,9 @@ private Map<String,Value> unpackMap() throws IOException
             int size = (int) unpacker.unpackMapHeader();
             if ( size == 0 )
             {
-                return EMPTY_STRING_VALUE_MAP;
+                return Collections.emptyMap();
             }
-            Map<String,Value> map = new HashMap<>( size );
+            Map<String,Value> map = Iterables.newHashMapWithSize( size );
             for ( int i = 0; i < size; i++ )
             {
                 String key = unpacker.unpackString();

driver/src/main/java/org/neo4j/driver/internal/util/Iterables.java

@@ -29,6 +29,8 @@
 
 public class Iterables
 {
+    private static final float DEFAULT_HASH_MAP_LOAD_FACTOR = 0.75F;
+
     public static int count( Iterable<?> it )
     {
         if ( it instanceof Collection ) { return ((Collection) it).size(); }
@@ -68,7 +70,7 @@ public static <T> T single( Iterable<T> it )
 
     public static Map<String, String> map( String ... alternatingKeyValue )
     {
-        Map<String, String> out = new HashMap<>();
+        Map<String,String> out = newHashMapWithSize( alternatingKeyValue.length / 2 );
         for ( int i = 0; i < alternatingKeyValue.length; i+=2 )
         {
             out.put( alternatingKeyValue[i], alternatingKeyValue[i+1] );
@@ -107,4 +109,22 @@ public void remove()
             }
         };
     }
+
+    public static <K, V> HashMap<K,V> newHashMapWithSize( int expectedSize )
+    {
+        return new HashMap<>( hashMapCapacity( expectedSize ) );
+    }
+
+    private static int hashMapCapacity( int expectedSize )
+    {
+        if ( expectedSize < 3 )
+        {
+            if ( expectedSize < 0 )
+            {
+                throw new IllegalArgumentException( "Illegal map size: " + expectedSize );
+            }
+            return expectedSize + 1;
+        }
+        return (int) ((float) expectedSize / DEFAULT_HASH_MAP_LOAD_FACTOR + 1.0F);
+    }
 }

driver/src/main/java/org/neo4j/driver/v1/Statement.java

@@ -18,15 +18,15 @@
  */
 package org.neo4j.driver.v1;
 
-import java.util.HashMap;
 import java.util.Map;
 
 import org.neo4j.driver.v1.summary.ResultSummary;
 import org.neo4j.driver.v1.util.Immutable;
 
 import static java.lang.String.format;
-import static org.neo4j.driver.v1.Values.value;
+import static org.neo4j.driver.internal.util.Iterables.newHashMapWithSize;
 import static org.neo4j.driver.v1.Values.ofValue;
+import static org.neo4j.driver.v1.Values.value;
 
 /**
  * An executable statement, i.e. the statements' text and its parameters.
@@ -136,7 +136,7 @@ public Statement withUpdatedParameters( Value updates )
         }
         else
         {
-            Map<String, Value> newParameters = new HashMap<>( Math.max( parameters.size(), updates.size() ) );
+            Map<String,Value> newParameters = newHashMapWithSize( Math.max( parameters.size(), updates.size() ) );
             newParameters.putAll( parameters.asMap( ofValue() ) );
             for ( Map.Entry<String, Value> entry : updates.asMap( ofValue() ).entrySet() )
             {

driver/src/main/java/org/neo4j/driver/v1/Values.java

@@ -44,6 +44,8 @@
 import org.neo4j.driver.v1.types.TypeSystem;
 import org.neo4j.driver.v1.util.Function;
 
+import static org.neo4j.driver.internal.util.Iterables.newHashMapWithSize;
+
 /**
  * Utility for wrapping regular Java types and exposing them as {@link Value}
  * objects, and vice versa.
@@ -247,7 +249,7 @@ public static Value value( final boolean val )
 
     public static Value value( final Map<String,Object> val )
     {
-        Map<String,Value> asValues = new HashMap<>( val.size() );
+        Map<String,Value> asValues = newHashMapWithSize( val.size() );
         for ( Map.Entry<String,Object> entry : val.entrySet() )
         {
             asValues.put( entry.getKey(), value( entry.getValue() ) );
@@ -284,7 +286,7 @@ public static Value parameters( Object... keysAndValues )
                                        "alternating key and value. Arguments were: " +
                                        Arrays.toString( keysAndValues ) + "." );
         }
-        HashMap<String,Value> map = new HashMap<>( keysAndValues.length / 2 );
+        HashMap<String,Value> map = newHashMapWithSize( keysAndValues.length / 2 );
         for ( int i = 0; i < keysAndValues.length; i += 2 )
         {
             Object value = keysAndValues[i + 1];

driver/src/test/java/org/neo4j/driver/internal/util/IterablesTest.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed 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.neo4j.driver.internal.util;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+public class IterablesTest
+{
+    @Test
+    public void shouldCreateHashMapWithExpectedSize()
+    {
+        assertNotNull( Iterables.newHashMapWithSize( 42 ) );
+    }
+
+    @Test
+    public void shouldThrowWhenNegativeHashMapSizeGiven()
+    {
+        try
+        {
+            Iterables.newHashMapWithSize( -42 );
+            fail( "Exception expected" );
+        }
+        catch ( IllegalArgumentException ignore )
+        {
+        }
+    }
+}