return toolchains.stream().filter(t -> !isValidToolchain(t)).collect(Collectors.toList());
    }

    private static List<JvmToolchainMetadata> validToolchains(Collection<JvmToolchainMetadata> toolchains) {
        return toolchains.stream().filter(ShowToolchainsTask::isValidToolchain).sorted(TOOLCHAIN_COMPARATOR).collect(Collectors.toList());
    }

import static com.google.common.collect.ImmutableSet.toImmutableSet;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.mapping;
import static org.gradle.api.problems.Severity.ERROR;
import static org.gradle.api.problems.Severity.WARNING;
import static org.gradle.internal.deprecation.Documentation.userManual;

import java.io.RandomAccessFile;

/**
 * Writes to a {@link RandomAccessFile}. Each operation writes to and advances the current position of the file.
 *
 * <p>Closing this stream does not close the underlying file. Flushing this stream does nothing.
 */
// TODO Replace with Channels.newOutputStream(SeekableByteChannel)
public class RandomAccessFileOutputStream extends OutputStream {
    private final RandomAccessFile file;

                }
            }
        });
    }

    private static Set<String> collectSuperTypes(ClassReader reader) {
        return Stream.concat(Stream.of(reader.getSuperName()), Stream.of(reader.getInterfaces()))
            .filter(InstrumentationAnalysisTransform::isTypeAccepted)
            .collect(toImmutableSortedSet(Ordering.natural()));
    }

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.plugin;

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

import org.apache.maven.model.Plugin;

/**
 * Exception occurring trying to resolve a plugin.
 *
 */
public class PluginResolutionException extends Exception {

        then:
        getPrintedJavaHome(result) == currentJavaHome
        try (def stream = Files.list(jdkDir)) {
            def entries = stream.collect(Collectors.toList())
            entries.size() == 1
            currentJavaHome.startsWith(entries.get(0).toAbsolutePath())
        }
    }

package org.apache.maven.lifecycle;

import javax.inject.Inject;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.maven.internal.impl.DefaultLifecycleRegistry;
import org.apache.maven.internal.impl.DefaultLookup;
import org.codehaus.plexus.PlexusContainer;

            ProfileActivationContext context,
            ModelProblemCollector problems) {
        return getActiveProfiles(profiles.stream().map(Profile::new).collect(Collectors.toList()), context, problems)
                .stream()
                .map(Profile::getDelegate)
                .collect(Collectors.toList());
    }

    @Override
    public List<Profile> getActiveProfiles(

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import com.google.inject.Key;
import com.google.inject.OutOfScopeException;
import com.google.inject.Provider;
import com.google.inject.Scope;
import com.google.inject.name.Names;

/**

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;

/**
 * Allows a stream of bytes to be read from a particular location of some backing byte stream.
 */
class ByteInput {
    private final RandomAccessFile file;
    private final ResettableBufferedInputStream bufferedInputStream;
    private CountingInputStream countingInputStream;