Optimise validation memory usage by not using stream API

Using the stream API results in the creation of quite a lot of objects.
In scenarios where a lot of JSONs are validated, this causes frequent,
and large, garbage collection. In this commit, maps are replaced with
for loops, and filters with if statements.

Author: Lionel Montrieux

core/src/main/java/org/everit/json/schema/ArraySchema.java

@@ -298,15 +298,13 @@ private void testContains(JSONArray arrSubject) {
         if (containedItemSchema == null) {
             return;
         }
-        boolean anyMatch = IntStream.range(0, arrSubject.length())
-                .mapToObj(arrSubject::get)
-                .map(item -> ifFails(containedItemSchema, item))
-                .filter(maybeFailure -> !maybeFailure.isPresent())
-                .findFirst()
-                .isPresent();
-        if (!anyMatch) {
-            addValidationException(failure("expected at least one array item to match 'contains' schema", "contains"));
+        for (int i = 0; i < arrSubject.length(); i++) {
+            Optional<ValidationException> exception = ifFails(containedItemSchema, arrSubject.get(i));
+            if (!exception.isPresent()) {
+                return;
+            }
         }
+        addValidationException(failure("expected at least one array item to match 'contains' schema", "contains"));
     }
 
     @Override

core/src/main/java/org/everit/json/schema/CombinedSchema.java

@@ -1,15 +1,14 @@
 package org.everit.json.schema;
 
-import static java.lang.String.format;
-import static java.util.Objects.requireNonNull;
+import org.everit.json.schema.internal.JSONPrinter;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
-import java.util.stream.Collectors;
 
-import org.everit.json.schema.internal.JSONPrinter;
+import static java.lang.String.format;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Validator for {@code allOf}, {@code oneOf}, {@code anyOf} schemas.
@@ -183,10 +182,13 @@ private ValidationException getFailure(final Schema schema, final Object subject
 
     @Override
     public void validate(final Object subject) {
-        List<ValidationException> failures = subschemas.stream()
-                .map(schema -> getFailure(schema, subject))
-                .filter(Objects::nonNull)
-                .collect(Collectors.toList());
+        List<ValidationException> failures = new ArrayList<>();
+        for (Schema subschema: subschemas) {
+            ValidationException exception = getFailure(subschema, subject);
+            if (null != exception) {
+                failures.add(exception);
+            }
+        }
         int matchingCount = subschemas.size() - failures.size();
         try {
             criterion.validate(subschemas.size(), matchingCount);
@@ -202,9 +204,12 @@ public void validate(final Object subject) {
 
     @Override
     public boolean definesProperty(final String field) {
-        List<Schema> matching = subschemas.stream()
-                .filter(schema -> schema.definesProperty(field))
-                .collect(Collectors.toList());
+        List<Schema> matching = new ArrayList<>();
+        for (Schema subschema: subschemas) {
+            if (subschema.definesProperty(field)) {
+                matching.add(subschema);
+            }
+        }
         try {
             criterion.validate(subschemas.size(), matching.size());
         } catch (ValidationException e) {

core/src/main/java/org/everit/json/schema/EnumSchema.java

@@ -1,16 +1,16 @@
 package org.everit.json.schema;
 
-import static java.lang.String.format;
-import static java.util.stream.Collectors.toSet;
+import org.everit.json.schema.internal.JSONPrinter;
+import org.json.JSONArray;
+import org.json.JSONObject;
 
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
 
-import org.everit.json.schema.internal.JSONPrinter;
-import org.json.JSONArray;
-import org.json.JSONObject;
+import static java.lang.String.format;
+import static java.util.stream.Collectors.toSet;
 
 /**
  * Enum schema validator.
@@ -72,12 +72,12 @@ public Set<Object> getPossibleValues() {
     @Override
     public void validate(final Object subject) {
         Object effectiveSubject = toJavaValue(subject);
-        possibleValues
-                .stream()
-                .filter(val -> ObjectComparator.deepEquals(val, effectiveSubject))
-                .findAny()
-                .orElseThrow(
-                        () -> failure(format("%s is not a valid enum value", subject), "enum"));
+        for (Object possibleValue: possibleValues) {
+            if (ObjectComparator.deepEquals(possibleValue, effectiveSubject)) {
+                return;
+            }
+        }
+        throw failure(format("%s is not a valid enum value", subject), "enum");
     }
 
     @Override

core/src/main/java/org/everit/json/schema/ObjectSchema.java

@@ -4,8 +4,6 @@
 import org.json.JSONObject;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -16,12 +14,10 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.regex.Pattern;
-import java.util.stream.Stream;
 
 import static java.lang.String.format;
 import static java.util.Arrays.asList;
 import static java.util.Objects.requireNonNull;
-import static java.util.stream.Collectors.toList;
 
 /**
  * Object schema validator.
@@ -200,15 +196,18 @@ public ObjectSchema(final Builder builder) {
         this.propertyNameSchema = builder.propertyNameSchema;
     }
 
-    private Stream<String> getAdditionalProperties(final JSONObject subject) {
+    private List<String> getAdditionalProperties(final JSONObject subject) {
         String[] names = JSONObject.getNames(subject);
         if (names == null) {
-            return Stream.empty();
+            return new ArrayList<>();
         } else {
-            return Arrays
-                    .stream(names)
-                    .filter(key -> !propertySchemas.containsKey(key))
-                    .filter(key -> !matchesAnyPattern(key));
+            List<String> namesList = new ArrayList<>();
+            for (String name:names) {
+                if (!propertySchemas.containsKey(name) && !matchesAnyPattern(name)) {
+                    namesList.add(name);
+                }
+            }
+            return namesList;
         }
     }
 
@@ -258,10 +257,12 @@ private Optional<ValidationException> ifFails(final Schema schema, final Object
     }
 
     private boolean matchesAnyPattern(final String key) {
-        return patternProperties.keySet().stream()
-                .filter(pattern -> pattern.matcher(key).find())
-                .findAny()
-                .isPresent();
+        for (Pattern pattern: patternProperties.keySet()) {
+            if (pattern.matcher(key).find()) {
+                return true;
+            }
+        }
+        return false;
     }
 
     public boolean permitsAdditionalProperties() {
@@ -274,19 +275,23 @@ public boolean requiresObject() {
 
     private void testAdditionalProperties(final JSONObject subject) {
         if (!additionalProperties) {
-            addValidationExceptions(getAdditionalProperties(subject)
-                    .map(unneeded -> format("extraneous key [%s] is not permitted", unneeded))
-                    .map(msg -> new ValidationException(this, msg, "additionalProperties"))
-                    .collect(toList()));
+            List<String> additionalProperties = getAdditionalProperties(subject);
+            if (null == additionalProperties || additionalProperties.isEmpty()) {
+                return;
+            }
+            for (String additionalProperty: additionalProperties) {
+                addValidationException(new ValidationException(this,
+                        format("extraneous key [%s] is not permitted", additionalProperty), "additionalProperties"));
+            }
             return;
         } else if (schemaOfAdditionalProperties != null) {
-            List<String> additionalPropNames = getAdditionalProperties(subject)
-                    .collect(toList());
+            List<String> additionalPropNames = getAdditionalProperties(subject);
             for (String propName : additionalPropNames) {
                 Object propVal = subject.get(propName);
-                ifFails(schemaOfAdditionalProperties, propVal)
-                        .map(failure -> failure.prepend(propName, this))
-                        .ifPresent(this::addValidationException);
+                Optional<ValidationException> exception = ifFails(schemaOfAdditionalProperties, propVal);
+                if (exception.isPresent()) {
+                    addValidationException(exception.get().prepend(propName, this));
+                }
             }
         }
     }
@@ -299,9 +304,10 @@ private void testPatternProperties(final JSONObject subject) {
         for (Entry<Pattern, Schema> entry : patternProperties.entrySet()) {
             for (String propName : propNames) {
                 if (entry.getKey().matcher(propName).find()) {
-                    ifFails(entry.getValue(), subject.get(propName))
-                            .map(exc -> exc.prepend(propName))
-                            .ifPresent(this::addValidationException);
+                    Optional<ValidationException> exception = ifFails(entry.getValue(), subject.get(propName));
+                    if (exception.isPresent()) {
+                        addValidationException(exception.get().prepend(propName));
+                    }
                 }
             }
         }
@@ -312,30 +318,33 @@ private void testProperties(final JSONObject subject) {
             for (Entry<String, Schema> entry : propertySchemas.entrySet()) {
                 String key = entry.getKey();
                 if (subject.has(key)) {
-                    ifFails(entry.getValue(), subject.get(key))
-                            .map(exc -> exc.prepend(key))
-                            .ifPresent(this::addValidationException);
+                    Optional<ValidationException> exception = ifFails(entry.getValue(), subject.get(key));
+                    if (exception.isPresent()) {
+                        addValidationException(exception.get().prepend(key));
+                    }
                 }
             }
         }
     }
 
     private void testPropertyDependencies(final JSONObject subject) {
-        addValidationExceptions(propertyDependencies.keySet().stream()
-                .filter(subject::has)
-                .flatMap(ifPresent -> propertyDependencies.get(ifPresent).stream())
-                .filter(mustBePresent -> !subject.has(mustBePresent))
-                .map(missingKey -> format("property [%s] is required", missingKey))
-                .map(excMessage -> failure(excMessage, "dependencies"))
-                .collect(toList()));
+        for (String property: propertyDependencies.keySet()) {
+            if (subject.has(property)) {
+                for (String mustBePresent : propertyDependencies.get(property)) {
+                    if (!subject.has(mustBePresent)) {
+                        addValidationException(failure(format("property [%s] is required", mustBePresent), "dependencies"));
+                    }
+                }
+            }
+        }
     }
 
     private void testRequiredProperties(final JSONObject subject) {
-        addValidationExceptions(requiredProperties.stream()
-                .filter(key -> !subject.has(key))
-                .map(missingKey -> format("required key [%s] not found", missingKey))
-                .map(excMessage -> failure(excMessage, "required"))
-                .collect(toList()));
+        for (String required:requiredProperties) {
+            if (!subject.has(required)) {
+                addValidationException(failure(format("required key [%s] not found", required), "required"));
+            }
+        }
     }
 
     private void testSchemaDependencies(final JSONObject subject) {
@@ -389,18 +398,13 @@ private void testPropertyNames(JSONObject subject) {
             if (names == null || names.length == 0) {
                 return;
             }
-            Collection<ValidationException> failures = Arrays.stream(names)
-                    .map(name -> {
-                        try {
-                            propertyNameSchema.validate(name);
-                            return null;
-                        } catch (ValidationException e) {
-                            return e.prepend(name);
-                        }
-                    })
-                    .filter(Objects::nonNull)
-                    .collect(toList());
-            validationExceptions.addAll(failures);
+            for (String name: names) {
+                try {
+                    propertyNameSchema.validate(name);
+                } catch (ValidationException e) {
+                    addValidationException(e.prepend(name));
+                }
+            }
         }
     }
 
@@ -435,21 +439,26 @@ private boolean definesSchemaProperty(String current, final String remaining) {
     }
 
     private boolean definesPatternProperty(final String current, final String remaining) {
-        return patternProperties.keySet()
-                .stream()
-                .filter(pattern -> pattern.matcher(current).matches())
-                .map(pattern -> patternProperties.get(pattern))
-                .filter(schema -> remaining == null || schema.definesProperty(remaining))
-                .findAny()
-                .isPresent();
+        for (Pattern pattern: patternProperties.keySet()) {
+            if (pattern.matcher(current).matches()) {
+                if (remaining == null || patternProperties.get(pattern).definesProperty(remaining)) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
 
     private boolean definesSchemaDependencyProperty(final String field) {
-        return schemaDependencies.containsKey(field)
-                || schemaDependencies.values().stream()
-                .filter(schema -> schema.definesProperty(field))
-                .findAny()
-                .isPresent();
+        if (schemaDependencies.containsKey(field)) {
+            return true;
+        }
+        for (Schema schema: schemaDependencies.values()) {
+            if (schema.definesProperty(field)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     private String unescape(final String value) {

core/src/main/java/org/everit/json/schema/StringSchema.java

@@ -148,9 +148,10 @@ public void validate(final Object subject) {
             String stringSubject = (String) subject;
             testLength(stringSubject);
             testPattern(stringSubject);
-            formatValidator.validate(stringSubject)
-                    .map(failure -> failure(failure, "format"))
-                    .ifPresent(this::addValidationException);
+            Optional<String> failure = formatValidator.validate(stringSubject);
+            if (failure.isPresent()) {
+                addValidationException(failure(failure.get(), "format"));
+            }
             if (null != validationExceptions) {
                 ValidationException.throwFor(this, validationExceptions);
             }

core/src/main/java/org/everit/json/schema/internal/DateTimeFormatValidator.java

@@ -1,16 +1,15 @@
 package org.everit.json.schema.internal;
 
+import com.google.common.collect.ImmutableList;
+import org.everit.json.schema.FormatValidator;
+
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeFormatterBuilder;
 import java.time.format.DateTimeParseException;
 import java.time.temporal.ChronoField;
 import java.util.List;
 import java.util.Optional;
 
-import org.everit.json.schema.FormatValidator;
-
-import com.google.common.collect.ImmutableList;
-
 /**
  * Implementation of the "date-time" format value.
  */