graphql-java
diff --git a/src/main/java/graphql/GraphqlErrorHelper.java b/src/main/java/graphql/GraphqlErrorHelper.java
@@ -1,13 +1,13 @@
 package graphql;
 
 import graphql.language.SourceLocation;
+import graphql.util.FpKit;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.stream.Collectors;
 
 import static graphql.collect.ImmutableKit.mapAndDropNulls;
 
@@ -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 = FpKit.arrayListSizedTo(specificationMaps);
+        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
@@ -184,9 +184,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();
@@ -259,9 +257,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
@@ -366,9 +366,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
@@ -283,9 +283,7 @@ private BiConsumer<List<Object>, Throwable> buildFieldValueMap(List<String> fiel
     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,
@@ -908,9 +906,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,18 @@ 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> listOrSingletonList = FpKit.toListOrSingletonList(value);
+        List<Object> list = FpKit.arrayListSizedTo(listOrSingletonList);
+        for (Object val : listOrSingletonList) {
+            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,11 @@ 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<Object> listOrSingletonList = FpKit.toListOrSingletonList(value);
+            List<Value> valuesNodes = FpKit.arrayListSizedTo(listOrSingletonList);
+            for (Object item : listOrSingletonList) {
+                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
@@ -18,14 +18,14 @@
 
 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
@@ -107,19 +107,23 @@ 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());
+            ImmutableSet<DeferredExecution> deferredExecutions = deferredExecutionToFields.keySet();
+            Set<IncrementalCall<? extends IncrementalPayload>> set = new HashSet<>(deferredExecutions.size());
+            for (DeferredExecution deferredExecution : deferredExecutions) {
+                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 = FpKit.arrayListSizedTo(mergedFields);
+            for (MergedField currentField : mergedFields) {
+                calls.add(this.createResultSupplier(currentField, deferredCallContext, executionStrategyParameters));
+            }
 
             return new DeferredFragmentCall(
                     deferredExecution.getLabel(),

diff --git a/...instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyWithDeferAlwaysDispatch.java b/...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
@@ -1,12 +1,12 @@
 package graphql.incremental;
 
 import graphql.ExperimentalApi;
+import graphql.util.FpKit;
 
 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 = FpKit.arrayListSizedTo(incrementalItems);
+            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
@@ -3,6 +3,7 @@
 import graphql.ExperimentalApi;
 import graphql.GraphQLError;
 import graphql.execution.ResultPath;
+import graphql.util.FpKit;
 import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -11,8 +12,6 @@
 import java.util.Map;
 import java.util.Objects;
 
-import static java.util.stream.Collectors.toList;
-
 /**
  * Represents a payload that can be resolved after the initial response.
  */
@@ -80,16 +79,24 @@ public Map<String, Object> toSpecification() {
     }
 
     protected Object errorsToSpec(List<GraphQLError> errors) {
-        return errors.stream().map(GraphQLError::toSpecification).collect(toList());
+        List<Map<String, Object>> list = FpKit.arrayListSizedTo(errors);
+        for (GraphQLError error : errors) {
+            list.add(error.toSpecification());
+        }
+        return list;
     }
 
     public int hashCode() {
         return Objects.hash(path, label, errors, extensions);
     }
 
     public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (obj == null || getClass() != obj.getClass()) return false;
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
         IncrementalPayload that = (IncrementalPayload) obj;
         return Objects.equals(path, that.path) &&
                 Objects.equals(label, that.label) &&

diff --git a/src/main/java/graphql/schema/fetching/LambdaFetchingSupport.java b/src/main/java/graphql/schema/fetching/LambdaFetchingSupport.java
@@ -2,6 +2,7 @@
 
 import graphql.Internal;
 import graphql.VisibleForTesting;
+import graphql.util.FpKit;
 
 import java.lang.invoke.CallSite;
 import java.lang.invoke.LambdaMetafactory;
@@ -17,8 +18,6 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
-import static java.util.stream.Collectors.toList;
-
 @Internal
 public class LambdaFetchingSupport {
 
@@ -69,9 +68,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 = FpKit.arrayListSizedTo(allGetterMethods);
+        for (Method allGetterMethod : allGetterMethods) {
+            if (isPossiblePojoMethod(allGetterMethod)) {
+                pojoGetterMethods.add(allGetterMethod);
+            }
+        }
         if (!pojoGetterMethods.isEmpty()) {
             Method method = pojoGetterMethods.get(0);
             if (isBooleanGetter(method)) {
@@ -97,7 +99,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 +129,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();