Removing some fo the Optional.map() and .stream() for performance reasons.

bbakerman · bbakerman · commit 66d527c23b9e · 2025-04-24T14:24:25.000+10:00
diff --git a/src/main/java/graphql/GraphqlErrorHelper.java b/src/main/java/graphql/GraphqlErrorHelper.java
@@ -77,8 +77,11 @@ public static Object location(SourceLocation location) {
     }
 
     static List<GraphQLError> fromSpecification(List<Map<String, Object>> specificationMaps) {
-        return specificationMaps.stream()
-                .map(GraphqlErrorHelper::fromSpecification).collect(Collectors.toList());
+        List<GraphQLError> list = new ArrayList<>();
+        for (Map<String, Object> specificationMap : specificationMaps) {
+            list.add(fromSpecification(specificationMap));
+        }
+        return list;
     }
 
     static GraphQLError fromSpecification(Map<String, Object> specificationMap) {
diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java
@@ -180,9 +180,7 @@ private CompletableFuture<ExecutionResult> executeOperation(ExecutionContext exe
         MergedSelectionSet fields = fieldCollector.collectFields(
                 collectorParameters,
                 operationDefinition.getSelectionSet(),
-                Optional.ofNullable(executionContext.getGraphQLContext())
-                        .map(graphqlContext -> graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT))
-                        .orElse(false)
+                executionContext.hasIncrementalSupport()
         );
 
         ResultPath path = ResultPath.rootPath();
@@ -255,9 +253,7 @@ private DataLoaderDispatchStrategy createDataLoaderDispatchStrategy(ExecutionCon
             return DataLoaderDispatchStrategy.NO_OP;
         }
         if (!executionContext.isSubscriptionOperation()) {
-            boolean deferEnabled = Optional.ofNullable(executionContext.getGraphQLContext())
-                    .map(graphqlContext -> graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT))
-                    .orElse(false);
+            boolean deferEnabled = executionContext.hasIncrementalSupport();
 
             // Dedicated strategy for defer support, for safety purposes.
             return deferEnabled ?
diff --git a/src/main/java/graphql/execution/ExecutionContext.java b/src/main/java/graphql/execution/ExecutionContext.java
@@ -360,9 +360,14 @@ public ResultNodesInfo getResultNodesInfo() {
         return resultNodesInfo;
     }
 
+    @Internal
+    public boolean hasIncrementalSupport() {
+        GraphQLContext graphqlContext = getGraphQLContext();
+        return graphqlContext != null && graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT);
+    }
+
     @Internal
     public EngineRunningState getEngineRunningState() {
         return engineRunningState;
     }
-
 }
