return skippedTestByFilePatternTransformations.keySet().stream()
            .map(key -> String.join(",", key.getIncludes()) + skippedTestByFilePatternTransformations.get(key))
            .collect(Collectors.joining());
    }

    @Input
    public String getSkippedTestByTestNameTransformations() {

        return skippedTestByTestNameTransformations.keySet().stream()

      synchronized (mutex) {
        return delegate().spliterator();
      }
    }

    @Override
    public Stream<E> stream() {
      synchronized (mutex) {
        return delegate().stream();
      }
    }

    @Override
    public Stream<E> parallelStream() {
      synchronized (mutex) {
        return delegate().parallelStream();
      }
    }

    @Override

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.codelibs.core.io.FileUtil;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.misc.Pair;
import org.codelibs.core.misc.Tuple3;

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.model.v4;

import javax.xml.stream.XMLStreamException;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.LinkedHashMap;
import java.util.Map;

import org.apache.maven.api.model.Model;

     *
     * @return a SuggestItem representing this ElevateWord
     */
    public SuggestItem toSuggestItem() {
        final String[][] readingArray =
                this.getReadings().stream().map(reading -> new String[] { reading }).toArray(count -> new String[count][]);
        return new SuggestItem(new String[] { this.getElevateWord() }, readingArray, fields.toArray(new String[fields.size()]), 1, 0,

        }

        if (logger.isDebugEnabled()) {
            try {
                ManagementFactory.getRuntimeMXBean().getInputArguments().stream().forEach(s -> logger.debug("Parameter: {}", s));
                System.getProperties()
                        .entrySet()
                        .stream()
                        .forEach(e -> logger.debug("Property: {}={}", e.getKey(),

import static org.codelibs.fess.app.web.admin.scheduler.AdminSchedulerAction.getScheduledJob;

import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.Constants;
import org.codelibs.fess.app.pager.SchedulerPager;

Au lieu de renvoyer une `StreamingResponse` directement, vous devriez probablement suivre le style de [Diffuser des données](./stream-data.md), c'est beaucoup plus pratique et gère l'annulation en arrière-plan pour vous.

Si vous diffusez des JSON Lines, suivez le didacticiel [Diffuser des JSON Lines](../tutorial/stream-json-lines.md).

///

### `FileResponse` { #fileresponse }

Diffuse de façon asynchrone un fichier comme réponse.

    @SkipWhenEmpty
    public FileCollection getClassDirectories() {
        return getProject().getExtensions().getByType(JavaPluginExtension.class)
            .getSourceSets()
            .stream()
            // Don't pick up all source sets like the java9 ones as logger-check doesn't support the class format
            .filter(
                sourceSet -> sourceSet.getName().equals(SourceSet.MAIN_SOURCE_SET_NAME)

     * <p>
     * Uses the thread-local Kryo instance to serialize the object along with
     * its class information. The serialized data is written to a byte array
     * output stream.
     * </p>
     *
     * @param obj the object to serialize
     * @return the serialized object as a byte array
     * @throws IORuntimeException if an I/O error occurs during serialization
     */