javax.json.stream.JsonCollectors Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* Copyright (c) 2015, 2017 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package javax.json.stream;
import java.util.Map;
import java.util.HashMap;
import java.util.stream.Collector;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.BiConsumer;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.json.JsonValue;
import javax.json.JsonException;
/**
* This class contains some implementations of {@code java.util.stream.Collector} for accumulating
* {@link JsonValue}s into {@link JsonArray} and {@link JsonObject}.
*
* @since 1.1
*/
public final class JsonCollectors {
private JsonCollectors() {
}
/**
* Constructs a {@code java.util.stream.Collector} that accumulates the input {@code JsonValue}
* elements into a {@code JsonArray}.
*
* @return the constructed Collector
*/
public static Collector toJsonArray() {
return Collector.of(
Json::createArrayBuilder,
JsonArrayBuilder::add,
JsonArrayBuilder::addAll,
JsonArrayBuilder::build);
}
/**
* Constructs a {@code java.util.stream.Collector} that accumulates the input {@code Map.Entry}
* elements into a {@code JsonObject}.
*
* @return the constructed Collector
*/
public static Collector, JsonObjectBuilder, JsonObject> toJsonObject() {
return Collector.of(
Json::createObjectBuilder,
(JsonObjectBuilder b, Map.Entry v) -> b.add(v.getKey(), v.getValue()),
JsonObjectBuilder::addAll,
JsonObjectBuilder::build);
}
/**
* Constructs a {@code java.util.stream.Collector} that accumulates the input {@code JsonValue}
* elements into a {@code JsonObject}. The name/value pairs of the {@code JsonObject} are computed
* by applying the provided mapping functions.
*
* @param keyMapper a mapping function to produce names.
* @param valueMapper a mapping function to produce values
* @return the constructed Collector
*/
public static Collector
toJsonObject(Function keyMapper,
Function valueMapper) {
return Collector.of(
Json::createObjectBuilder,
(b, v) -> b.add(keyMapper.apply(v), valueMapper.apply(v)),
JsonObjectBuilder::addAll,
JsonObjectBuilder::build,
Collector.Characteristics.UNORDERED);
}
/**
* Constructs a {@code java.util.stream.Collector} that implements a "group by" operation on the
* input {@code JsonValue} elements. A classifier function maps the input {@code JsonValue}s to keys, and
* the {@code JsonValue}s are partitioned into groups according to the value of the key.
* A reduction operation is performed on the {@code JsonValue}s in each group, using the
* downstream {@code Collector}. For each group, the key and the results of the reduction operation
* become the name/value pairs of the resultant {@code JsonObject}.
*
* @param the intermediate accumulation {@code JsonArrayBuilder} of the downstream collector
* @param classifier a function mapping the input {@code JsonValue}s to a String, producing keys
* @param downstream a {@code Collector} that implements a reduction operation on the
* {@code JsonValue}s in each group.
* @return the constructed {@code Collector}
*/
public static Collector, JsonObject>
groupingBy(Function classifier,
Collector downstream) {
BiConsumer, JsonValue> accumulator =
(map, value) -> {
String key = classifier.apply(value);
if (key == null) {
throw new JsonException("element cannot be mapped to a null key");
}
// Build a map of key to JsonArrayBuilder
T arrayBuilder =
map.computeIfAbsent(key, v->downstream.supplier().get());
// Add elements from downstream Collector to the arrayBuilder.
downstream.accumulator().accept(arrayBuilder, value);
};
Function, JsonObject> finisher =
map -> {
// transform the map of name: JsonArrayBuilder to
// name: JsonArray
// using the downstream collector for reducing the JsonArray
JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
map.forEach((k, v) -> {
JsonArray array = downstream.finisher().apply(v);
objectBuilder.add(k, array);
});
return objectBuilder.build();
};
BinaryOperator> combiner =
(map1, map2) -> {
map1.putAll(map2);
return map1;
};
return Collector.of(HashMap::new, accumulator, combiner, finisher,
Collector.Characteristics.UNORDERED);
}
/**
* Constructs a {@code java.util.stream.Collector} that implements a "group by" operation on the
* input {@code JsonValue} elements. A classifier function maps the input {@code JsonValue}s to keys, and
* the {@code JsonValue}s are partitioned into groups according to the value of the key.
* The {@code JsonValue}s in each group are added to a {@code JsonArray}. The key and the
* {@code JsonArray} in each group becomes the name/value pair of the resultant {@code JsonObject}.
*
* @param classifier a function mapping the input {@code JsonValue}s to a String, producing keys
* @return the constructed {@code Collector}
*/
public static Collector, JsonObject>
groupingBy(Function classifier) {
return groupingBy(classifier, toJsonArray());
}
}