diff --git a/src/main/java/graphql/execution/ExecutionStrategy.java b/src/main/java/graphql/execution/ExecutionStrategy.java
@@ -300,9 +300,7 @@ private static Map<String, Object> buildFieldValueMap(List<String> fieldNames, L
     DeferredExecutionSupport createDeferredExecutionSupport(ExecutionContext executionContext, ExecutionStrategyParameters parameters) {
         MergedSelectionSet fields = parameters.getFields();
 
-        return Optional.ofNullable(executionContext.getGraphQLContext())
-                .map(graphqlContext -> graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT))
-                .orElse(false) ?
+        return executionContext.hasIncrementalSupport() ?
                 new DeferredExecutionSupport.DeferredExecutionSupportImpl(
                         fields,
                         parameters,
@@ -928,9 +926,7 @@ protected Object completeValueForObject(ExecutionContext executionContext, Execu
         MergedSelectionSet subFields = fieldCollector.collectFields(
                 collectorParameters,
                 parameters.getField(),
-                Optional.ofNullable(executionContext.getGraphQLContext())
-                        .map(graphqlContext -> graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT))
-                        .orElse(false)
+                executionContext.hasIncrementalSupport()
         );
 
         ExecutionStepInfo newExecutionStepInfo = executionStepInfo.changeTypeWithPreservedNonNull(resolvedObjectType);
diff --git a/src/main/java/graphql/execution/ValuesResolverConversion.java b/src/main/java/graphql/execution/ValuesResolverConversion.java
@@ -602,16 +602,17 @@ private static List externalValueToInternalValueForList(
     ) throws CoercingParseValueException, NonNullableValueCoercedAsNullException {
 
         GraphQLInputType wrappedType = (GraphQLInputType) graphQLList.getWrappedType();
-        return FpKit.toListOrSingletonList(value)
-                .stream()
-                .map(val -> externalValueToInternalValueImpl(
-                        inputInterceptor,
-                        fieldVisibility,
-                        wrappedType,
-                        val,
-                        graphqlContext,
-                        locale))
-                .collect(toList());
+        List<Object> list = new ArrayList<>();
+        for (Object val : FpKit.toListOrSingletonList(value)) {
+            list.add(externalValueToInternalValueImpl(
+                    inputInterceptor,
+                    fieldVisibility,
+                    wrappedType,
+                    val,
+                    graphqlContext,
+                    locale));
+        }
+        return list;
     }
 
     /**
diff --git a/src/main/java/graphql/execution/ValuesResolverLegacy.java b/src/main/java/graphql/execution/ValuesResolverLegacy.java
@@ -133,10 +133,10 @@ private static Value<?> handleNumberLegacy(String stringValue) {
     private static Value<?> handleListLegacy(Object value, GraphQLList type, GraphQLContext graphqlContext, Locale locale) {
         GraphQLType itemType = type.getWrappedType();
         if (FpKit.isIterable(value)) {
-            List<Value> valuesNodes = FpKit.toListOrSingletonList(value)
-                    .stream()
-                    .map(item -> valueToLiteralLegacy(item, itemType, graphqlContext, locale))
-                    .collect(toList());
+            List<Value> valuesNodes = new ArrayList<>();
+            for (Object item : FpKit.toListOrSingletonList(value)) {
+                valuesNodes.add(valueToLiteralLegacy(item, itemType, graphqlContext, locale));
+            }
             return ArrayValue.newArrayValue().values(valuesNodes).build();
         }
         return valueToLiteralLegacy(value, itemType, graphqlContext, locale);
diff --git a/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java b/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java
@@ -15,16 +15,17 @@
 import graphql.incremental.IncrementalPayload;
 import graphql.util.FpKit;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Supplier;
-import java.util.stream.Collectors;
 
 /**
  * The purpose of this class hierarchy is to encapsulate most of the logic for deferring field execution, thus
@@ -106,19 +107,22 @@ public List<String> getNonDeferredFieldNames(List<String> allFieldNames) {
 
         @Override
         public Set<IncrementalCall<? extends IncrementalPayload>> createCalls(ExecutionStrategyParameters executionStrategyParameters) {
-            return deferredExecutionToFields.keySet().stream()
-                    .map(deferredExecution -> this.createDeferredFragmentCall(deferredExecution, executionStrategyParameters))
-                    .collect(Collectors.toSet());
+            Set<IncrementalCall<? extends IncrementalPayload>> set = new HashSet<>();
+            for (DeferredExecution deferredExecution : deferredExecutionToFields.keySet()) {
+                set.add(this.createDeferredFragmentCall(deferredExecution, executionStrategyParameters));
+            }
+            return set;
         }
 
         private DeferredFragmentCall createDeferredFragmentCall(DeferredExecution deferredExecution, ExecutionStrategyParameters executionStrategyParameters) {
             DeferredCallContext deferredCallContext = new DeferredCallContext();
 
             List<MergedField> mergedFields = deferredExecutionToFields.get(deferredExecution);
 
-            List<Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>> calls = mergedFields.stream()
-                    .map(currentField -> this.createResultSupplier(currentField, deferredCallContext, executionStrategyParameters))
-                    .collect(Collectors.toList());
+            List<Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>> calls = new ArrayList<>();
+            for (MergedField currentField : mergedFields) {
+                calls.add(this.createResultSupplier(currentField, deferredCallContext, executionStrategyParameters));
+            }
 
             return new DeferredFragmentCall(
                     deferredExecution.getLabel(),
diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java
@@ -6,6 +6,7 @@
 import graphql.execution.ExecutionContext;
 import graphql.execution.ExecutionStrategyParameters;
 import graphql.execution.FieldValueInfo;
+import graphql.execution.MergedField;
 import graphql.schema.DataFetcher;
 import graphql.util.LockKit;
 import org.dataloader.DataLoaderRegistry;
@@ -195,10 +196,13 @@ public void fieldFetched(ExecutionContext executionContext,
     }
 
     private void increaseCallCounts(int curLevel, ExecutionStrategyParameters parameters) {
-        int nonDeferredFieldCount = (int) parameters.getFields().getSubFieldsList().stream()
-                .filter(field -> !field.isDeferred())
-                .count();
-
+        int count = 0;
+        for (MergedField field : parameters.getFields().getSubFieldsList()) {
+            if (!field.isDeferred()) {
+                count++;
+            }
+        }
+        int nonDeferredFieldCount = count;
         callStack.lock.runLocked(() -> {
             callStack.increaseExpectedFetchCount(curLevel, nonDeferredFieldCount);
             callStack.increaseHappenedStrategyCalls(curLevel);
diff --git a/src/main/java/graphql/incremental/DelayedIncrementalPartialResultImpl.java b/src/main/java/graphql/incremental/DelayedIncrementalPartialResultImpl.java
@@ -2,11 +2,11 @@
 
 import graphql.ExperimentalApi;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 @ExperimentalApi
 public class DelayedIncrementalPartialResultImpl implements DelayedIncrementalPartialResult {
@@ -44,10 +44,12 @@ public Map<String, Object> toSpecification() {
             result.put("extensions", extensions);
         }
 
-        if(incrementalItems != null) {
-            result.put("incremental", incrementalItems.stream()
-                    .map(IncrementalPayload::toSpecification)
-                    .collect(Collectors.toList()));
+        if (incrementalItems != null) {
+            List<Map<String, Object>> list = new ArrayList<>();
+            for (IncrementalPayload incrementalItem : incrementalItems) {
+                list.add(incrementalItem.toSpecification());
+            }
+            result.put("incremental", list);
         }
 
         return result;
diff --git a/src/main/java/graphql/incremental/IncrementalExecutionResultImpl.java b/src/main/java/graphql/incremental/IncrementalExecutionResultImpl.java
@@ -11,7 +11,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
-import java.util.stream.Collectors;
 
 @ExperimentalApi
 public class IncrementalExecutionResultImpl extends ExecutionResultImpl implements IncrementalExecutionResult {
@@ -66,11 +65,11 @@ public Map<String, Object> toSpecification() {
         map.put("hasNext", hasNext);
 
         if (this.incremental != null) {
-            map.put("incremental",
-                    this.incremental.stream()
-                            .map(IncrementalPayload::toSpecification)
-                            .collect(Collectors.toCollection(LinkedList::new))
-            );
+            LinkedList<Map<String, Object>> linkedList = new LinkedList<>();
+            for (IncrementalPayload incrementalPayload : this.incremental) {
+                linkedList.add(incrementalPayload.toSpecification());
+            }
+            map.put("incremental", linkedList);
         }
 
         return map;
diff --git a/src/main/java/graphql/incremental/IncrementalPayload.java b/src/main/java/graphql/incremental/IncrementalPayload.java
@@ -80,7 +80,11 @@ public Map<String, Object> toSpecification() {
     }
 
     protected Object errorsToSpec(List<GraphQLError> errors) {
-        return errors.stream().map(GraphQLError::toSpecification).collect(toList());
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (GraphQLError error : errors) {
+            list.add(error.toSpecification());
+        }
+        return list;
     }
 
     public int hashCode() {
diff --git a/src/main/java/graphql/schema/fetching/LambdaFetchingSupport.java b/src/main/java/graphql/schema/fetching/LambdaFetchingSupport.java
@@ -69,9 +69,12 @@ private static Method getCandidateMethod(Class<?> sourceClass, String propertyNa
         Predicate<Method> getterPredicate = method -> isGetterNamed(method) && propertyName.equals(mkPropertyNameGetter(method));
         List<Method> allGetterMethods = findMethodsForProperty(sourceClass,
                 getterPredicate);
-        List<Method> pojoGetterMethods = allGetterMethods.stream()
-                .filter(LambdaFetchingSupport::isPossiblePojoMethod)
-                .collect(toList());
+        List<Method> pojoGetterMethods = new ArrayList<>();
+        for (Method allGetterMethod : allGetterMethods) {
+            if (isPossiblePojoMethod(allGetterMethod)) {
+                pojoGetterMethods.add(allGetterMethod);
+            }
+        }
         if (!pojoGetterMethods.isEmpty()) {
             Method method = pojoGetterMethods.get(0);
             if (isBooleanGetter(method)) {
@@ -97,7 +100,13 @@ private static Method checkForSingleParameterPeer(Method candidateMethod, List<M
 
     private static Method findBestBooleanGetter(List<Method> methods) {
         // we prefer isX() over getX() if both happen to be present
-        Optional<Method> isMethod = methods.stream().filter(method -> method.getName().startsWith("is")).findFirst();
+        Optional<Method> isMethod = Optional.empty();
+        for (Method method : methods) {
+            if (method.getName().startsWith("is")) {
+                isMethod = Optional.of(method);
+                break;
+            }
+        }
         return isMethod.orElse(methods.get(0));
     }
 
@@ -121,9 +130,9 @@ private static List<Method> findMethodsForProperty(Class<?> sourceClass, Predica
             currentClass = currentClass.getSuperclass();
         }
 
-        return methods.stream()
-                .sorted(Comparator.comparing(Method::getName))
-                .collect(toList());
+        List<Method> list = new ArrayList<>(methods);
+        list.sort(Comparator.comparing(Method::getName));
+        return list;
     }
 
     private static boolean isPossiblePojoMethod(Method method) {
diff --git a/src/main/java/graphql/schema/transform/FieldVisibilitySchemaTransformation.java b/src/main/java/graphql/schema/transform/FieldVisibilitySchemaTransformation.java
@@ -62,9 +62,10 @@ public final GraphQLSchema apply(GraphQLSchema schema) {
         Set<GraphQLType> markedForRemovalTypes = new HashSet<>();
 
         // query, mutation, and subscription types should not be removed
-        final Set<String> protectedTypeNames = getOperationTypes(schema).stream()
-                .map(GraphQLObjectType::getName)
-                .collect(Collectors.toSet());
+        final Set<String> protectedTypeNames = new HashSet<>();
+        for (GraphQLObjectType graphQLObjectType : getOperationTypes(schema)) {
+            protectedTypeNames.add(graphQLObjectType.getName());
+        }
 
         beforeTransformationHook.run();
 
diff --git a/src/main/java/graphql/util/FpKit.java b/src/main/java/graphql/util/FpKit.java

Original file line number	Diff line number	Diff line change
`@@ -77,8 +77,11 @@ public static Object location(SourceLocation location) {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`static List<GraphQLError> fromSpecification(List<Map<String, Object>> specificationMaps) {`
`80`		`- return specificationMaps.stream()`
`81`		`- .map(GraphqlErrorHelper::fromSpecification).collect(Collectors.toList());`
	`80`	`+ List<GraphQLError> list = new ArrayList<>();`
	`81`	`+ for (Map<String, Object> specificationMap : specificationMaps) {`
	`82`	`+ list.add(fromSpecification(specificationMap));`
	`83`	`+ }`
	`84`	`+ return list;`
`82`	`85`	`}`
`83`	`86`
`84`	`87`	`static GraphQLError fromSpecification(Map<String, Object> specificationMap) {`
Original file line number	Diff line number	Diff line change
`@@ -360,9 +360,14 @@ public ResultNodesInfo getResultNodesInfo() {`
`360`	`360`	`return resultNodesInfo;`
`361`	`361`	`}`
`362`	`362`
	`363`	`+ @Internal`
	`364`	`+ public boolean hasIncrementalSupport() {`
	`365`	`+ GraphQLContext graphqlContext = getGraphQLContext();`
	`366`	`+ return graphqlContext != null && graphqlContext.getBoolean(ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT);`
	`367`	`+ }`
	`368`	`+`
`363`	`369`	`@Internal`
`364`	`370`	`public EngineRunningState getEngineRunningState() {`
`365`	`371`	`return engineRunningState;`
`366`	`372`	`}`
`367`		`-`
`368`	`373`	`}`