Index (net.sourceforge.streamsupport:streamsupport 1.3.1 API)

A B C D E F G H I J L M N O P Q R S T U V W

A

AbstractDoubleSpliterator(long, int) - Constructor for class java8.util.Spliterators.AbstractDoubleSpliterator: Creates a spliterator reporting the given estimated size and characteristics.
AbstractIntSpliterator(long, int) - Constructor for class java8.util.Spliterators.AbstractIntSpliterator: Creates a spliterator reporting the given estimated size and characteristics.
AbstractLongSpliterator(long, int) - Constructor for class java8.util.Spliterators.AbstractLongSpliterator: Creates a spliterator reporting the given estimated size and characteristics.
AbstractSpliterator(long, int) - Constructor for class java8.util.Spliterators.AbstractSpliterator: Creates a spliterator reporting the given estimated size and additionalCharacteristics.
accept(double) - Method in class java8.util.DoubleSummaryStatistics: Records another value into the summary information.
accept(T, U) - Method in interface java8.util.function.BiConsumer: Performs this operation on the given arguments.
accept(T) - Method in interface java8.util.function.Consumer: Performs this operation on the given argument.
accept(double) - Method in interface java8.util.function.DoubleConsumer: Performs this operation on the given argument.
accept(int) - Method in interface java8.util.function.IntConsumer: Performs this operation on the given argument.
accept(long) - Method in interface java8.util.function.LongConsumer: Performs this operation on the given argument.
accept(T, double) - Method in interface java8.util.function.ObjDoubleConsumer: Performs this operation on the given arguments.
accept(T, int) - Method in interface java8.util.function.ObjIntConsumer: Performs this operation on the given arguments.
accept(T, long) - Method in interface java8.util.function.ObjLongConsumer: Performs this operation on the given arguments.
accept(int) - Method in class java8.util.IntSummaryStatistics: Records a new value into the summary information
accept(int) - Method in class java8.util.LongSummaryStatistics: Records a new int value into the summary information.
accept(long) - Method in class java8.util.LongSummaryStatistics: Records a new long value into the summary information.
accept(double) - Method in interface java8.util.stream.DoubleStream.Builder: Adds an element to the stream being built.
accept(int) - Method in interface java8.util.stream.IntStream.Builder: Adds an element to the stream being built.
accept(long) - Method in interface java8.util.stream.LongStream.Builder: Adds an element to the stream being built.
accept(T) - Method in interface java8.util.stream.Stream.Builder: Adds an element to the stream being built.
acceptEither(CompletionStage<? extends T>, Consumer<? super T>) - Method in class java8.util.concurrent.CompletableFuture
acceptEither(CompletionStage<? extends T>, Consumer<? super T>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed with the corresponding result as argument to the supplied action.
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>) - Method in class java8.util.concurrent.CompletableFuture
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>, Executor) - Method in class java8.util.concurrent.CompletableFuture
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using this stage's default asynchronous execution facility, with the corresponding result as argument to the supplied action.
acceptEitherAsync(CompletionStage<? extends T>, Consumer<? super T>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using the supplied executor, with the corresponding result as argument to the supplied function.
accumulate(double) - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Updates with the given value.
accumulate(long) - Method in class java8.util.concurrent.atomic.LongAccumulator: Updates with the given value.
accumulator() - Method in interface java8.util.stream.Collector: A function that folds a value into a mutable result container.
adapt(Runnable) - Static method in class java8.util.concurrent.ForkJoinTask: Returns a new ForkJoinTask that performs the run method of the given Runnable as its action, and returns a null result upon ForkJoinTask.join().
adapt(Runnable, T) - Static method in class java8.util.concurrent.ForkJoinTask: Returns a new ForkJoinTask that performs the run method of the given Runnable as its action, and returns the given result upon ForkJoinTask.join().
adapt(Callable<? extends T>) - Static method in class java8.util.concurrent.ForkJoinTask: Returns a new ForkJoinTask that performs the call method of the given Callable as its action, and returns its result upon ForkJoinTask.join(), translating any checked exceptions encountered into RuntimeException.
add(double) - Method in class java8.util.concurrent.atomic.DoubleAdder: Adds the given value.
add(long) - Method in class java8.util.concurrent.atomic.LongAdder: Adds the given value.
add(double) - Method in interface java8.util.stream.DoubleStream.Builder: Adds an element to the stream being built.
add(int) - Method in interface java8.util.stream.IntStream.Builder: Adds an element to the stream being built.
add(long) - Method in interface java8.util.stream.LongStream.Builder: Adds an element to the stream being built.
add(T) - Method in interface java8.util.stream.Stream.Builder: Adds an element to the stream being built.
add(CharSequence) - Method in class java8.util.StringJoiner: Adds a copy of the given CharSequence value as the next element of the StringJoiner value.
addToPendingCount(int) - Method in class java8.util.concurrent.CountedCompleter: Adds (atomically) the given value to the pending count.
allMatch(DoublePredicate) - Method in interface java8.util.stream.DoubleStream: Returns whether all elements of this stream match the provided predicate.
allMatch(IntPredicate) - Method in interface java8.util.stream.IntStream: Returns whether all elements of this stream match the provided predicate.
allMatch(LongPredicate) - Method in interface java8.util.stream.LongStream: Returns whether all elements of this stream match the provided predicate.
allMatch(Predicate<? super T>) - Method in interface java8.util.stream.Stream: Returns whether all elements of this stream match the provided predicate.
allOf(CompletableFuture<?>...) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete.
and(BiPredicate<? super T, ? super U>, BiPredicate<? super T, ? super U>) - Static method in class java8.util.function.BiPredicates: Returns a composed predicate that represents a short-circuiting logical AND of the this_ predicate and another.
and(DoublePredicate, DoublePredicate) - Static method in class java8.util.function.DoublePredicates: Returns a composed predicate that represents a short-circuiting logical AND of the this_ predicate and another.
and(IntPredicate, IntPredicate) - Static method in class java8.util.function.IntPredicates: Returns a composed predicate that represents a short-circuiting logical AND of the this_ predicate and another.
and(LongPredicate, LongPredicate) - Static method in class java8.util.function.LongPredicates: Returns a composed predicate that represents a short-circuiting logical AND of the this_ predicate and another.
and(Predicate<? super T>, Predicate<? super T>) - Static method in class java8.util.function.Predicates: Returns a composed predicate that represents a short-circuiting logical AND of the this_ predicate and another.
andThen(BiConsumer<? super T, ? super U>, BiConsumer<? super T, ? super U>) - Static method in class java8.util.function.BiConsumers: Returns a composed BiConsumer that performs, in sequence, this_ operation followed by the after operation.
andThen(BiFunction<? super T, ? super U, ? extends R>, Function<? super R, ? extends V>) - Static method in class java8.util.function.BiFunctions: Returns a composed function that first applies the this_ function to its inputs, and then applies the after function to the result.
andThen(Consumer<? super T>, Consumer<? super T>) - Static method in class java8.util.function.Consumers: Returns a composed Consumer that performs, in sequence, the this_ operation followed by the after operation.
andThen(DoubleConsumer, DoubleConsumer) - Static method in class java8.util.function.DoubleConsumers: Returns a composed DoubleConsumer that performs, in sequence, the this_ operation followed by the after operation.
andThen(DoubleUnaryOperator, DoubleUnaryOperator) - Static method in class java8.util.function.DoubleUnaryOperators: Returns a composed operator that first applies the this_ operator to its input, and then applies the after operator to the result.
andThen(Function<? super T, ? extends R>, Function<? super R, ? extends V>) - Static method in class java8.util.function.Functions: Returns a composed function that first applies the this_ function to its input, and then applies the after function to the result.
andThen(IntConsumer, IntConsumer) - Static method in class java8.util.function.IntConsumers: Returns a composed IntConsumer that performs, in sequence, the this_ operation followed by the after operation.
andThen(IntUnaryOperator, IntUnaryOperator) - Static method in class java8.util.function.IntUnaryOperators: Returns a composed operator that first applies the this_ operator to its input, and then applies the after operator to the result.
andThen(LongConsumer, LongConsumer) - Static method in class java8.util.function.LongConsumers: Returns a composed LongConsumer that performs, in sequence, the this_ operation followed by the after operation.
andThen(LongUnaryOperator, LongUnaryOperator) - Static method in class java8.util.function.LongUnaryOperators: Returns a composed operator that first applies the this_ operator to its input, and then applies the after operator to the result.
anyMatch(DoublePredicate) - Method in interface java8.util.stream.DoubleStream: Returns whether any elements of this stream match the provided predicate.
anyMatch(IntPredicate) - Method in interface java8.util.stream.IntStream: Returns whether any elements of this stream match the provided predicate.
anyMatch(LongPredicate) - Method in interface java8.util.stream.LongStream: Returns whether any elements of this stream match the provided predicate.
anyMatch(Predicate<? super T>) - Method in interface java8.util.stream.Stream: Returns whether any elements of this stream match the provided predicate.
anyOf(CompletableFuture<?>...) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.
apply(T, U) - Method in interface java8.util.function.BiFunction: Applies this function to the given arguments.
apply(double) - Method in interface java8.util.function.DoubleFunction: Applies this function to the given argument.
apply(T) - Method in interface java8.util.function.Function: Applies this function to the given argument.
apply(int) - Method in interface java8.util.function.IntFunction: Applies this function to the given argument.
apply(long) - Method in interface java8.util.function.LongFunction: Applies this function to the given argument.
applyAsDouble(double, double) - Method in interface java8.util.function.DoubleBinaryOperator: Applies this operator to the given operands.
applyAsDouble(double) - Method in interface java8.util.function.DoubleUnaryOperator: Applies this operator to the given operand.
applyAsDouble(int) - Method in interface java8.util.function.IntToDoubleFunction: Applies this function to the given argument.
applyAsDouble(long) - Method in interface java8.util.function.LongToDoubleFunction: Applies this function to the given argument.
applyAsDouble(T, U) - Method in interface java8.util.function.ToDoubleBiFunction: Applies this function to the given arguments.
applyAsDouble(T) - Method in interface java8.util.function.ToDoubleFunction: Applies this function to the given argument.
applyAsInt(double) - Method in interface java8.util.function.DoubleToIntFunction: Applies this function to the given argument.
applyAsInt(int, int) - Method in interface java8.util.function.IntBinaryOperator: Applies this operator to the given operands.
applyAsInt(int) - Method in interface java8.util.function.IntUnaryOperator: Applies this operator to the given operand.
applyAsInt(long) - Method in interface java8.util.function.LongToIntFunction: Applies this function to the given argument.
applyAsInt(T, U) - Method in interface java8.util.function.ToIntBiFunction: Applies this function to the given arguments.
applyAsInt(T) - Method in interface java8.util.function.ToIntFunction: Applies this function to the given argument.
applyAsLong(double) - Method in interface java8.util.function.DoubleToLongFunction: Applies this function to the given argument.
applyAsLong(int) - Method in interface java8.util.function.IntToLongFunction: Applies this function to the given argument.
applyAsLong(long, long) - Method in interface java8.util.function.LongBinaryOperator: Applies this operator to the given operands.
applyAsLong(long) - Method in interface java8.util.function.LongUnaryOperator: Applies this operator to the given operand.
applyAsLong(T, U) - Method in interface java8.util.function.ToLongBiFunction: Applies this function to the given arguments.
applyAsLong(T) - Method in interface java8.util.function.ToLongFunction: Applies this function to the given argument.
applyToEither(CompletionStage<? extends T>, Function<? super T, U>) - Method in class java8.util.concurrent.CompletableFuture
applyToEither(CompletionStage<? extends T>, Function<? super T, U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed with the corresponding result as argument to the supplied function.
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>) - Method in class java8.util.concurrent.CompletableFuture
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>, Executor) - Method in class java8.util.concurrent.CompletableFuture
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using this stage's default asynchronous execution facility, with the corresponding result as argument to the supplied function.
applyToEitherAsync(CompletionStage<? extends T>, Function<? super T, U>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using the supplied executor, with the corresponding result as argument to the supplied function.
arrive() - Method in class java8.util.concurrent.Phaser: Arrives at this phaser, without waiting for others to arrive.
arriveAndAwaitAdvance() - Method in class java8.util.concurrent.Phaser: Arrives at this phaser and awaits others.
arriveAndDeregister() - Method in class java8.util.concurrent.Phaser: Arrives at this phaser and deregisters from it without waiting for others to arrive.
asDoubleStream() - Method in interface java8.util.stream.IntStream: Returns a DoubleStream consisting of the elements of this stream, converted to double.
asDoubleStream() - Method in interface java8.util.stream.LongStream: Returns a DoubleStream consisting of the elements of this stream, converted to double.
asIterator(Enumeration<E>) - Static method in class java8.util.Iterators: Returns an Iterator that traverses the remaining elements covered by the passed enumeration.
asLongStream() - Method in interface java8.util.stream.IntStream: Returns a LongStream consisting of the elements of this stream, converted to long.
average() - Method in interface java8.util.stream.DoubleStream: Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
average() - Method in interface java8.util.stream.IntStream: Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
average() - Method in interface java8.util.stream.LongStream: Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
averagingDouble(ToDoubleFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the arithmetic mean of a double-valued function applied to the input elements.
averagingInt(ToIntFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the arithmetic mean of an integer-valued function applied to the input elements.
averagingLong(ToLongFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the arithmetic mean of a long-valued function applied to the input elements.
awaitAdvance(int) - Method in class java8.util.concurrent.Phaser: Awaits the phase of this phaser to advance from the given phase value, returning immediately if the current phase is not equal to the given phase value or this phaser is terminated.
awaitAdvanceInterruptibly(int) - Method in class java8.util.concurrent.Phaser: Awaits the phase of this phaser to advance from the given phase value, throwing InterruptedException if interrupted while waiting, or returning immediately if the current phase is not equal to the given phase value or this phaser is terminated.
awaitAdvanceInterruptibly(int, long, TimeUnit) - Method in class java8.util.concurrent.Phaser: Awaits the phase of this phaser to advance from the given phase value or the given timeout to elapse, throwing InterruptedException if interrupted while waiting, or returning immediately if the current phase is not equal to the given phase value or this phaser is terminated.
awaitQuiescence(long, TimeUnit) - Method in class java8.util.concurrent.ForkJoinPool: If called by a ForkJoinTask operating in this pool, equivalent in effect to ForkJoinTask.helpQuiesce().
awaitTermination(long, TimeUnit) - Method in class java8.util.concurrent.ForkJoinPool: Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.

B

BaseStream<T,S extends BaseStream<T,S>> - Interface in java8.util.stream: Base interface for streams, which are sequences of elements supporting sequential and parallel aggregate operations.
BiConsumer<T,U> - Interface in java8.util.function: Represents an operation that accepts two input arguments and returns no result.
BiConsumers - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the BiConsumer interface.
BiFunction<T,U,R> - Interface in java8.util.function: Represents a function that accepts two arguments and produces a result.
BiFunctions - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the BiFunction interface.
BinaryOperator<T> - Interface in java8.util.function: Represents an operation upon two operands of the same type, producing a result of the same type as the operands.
BinaryOperators - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the BinaryOperator interface.
BiPredicate<T,U> - Interface in java8.util.function: Represents a predicate (boolean-valued function) of two arguments.
BiPredicates - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the BiPredicate interface.
block() - Method in interface java8.util.concurrent.ForkJoinPool.ManagedBlocker: Possibly blocks the current thread, for example waiting for a lock or condition.
BooleanSupplier - Interface in java8.util.function: Represents a supplier of boolean-valued results.
boxed() - Method in interface java8.util.stream.DoubleStream: Returns a Stream consisting of the elements of this stream, boxed to Double.
boxed() - Method in interface java8.util.stream.IntStream: Returns a Stream consisting of the elements of this stream, each boxed to an Integer.
boxed() - Method in interface java8.util.stream.LongStream: Returns a Stream consisting of the elements of this stream, each boxed to a Long.
build() - Method in interface java8.util.stream.DoubleStream.Builder: Builds the stream, transitioning this builder to the built state.
build() - Method in interface java8.util.stream.IntStream.Builder: Builds the stream, transitioning this builder to the built state.
build() - Method in interface java8.util.stream.LongStream.Builder: Builds the stream, transitioning this builder to the built state.
build() - Method in interface java8.util.stream.Stream.Builder: Builds the stream, transitioning this builder to the built state.
builder() - Static method in class java8.util.stream.DoubleStreams: Returns a builder for a DoubleStream.
builder() - Static method in class java8.util.stream.IntStreams: Returns a builder for an IntStream.
builder() - Static method in class java8.util.stream.LongStreams: Returns a builder for a LongStream.
builder() - Static method in class java8.util.stream.RefStreams: Returns a builder for a Stream.
builder() - Static method in class java8.util.stream.StreamSupport: Returns a builder for a Stream.
bulkRegister(int) - Method in class java8.util.concurrent.Phaser: Adds the given number of new unarrived parties to this phaser.

C

cancel(boolean) - Method in class java8.util.concurrent.CompletableFuture: If not already completed, completes this CompletableFuture with a CancellationException.
cancel(boolean) - Method in class java8.util.concurrent.ForkJoinTask: Attempts to cancel execution of this task.
characteristics() - Method in interface java8.util.Spliterator: Returns a set of characteristics of this Spliterator and its elements.
characteristics() - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: Returns a set of characteristics of this Spliterator and its elements.
characteristics() - Method in class java8.util.Spliterators.AbstractIntSpliterator: Returns a set of characteristics of this Spliterator and its elements.
characteristics() - Method in class java8.util.Spliterators.AbstractLongSpliterator: Returns a set of characteristics of this Spliterator and its elements.
characteristics() - Method in class java8.util.Spliterators.AbstractSpliterator: Returns a set of characteristics of this Spliterator and its elements.
characteristics() - Method in interface java8.util.stream.Collector: Returns a Set of Collector.Characteristics indicating the characteristics of this Collector.
close() - Method in interface java8.util.stream.BaseStream: Closes this stream, causing all close handlers for this stream pipeline to be called.
collect(Supplier<R>, ObjDoubleConsumer<R>, BiConsumer<R, R>) - Method in interface java8.util.stream.DoubleStream: Performs a mutable reduction operation on the elements of this stream.
collect(Supplier<R>, ObjIntConsumer<R>, BiConsumer<R, R>) - Method in interface java8.util.stream.IntStream: Performs a mutable reduction operation on the elements of this stream.
collect(Supplier<R>, ObjLongConsumer<R>, BiConsumer<R, R>) - Method in interface java8.util.stream.LongStream: Performs a mutable reduction operation on the elements of this stream.
collect(Supplier<R>, BiConsumer<R, ? super T>, BiConsumer<R, R>) - Method in interface java8.util.stream.Stream: Performs a mutable reduction operation on the elements of this stream.
collect(Collector<? super T, A, R>) - Method in interface java8.util.stream.Stream: Performs a mutable reduction operation on the elements of this stream using a Collector.
collectingAndThen(Collector<T, A, R>, Function<R, RR>) - Static method in class java8.util.stream.Collectors: Adapts a Collector to perform an additional finishing transformation.
Collector<T,A,R> - Interface in java8.util.stream: A mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed.
Collector.Characteristics - Enum in java8.util.stream: Characteristics indicating properties of a Collector, which can be used to optimize reduction implementations.
Collectors - Class in java8.util.stream: Implementations of Collector that implement various useful reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.
combine(DoubleSummaryStatistics) - Method in class java8.util.DoubleSummaryStatistics: Combines the state of another DoubleSummaryStatistics into this one.
combine(IntSummaryStatistics) - Method in class java8.util.IntSummaryStatistics: Combines the state of another IntSummaryStatistics into this one.
combine(LongSummaryStatistics) - Method in class java8.util.LongSummaryStatistics: Combines the state of another LongSummaryStatistics into this one.
combiner() - Method in interface java8.util.stream.Collector: A function that accepts two partial results and merges them.
commonPool() - Static method in class java8.util.concurrent.ForkJoinPool: Returns the common pool instance.
Comparators - Class in java8.util: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Comparator interface.
compare(int, int) - Static method in class java8.lang.Integers: Compares two int values numerically.
compare(long, long) - Static method in class java8.lang.Longs: Compares two long values numerically.
compare(T, T, Comparator<? super T>) - Static method in class java8.util.Objects: Returns 0 if the arguments are identical and c.compare(a, b) otherwise.
compareAndSetForkJoinTaskTag(short, short) - Method in class java8.util.concurrent.ForkJoinTask: Atomically conditionally sets the tag value for this task.
compareAndSetPendingCount(int, int) - Method in class java8.util.concurrent.CountedCompleter: Sets (atomically) the pending count to the given count only if it currently holds the given expected value.
compareUnsigned(int, int) - Static method in class java8.lang.Integers: Compares two int values numerically treating the values as unsigned.
compareUnsigned(long, long) - Static method in class java8.lang.Longs: Compares two long values numerically treating the values as unsigned.
comparing(Function<? super T, ? extends U>, Comparator<? super U>) - Static method in class java8.util.Comparators: Accepts a function that extracts a sort key from a type T, and returns a Comparator<T> that compares by that sort key using the specified Comparator.
comparing(Function<? super T, ? extends U>) - Static method in class java8.util.Comparators: Accepts a function that extracts a Comparable sort key from a type T, and returns a Comparator<T> that compares by that sort key.
comparingByKey() - Static method in class java8.util.Maps.Entry: Returns a comparator that compares Map.Entry in natural order on key.
comparingByKey(Comparator<? super K>) - Static method in class java8.util.Maps.Entry: Returns a comparator that compares Map.Entry by key using the given Comparator.
comparingByValue() - Static method in class java8.util.Maps.Entry: Returns a comparator that compares Map.Entry in natural order on value.
comparingByValue(Comparator<? super V>) - Static method in class java8.util.Maps.Entry: Returns a comparator that compares Map.Entry by value using the given Comparator.
comparingDouble(ToDoubleFunction<? super T>) - Static method in class java8.util.Comparators: Accepts a function that extracts a double sort key from a type T, and returns a Comparator<T> that compares by that sort key.
comparingInt(ToIntFunction<? super T>) - Static method in class java8.util.Comparators: Accepts a function that extracts an int sort key from a type T, and returns a Comparator<T> that compares by that sort key.
comparingLong(ToLongFunction<? super T>) - Static method in class java8.util.Comparators: Accepts a function that extracts a long sort key from a type T, and returns a Comparator<T> that compares by that sort key.
CompletableFuture<T> - Class in java8.util.concurrent: A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion.
CompletableFuture() - Constructor for class java8.util.concurrent.CompletableFuture: Creates a new incomplete CompletableFuture.
CompletableFuture.AsynchronousCompletionTask - Interface in java8.util.concurrent: A marker interface identifying asynchronous tasks produced by async methods.
complete(T) - Method in class java8.util.concurrent.CompletableFuture: If not already completed, sets the value returned by CompletableFuture.get() and related methods to the given value.
complete(T) - Method in class java8.util.concurrent.CountedCompleter: Regardless of pending count, invokes CountedCompleter.onCompletion(CountedCompleter), marks this task as complete and further triggers CountedCompleter.tryComplete() on this task's completer, if one exists.
complete(V) - Method in class java8.util.concurrent.ForkJoinTask: Completes this task, and if not already aborted or cancelled, returning the given value as the result of subsequent invocations of join and related operations.
completedFuture(U) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is already completed with the given value.
completeExceptionally(Throwable) - Method in class java8.util.concurrent.CompletableFuture: If not already completed, causes invocations of CompletableFuture.get() and related methods to throw the given exception.
completeExceptionally(Throwable) - Method in class java8.util.concurrent.ForkJoinTask: Completes this task abnormally, and if not already aborted or cancelled, causes it to throw the given exception upon join and related operations.
CompletionException - Exception in java8.util.concurrent: Exception thrown when an error or other exception is encountered in the course of completing a result or task.
CompletionException() - Constructor for exception java8.util.concurrent.CompletionException: Constructs a CompletionException with no detail message.
CompletionException(String) - Constructor for exception java8.util.concurrent.CompletionException: Constructs a CompletionException with the specified detail message.
CompletionException(String, Throwable) - Constructor for exception java8.util.concurrent.CompletionException: Constructs a CompletionException with the specified detail message and cause.
CompletionException(Throwable) - Constructor for exception java8.util.concurrent.CompletionException: Constructs a CompletionException with the specified cause.
CompletionStage<T> - Interface in java8.util.concurrent: A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
compose(DoubleUnaryOperator, DoubleUnaryOperator) - Static method in class java8.util.function.DoubleUnaryOperators: Returns a composed operator that first applies the before operator to its input, and then applies the this_ operator to the result.
compose(Function<? super T, ? extends R>, Function<? super V, ? extends T>) - Static method in class java8.util.function.Functions: Returns a composed function that first applies the before function to its input, and then applies the this_ function to the result.
compose(IntUnaryOperator, IntUnaryOperator) - Static method in class java8.util.function.IntUnaryOperators: Returns a composed operator that first applies the before operator to its input, and then applies the this_ operator to the result.
compose(LongUnaryOperator, LongUnaryOperator) - Static method in class java8.util.function.LongUnaryOperators: Returns a composed operator that first applies the before operator to its input, and then applies the this_ operator to the result.
compute() - Method in class java8.util.concurrent.CountedCompleter: The main computation performed by this task.
compute() - Method in class java8.util.concurrent.RecursiveAction: The main computation performed by this task.
compute() - Method in class java8.util.concurrent.RecursiveTask: The main computation performed by this task.
compute(Map<K, V>, K, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.Maps: Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
computeIfAbsent(Map<K, V>, K, Function<? super K, ? extends V>) - Static method in class java8.util.Maps: If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into the passed map unless null.
computeIfAbsentConcurrent(ConcurrentMap<K, V>, K, Function<? super K, ? extends V>) - Static method in class java8.util.Maps: If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into the passed map unless null.
computeIfPresent(Map<K, V>, K, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.Maps: If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
concat(DoubleStream, DoubleStream) - Static method in class java8.util.stream.DoubleStreams: Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
concat(IntStream, IntStream) - Static method in class java8.util.stream.IntStreams: Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
concat(LongStream, LongStream) - Static method in class java8.util.stream.LongStreams: Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
concat(Stream<? extends T>, Stream<? extends T>) - Static method in class java8.util.stream.RefStreams: Creates a lazily concatenated Stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
concat(Stream<? extends T>, Stream<? extends T>) - Static method in class java8.util.stream.StreamSupport: Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
CONCURRENT - Static variable in interface java8.util.Spliterator: Characteristic value signifying that the element source may be safely concurrently modified (allowing additions, replacements, and/or removals) by multiple threads without external synchronization.
Consumer<T> - Interface in java8.util.function: Represents an operation that accepts a single input argument and returns no result.
Consumers - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Consumer interface.
count() - Method in interface java8.util.stream.DoubleStream: Returns the count of elements in this stream.
count() - Method in interface java8.util.stream.IntStream: Returns the count of elements in this stream.
count() - Method in interface java8.util.stream.LongStream: Returns the count of elements in this stream.
count() - Method in interface java8.util.stream.Stream: Returns the count of elements in this stream.
CountedCompleter<T> - Class in java8.util.concurrent: A ForkJoinTask with a completion action performed when triggered and there are no remaining pending actions.
CountedCompleter(CountedCompleter<?>, int) - Constructor for class java8.util.concurrent.CountedCompleter: Creates a new CountedCompleter with the given completer and initial pending count.
CountedCompleter(CountedCompleter<?>) - Constructor for class java8.util.concurrent.CountedCompleter: Creates a new CountedCompleter with the given completer and an initial pending count of zero.
CountedCompleter() - Constructor for class java8.util.concurrent.CountedCompleter: Creates a new CountedCompleter with no completer and an initial pending count of zero.
counting() - Static method in class java8.util.stream.Collectors: Returns a Collector accepting elements of type T that counts the number of input elements.
current() - Static method in class java8.util.concurrent.ThreadLocalRandom: Returns the current thread's ThreadLocalRandom.

D

decrement() - Method in class java8.util.concurrent.atomic.LongAdder: Equivalent to add(-1).
decrementPendingCountUnlessZero() - Method in class java8.util.concurrent.CountedCompleter: If the pending count is nonzero, (atomically) decrements it.
deepEquals(Object, Object) - Static method in class java8.util.Objects: Returns true if the arguments are deeply equal to each other and false otherwise.
defaultForkJoinWorkerThreadFactory - Static variable in class java8.util.concurrent.ForkJoinPool: Creates a new ForkJoinWorkerThread.
DISTINCT - Static variable in interface java8.util.Spliterator: Characteristic value signifying that, for each pair of encountered elements x, y, {@code !
distinct() - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the distinct elements of this stream.
distinct() - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the distinct elements of this stream.
distinct() - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the distinct elements of this stream.
distinct() - Method in interface java8.util.stream.Stream: Returns a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream.
divideUnsigned(int, int) - Static method in class java8.lang.Integers: Returns the unsigned quotient of dividing the first argument by the second where each argument and the result is interpreted as an unsigned value.
divideUnsigned(long, long) - Static method in class java8.lang.Longs: Returns the unsigned quotient of dividing the first argument by the second where each argument and the result is interpreted as an unsigned value.
DoubleAccumulator - Class in java8.util.concurrent.atomic: One or more variables that together maintain a running double value updated using a supplied function.
DoubleAccumulator(DoubleBinaryOperator, double) - Constructor for class java8.util.concurrent.atomic.DoubleAccumulator: Creates a new instance using the given accumulator function and identity element.
DoubleAdder - Class in java8.util.concurrent.atomic: One or more variables that together maintain an initially zero double sum.
DoubleAdder() - Constructor for class java8.util.concurrent.atomic.DoubleAdder: Creates a new adder with initial sum of zero.
DoubleBinaryOperator - Interface in java8.util.function: Represents an operation upon two double-valued operands and producing a double-valued result.
DoubleConsumer - Interface in java8.util.function: Represents an operation that accepts a single double-valued argument and returns no result.
DoubleConsumers - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the DoubleConsumer interface.
DoubleFunction<R> - Interface in java8.util.function: Represents a function that accepts a double-valued argument and produces a result.
DoublePredicate - Interface in java8.util.function: Represents a predicate (boolean-valued function) of one double-valued argument.
DoublePredicates - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the DoublePredicate interface.
doubles(long) - Method in class java.util.Random: Throws AssertionError always.
doubles() - Method in class java.util.Random: Throws AssertionError always.
doubles(long, double, double) - Method in class java.util.Random: Throws AssertionError always.
doubles(double, double) - Method in class java.util.Random: Throws AssertionError always.
Doubles - Class in java8.lang: A place for static default implementations of the new Java 8 static methods in the Double class.
doubles(long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a stream producing the given streamSize number of pseudorandom double values, each between zero (inclusive) and one (exclusive).
doubles() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns an effectively unlimited stream of pseudorandom double values, each between zero (inclusive) and one (exclusive).
doubles(long, double, double) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a stream producing the given streamSize number of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).
doubles(double, double) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns an effectively unlimited stream of pseudorandom double values, each conforming to the given origin (inclusive) and bound (exclusive).
doubles(long) - Method in class java8.util.SplittableRandom: Returns a stream producing the given streamSize number of pseudorandom double values from this generator and/or one split from it; each value is between zero (inclusive) and one (exclusive).
doubles() - Method in class java8.util.SplittableRandom: Returns an effectively unlimited stream of pseudorandom double values from this generator and/or one split from it; each value is between zero (inclusive) and one (exclusive).
doubles(long, double, double) - Method in class java8.util.SplittableRandom: Returns a stream producing the given streamSize number of pseudorandom double values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
doubles(double, double) - Method in class java8.util.SplittableRandom: Returns an effectively unlimited stream of pseudorandom double values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
DoubleStream - Interface in java8.util.stream: A sequence of primitive double-valued elements supporting sequential and parallel aggregate operations.
doubleStream(Spliterator.OfDouble, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel DoubleStream from a Spliterator.OfDouble.
doubleStream(Supplier<? extends Spliterator.OfDouble>, int, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel DoubleStream from a Supplier of Spliterator.OfDouble.
DoubleStream.Builder - Interface in java8.util.stream: A mutable builder for a DoubleStream.
DoubleStreams - Class in java8.util.stream: A place for static default implementations of the new Java 8/9 static interface methods and default interface methods (takeWhile(), dropWhile()) in the DoubleStream interface.
DoubleSummaryStatistics - Class in java8.util: A state object for collecting statistics such as count, min, max, sum, and average.
DoubleSummaryStatistics() - Constructor for class java8.util.DoubleSummaryStatistics: Construct an empty instance with zero count, zero sum, Double.POSITIVE_INFINITY min, Double.NEGATIVE_INFINITY max and zero average.
DoubleSupplier - Interface in java8.util.function: Represents a supplier of double-valued results.
DoubleToIntFunction - Interface in java8.util.function: Represents a function that accepts a double-valued argument and produces an int-valued result.
DoubleToLongFunction - Interface in java8.util.function: Represents a function that accepts a double-valued argument and produces a long-valued result.
DoubleUnaryOperator - Interface in java8.util.function: Represents an operation on a single double-valued operand that produces a double-valued result.
DoubleUnaryOperators - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the DoubleUnaryOperator interface.
doubleValue() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Equivalent to DoubleAccumulator.get().
doubleValue() - Method in class java8.util.concurrent.atomic.DoubleAdder: Equivalent to DoubleAdder.sum().
doubleValue() - Method in class java8.util.concurrent.atomic.LongAccumulator: Returns the current value as a double after a widening primitive conversion.
doubleValue() - Method in class java8.util.concurrent.atomic.LongAdder: Returns the LongAdder.sum() as a double after a widening primitive conversion.
drainTasksTo(Collection<? super ForkJoinTask<?>>) - Method in class java8.util.concurrent.ForkJoinPool: Removes all available unexecuted submitted and forked tasks from scheduling queues and adds them to the given collection, without altering their execution status.
dropWhile(DoublePredicate) - Method in interface java8.util.stream.DoubleStream: Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate.
dropWhile(DoubleStream, DoublePredicate) - Static method in class java8.util.stream.DoubleStreams: Returns a stream consisting of the remaining elements of the passed stream after discarding elements that match the given predicate up to, but not discarding, the first element encountered that does not match the predicate.
dropWhile(IntPredicate) - Method in interface java8.util.stream.IntStream: Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate.
dropWhile(IntStream, IntPredicate) - Static method in class java8.util.stream.IntStreams: Returns a stream consisting of the remaining elements of the passed stream after discarding elements that match the given predicate up to, but not discarding, the first element encountered that does not match the predicate.
dropWhile(LongPredicate) - Method in interface java8.util.stream.LongStream: Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate.
dropWhile(LongStream, LongPredicate) - Static method in class java8.util.stream.LongStreams: Returns a stream consisting of the remaining elements of the passed stream after discarding elements that match the given predicate up to, but not discarding, the first element encountered that does not match the predicate.
dropWhile(Stream<? extends T>, Predicate<? super T>) - Static method in class java8.util.stream.RefStreams: Returns, if the passed stream is ordered, a stream consisting of the remaining elements of the passed stream after dropping the longest prefix of elements that match the given predicate.
dropWhile(Predicate<? super T>) - Method in interface java8.util.stream.Stream: Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate.

E

empty() - Static method in class java8.util.Optional: Returns an empty Optional instance.
empty() - Static method in class java8.util.OptionalDouble: Returns an empty OptionalDouble instance.
empty() - Static method in class java8.util.OptionalInt: Returns an empty OptionalInt instance.
empty() - Static method in class java8.util.OptionalLong: Returns an empty OptionalLong instance.
empty() - Static method in class java8.util.stream.DoubleStreams: Returns an empty sequential DoubleStream.
empty() - Static method in class java8.util.stream.IntStreams: Returns an empty sequential IntStream.
empty() - Static method in class java8.util.stream.LongStreams: Returns an empty sequential LongStream.
empty() - Static method in class java8.util.stream.RefStreams: Returns an empty sequential Stream.
empty() - Static method in class java8.util.stream.StreamSupport: Returns an empty sequential Stream.
emptyDoubleSpliterator() - Static method in class java8.util.Spliterators: Creates an empty Spliterator.OfDouble The empty spliterator reports Spliterator.SIZED and Spliterator.SUBSIZED.
emptyIntSpliterator() - Static method in class java8.util.Spliterators: Creates an empty Spliterator.OfInt The empty spliterator reports Spliterator.SIZED and Spliterator.SUBSIZED.
emptyLongSpliterator() - Static method in class java8.util.Spliterators: Creates an empty Spliterator.OfLong The empty spliterator reports Spliterator.SIZED and Spliterator.SUBSIZED.
emptySpliterator() - Static method in class java8.util.Spliterators: Creates an empty Spliterator The empty spliterator reports Spliterator.SIZED and Spliterator.SUBSIZED.
equals(Object, Object) - Static method in class java8.util.Objects: Returns true if the arguments are equal to each other and false otherwise.
equals(Object) - Method in class java8.util.Optional: Indicates whether some other object is "equal to" this Optional.
equals(Object) - Method in class java8.util.OptionalDouble: Indicates whether some other object is "equal to" this OptionalDouble.
equals(Object) - Method in class java8.util.OptionalInt: Indicates whether some other object is "equal to" this OptionalInt.
equals(Object) - Method in class java8.util.OptionalLong: Indicates whether some other object is "equal to" this OptionalLong.
estimateSize() - Method in interface java8.util.Spliterator: Returns an estimate of the number of elements that would be encountered by a Spliterator.forEachRemaining(java8.util.function.Consumer<? super T>) traversal, or returns Long.MAX_VALUE if infinite, unknown, or too expensive to compute.
estimateSize() - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: Returns an estimate of the number of elements that would be encountered by a Spliterator.forEachRemaining(java8.util.function.Consumer<? super T>) traversal, or returns Long.MAX_VALUE if infinite, unknown, or too expensive to compute.
estimateSize() - Method in class java8.util.Spliterators.AbstractIntSpliterator: Returns an estimate of the number of elements that would be encountered by a Spliterator.forEachRemaining(java8.util.function.Consumer<? super T>) traversal, or returns Long.MAX_VALUE if infinite, unknown, or too expensive to compute.
estimateSize() - Method in class java8.util.Spliterators.AbstractLongSpliterator: Returns an estimate of the number of elements that would be encountered by a Spliterator.forEachRemaining(java8.util.function.Consumer<? super T>) traversal, or returns Long.MAX_VALUE if infinite, unknown, or too expensive to compute.
estimateSize() - Method in class java8.util.Spliterators.AbstractSpliterator: Returns an estimate of the number of elements that would be encountered by a Spliterator.forEachRemaining(java8.util.function.Consumer<? super T>) traversal, or returns Long.MAX_VALUE if infinite, unknown, or too expensive to compute.
exceptionally(Function<Throwable, ? extends T>) - Method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is completed when this CompletableFuture completes, with the result of the given function of the exception triggering this CompletableFuture's completion when it completes exceptionally; otherwise, if this CompletableFuture completes normally, then the returned CompletableFuture also completes normally with the same value.
exceptionally(Function<Throwable, ? extends T>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes exceptionally, is executed with this stage's exception as the argument to the supplied function.
exec() - Method in class java8.util.concurrent.CountedCompleter: Implements execution conventions for CountedCompleters.
exec() - Method in class java8.util.concurrent.ForkJoinTask: Immediately performs the base action of this task and returns true if, upon return from this method, this task is guaranteed to have completed normally.
exec() - Method in class java8.util.concurrent.RecursiveAction: Implements execution conventions for RecursiveActions.
exec() - Method in class java8.util.concurrent.RecursiveTask: Implements execution conventions for RecursiveTask.
execute(ForkJoinTask<?>) - Method in class java8.util.concurrent.ForkJoinPool: Arranges for (asynchronous) execution of the given task.
execute(Runnable) - Method in class java8.util.concurrent.ForkJoinPool

F

filter(Predicate<? super T>) - Method in class java8.util.Optional: If a value is present, and the value matches the given predicate, return an Optional describing the value, otherwise return an empty Optional.
filter(DoublePredicate) - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the elements of this stream that match the given predicate.
filter(IntPredicate) - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the elements of this stream that match the given predicate.
filter(LongPredicate) - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the elements of this stream that match the given predicate.
filter(Predicate<? super T>) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the elements of this stream that match the given predicate.
findAny() - Method in interface java8.util.stream.DoubleStream: Returns an OptionalDouble describing some element of the stream, or an empty OptionalDouble if the stream is empty.
findAny() - Method in interface java8.util.stream.IntStream: Returns an OptionalInt describing some element of the stream, or an empty OptionalInt if the stream is empty.
findAny() - Method in interface java8.util.stream.LongStream: Returns an OptionalLong describing some element of the stream, or an empty OptionalLong if the stream is empty.
findAny() - Method in interface java8.util.stream.Stream: Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty.
findFirst() - Method in interface java8.util.stream.DoubleStream: Returns an OptionalDouble describing the first element of this stream, or an empty OptionalDouble if the stream is empty.
findFirst() - Method in interface java8.util.stream.IntStream: Returns an OptionalInt describing the first element of this stream, or an empty OptionalInt if the stream is empty.
findFirst() - Method in interface java8.util.stream.LongStream: Returns an OptionalLong describing the first element of this stream, or an empty OptionalLong if the stream is empty.
findFirst() - Method in interface java8.util.stream.Stream: Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty.
finisher() - Method in interface java8.util.stream.Collector: Perform the final transformation from the intermediate accumulation type A to the final result type R.
firstComplete() - Method in class java8.util.concurrent.CountedCompleter: If this task's pending count is zero, returns this task; otherwise decrements its pending count and returns null.
flatMap(Function<? super T, Optional>) - Method in class java8.util.Optional: If a value is present, apply the provided Optional-bearing mapping function to it, return that result, otherwise return an empty Optional.
flatMap(DoubleFunction<? extends DoubleStream>) - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMap(IntFunction<? extends IntStream>) - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMap(LongFunction<? extends LongStream>) - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMap(Function<? super T, ? extends Stream<? extends R>>) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMapping(Function<? super T, ? extends Stream<? extends U>>, Collector<? super U, A, R>) - Static method in class java8.util.stream.Collectors: Adapts a Collector accepting elements of type U to one accepting elements of type T by applying a flat mapping function to each input element before accumulation.
flatMapToDouble(Function<? super T, ? extends DoubleStream>) - Method in interface java8.util.stream.Stream: Returns an DoubleStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMapToInt(Function<? super T, ? extends IntStream>) - Method in interface java8.util.stream.Stream: Returns an IntStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
flatMapToLong(Function<? super T, ? extends LongStream>) - Method in interface java8.util.stream.Stream: Returns an LongStream consisting of the results of replacing each element of this stream with the contents of a mapped stream produced by applying the provided mapping function to each element.
floatValue() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Returns the current value as a float after a narrowing primitive conversion.
floatValue() - Method in class java8.util.concurrent.atomic.DoubleAdder: Returns the DoubleAdder.sum() as a float after a narrowing primitive conversion.
floatValue() - Method in class java8.util.concurrent.atomic.LongAccumulator: Returns the current value as a float after a widening primitive conversion.
floatValue() - Method in class java8.util.concurrent.atomic.LongAdder: Returns the LongAdder.sum() as a float after a widening primitive conversion.
forceTermination() - Method in class java8.util.concurrent.Phaser: Forces this phaser to enter termination state.
forEach(Iterable<? extends T>, Consumer<? super T>) - Static method in class java8.lang.Iterables: Performs the given action for each element of the passed Iterable until all elements have been processed or the action throws an exception.
forEach(Map<K, V>, BiConsumer<? super K, ? super V>) - Static method in class java8.util.Maps: Performs the given action for each entry in the map until all entries have been processed or the action throws an exception.
forEach(DoubleConsumer) - Method in interface java8.util.stream.DoubleStream: Performs an action for each element of this stream.
forEach(IntConsumer) - Method in interface java8.util.stream.IntStream: Performs an action for each element of this stream.
forEach(LongConsumer) - Method in interface java8.util.stream.LongStream: Performs an action for each element of this stream.
forEach(Consumer<? super T>) - Method in interface java8.util.stream.Stream: Performs an action for each element of this stream.
forEachConcurrent(ConcurrentMap<K, V>, BiConsumer<? super K, ? super V>) - Static method in class java8.util.Maps: Performs the given action for each entry in the map until all entries have been processed or the action throws an exception.
forEachOrdered(DoubleConsumer) - Method in interface java8.util.stream.DoubleStream: Performs an action for each element of this stream, guaranteeing that each element is processed in encounter order for streams that have a defined encounter order.
forEachOrdered(IntConsumer) - Method in interface java8.util.stream.IntStream: Performs an action for each element of this stream, guaranteeing that each element is processed in encounter order for streams that have a defined encounter order.
forEachOrdered(LongConsumer) - Method in interface java8.util.stream.LongStream: Performs an action for each element of this stream, guaranteeing that each element is processed in encounter order for streams that have a defined encounter order.
forEachOrdered(Consumer<? super T>) - Method in interface java8.util.stream.Stream: Performs an action for each element of this stream, in the encounter order of the stream if the stream has a defined encounter order.
forEachRemaining(Iterator<E>, Consumer<? super E>) - Static method in class java8.util.Iterators: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(PrimitiveIterator.OfInt, IntConsumer) - Static method in class java8.util.Iterators: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(PrimitiveIterator.OfLong, LongConsumer) - Static method in class java8.util.Iterators: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(PrimitiveIterator.OfDouble, DoubleConsumer) - Static method in class java8.util.Iterators: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(T_CONS) - Method in interface java8.util.PrimitiveIterator: Performs the given action for each remaining element, in the order elements occur when iterating, until all elements have been processed or the action throws an exception.
forEachRemaining(DoubleConsumer) - Method in interface java8.util.PrimitiveIterator.OfDouble: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(IntConsumer) - Method in interface java8.util.PrimitiveIterator.OfInt: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(LongConsumer) - Method in interface java8.util.PrimitiveIterator.OfLong: Performs the given action for each remaining element until all elements have been processed or the action throws an exception.
forEachRemaining(Consumer<? super T>) - Method in interface java8.util.Spliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(DoubleConsumer) - Method in interface java8.util.Spliterator.OfDouble
forEachRemaining(Consumer<? super Double>) - Method in interface java8.util.Spliterator.OfDouble: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(IntConsumer) - Method in interface java8.util.Spliterator.OfInt
forEachRemaining(Consumer<? super Integer>) - Method in interface java8.util.Spliterator.OfInt: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(LongConsumer) - Method in interface java8.util.Spliterator.OfLong
forEachRemaining(Consumer<? super Long>) - Method in interface java8.util.Spliterator.OfLong: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(T_CONS) - Method in interface java8.util.Spliterator.OfPrimitive: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(DoubleConsumer) - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Consumer<? super Double>) - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(IntConsumer) - Method in class java8.util.Spliterators.AbstractIntSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Consumer<? super Integer>) - Method in class java8.util.Spliterators.AbstractIntSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(LongConsumer) - Method in class java8.util.Spliterators.AbstractLongSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Consumer<? super Long>) - Method in class java8.util.Spliterators.AbstractLongSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Consumer<? super T>) - Method in class java8.util.Spliterators.AbstractSpliterator: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator<T>, Consumer<? super T>) - Static method in class java8.util.Spliterators: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfDouble, DoubleConsumer) - Static method in class java8.util.Spliterators.OfDouble: Performs the given action for each remaining element of the passed Spliterator, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfDouble, Consumer<? super Double>) - Static method in class java8.util.Spliterators.OfDouble: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfInt, IntConsumer) - Static method in class java8.util.Spliterators.OfInt: Performs the given action for each remaining element of the passed Spliterator, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfInt, Consumer<? super Integer>) - Static method in class java8.util.Spliterators.OfInt: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfLong, LongConsumer) - Static method in class java8.util.Spliterators.OfLong: Performs the given action for each remaining element of the passed Spliterator, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfLong, Consumer<? super Long>) - Static method in class java8.util.Spliterators.OfLong: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
forEachRemaining(Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>, T_CONS) - Static method in class java8.util.Spliterators.OfPrimitive: Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
fork() - Method in class java8.util.concurrent.ForkJoinTask: Arranges to asynchronously execute this task in the pool the current task is running in, if applicable, or using the ForkJoinPool.commonPool() if not ForkJoinTask.inForkJoinPool().
ForkJoinPool - Class in java8.util.concurrent: An ExecutorService for running ForkJoinTasks.
ForkJoinPool() - Constructor for class java8.util.concurrent.ForkJoinPool: Creates a ForkJoinPool with parallelism equal to Runtime.availableProcessors(), using the default thread factory, no UncaughtExceptionHandler, and non-async LIFO processing mode.
ForkJoinPool(int) - Constructor for class java8.util.concurrent.ForkJoinPool: Creates a ForkJoinPool with the indicated parallelism level, the default thread factory, no UncaughtExceptionHandler, and non-async LIFO processing mode.
ForkJoinPool(int, ForkJoinPool.ForkJoinWorkerThreadFactory, Thread.UncaughtExceptionHandler, boolean) - Constructor for class java8.util.concurrent.ForkJoinPool: Creates a ForkJoinPool with the given parameters.
ForkJoinPool.ForkJoinWorkerThreadFactory - Interface in java8.util.concurrent: Factory for creating new ForkJoinWorkerThreads.
ForkJoinPool.ManagedBlocker - Interface in java8.util.concurrent: Interface for extending managed parallelism for tasks running in ForkJoinPools.
ForkJoinTask<V> - Class in java8.util.concurrent: Abstract base class for tasks that run within a ForkJoinPool.
ForkJoinTask() - Constructor for class java8.util.concurrent.ForkJoinTask
ForkJoinWorkerThread - Class in java8.util.concurrent: A thread managed by a ForkJoinPool, which executes ForkJoinTasks.
ForkJoinWorkerThread(ForkJoinPool) - Constructor for class java8.util.concurrent.ForkJoinWorkerThread: Creates a ForkJoinWorkerThread operating in the given pool.
Function<T,R> - Interface in java8.util.function: Represents a function that accepts one argument and produces a result.
FunctionalInterface - Annotation Type in java8.lang: An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification.
Functions - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Function interface.

G

generate(DoubleSupplier) - Static method in class java8.util.stream.DoubleStreams: Returns an infinite sequential unordered stream where each element is generated by the provided DoubleSupplier.
generate(IntSupplier) - Static method in class java8.util.stream.IntStreams: Returns an infinite sequential unordered stream where each element is generated by the provided IntSupplier.
generate(LongSupplier) - Static method in class java8.util.stream.LongStreams: Returns an infinite sequential unordered stream where each element is generated by the provided LongSupplier.
generate(Supplier<? extends T>) - Static method in class java8.util.stream.RefStreams: Returns an infinite sequential unordered Stream where each element is generated by the provided Supplier.
generate(Supplier<? extends T>) - Static method in class java8.util.stream.StreamSupport: Returns an infinite sequential unordered stream where each element is generated by the provided Supplier.
get() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Returns the current value.
get() - Method in class java8.util.concurrent.atomic.LongAccumulator: Returns the current value.
get() - Method in class java8.util.concurrent.CompletableFuture: Waits if necessary for this future to complete, and then returns its result.
get(long, TimeUnit) - Method in class java8.util.concurrent.CompletableFuture: Waits if necessary for at most the given time for this future to complete, and then returns its result, if available.
get() - Method in class java8.util.concurrent.ForkJoinTask: Waits if necessary for the computation to complete, and then retrieves its result.
get(long, TimeUnit) - Method in class java8.util.concurrent.ForkJoinTask: Waits if necessary for at most the given time for the computation to complete, and then retrieves its result, if available.
get() - Method in interface java8.util.function.Supplier: Gets a result.
get() - Method in class java8.util.Optional: If a value is present in this Optional, returns the value, otherwise throws NoSuchElementException.
getActiveThreadCount() - Method in class java8.util.concurrent.ForkJoinPool: Returns an estimate of the number of threads that are currently stealing or executing tasks.
getArrivedParties() - Method in class java8.util.concurrent.Phaser: Returns the number of registered parties that have arrived at the current phase of this phaser.
getAsBoolean() - Method in interface java8.util.function.BooleanSupplier: Gets a result.
getAsDouble() - Method in interface java8.util.function.DoubleSupplier: Gets a result.
getAsDouble() - Method in class java8.util.OptionalDouble: If a value is present in this OptionalDouble, returns the value, otherwise throws NoSuchElementException.
getAsInt() - Method in interface java8.util.function.IntSupplier: Gets a result.
getAsInt() - Method in class java8.util.OptionalInt: If a value is present in this OptionalInt, returns the value, otherwise throws NoSuchElementException.
getAsLong() - Method in interface java8.util.function.LongSupplier: Gets a result.
getAsLong() - Method in class java8.util.OptionalLong: If a value is present in this OptionalLong, returns the value, otherwise throws NoSuchElementException.
getAsyncMode() - Method in class java8.util.concurrent.ForkJoinPool: Returns true if this pool uses local first-in-first-out scheduling mode for forked tasks that are never joined.
getAverage() - Method in class java8.util.DoubleSummaryStatistics: Returns the arithmetic mean of values recorded, or zero if no values have been recorded.
getAverage() - Method in class java8.util.IntSummaryStatistics: Returns the arithmetic mean of values recorded, or zero if no values have been recorded.
getAverage() - Method in class java8.util.LongSummaryStatistics: Returns the arithmetic mean of values recorded, or zero if no values have been recorded.
getCommonPoolParallelism() - Static method in class java8.util.concurrent.ForkJoinPool: Returns the targeted parallelism level of the common pool.
getComparator() - Method in interface java8.util.Spliterator: If this Spliterator's source is Spliterator.SORTED by a Comparator, returns that Comparator.
getComparator() - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: If this Spliterator's source is Spliterator.SORTED by a Comparator, returns that Comparator.
getComparator() - Method in class java8.util.Spliterators.AbstractIntSpliterator: If this Spliterator's source is Spliterator.SORTED by a Comparator, returns that Comparator.
getComparator() - Method in class java8.util.Spliterators.AbstractLongSpliterator: If this Spliterator's source is Spliterator.SORTED by a Comparator, returns that Comparator.
getComparator() - Method in class java8.util.Spliterators.AbstractSpliterator: If this Spliterator's source is Spliterator.SORTED by a Comparator, returns that Comparator.
getComparator(Spliterator<T>) - Static method in class java8.util.Spliterators: If the Spliterator's source is Spliterator.SORTED by a Comparator, returns that Comparator.
getCompleter() - Method in class java8.util.concurrent.CountedCompleter: Returns the completer established in this task's constructor, or null if none.
getCount() - Method in class java8.util.DoubleSummaryStatistics: Return the count of values recorded.
getCount() - Method in class java8.util.IntSummaryStatistics: Returns the count of values recorded.
getCount() - Method in class java8.util.LongSummaryStatistics: Returns the count of values recorded.
getExactSizeIfKnown() - Method in interface java8.util.Spliterator: Convenience method that returns Spliterator.estimateSize() if this Spliterator is Spliterator.SIZED, else -1.
getExactSizeIfKnown() - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: Convenience method that returns Spliterator.estimateSize() if this Spliterator is Spliterator.SIZED, else -1.
getExactSizeIfKnown() - Method in class java8.util.Spliterators.AbstractIntSpliterator: Convenience method that returns Spliterator.estimateSize() if this Spliterator is Spliterator.SIZED, else -1.
getExactSizeIfKnown() - Method in class java8.util.Spliterators.AbstractLongSpliterator: Convenience method that returns Spliterator.estimateSize() if this Spliterator is Spliterator.SIZED, else -1.
getExactSizeIfKnown() - Method in class java8.util.Spliterators.AbstractSpliterator: Convenience method that returns Spliterator.estimateSize() if this Spliterator is Spliterator.SIZED, else -1.
getExactSizeIfKnown(Spliterator<T>) - Static method in class java8.util.Spliterators: Convenience method that returns Spliterator.estimateSize() if the this_ Spliterator is Spliterator.SIZED, else -1.
getException() - Method in class java8.util.concurrent.ForkJoinTask: Returns the exception thrown by the base computation, or a CancellationException if cancelled, or null if none or if the method has not yet completed.
getFactory() - Method in class java8.util.concurrent.ForkJoinPool: Returns the factory used for constructing new workers.
getForkJoinTaskTag() - Method in class java8.util.concurrent.ForkJoinTask: Returns the tag for this task.
getMax() - Method in class java8.util.DoubleSummaryStatistics: Returns the maximum recorded value, Double.NaN if any recorded value was NaN or Double.NEGATIVE_INFINITY if no values were recorded.
getMax() - Method in class java8.util.IntSummaryStatistics: Returns the maximum value recorded, or Integer.MIN_VALUE if no values have been recorded.
getMax() - Method in class java8.util.LongSummaryStatistics: Returns the maximum value recorded, or Long.MIN_VALUE if no values have been recorded
getMin() - Method in class java8.util.DoubleSummaryStatistics: Returns the minimum recorded value, Double.NaN if any recorded value was NaN or Double.POSITIVE_INFINITY if no values were recorded.
getMin() - Method in class java8.util.IntSummaryStatistics: Returns the minimum value recorded, or Integer.MAX_VALUE if no values have been recorded.
getMin() - Method in class java8.util.LongSummaryStatistics: Returns the minimum value recorded, or Long.MAX_VALUE if no values have been recorded.
getNow(T) - Method in class java8.util.concurrent.CompletableFuture: Returns the result value (or throws any encountered exception) if completed, else returns the given valueIfAbsent.
getNumberOfDependents() - Method in class java8.util.concurrent.CompletableFuture: Returns the estimated number of CompletableFutures whose completions are awaiting completion of this CompletableFuture.
getOrDefault(Map<K, V>, Object, V) - Static method in class java8.util.Maps: Returns the value to which the specified key is mapped, or defaultValue if the map contains no mapping for the key.
getOrDefaultConcurrent(ConcurrentMap<K, V>, Object, V) - Static method in class java8.util.Maps: Returns the value to which the specified key is mapped, or defaultValue if the map contains no mapping for the key.
getParallelism() - Method in class java8.util.concurrent.ForkJoinPool: Returns the targeted parallelism level of this pool.
getParent() - Method in class java8.util.concurrent.Phaser: Returns the parent of this phaser, or null if none.
getPendingCount() - Method in class java8.util.concurrent.CountedCompleter: Returns the current pending count.
getPhase() - Method in class java8.util.concurrent.Phaser: Returns the current phase number.
getPool() - Static method in class java8.util.concurrent.ForkJoinTask: Returns the pool hosting the current task execution, or null if this task is executing outside of any ForkJoinPool.
getPool() - Method in class java8.util.concurrent.ForkJoinWorkerThread: Returns the pool hosting this thread.
getPoolIndex() - Method in class java8.util.concurrent.ForkJoinWorkerThread: Returns the unique index number of this thread in its pool.
getPoolSize() - Method in class java8.util.concurrent.ForkJoinPool: Returns the number of worker threads that have started but not yet terminated.
getQueuedSubmissionCount() - Method in class java8.util.concurrent.ForkJoinPool: Returns an estimate of the number of tasks submitted to this pool that have not yet begun executing.
getQueuedTaskCount() - Method in class java8.util.concurrent.ForkJoinPool: Returns an estimate of the total number of tasks currently held in queues by worker threads (but not including tasks submitted to the pool that have not begun executing).
getQueuedTaskCount() - Static method in class java8.util.concurrent.ForkJoinTask: Returns an estimate of the number of tasks that have been forked by the current worker thread but not yet executed.
getRawResult() - Method in class java8.util.concurrent.CountedCompleter: Returns the result of the computation.
getRawResult() - Method in class java8.util.concurrent.ForkJoinTask: Returns the result that would be returned by ForkJoinTask.join(), even if this task completed abnormally, or null if this task is not known to have been completed.
getRawResult() - Method in class java8.util.concurrent.RecursiveAction: Always returns null.
getRawResult() - Method in class java8.util.concurrent.RecursiveTask
getRegisteredParties() - Method in class java8.util.concurrent.Phaser: Returns the number of parties registered at this phaser.
getRoot() - Method in class java8.util.concurrent.CountedCompleter: Returns the root of the current computation; i.e., this task if it has no completer, else its completer's root.
getRoot() - Method in class java8.util.concurrent.Phaser: Returns the root ancestor of this phaser, which is the same as this phaser if it has no parent.
getRunningThreadCount() - Method in class java8.util.concurrent.ForkJoinPool: Returns an estimate of the number of worker threads that are not blocked waiting to join tasks or for other managed synchronization.
getStealCount() - Method in class java8.util.concurrent.ForkJoinPool: Returns an estimate of the total number of tasks stolen from one thread's work queue by another.
getSum() - Method in class java8.util.DoubleSummaryStatistics: Returns the sum of values recorded, or zero if no values have been recorded.
getSum() - Method in class java8.util.IntSummaryStatistics: Returns the sum of values recorded, or zero if no values have been recorded.
getSum() - Method in class java8.util.LongSummaryStatistics: Returns the sum of values recorded, or zero if no values have been recorded.
getSurplusQueuedTaskCount() - Static method in class java8.util.concurrent.ForkJoinTask: Returns an estimate of how many more locally queued tasks are held by the current worker thread than there are other worker threads that might steal them, or zero if this thread is not operating in a ForkJoinPool.
getThenReset() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Equivalent in effect to DoubleAccumulator.get() followed by DoubleAccumulator.reset().
getThenReset() - Method in class java8.util.concurrent.atomic.LongAccumulator: Equivalent in effect to LongAccumulator.get() followed by LongAccumulator.reset().
getUnarrivedParties() - Method in class java8.util.concurrent.Phaser: Returns the number of registered parties that have not yet arrived at the current phase of this phaser.
getUncaughtExceptionHandler() - Method in class java8.util.concurrent.ForkJoinPool: Returns the handler for internal worker threads that terminate due to unrecoverable errors encountered while executing tasks.
groupingBy(Function<? super T, ? extends K>) - Static method in class java8.util.stream.Collectors: Returns a Collector implementing a "group by" operation on input elements of type T, grouping elements according to a classification function, and returning the results in a Map.
groupingBy(Function<? super T, ? extends K>, Collector<? super T, A, D>) - Static method in class java8.util.stream.Collectors: Returns a Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
groupingBy(Function<? super T, ? extends K>, Supplier<M>, Collector<? super T, A, D>) - Static method in class java8.util.stream.Collectors: Returns a Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
groupingByConcurrent(Function<? super T, ? extends K>) - Static method in class java8.util.stream.Collectors: Returns a concurrent Collector implementing a "group by" operation on input elements of type T, grouping elements according to a classification function.
groupingByConcurrent(Function<? super T, ? extends K>, Collector<? super T, A, D>) - Static method in class java8.util.stream.Collectors: Returns a concurrent Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
groupingByConcurrent(Function<? super T, ? extends K>, Supplier<M>, Collector<? super T, A, D>) - Static method in class java8.util.stream.Collectors: Returns a concurrent Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.

H

handle(BiFunction<? super T, Throwable, ? extends U>) - Method in class java8.util.concurrent.CompletableFuture
handle(BiFunction<? super T, Throwable, ? extends U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes either normally or exceptionally, is executed with this stage's result and exception as arguments to the supplied function.
handleAsync(BiFunction<? super T, Throwable, ? extends U>) - Method in class java8.util.concurrent.CompletableFuture
handleAsync(BiFunction<? super T, Throwable, ? extends U>, Executor) - Method in class java8.util.concurrent.CompletableFuture
handleAsync(BiFunction<? super T, Throwable, ? extends U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes either normally or exceptionally, is executed using this stage's default asynchronous execution facility, with this stage's result and exception as arguments to the supplied function.
handleAsync(BiFunction<? super T, Throwable, ? extends U>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes either normally or exceptionally, is executed using the supplied executor, with this stage's result and exception as arguments to the supplied function.
hasCharacteristics(int) - Method in interface java8.util.Spliterator: Returns true if this Spliterator's Spliterator.characteristics() contain all of the given characteristics.
hasCharacteristics(int) - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: Returns true if this Spliterator's Spliterator.characteristics() contain all of the given characteristics.
hasCharacteristics(int) - Method in class java8.util.Spliterators.AbstractIntSpliterator: Returns true if this Spliterator's Spliterator.characteristics() contain all of the given characteristics.
hasCharacteristics(int) - Method in class java8.util.Spliterators.AbstractLongSpliterator: Returns true if this Spliterator's Spliterator.characteristics() contain all of the given characteristics.
hasCharacteristics(int) - Method in class java8.util.Spliterators.AbstractSpliterator: Returns true if this Spliterator's Spliterator.characteristics() contain all of the given characteristics.
hasCharacteristics(Spliterator<T>, int) - Static method in class java8.util.Spliterators: Returns true if the this_ Spliterator's Spliterator.characteristics() contain all of the given characteristics.
hash(Object...) - Static method in class java8.util.Objects: Generates a hash code for a sequence of input values.
hashCode(double) - Static method in class java8.lang.Doubles: Returns a hash code for a double value; compatible with Double.hashCode().
hashCode(int) - Static method in class java8.lang.Integers: Returns a hash code for a int value; compatible with Integer.hashCode().
hashCode(long) - Static method in class java8.lang.Longs: Returns a hash code for a long value; compatible with Long.hashCode().
hashCode(Object) - Static method in class java8.util.Objects: Returns the hash code of a non-null argument and 0 for a null argument.
hashCode() - Method in class java8.util.Optional: Returns the hash code value of the present value, if any, or 0 (zero) if no value is present.
hashCode() - Method in class java8.util.OptionalDouble: Returns the hash code value of the present value, if any, or 0 (zero) if no value is present.
hashCode() - Method in class java8.util.OptionalInt: Returns the hash code value of the present value, if any, or 0 (zero) if no value is present.
hashCode() - Method in class java8.util.OptionalLong: Returns the hash code value of the present value, if any, or 0 (zero) if no value is present.
hasQueuedSubmissions() - Method in class java8.util.concurrent.ForkJoinPool: Returns true if there are any tasks submitted to this pool that have not yet begun executing.
helpComplete(int) - Method in class java8.util.concurrent.CountedCompleter: If this task has not completed, attempts to process at most the given number of other unprocessed tasks for which this task is on the completion path, if any are known to exist.
helpQuiesce() - Static method in class java8.util.concurrent.ForkJoinTask: Possibly executes tasks until the pool hosting the current task is quiescent.

I

identity() - Static method in class java8.util.function.DoubleUnaryOperators: Returns a unary operator that always returns its input argument.
identity() - Static method in class java8.util.function.Functions: Returns a function that always returns its input argument.
identity() - Static method in class java8.util.function.IntUnaryOperators: Returns a unary operator that always returns its input argument.
identity() - Static method in class java8.util.function.LongUnaryOperators: Returns a unary operator that always returns its input argument.
identity() - Static method in class java8.util.function.UnaryOperators: Returns a unary operator that always returns its input argument.
ifPresent(Consumer<? super T>) - Method in class java8.util.Optional: If a value is present, perform the given action with the value, otherwise do nothing.
ifPresent(DoubleConsumer) - Method in class java8.util.OptionalDouble: If a value is present, perform the given action with the value, otherwise do nothing.
ifPresent(IntConsumer) - Method in class java8.util.OptionalInt: If a value is present, perform the given action with the value, otherwise do nothing.
ifPresent(LongConsumer) - Method in class java8.util.OptionalLong: If a value is present, perform the given action with the value, otherwise do nothing.
ifPresentOrElse(Consumer<? super T>, Runnable) - Method in class java8.util.Optional: If a value is present, perform the given action with the value, otherwise perform the given empty-based action.
ifPresentOrElse(DoubleConsumer, Runnable) - Method in class java8.util.OptionalDouble: If a value is present, perform the given action with the value, otherwise perform the given empty-based action.
ifPresentOrElse(IntConsumer, Runnable) - Method in class java8.util.OptionalInt: If a value is present, perform the given action with the value, otherwise perform the given empty-based action.
ifPresentOrElse(LongConsumer, Runnable) - Method in class java8.util.OptionalLong: If a value is present, perform the given action with the value, otherwise perform the given empty-based action.
IMMUTABLE - Static variable in interface java8.util.Spliterator: Characteristic value signifying that the element source cannot be structurally modified; that is, the size of the source cannot be changed, nor can it be modified in a way that would interfere with traversal.
increment() - Method in class java8.util.concurrent.atomic.LongAdder: Equivalent to add(1).
inForkJoinPool() - Static method in class java8.util.concurrent.ForkJoinTask: Returns true if the current thread is a ForkJoinWorkerThread executing as a ForkJoinPool computation.
IntBinaryOperator - Interface in java8.util.function: Represents an operation upon two int-valued operands and producing an int-valued result.
IntConsumer - Interface in java8.util.function: Represents an operation that accepts a single int-valued argument and returns no result.
IntConsumers - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the IntConsumer interface.
Integers - Class in java8.lang: A place for static default implementations of the new Java 8 static methods in the Integer class.
IntFunction<R> - Interface in java8.util.function: Represents a function that accepts an int-valued argument and produces a result.
IntPredicate - Interface in java8.util.function: Represents a predicate (boolean-valued function) of one int-valued argument.
IntPredicates - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the IntPredicate interface.
ints(long) - Method in class java.util.Random: Throws AssertionError always.
ints() - Method in class java.util.Random: Throws AssertionError always.
ints(long, int, int) - Method in class java.util.Random: Throws AssertionError always.
ints(int, int) - Method in class java.util.Random: Throws AssertionError always.
ints(long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a stream producing the given streamSize number of pseudorandom int values.
ints() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns an effectively unlimited stream of pseudorandom int values.
ints(long, int, int) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a stream producing the given streamSize number of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).
ints(int, int) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns an effectively unlimited stream of pseudorandom int values, each conforming to the given origin (inclusive) and bound (exclusive).
ints(long) - Method in class java8.util.SplittableRandom: Returns a stream producing the given streamSize number of pseudorandom int values from this generator and/or one split from it.
ints() - Method in class java8.util.SplittableRandom: Returns an effectively unlimited stream of pseudorandom int values from this generator and/or one split from it.
ints(long, int, int) - Method in class java8.util.SplittableRandom: Returns a stream producing the given streamSize number of pseudorandom int values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
ints(int, int) - Method in class java8.util.SplittableRandom: Returns an effectively unlimited stream of pseudorandom int values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
IntStream - Interface in java8.util.stream: A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations.
intStream(Spliterator.OfInt, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel IntStream from a Spliterator.OfInt.
intStream(Supplier<? extends Spliterator.OfInt>, int, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel IntStream from a Supplier of Spliterator.OfInt.
IntStream.Builder - Interface in java8.util.stream: A mutable builder for an IntStream.
IntStreams - Class in java8.util.stream: A place for static default implementations of the new Java 8/9 static interface methods and default interface methods (takeWhile(), dropWhile()) in the IntStream interface.
IntSummaryStatistics - Class in java8.util: A state object for collecting statistics such as count, min, max, sum, and average.
IntSummaryStatistics() - Constructor for class java8.util.IntSummaryStatistics: Construct an empty instance with zero count, zero sum, Integer.MAX_VALUE min, Integer.MIN_VALUE max and zero average.
IntSupplier - Interface in java8.util.function: Represents a supplier of int-valued results.
IntToDoubleFunction - Interface in java8.util.function: Represents a function that accepts an int-valued argument and produces a double-valued result.
IntToLongFunction - Interface in java8.util.function: Represents a function that accepts an int-valued argument and produces a long-valued result.
IntUnaryOperator - Interface in java8.util.function: Represents an operation on a single int-valued operand that produces an int-valued result.
IntUnaryOperators - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the IntUnaryOperator interface.
intValue() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Returns the current value as an int after a narrowing primitive conversion.
intValue() - Method in class java8.util.concurrent.atomic.DoubleAdder: Returns the DoubleAdder.sum() as an int after a narrowing primitive conversion.
intValue() - Method in class java8.util.concurrent.atomic.LongAccumulator: Returns the current value as an int after a narrowing primitive conversion.
intValue() - Method in class java8.util.concurrent.atomic.LongAdder: Returns the LongAdder.sum() as an int after a narrowing primitive conversion.
invoke(ForkJoinTask<T>) - Method in class java8.util.concurrent.ForkJoinPool: Performs the given task, returning its result upon completion.
invoke() - Method in class java8.util.concurrent.ForkJoinTask: Commences performing this task, awaits its completion if necessary, and returns its result, or throws an (unchecked) RuntimeException or Error if the underlying computation did so.
invokeAll(Collection<? extends Callable<T>>) - Method in class java8.util.concurrent.ForkJoinPool
invokeAll(ForkJoinTask<?>, ForkJoinTask<?>) - Static method in class java8.util.concurrent.ForkJoinTask: Forks the given tasks, returning when isDone holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown.
invokeAll(ForkJoinTask<?>...) - Static method in class java8.util.concurrent.ForkJoinTask: Forks the given tasks, returning when isDone holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown.
invokeAll(Collection<T>) - Static method in class java8.util.concurrent.ForkJoinTask: Forks all tasks in the specified collection, returning when isDone holds for each task or an (unchecked) exception is encountered, in which case the exception is rethrown.
isCancelled() - Method in class java8.util.concurrent.CompletableFuture: Returns true if this CompletableFuture was cancelled before it completed normally.
isCancelled() - Method in class java8.util.concurrent.ForkJoinTask
isCompletedAbnormally() - Method in class java8.util.concurrent.ForkJoinTask: Returns true if this task threw an exception or was cancelled.
isCompletedExceptionally() - Method in class java8.util.concurrent.CompletableFuture: Returns true if this CompletableFuture completed exceptionally, in any way.
isCompletedNormally() - Method in class java8.util.concurrent.ForkJoinTask: Returns true if this task completed without throwing an exception and was not cancelled.
isDone() - Method in class java8.util.concurrent.CompletableFuture: Returns true if completed in any fashion: normally, exceptionally, or via cancellation.
isDone() - Method in class java8.util.concurrent.ForkJoinTask
isEqual(Object) - Static method in class java8.util.function.Predicates: Returns a predicate that tests if two arguments are equal according to Objects.equals(Object, Object).
isFinite(double) - Static method in class java8.lang.Doubles: Returns true if the argument is a finite floating-point value; returns false otherwise (for NaN and infinity arguments).
isNull(Object) - Static method in class java8.util.Objects: Returns true if the provided reference is null otherwise returns false.
isParallel() - Method in interface java8.util.stream.BaseStream: Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
isPresent() - Method in class java8.util.Optional: Return true if there is a value present, otherwise false.
isPresent() - Method in class java8.util.OptionalDouble: Return true if there is a value present, otherwise false.
isPresent() - Method in class java8.util.OptionalInt: Return true if there is a value present, otherwise false.
isPresent() - Method in class java8.util.OptionalLong: Return true if there is a value present, otherwise false.
isQuiescent() - Method in class java8.util.concurrent.ForkJoinPool: Returns true if all worker threads are currently idle.
isReleasable() - Method in interface java8.util.concurrent.ForkJoinPool.ManagedBlocker: Returns true if blocking is unnecessary.
isShutdown() - Method in class java8.util.concurrent.ForkJoinPool: Returns true if this pool has been shut down.
isTerminated() - Method in class java8.util.concurrent.ForkJoinPool: Returns true if all tasks have completed following shut down.
isTerminated() - Method in class java8.util.concurrent.Phaser: Returns true if this phaser has been terminated.
isTerminating() - Method in class java8.util.concurrent.ForkJoinPool: Returns true if the process of termination has commenced but not yet completed.
Iterables - Class in java8.lang: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Iterable interface (and also for removeIf from Collection).
iterate(double, DoubleUnaryOperator) - Static method in class java8.util.stream.DoubleStreams: Returns an infinite sequential ordered DoubleStream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
iterate(int, IntUnaryOperator) - Static method in class java8.util.stream.IntStreams: Returns an infinite sequential ordered IntStream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
iterate(long, LongUnaryOperator) - Static method in class java8.util.stream.LongStreams: Returns an infinite sequential ordered LongStream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
iterate(S, UnaryOperator<S>) - Static method in class java8.util.stream.RefStreams: Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
iterate(S, UnaryOperator<S>) - Static method in class java8.util.stream.StreamSupport: Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
iterator(Spliterator<? extends T>) - Static method in class java8.util.Spliterators: Creates an Iterator from a Spliterator.
iterator(Spliterator.OfInt) - Static method in class java8.util.Spliterators: Creates an PrimitiveIterator.OfInt from a Spliterator.OfInt.
iterator(Spliterator.OfLong) - Static method in class java8.util.Spliterators: Creates an PrimitiveIterator.OfLong from a Spliterator.OfLong.
iterator(Spliterator.OfDouble) - Static method in class java8.util.Spliterators: Creates an PrimitiveIterator.OfDouble from a Spliterator.OfDouble.
iterator() - Method in interface java8.util.stream.BaseStream: Returns an iterator for the elements of this stream.
iterator() - Method in interface java8.util.stream.DoubleStream
iterator() - Method in interface java8.util.stream.IntStream
iterator() - Method in interface java8.util.stream.LongStream
Iterators - Class in java8.util: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Iterator interface.

J

J8Arrays - Class in java8.util: A place for static default implementations of the new Java 8 parallel methods of the Arrays class.
java.util - package java.util
java8.lang - package java8.lang: Provides classes for some of the new static methods that were added in Java 8.
java8.util - package java8.util: Provides some of the new java.util classes and implementations of static and default interface methods added in Java 8.
java8.util.concurrent - package java8.util.concurrent: The Java 7 and Java 8 utility classes commonly used in concurrent programming.
java8.util.concurrent.atomic - package java8.util.concurrent.atomic: Some of the new classes that support lock-free thread-safe programming on single variables that were added in Java 8.
java8.util.function - package java8.util.function: Functional interfaces provide target types for lambda expressions and method references.
java8.util.stream - package java8.util.stream: Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
join() - Method in class java8.util.concurrent.CompletableFuture: Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally.
join() - Method in class java8.util.concurrent.ForkJoinTask: Returns the result of the computation when it is done.
joining() - Static method in class java8.util.stream.Collectors: Returns a Collector that concatenates the input elements into a String, in encounter order.
joining(CharSequence) - Static method in class java8.util.stream.Collectors: Returns a Collector that concatenates the input elements, separated by the specified delimiter, in encounter order.
joining(CharSequence, CharSequence, CharSequence) - Static method in class java8.util.stream.Collectors: Returns a Collector that concatenates the input elements, separated by the specified delimiter, with the specified prefix and suffix, in encounter order.

L

length() - Method in class java8.util.StringJoiner: Returns the length of the String representation of this StringJoiner.
limit(long) - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
limit(long) - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
limit(long) - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
limit(long) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
Lists - Class in java8.util: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the List interface.
LongAccumulator - Class in java8.util.concurrent.atomic: One or more variables that together maintain a running long value updated using a supplied function.
LongAccumulator(LongBinaryOperator, long) - Constructor for class java8.util.concurrent.atomic.LongAccumulator: Creates a new instance using the given accumulator function and identity element.
LongAdder - Class in java8.util.concurrent.atomic: One or more variables that together maintain an initially zero long sum.
LongAdder() - Constructor for class java8.util.concurrent.atomic.LongAdder: Creates a new adder with initial sum of zero.
LongBinaryOperator - Interface in java8.util.function: Represents an operation upon two long-valued operands and producing a long-valued result.
LongConsumer - Interface in java8.util.function: Represents an operation that accepts a single long-valued argument and returns no result.
LongConsumers - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the LongConsumer interface.
LongFunction<R> - Interface in java8.util.function: Represents a function that accepts a long-valued argument and produces a result.
LongPredicate - Interface in java8.util.function: Represents a predicate (boolean-valued function) of one long-valued argument.
LongPredicates - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the LongPredicate interface.
longs(long) - Method in class java.util.Random: Throws AssertionError always.
longs() - Method in class java.util.Random: Throws AssertionError always.
longs(long, long, long) - Method in class java.util.Random: Throws AssertionError always.
longs(long, long) - Method in class java.util.Random: Throws AssertionError always.
Longs - Class in java8.lang: A place for static default implementations of the new Java 8 static methods in the Long class.
longs(long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a stream producing the given streamSize number of pseudorandom long values.
longs() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns an effectively unlimited stream of pseudorandom long values.
longs(long, long, long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a stream producing the given streamSize number of pseudorandom long, each conforming to the given origin (inclusive) and bound (exclusive).
longs(long, long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns an effectively unlimited stream of pseudorandom long values, each conforming to the given origin (inclusive) and bound (exclusive).
longs(long) - Method in class java8.util.SplittableRandom: Returns a stream producing the given streamSize number of pseudorandom long values from this generator and/or one split from it.
longs() - Method in class java8.util.SplittableRandom: Returns an effectively unlimited stream of pseudorandom long values from this generator and/or one split from it.
longs(long, long, long) - Method in class java8.util.SplittableRandom: Returns a stream producing the given streamSize number of pseudorandom long values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
longs(long, long) - Method in class java8.util.SplittableRandom: Returns an effectively unlimited stream of pseudorandom long values from this generator and/or one split from it; each value conforms to the given origin (inclusive) and bound (exclusive).
LongStream - Interface in java8.util.stream: A sequence of primitive long-valued elements supporting sequential and parallel aggregate operations.
longStream(Spliterator.OfLong, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel LongStream from a Spliterator.OfLong.
longStream(Supplier<? extends Spliterator.OfLong>, int, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel LongStream from a Supplier of Spliterator.OfLong.
LongStream.Builder - Interface in java8.util.stream: A mutable builder for a LongStream.
LongStreams - Class in java8.util.stream: A place for static default implementations of the new Java 8/9 static interface methods and default interface methods (takeWhile(), dropWhile()) in the LongStream interface.
LongSummaryStatistics - Class in java8.util: A state object for collecting statistics such as count, min, max, sum, and average.
LongSummaryStatistics() - Constructor for class java8.util.LongSummaryStatistics: Construct an empty instance with zero count, zero sum, Long.MAX_VALUE min, Long.MIN_VALUE max and zero average.
LongSupplier - Interface in java8.util.function: Represents a supplier of long-valued results.
LongToDoubleFunction - Interface in java8.util.function: Represents a function that accepts a long-valued argument and produces a double-valued result.
LongToIntFunction - Interface in java8.util.function: Represents a function that accepts a long-valued argument and produces an int-valued result.
LongUnaryOperator - Interface in java8.util.function: Represents an operation on a single long-valued operand that produces a long-valued result.
LongUnaryOperators - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the LongUnaryOperator interface.
longValue() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Returns the current value as a long after a narrowing primitive conversion.
longValue() - Method in class java8.util.concurrent.atomic.DoubleAdder: Returns the DoubleAdder.sum() as a long after a narrowing primitive conversion.
longValue() - Method in class java8.util.concurrent.atomic.LongAccumulator: Equivalent to LongAccumulator.get().
longValue() - Method in class java8.util.concurrent.atomic.LongAdder: Equivalent to LongAdder.sum().

M

managedBlock(ForkJoinPool.ManagedBlocker) - Static method in class java8.util.concurrent.ForkJoinPool: Runs the given possibly blocking task.
map(Function<? super T, ? extends U>) - Method in class java8.util.Optional: If a value is present, apply the provided mapping function to it, and if the result is non-null, return an Optional describing the result.
map(DoubleUnaryOperator) - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the results of applying the given function to the elements of this stream.
map(IntUnaryOperator) - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the results of applying the given function to the elements of this stream.
map(LongUnaryOperator) - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the results of applying the given function to the elements of this stream.
map(Function<? super T, ? extends R>) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the results of applying the given function to the elements of this stream.
mapping(Function<? super T, ? extends U>, Collector<? super U, A, R>) - Static method in class java8.util.stream.Collectors: Adapts a Collector accepting elements of type U to one accepting elements of type T by applying a mapping function to each input element before accumulation.
Maps - Class in java8.util: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Map and ConcurrentMap interfaces.
Maps.Entry - Class in java8.util: A place for the static interface methods of the Java 8 Map.Entry interface.
mapToDouble(IntToDoubleFunction) - Method in interface java8.util.stream.IntStream: Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
mapToDouble(LongToDoubleFunction) - Method in interface java8.util.stream.LongStream: Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
mapToDouble(ToDoubleFunction<? super T>) - Method in interface java8.util.stream.Stream: Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
mapToInt(DoubleToIntFunction) - Method in interface java8.util.stream.DoubleStream: Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
mapToInt(LongToIntFunction) - Method in interface java8.util.stream.LongStream: Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
mapToInt(ToIntFunction<? super T>) - Method in interface java8.util.stream.Stream: Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
mapToLong(DoubleToLongFunction) - Method in interface java8.util.stream.DoubleStream: Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
mapToLong(IntToLongFunction) - Method in interface java8.util.stream.IntStream: Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
mapToLong(ToLongFunction<? super T>) - Method in interface java8.util.stream.Stream: Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
mapToObj(DoubleFunction<? extends U>) - Method in interface java8.util.stream.DoubleStream: Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
mapToObj(IntFunction<? extends U>) - Method in interface java8.util.stream.IntStream: Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
mapToObj(LongFunction<? extends U>) - Method in interface java8.util.stream.LongStream: Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
max(double, double) - Static method in class java8.lang.Doubles: Returns the greater of two double values as if by calling Math.max.
max(int, int) - Static method in class java8.lang.Integers: Returns the greater of two int values as if by calling Math.max.
max(long, long) - Static method in class java8.lang.Longs: Returns the greater of two long values as if by calling Math.max.
max() - Method in interface java8.util.stream.DoubleStream: Returns an OptionalDouble describing the maximum element of this stream, or an empty OptionalDouble if this stream is empty.
max() - Method in interface java8.util.stream.IntStream: Returns an OptionalInt describing the maximum element of this stream, or an empty optional if this stream is empty.
max() - Method in interface java8.util.stream.LongStream: Returns an OptionalLong describing the maximum element of this stream, or an empty optional if this stream is empty.
max(Comparator<? super T>) - Method in interface java8.util.stream.Stream: Returns the maximum element of this stream according to the provided Comparator.
maxBy(Comparator<? super T>) - Static method in class java8.util.function.BinaryOperators: Returns a BinaryOperator which returns the greater of two elements according to the specified Comparator.
maxBy(Comparator<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the maximal element according to a given Comparator, described as an Optional<T>.
merge(Map<K, V>, K, V, BiFunction<? super V, ? super V, ? extends V>) - Static method in class java8.util.Maps: If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
merge(StringJoiner) - Method in class java8.util.StringJoiner: Adds the contents of the given StringJoiner without prefix and suffix as the next element if it is non-empty.
mergeConcurrent(ConcurrentMap<K, V>, K, V, BiFunction<? super V, ? super V, ? extends V>) - Static method in class java8.util.Maps: If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
min(double, double) - Static method in class java8.lang.Doubles: Returns the smaller of two double values as if by calling Math.min.
min(int, int) - Static method in class java8.lang.Integers: Returns the smaller of two int values as if by calling Math.min.
min(long, long) - Static method in class java8.lang.Longs: Returns the smaller of two long values as if by calling Math.min.
min() - Method in interface java8.util.stream.DoubleStream: Returns an OptionalDouble describing the minimum element of this stream, or an empty OptionalDouble if this stream is empty.
min() - Method in interface java8.util.stream.IntStream: Returns an OptionalInt describing the minimum element of this stream, or an empty optional if this stream is empty.
min() - Method in interface java8.util.stream.LongStream: Returns an OptionalLong describing the minimum element of this stream, or an empty optional if this stream is empty.
min(Comparator<? super T>) - Method in interface java8.util.stream.Stream: Returns the minimum element of this stream according to the provided Comparator.
minBy(Comparator<? super T>) - Static method in class java8.util.function.BinaryOperators: Returns a BinaryOperator which returns the lesser of two elements according to the specified Comparator.
minBy(Comparator<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the minimal element according to a given Comparator, described as an Optional<T>.

N

naturalOrder() - Static method in class java8.util.Comparators: Returns a comparator that compares Comparable objects in natural order.
negate(BiPredicate<? super T, ? super U>) - Static method in class java8.util.function.BiPredicates: Returns a predicate that represents the logical negation of the this_ predicate.
negate(DoublePredicate) - Static method in class java8.util.function.DoublePredicates: Returns a predicate that represents the logical negation of the this_ predicate.
negate(IntPredicate) - Static method in class java8.util.function.IntPredicates: Returns a predicate that represents the logical negation of the this_ predicate.
negate(LongPredicate) - Static method in class java8.util.function.LongPredicates: Returns a predicate that represents the logical negation of the this_ predicate.
negate(Predicate<? super T>) - Static method in class java8.util.function.Predicates: Returns a predicate that represents the logical negation of the this_ predicate.
newTaskFor(Runnable, T) - Method in class java8.util.concurrent.ForkJoinPool
newTaskFor(Callable<T>) - Method in class java8.util.concurrent.ForkJoinPool
newThread(ForkJoinPool) - Method in interface java8.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory: Returns a new worker thread operating in the given pool.
next() - Method in interface java8.util.PrimitiveIterator.OfDouble: Implementation Requirements:
The default implementation boxes the result of calling PrimitiveIterator.OfDouble.nextDouble(), and returns that boxed result.
next() - Method in interface java8.util.PrimitiveIterator.OfInt: Implementation Requirements:
The default implementation boxes the result of calling PrimitiveIterator.OfInt.nextInt(), and returns that boxed result.
next() - Method in interface java8.util.PrimitiveIterator.OfLong: Implementation Requirements:
The default implementation boxes the result of calling PrimitiveIterator.OfLong.nextLong(), and returns that boxed result.
nextBoolean() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom boolean value.
nextBoolean() - Method in class java8.util.SplittableRandom: Returns a pseudorandom boolean value.
nextComplete() - Method in class java8.util.concurrent.CountedCompleter: If this task does not have a completer, invokes ForkJoinTask.quietlyComplete() and returns null.
nextDouble() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom double value between zero (inclusive) and one (exclusive).
nextDouble(double) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom double value between 0.0 (inclusive) and the specified bound (exclusive).
nextDouble(double, double) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom double value between the specified origin (inclusive) and bound (exclusive).
nextDouble() - Method in interface java8.util.PrimitiveIterator.OfDouble: Returns the next double element in the iteration.
nextDouble() - Method in class java8.util.SplittableRandom: Returns a pseudorandom double value between zero (inclusive) and one (exclusive).
nextDouble(double) - Method in class java8.util.SplittableRandom: Returns a pseudorandom double value between 0.0 (inclusive) and the specified bound (exclusive).
nextDouble(double, double) - Method in class java8.util.SplittableRandom: Returns a pseudorandom double value between the specified origin (inclusive) and bound (exclusive).
nextFloat() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom float value between zero (inclusive) and one (exclusive).
nextGaussian() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns the next pseudorandom, Gaussian ("normally") distributed double value with mean 0.0 and standard deviation 1.0 from this random number generator's sequence.
nextInt() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom int value.
nextInt(int) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom int value between zero (inclusive) and the specified bound (exclusive).
nextInt(int, int) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom int value between the specified origin (inclusive) and the specified bound (exclusive).
nextInt() - Method in interface java8.util.PrimitiveIterator.OfInt: Returns the next int element in the iteration.
nextInt() - Method in class java8.util.SplittableRandom: Returns a pseudorandom int value.
nextInt(int) - Method in class java8.util.SplittableRandom: Returns a pseudorandom int value between zero (inclusive) and the specified bound (exclusive).
nextInt(int, int) - Method in class java8.util.SplittableRandom: Returns a pseudorandom int value between the specified origin (inclusive) and the specified bound (exclusive).
nextLong() - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom long value.
nextLong(long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom long value between zero (inclusive) and the specified bound (exclusive).
nextLong(long, long) - Method in class java8.util.concurrent.ThreadLocalRandom: Returns a pseudorandom long value between the specified origin (inclusive) and the specified bound (exclusive).
nextLong() - Method in interface java8.util.PrimitiveIterator.OfLong: Returns the next long element in the iteration.
nextLong() - Method in class java8.util.SplittableRandom: Returns a pseudorandom long value.
nextLong(long) - Method in class java8.util.SplittableRandom: Returns a pseudorandom long value between zero (inclusive) and the specified bound (exclusive).
nextLong(long, long) - Method in class java8.util.SplittableRandom: Returns a pseudorandom long value between the specified origin (inclusive) and the specified bound (exclusive).
noneMatch(DoublePredicate) - Method in interface java8.util.stream.DoubleStream: Returns whether no elements of this stream match the provided predicate.
noneMatch(IntPredicate) - Method in interface java8.util.stream.IntStream: Returns whether no elements of this stream match the provided predicate.
noneMatch(LongPredicate) - Method in interface java8.util.stream.LongStream: Returns whether no elements of this stream match the provided predicate.
noneMatch(Predicate<? super T>) - Method in interface java8.util.stream.Stream: Returns whether no elements of this stream match the provided predicate.
nonNull(Object) - Static method in class java8.util.Objects: Returns true if the provided reference is non-null otherwise returns false.
NONNULL - Static variable in interface java8.util.Spliterator: Characteristic value signifying that the source guarantees that encountered elements will not be null.
nullsFirst(Comparator<? super T>) - Static method in class java8.util.Comparators: Returns a null-friendly comparator that considers null to be less than non-null.
nullsLast(Comparator<? super T>) - Static method in class java8.util.Comparators: Returns a null-friendly comparator that considers null to be greater than non-null.

O

ObjDoubleConsumer<T> - Interface in java8.util.function: Represents an operation that accepts an object-valued and a double-valued argument, and returns no result.
Objects - Class in java8.util: This class consists of static utility methods for operating on objects.
ObjIntConsumer<T> - Interface in java8.util.function: Represents an operation that accepts an object-valued and a int-valued argument, and returns no result.
ObjLongConsumer<T> - Interface in java8.util.function: Represents an operation that accepts an object-valued and a long-valued argument, and returns no result.
obtrudeException(Throwable) - Method in class java8.util.concurrent.CompletableFuture: Forcibly causes subsequent invocations of method CompletableFuture.get() and related methods to throw the given exception, whether or not already completed.
obtrudeValue(T) - Method in class java8.util.concurrent.CompletableFuture: Forcibly sets or resets the value subsequently returned by method CompletableFuture.get() and related methods, whether or not already completed.
of(T) - Static method in class java8.util.Optional: Returns an Optional with the specified present non-null value.
of(double) - Static method in class java8.util.OptionalDouble: Return an OptionalDouble with the specified value present.
of(int) - Static method in class java8.util.OptionalInt: Return an OptionalInt with the specified value present.
of(long) - Static method in class java8.util.OptionalLong: Return an OptionalLong with the specified value present.
of(Supplier<R>, BiConsumer<R, T>, BinaryOperator<R>, Collector.Characteristics...) - Static method in class java8.util.stream.Collectors: Returns a new Collector described by the given supplier, accumulator, and combiner functions.
of(Supplier<A>, BiConsumer<A, T>, BinaryOperator<A>, Function<A, R>, Collector.Characteristics...) - Static method in class java8.util.stream.Collectors: Returns a new Collector described by the given supplier, accumulator, combiner, and finisher functions.
of(double) - Static method in class java8.util.stream.DoubleStreams: Returns a sequential DoubleStream containing a single element.
of(double...) - Static method in class java8.util.stream.DoubleStreams: Returns a sequential ordered stream whose elements are the specified values.
of(int) - Static method in class java8.util.stream.IntStreams: Returns a sequential IntStream containing a single element.
of(int...) - Static method in class java8.util.stream.IntStreams: Returns a sequential ordered stream whose elements are the specified values.
of(long) - Static method in class java8.util.stream.LongStreams: Returns a sequential LongStream containing a single element.
of(long...) - Static method in class java8.util.stream.LongStreams: Returns a sequential ordered stream whose elements are the specified values.
of(T) - Static method in class java8.util.stream.RefStreams: Returns a sequential Stream containing a single element.
of(T...) - Static method in class java8.util.stream.RefStreams: Returns a sequential ordered Stream whose elements are the specified values.
of(T) - Static method in class java8.util.stream.StreamSupport: Returns a sequential Stream containing a single element.
of(T...) - Static method in class java8.util.stream.StreamSupport: Returns a sequential ordered stream whose elements are the specified values.
ofNullable(T) - Static method in class java8.util.Optional: Returns an Optional describing the specified value, if non-null, otherwise returns an empty Optional.
ofNullable(T) - Static method in class java8.util.stream.RefStreams: Returns a sequential Stream containing a single element, if non-null, otherwise returns an empty Stream.
ofNullable(T) - Static method in class java8.util.stream.StreamSupport: Returns a sequential Stream containing a single element, if non-null, otherwise returns an empty Stream.
onAdvance(int, int) - Method in class java8.util.concurrent.Phaser: Overridable method to perform an action upon impending phase advance, and to control termination.
onClose(Runnable) - Method in interface java8.util.stream.BaseStream: Returns an equivalent stream with an additional close handler.
onCompletion(CountedCompleter<?>) - Method in class java8.util.concurrent.CountedCompleter: Performs an action when method CountedCompleter.tryComplete() is invoked and the pending count is zero, or when the unconditional method CountedCompleter.complete(T) is invoked.
onExceptionalCompletion(Throwable, CountedCompleter<?>) - Method in class java8.util.concurrent.CountedCompleter: Performs an action when method ForkJoinTask.completeExceptionally(Throwable) is invoked or method CountedCompleter.compute() throws an exception, and this task has not already otherwise completed normally.
onStart() - Method in class java8.util.concurrent.ForkJoinWorkerThread: Initializes internal state after construction but before processing any tasks.
onTermination(Throwable) - Method in class java8.util.concurrent.ForkJoinWorkerThread: Performs cleanup associated with termination of this worker thread.
Optional<T> - Class in java8.util: A container object which may or may not contain a non-null value.
OptionalDouble - Class in java8.util: A container object which may or may not contain a double value.
OptionalInt - Class in java8.util: A container object which may or may not contain a int value.
OptionalLong - Class in java8.util: A container object which may or may not contain a long value.
or(BiPredicate<? super T, ? super U>, BiPredicate<? super T, ? super U>) - Static method in class java8.util.function.BiPredicates: Returns a composed predicate that represents a short-circuiting logical OR of the this_ predicate and another.
or(DoublePredicate, DoublePredicate) - Static method in class java8.util.function.DoublePredicates: Returns a composed predicate that represents a short-circuiting logical OR of the this_ predicate and another.
or(IntPredicate, IntPredicate) - Static method in class java8.util.function.IntPredicates: Returns a composed predicate that represents a short-circuiting logical OR of the this_ predicate and another.
or(LongPredicate, LongPredicate) - Static method in class java8.util.function.LongPredicates: Returns a composed predicate that represents a short-circuiting logical OR of the this_ predicate and another.
or(Predicate<? super T>, Predicate<? super T>) - Static method in class java8.util.function.Predicates: Returns a composed predicate that represents a short-circuiting logical OR of the this_ predicate and another.
ORDERED - Static variable in interface java8.util.Spliterator: Characteristic value signifying that an encounter order is defined for elements.
orElse(T) - Method in class java8.util.Optional: Return the value if present, otherwise return other.
orElse(double) - Method in class java8.util.OptionalDouble: Return the value if present, otherwise return other.
orElse(int) - Method in class java8.util.OptionalInt: Return the value if present, otherwise return other.
orElse(long) - Method in class java8.util.OptionalLong: Return the value if present, otherwise return other.
orElseGet(Supplier<? extends T>) - Method in class java8.util.Optional: Return the value if present, otherwise invoke other and return the result of that invocation.
orElseGet(DoubleSupplier) - Method in class java8.util.OptionalDouble: Return the value if present, otherwise invoke other and return the result of that invocation.
orElseGet(IntSupplier) - Method in class java8.util.OptionalInt: Return the value if present, otherwise invoke other and return the result of that invocation.
orElseGet(LongSupplier) - Method in class java8.util.OptionalLong: Return the value if present, otherwise invoke other and return the result of that invocation.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.Optional: Return the contained value, if present, otherwise throw an exception to be created by the provided supplier.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.OptionalDouble: Return the contained value, if present, otherwise throw an exception to be created by the provided supplier.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.OptionalInt: Return the contained value, if present, otherwise throw an exception to be created by the provided supplier.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.OptionalLong: Return the contained value, if present, otherwise throw an exception to be created by the provided supplier.

P

parallel() - Method in interface java8.util.stream.BaseStream: Returns an equivalent stream that is parallel.
parallel() - Method in interface java8.util.stream.DoubleStream
parallel() - Method in interface java8.util.stream.IntStream
parallel() - Method in interface java8.util.stream.LongStream
parallelPrefix(T[], BinaryOperator<T>) - Static method in class java8.util.J8Arrays: Cumulates, in parallel, each element of the given array in place, using the supplied function.
parallelPrefix(T[], int, int, BinaryOperator<T>) - Static method in class java8.util.J8Arrays: Performs J8Arrays.parallelPrefix(Object[], BinaryOperator) for the given subrange of the array.
parallelPrefix(long[], LongBinaryOperator) - Static method in class java8.util.J8Arrays: Cumulates, in parallel, each element of the given array in place, using the supplied function.
parallelPrefix(long[], int, int, LongBinaryOperator) - Static method in class java8.util.J8Arrays: Performs J8Arrays.parallelPrefix(long[], LongBinaryOperator) for the given subrange of the array.
parallelPrefix(double[], DoubleBinaryOperator) - Static method in class java8.util.J8Arrays: Cumulates, in parallel, each element of the given array in place, using the supplied function.
parallelPrefix(double[], int, int, DoubleBinaryOperator) - Static method in class java8.util.J8Arrays: Performs J8Arrays.parallelPrefix(double[], DoubleBinaryOperator) for the given subrange of the array.
parallelPrefix(int[], IntBinaryOperator) - Static method in class java8.util.J8Arrays: Cumulates, in parallel, each element of the given array in place, using the supplied function.
parallelPrefix(int[], int, int, IntBinaryOperator) - Static method in class java8.util.J8Arrays: Performs J8Arrays.parallelPrefix(int[], IntBinaryOperator) for the given subrange of the array.
parallelSetAll(T[], IntFunction<? extends T>) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, in parallel, using the provided generator function to compute each element.
parallelSetAll(int[], IntUnaryOperator) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, in parallel, using the provided generator function to compute each element.
parallelSetAll(long[], IntToLongFunction) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, in parallel, using the provided generator function to compute each element.
parallelSetAll(double[], IntToDoubleFunction) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, in parallel, using the provided generator function to compute each element.
parallelSort(byte[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(byte[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(char[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(char[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(short[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(short[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(int[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(int[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(long[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(long[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(float[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(float[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(double[]) - Static method in class java8.util.J8Arrays: Sorts the specified array into ascending numerical order.
parallelSort(double[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the array into ascending numerical order.
parallelSort(T[]) - Static method in class java8.util.J8Arrays: Sorts the specified array of objects into ascending order, according to the natural ordering of its elements.
parallelSort(T[], int, int) - Static method in class java8.util.J8Arrays: Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements.
parallelSort(T[], Comparator<? super T>) - Static method in class java8.util.J8Arrays: Sorts the specified array of objects according to the order induced by the specified comparator.
parallelSort(T[], int, int, Comparator<? super T>) - Static method in class java8.util.J8Arrays: Sorts the specified range of the specified array of objects according to the order induced by the specified comparator.
parallelStream(Collection<? extends T>) - Static method in class java8.util.stream.StreamSupport: Creates a new possibly parallel Stream using either the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size or a specialized Spliterator implementation (effectively the same one that Java 8 uses) if the passed Collection is one of the types listed below.
partitioningBy(Predicate<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector which partitions the input elements according to a Predicate, and organizes them into a Map<Boolean, List<T>>.
partitioningBy(Predicate<? super T>, Collector<? super T, A, D>) - Static method in class java8.util.stream.Collectors: Returns a Collector which partitions the input elements according to a Predicate, reduces the values in each partition according to another Collector, and organizes them into a Map<Boolean, D> whose values are the result of the downstream reduction.
peek(DoubleConsumer) - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
peek(IntConsumer) - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
peek(LongConsumer) - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
peek(Consumer<? super T>) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
peekNextLocalTask() - Static method in class java8.util.concurrent.ForkJoinTask: Returns, but does not unschedule or execute, a task queued by the current thread but not yet executed, if one is immediately available.
Phaser - Class in java8.util.concurrent: A reusable synchronization barrier, similar in functionality to CyclicBarrier and CountDownLatch but supporting more flexible usage.
Phaser() - Constructor for class java8.util.concurrent.Phaser: Creates a new phaser with no initially registered parties, no parent, and initial phase number 0.
Phaser(int) - Constructor for class java8.util.concurrent.Phaser: Creates a new phaser with the given number of registered unarrived parties, no parent, and initial phase number 0.
Phaser(Phaser) - Constructor for class java8.util.concurrent.Phaser: Equivalent to Phaser(parent, 0).
Phaser(Phaser, int) - Constructor for class java8.util.concurrent.Phaser: Creates a new phaser with the given parent and number of registered unarrived parties.
pollNextLocalTask() - Static method in class java8.util.concurrent.ForkJoinTask: Unschedules and returns, without executing, the next task queued by the current thread but not yet executed, if the current thread is operating in a ForkJoinPool.
pollSubmission() - Method in class java8.util.concurrent.ForkJoinPool: Removes and returns the next unexecuted submission if one is available.
pollTask() - Static method in class java8.util.concurrent.ForkJoinTask: If the current thread is operating in a ForkJoinPool, unschedules and returns, without executing, the next task queued by the current thread but not yet executed, if one is available, or if not available, a task that was forked by some other thread, if available.
Predicate<T> - Interface in java8.util.function: Represents a predicate (boolean-valued function) of one argument.
Predicates - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the Predicate interface.
PrimitiveIterator<T,T_CONS> - Interface in java8.util: A base type for primitive specializations of Iterator.
PrimitiveIterator.OfDouble - Interface in java8.util: An Iterator specialized for double values.
PrimitiveIterator.OfInt - Interface in java8.util: An Iterator specialized for int values.
PrimitiveIterator.OfLong - Interface in java8.util: An Iterator specialized for long values.
propagateCompletion() - Method in class java8.util.concurrent.CountedCompleter: Equivalent to CountedCompleter.tryComplete() but does not invoke CountedCompleter.onCompletion(CountedCompleter) along the completion path: If the pending count is nonzero, decrements the count; otherwise, similarly tries to complete this task's completer, if one exists, else marks this task as complete.
putIfAbsent(Map<K, V>, K, V) - Static method in class java8.util.Maps: If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value.

Q

quietlyComplete() - Method in class java8.util.concurrent.ForkJoinTask: Completes this task normally without setting a value.
quietlyCompleteRoot() - Method in class java8.util.concurrent.CountedCompleter: Equivalent to getRoot().quietlyComplete().
quietlyInvoke() - Method in class java8.util.concurrent.ForkJoinTask: Commences performing this task and awaits its completion if necessary, without returning its result or throwing its exception.
quietlyJoin() - Method in class java8.util.concurrent.ForkJoinTask: Joins this task, without returning its result or throwing its exception.

R

Random - Class in java.util: A compilation stub only.
Random() - Constructor for class java.util.Random
range(int, int) - Static method in class java8.util.stream.IntStreams: Returns a sequential ordered IntStream from startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1.
range(long, long) - Static method in class java8.util.stream.LongStreams: Returns a sequential ordered LongStream from startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1.
rangeClosed(int, int) - Static method in class java8.util.stream.IntStreams: Returns a sequential ordered IntStream from startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1.
rangeClosed(long, long) - Static method in class java8.util.stream.LongStreams: Returns a sequential ordered LongStream from startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1.
RecursiveAction - Class in java8.util.concurrent: A recursive resultless ForkJoinTask.
RecursiveAction() - Constructor for class java8.util.concurrent.RecursiveAction
RecursiveTask<V> - Class in java8.util.concurrent: A recursive result-bearing ForkJoinTask.
RecursiveTask() - Constructor for class java8.util.concurrent.RecursiveTask
reduce(double, DoubleBinaryOperator) - Method in interface java8.util.stream.DoubleStream: Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
reduce(DoubleBinaryOperator) - Method in interface java8.util.stream.DoubleStream: Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalDouble describing the reduced value, if any.
reduce(int, IntBinaryOperator) - Method in interface java8.util.stream.IntStream: Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
reduce(IntBinaryOperator) - Method in interface java8.util.stream.IntStream: Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalInt describing the reduced value, if any.
reduce(long, LongBinaryOperator) - Method in interface java8.util.stream.LongStream: Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
reduce(LongBinaryOperator) - Method in interface java8.util.stream.LongStream: Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalLong describing the reduced value, if any.
reduce(T, BinaryOperator<T>) - Method in interface java8.util.stream.Stream: Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
reduce(BinaryOperator<T>) - Method in interface java8.util.stream.Stream: Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any.
reduce(U, BiFunction<U, ? super T, U>, BinaryOperator) - Method in interface java8.util.stream.Stream: Performs a reduction on the elements of this stream, using the provided identity, accumulation and combining functions.
reducing(T, BinaryOperator<T>) - Static method in class java8.util.stream.Collectors: Returns a Collector which performs a reduction of its input elements under a specified BinaryOperator using the provided identity.
reducing(BinaryOperator<T>) - Static method in class java8.util.stream.Collectors: Returns a Collector which performs a reduction of its input elements under a specified BinaryOperator.
reducing(U, Function<? super T, ? extends U>, BinaryOperator) - Static method in class java8.util.stream.Collectors: Returns a Collector which performs a reduction of its input elements under a specified mapping function and BinaryOperator.
RefStreams - Class in java8.util.stream: A place for static default implementations of the new Java 8/9 static interface methods and default interface methods (takeWhile(), dropWhile()) in the Stream interface.
register() - Method in class java8.util.concurrent.Phaser: Adds a new unarrived party to this phaser.
reinitialize() - Method in class java8.util.concurrent.ForkJoinTask: Resets the internal bookkeeping state of this task, allowing a subsequent fork.
remainderUnsigned(int, int) - Static method in class java8.lang.Integers: Returns the unsigned remainder from dividing the first argument by the second where each argument and the result is interpreted as an unsigned value.
remainderUnsigned(long, long) - Static method in class java8.lang.Longs: Returns the unsigned remainder from dividing the first argument by the second where each argument and the result is interpreted as an unsigned value.
remove(Map<K, V>, Object, Object) - Static method in class java8.util.Maps: Removes the entry for the specified key only if it is currently mapped to the specified value.
removeIf(Iterable<? extends T>, Predicate<? super T>) - Static method in class java8.lang.Iterables: Removes all of the elements of the passed Iterable that satisfy the given predicate.
replace(Map<K, V>, K, V, V) - Static method in class java8.util.Maps: Replaces the entry for the specified key only if currently mapped to the specified value.
replace(Map<K, V>, K, V) - Static method in class java8.util.Maps: Replaces the entry for the specified key only if it is currently mapped to some value.
replaceAll(List<E>, UnaryOperator<E>) - Static method in class java8.util.Lists: Replaces each element of the passed list with the result of applying the operator to that element.
replaceAll(Map<K, V>, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.Maps: Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
replaceAllConcurrent(ConcurrentMap<K, V>, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.Maps: Replaces each entry's value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
requireNonNull(T) - Static method in class java8.util.Objects: Checks that the specified object reference is not null.
requireNonNull(T, String) - Static method in class java8.util.Objects: Checks that the specified object reference is not null and throws a customized NullPointerException if it is.
requireNonNull(T, Supplier<String>) - Static method in class java8.util.Objects: Checks that the specified object reference is not null and throws a customized NullPointerException if it is.
reset() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Resets variables maintaining updates to the identity value.
reset() - Method in class java8.util.concurrent.atomic.DoubleAdder: Resets variables maintaining the sum to zero.
reset() - Method in class java8.util.concurrent.atomic.LongAccumulator: Resets variables maintaining updates to the identity value.
reset() - Method in class java8.util.concurrent.atomic.LongAdder: Resets variables maintaining the sum to zero.
reversed(Comparator<T>) - Static method in class java8.util.Comparators: Returns a comparator that imposes the reverse ordering of the passed comparator.
reverseOrder() - Static method in class java8.util.Comparators: Returns a comparator that imposes the reverse of the natural ordering.
run() - Method in class java8.util.concurrent.ForkJoinWorkerThread: This method is required to be public, but should never be called explicitly.
runAfterBoth(CompletionStage<?>, Runnable) - Method in class java8.util.concurrent.CompletableFuture
runAfterBoth(CompletionStage<?>, Runnable) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage both complete normally, executes the given action.
runAfterBothAsync(CompletionStage<?>, Runnable) - Method in class java8.util.concurrent.CompletableFuture
runAfterBothAsync(CompletionStage<?>, Runnable, Executor) - Method in class java8.util.concurrent.CompletableFuture
runAfterBothAsync(CompletionStage<?>, Runnable) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage complete normally, executes the given action using this stage's default asynchronous execution facility.
runAfterBothAsync(CompletionStage<?>, Runnable, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage complete normally, executes the given action using the supplied executor.
runAfterEither(CompletionStage<?>, Runnable) - Method in class java8.util.concurrent.CompletableFuture
runAfterEither(CompletionStage<?>, Runnable) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action.
runAfterEitherAsync(CompletionStage<?>, Runnable) - Method in class java8.util.concurrent.CompletableFuture
runAfterEitherAsync(CompletionStage<?>, Runnable, Executor) - Method in class java8.util.concurrent.CompletableFuture
runAfterEitherAsync(CompletionStage<?>, Runnable) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action using this stage's default asynchronous execution facility.
runAfterEitherAsync(CompletionStage<?>, Runnable, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action using the supplied executor.
runAsync(Runnable) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() after it runs the given action.
runAsync(Runnable, Executor) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is asynchronously completed by a task running in the given executor after it runs the given action.

S

sequential() - Method in interface java8.util.stream.BaseStream: Returns an equivalent stream that is sequential.
sequential() - Method in interface java8.util.stream.DoubleStream
sequential() - Method in interface java8.util.stream.IntStream
sequential() - Method in interface java8.util.stream.LongStream
setAll(T[], IntFunction<? extends T>) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, using the provided generator function to compute each element.
setAll(int[], IntUnaryOperator) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, using the provided generator function to compute each element.
setAll(long[], IntToLongFunction) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, using the provided generator function to compute each element.
setAll(double[], IntToDoubleFunction) - Static method in class java8.util.J8Arrays: Set all elements of the specified array, using the provided generator function to compute each element.
setEmptyValue(CharSequence) - Method in class java8.util.StringJoiner: Sets the sequence of characters to be used when determining the string representation of this StringJoiner and no elements have been added yet, that is, when it is empty.
setForkJoinTaskTag(short) - Method in class java8.util.concurrent.ForkJoinTask: Atomically sets the tag value for this task.
setPendingCount(int) - Method in class java8.util.concurrent.CountedCompleter: Sets the pending count to the given value.
setRawResult(T) - Method in class java8.util.concurrent.CountedCompleter: A method that result-bearing CountedCompleters may optionally use to help maintain result data.
setRawResult(V) - Method in class java8.util.concurrent.ForkJoinTask: Forces the given value to be returned as a result.
setRawResult(Void) - Method in class java8.util.concurrent.RecursiveAction: Requires null completion value.
setRawResult(V) - Method in class java8.util.concurrent.RecursiveTask
setSeed(long) - Method in class java8.util.concurrent.ThreadLocalRandom: Throws UnsupportedOperationException.
shutdown() - Method in class java8.util.concurrent.ForkJoinPool: Possibly initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
shutdownNow() - Method in class java8.util.concurrent.ForkJoinPool: Possibly attempts to cancel and/or stop all tasks, and reject all subsequently submitted tasks.
SIZED - Static variable in interface java8.util.Spliterator: Characteristic value signifying that the value returned from estimateSize() prior to traversal or splitting represents a finite size that, in the absence of structural source modification, represents an exact count of the number of elements that would be encountered by a complete traversal.
skip(long) - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.
skip(long) - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.
skip(long) - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.
skip(long) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream.
sort(List<E>, Comparator<? super E>) - Static method in class java8.util.Lists: Sorts the passed list using the supplied Comparator to compare elements.
SORTED - Static variable in interface java8.util.Spliterator: Characteristic value signifying that encounter order follows a defined sort order.
sorted() - Method in interface java8.util.stream.DoubleStream: Returns a stream consisting of the elements of this stream in sorted order.
sorted() - Method in interface java8.util.stream.IntStream: Returns a stream consisting of the elements of this stream in sorted order.
sorted() - Method in interface java8.util.stream.LongStream: Returns a stream consisting of the elements of this stream in sorted order.
sorted() - Method in interface java8.util.stream.Stream: Returns a stream consisting of the elements of this stream, sorted according to natural order.
sorted(Comparator<? super T>) - Method in interface java8.util.stream.Stream: Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator.
split() - Method in class java8.util.SplittableRandom: Constructs and returns a new SplittableRandom instance that shares no mutable state with this instance.
spliterator(Iterable<? extends T>) - Static method in class java8.lang.Iterables: Creates a Spliterator over the elements described by this Iterable.
spliterator(T[]) - Static method in class java8.util.J8Arrays: Returns a Spliterator covering all of the specified array.
spliterator(T[], int, int) - Static method in class java8.util.J8Arrays: Returns a Spliterator covering the specified range of the specified array.
spliterator(int[]) - Static method in class java8.util.J8Arrays: Returns a Spliterator.OfInt covering all of the specified array.
spliterator(int[], int, int) - Static method in class java8.util.J8Arrays: Returns a Spliterator.OfInt covering the specified range of the specified array.
spliterator(long[]) - Static method in class java8.util.J8Arrays: Returns a Spliterator.OfLong covering all of the specified array.
spliterator(long[], int, int) - Static method in class java8.util.J8Arrays: Returns a Spliterator.OfLong covering the specified range of the specified array.
spliterator(double[]) - Static method in class java8.util.J8Arrays: Returns a Spliterator.OfDouble covering all of the specified array.
spliterator(double[], int, int) - Static method in class java8.util.J8Arrays: Returns a Spliterator.OfDouble covering the specified range of the specified array.
spliterator(List<E>) - Static method in class java8.util.Lists: Creates a Spliterator over the elements in the passed list.
Spliterator<T> - Interface in java8.util: An object for traversing and partitioning elements of a source.
spliterator(Object[], int) - Static method in class java8.util.Spliterators: Creates a Spliterator covering the elements of a given array, using a customized set of spliterator characteristics.
spliterator(Object[], int, int, int) - Static method in class java8.util.Spliterators: Creates a Spliterator covering a range of elements of a given array, using a customized set of spliterator characteristics.
spliterator(int[], int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfInt covering the elements of a given array, using a customized set of spliterator characteristics.
spliterator(int[], int, int, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfInt covering a range of elements of a given array, using a customized set of spliterator characteristics.
spliterator(long[], int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfLong covering the elements of a given array, using a customized set of spliterator characteristics.
spliterator(long[], int, int, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfLong covering a range of elements of a given array, using a customized set of spliterator characteristics.
spliterator(double[], int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfDouble covering the elements of a given array, using a customized set of spliterator characteristics.
spliterator(double[], int, int, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfDouble covering a range of elements of a given array, using a customized set of spliterator characteristics.
spliterator(Collection<? extends T>) - Static method in class java8.util.Spliterators: Creates either a specialized Spliterator (effectively the same one that Java 8 uses) for the given collection provided it is one of the types listed below or a Spliterator using the given collection's Collection.iterator() as the source of elements, and reporting its Collection.size() as its initial size.
spliterator(Collection<? extends T>, int) - Static method in class java8.util.Spliterators: Creates a Spliterator using the given collection's Collection.iterator() as the source of elements, and reporting its Collection.size() as its initial size.
spliterator(Iterator<? extends T>, long, int) - Static method in class java8.util.Spliterators: Creates a Spliterator using a given Iterator as the source of elements, and with a given initially reported size.
spliterator(PrimitiveIterator.OfInt, long, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfInt using a given IntStream.IntIterator as the source of elements, and with a given initially reported size.
spliterator(PrimitiveIterator.OfLong, long, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfLong using a given LongStream.LongIterator as the source of elements, and with a given initially reported size.
spliterator(PrimitiveIterator.OfDouble, long, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfDouble using a given DoubleStream.DoubleIterator as the source of elements, and with a given initially reported size.
spliterator() - Method in interface java8.util.stream.BaseStream: Returns a spliterator for the elements of this stream.
spliterator() - Method in interface java8.util.stream.DoubleStream
spliterator() - Method in interface java8.util.stream.IntStream
spliterator() - Method in interface java8.util.stream.LongStream
Spliterator.OfDouble - Interface in java8.util: A Spliterator specialized for double values.
Spliterator.OfInt - Interface in java8.util: A Spliterator specialized for int values.
Spliterator.OfLong - Interface in java8.util: A Spliterator specialized for long values.
Spliterator.OfPrimitive<T,T_CONS,T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>> - Interface in java8.util: A Spliterator specialized for primitive values.
Spliterators - Class in java8.util: Static classes and methods for operating on or creating instances of Spliterator and its primitive specializations Spliterator.OfInt, Spliterator.OfLong, and Spliterator.OfDouble.
Spliterators.AbstractDoubleSpliterator - Class in java8.util: An abstract Spliterator.OfDouble that implements trySplit to permit limited parallelism.
Spliterators.AbstractIntSpliterator - Class in java8.util: An abstract Spliterator.OfInt that implements trySplit to permit limited parallelism.
Spliterators.AbstractLongSpliterator - Class in java8.util: An abstract Spliterator.OfLong that implements trySplit to permit limited parallelism.
Spliterators.AbstractSpliterator<T> - Class in java8.util: An abstract Spliterator that implements trySplit to permit limited parallelism.
Spliterators.OfDouble - Class in java8.util: Static default implementations for the Java 8 default methods of Spliterator.OfDouble
Spliterators.OfInt - Class in java8.util: Static default implementations for the Java 8 default methods of Spliterator.OfInt
Spliterators.OfLong - Class in java8.util: Static default implementations for the Java 8 default methods of Spliterator.OfLong
Spliterators.OfPrimitive - Class in java8.util: Static default implementations for the Java 8 default method of Spliterator.OfPrimitive
spliteratorUnknownSize(Iterator<? extends T>, int) - Static method in class java8.util.Spliterators: Creates a Spliterator using a given Iterator as the source of elements, with no initial size estimate.
spliteratorUnknownSize(PrimitiveIterator.OfInt, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfInt using a given IntStream.IntIterator as the source of elements, with no initial size estimate.
spliteratorUnknownSize(PrimitiveIterator.OfLong, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfLong using a given LongStream.LongIterator as the source of elements, with no initial size estimate.
spliteratorUnknownSize(PrimitiveIterator.OfDouble, int) - Static method in class java8.util.Spliterators: Creates a Spliterator.OfDouble using a given DoubleStream.DoubleIterator as the source of elements, with no initial size estimate.
SplittableRandom - Class in java8.util: A generator of uniform pseudorandom values applicable for use in (among other contexts) isolated parallel computations that may generate subtasks.
SplittableRandom(long) - Constructor for class java8.util.SplittableRandom: Creates a new SplittableRandom instance using the specified initial seed.
SplittableRandom() - Constructor for class java8.util.SplittableRandom: Creates a new SplittableRandom instance that is likely to generate sequences of values that are statistically independent of those of any other instances in the current program; and may, and typically does, vary across program invocations.
stream(T[]) - Static method in class java8.util.J8Arrays: Returns a sequential Stream with the specified array as its source.
stream(T[], int, int) - Static method in class java8.util.J8Arrays: Returns a sequential Stream with the specified range of the specified array as its source.
stream(int[]) - Static method in class java8.util.J8Arrays: Returns a sequential IntStream with the specified array as its source.
stream(int[], int, int) - Static method in class java8.util.J8Arrays: Returns a sequential IntStream with the specified range of the specified array as its source.
stream(long[]) - Static method in class java8.util.J8Arrays: Returns a sequential LongStream with the specified array as its source.
stream(long[], int, int) - Static method in class java8.util.J8Arrays: Returns a sequential LongStream with the specified range of the specified array as its source.
stream(double[]) - Static method in class java8.util.J8Arrays: Returns a sequential DoubleStream with the specified array as its source.
stream(double[], int, int) - Static method in class java8.util.J8Arrays: Returns a sequential DoubleStream with the specified range of the specified array as its source.
stream() - Method in class java8.util.Optional: If a value is present return a sequential Stream containing only that value, otherwise return an empty Stream.
stream() - Method in class java8.util.OptionalDouble: If a value is present return a sequential DoubleStream containing only that value, otherwise return an empty DoubleStream.
stream() - Method in class java8.util.OptionalInt: If a value is present return a sequential IntStream containing only that value, otherwise return an empty IntStream.
stream() - Method in class java8.util.OptionalLong: If a value is present return a sequential LongStream containing only that value, otherwise return an empty LongStream.
Stream<T> - Interface in java8.util.stream: A sequence of elements supporting sequential and parallel aggregate operations.
stream(Collection<? extends T>) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential Stream using either the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size or a specialized Spliterator implementation (effectively the same one that Java 8 uses) if the passed Collection is one of the types listed below.
stream(Collection<? extends T>, int) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential Stream using the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size.
stream(Collection<? extends T>, int, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel Stream using the given collection's Collection.iterator() as the source of elements for an internally created Spliterator which will report the collection's Collection.size() as its initial size.
stream(Spliterator<T>, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel Stream from a Spliterator.
stream(Supplier<? extends Spliterator<T>>, int, boolean) - Static method in class java8.util.stream.StreamSupport: Creates a new sequential or parallel Stream from a Supplier of Spliterator.
Stream.Builder<T> - Interface in java8.util.stream: A mutable builder for a Stream.
StreamSupport - Class in java8.util.stream: Low-level utility methods for creating and manipulating streams.
StringJoiner - Class in java8.util: StringJoiner is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix and ending with a supplied suffix.
StringJoiner(CharSequence) - Constructor for class java8.util.StringJoiner: Constructs a StringJoiner with no characters in it, with no prefix or suffix, and a copy of the supplied delimiter.
StringJoiner(CharSequence, CharSequence, CharSequence) - Constructor for class java8.util.StringJoiner: Constructs a StringJoiner with no characters in it using copies of the supplied prefix, delimiter and suffix.
submit(ForkJoinTask<T>) - Method in class java8.util.concurrent.ForkJoinPool: Submits a ForkJoinTask for execution.
submit(Callable<T>) - Method in class java8.util.concurrent.ForkJoinPool
submit(Runnable, T) - Method in class java8.util.concurrent.ForkJoinPool
submit(Runnable) - Method in class java8.util.concurrent.ForkJoinPool
SUBSIZED - Static variable in interface java8.util.Spliterator: Characteristic value signifying that all Spliterators resulting from trySplit() will be both Spliterator.SIZED and Spliterator.SUBSIZED.
sum(double, double) - Static method in class java8.lang.Doubles: Adds two double values together as per the + operator.
sum(int, int) - Static method in class java8.lang.Integers: Adds two integers together as per the + operator.
sum(long, long) - Static method in class java8.lang.Longs: Adds two long values together as per the + operator.
sum() - Method in class java8.util.concurrent.atomic.DoubleAdder: Returns the current sum.
sum() - Method in class java8.util.concurrent.atomic.LongAdder: Returns the current sum.
sum() - Method in interface java8.util.stream.DoubleStream: Returns the sum of elements in this stream.
sum() - Method in interface java8.util.stream.IntStream: Returns the sum of elements in this stream.
sum() - Method in interface java8.util.stream.LongStream: Returns the sum of elements in this stream.
summarizingDouble(ToDoubleFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector which applies an double-producing mapping function to each input element, and returns summary statistics for the resulting values.
summarizingInt(ToIntFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector which applies an int-producing mapping function to each input element, and returns summary statistics for the resulting values.
summarizingLong(ToLongFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector which applies an long-producing mapping function to each input element, and returns summary statistics for the resulting values.
summaryStatistics() - Method in interface java8.util.stream.DoubleStream: Returns a DoubleSummaryStatistics describing various summary data about the elements of this stream.
summaryStatistics() - Method in interface java8.util.stream.IntStream: Returns an IntSummaryStatistics describing various summary data about the elements of this stream.
summaryStatistics() - Method in interface java8.util.stream.LongStream: Returns a LongSummaryStatistics describing various summary data about the elements of this stream.
summingDouble(ToDoubleFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the sum of a double-valued function applied to the input elements.
summingInt(ToIntFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the sum of a integer-valued function applied to the input elements.
summingLong(ToLongFunction<? super T>) - Static method in class java8.util.stream.Collectors: Returns a Collector that produces the sum of a long-valued function applied to the input elements.
sumThenReset() - Method in class java8.util.concurrent.atomic.DoubleAdder: Equivalent in effect to DoubleAdder.sum() followed by DoubleAdder.reset().
sumThenReset() - Method in class java8.util.concurrent.atomic.LongAdder: Equivalent in effect to LongAdder.sum() followed by LongAdder.reset().
Supplier<T> - Interface in java8.util.function: Represents a supplier of results.
supplier() - Method in interface java8.util.stream.Collector: A function that creates and returns a new mutable result container.
supplyAsync(Supplier) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() with the value obtained by calling the given Supplier.
supplyAsync(Supplier, Executor) - Static method in class java8.util.concurrent.CompletableFuture: Returns a new CompletableFuture that is asynchronously completed by a task running in the given executor with the value obtained by calling the given Supplier.

T

takeWhile(DoublePredicate) - Method in interface java8.util.stream.DoubleStream: Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate.
takeWhile(DoubleStream, DoublePredicate) - Static method in class java8.util.stream.DoubleStreams: Returns a stream consisting of elements of the passed stream that match the given predicate up to, but discarding, the first element encountered that does not match the predicate.
takeWhile(IntPredicate) - Method in interface java8.util.stream.IntStream: Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate.
takeWhile(IntStream, IntPredicate) - Static method in class java8.util.stream.IntStreams: Returns a stream consisting of elements of the passed stream that match the given predicate up to, but discarding, the first element encountered that does not match the predicate.
takeWhile(LongPredicate) - Method in interface java8.util.stream.LongStream: Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate.
takeWhile(LongStream, LongPredicate) - Static method in class java8.util.stream.LongStreams: Returns a stream consisting of elements of the passed stream that match the given predicate up to, but discarding, the first element encountered that does not match the predicate.
takeWhile(Stream<? extends T>, Predicate<? super T>) - Static method in class java8.util.stream.RefStreams: Returns, if the passed stream is ordered, a stream consisting of the longest prefix of elements taken from the passed stream that match the given predicate.
takeWhile(Predicate<? super T>) - Method in interface java8.util.stream.Stream: Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate.
test(T, U) - Method in interface java8.util.function.BiPredicate: Evaluates this predicate on the given arguments.
test(double) - Method in interface java8.util.function.DoublePredicate: Evaluates this predicate on the given argument.
test(int) - Method in interface java8.util.function.IntPredicate: Evaluates this predicate on the given argument.
test(long) - Method in interface java8.util.function.LongPredicate: Evaluates this predicate on the given argument.
test(T) - Method in interface java8.util.function.Predicate: Evaluates this predicate on the given argument.
thenAccept(Consumer<? super T>) - Method in class java8.util.concurrent.CompletableFuture
thenAccept(Consumer<? super T>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied action.
thenAcceptAsync(Consumer<? super T>) - Method in class java8.util.concurrent.CompletableFuture
thenAcceptAsync(Consumer<? super T>, Executor) - Method in class java8.util.concurrent.CompletableFuture
thenAcceptAsync(Consumer<? super T>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed using this stage's default asynchronous execution facility, with this stage's result as the argument to the supplied action.
thenAcceptAsync(Consumer<? super T>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed using the supplied Executor, with this stage's result as the argument to the supplied action.
thenAcceptBoth(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in class java8.util.concurrent.CompletableFuture
thenAcceptBoth(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied action.
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in class java8.util.concurrent.CompletableFuture
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>, Executor) - Method in class java8.util.concurrent.CompletableFuture
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage complete normally, is executed using this stage's default asynchronous execution facility, with the two results as arguments to the supplied action.
thenAcceptBothAsync(CompletionStage<? extends U>, BiConsumer<? super T, ? super U>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage complete normally, is executed using the supplied executor, with the two results as arguments to the supplied function.
thenApply(Function<? super T, ? extends U>) - Method in class java8.util.concurrent.CompletableFuture
thenApply(Function<? super T, ? extends U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied function.
thenApplyAsync(Function<? super T, ? extends U>) - Method in class java8.util.concurrent.CompletableFuture
thenApplyAsync(Function<? super T, ? extends U>, Executor) - Method in class java8.util.concurrent.CompletableFuture
thenApplyAsync(Function<? super T, ? extends U>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed using this stage's default asynchronous execution facility, with this stage's result as the argument to the supplied function.
thenApplyAsync(Function<? super T, ? extends U>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed using the supplied Executor, with this stage's result as the argument to the supplied function.
thenCombine(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in class java8.util.concurrent.CompletableFuture
thenCombine(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied function.
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in class java8.util.concurrent.CompletableFuture
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>, Executor) - Method in class java8.util.concurrent.CompletableFuture
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage complete normally, is executed using this stage's default asynchronous execution facility, with the two results as arguments to the supplied function.
thenCombineAsync(CompletionStage<? extends U>, BiFunction<? super T, ? super U, ? extends V>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this and the other given stage complete normally, is executed using the supplied executor, with the two results as arguments to the supplied function.
thenComparing(Comparator<? super T>, Comparator<? super T>) - Static method in class java8.util.Comparators: Returns a lexicographic-order comparator with another comparator.
thenComparing(Comparator<? super T>, Function<? super T, ? extends U>, Comparator<? super U>) - Static method in class java8.util.Comparators: Returns a lexicographic-order comparator with a function that extracts a key to be compared with the given Comparator.
thenComparing(Comparator<? super T>, Function<? super T, ? extends U>) - Static method in class java8.util.Comparators: Returns a lexicographic-order comparator with a function that extracts a Comparable sort key.
thenComparingDouble(Comparator<? super T>, ToDoubleFunction<? super T>) - Static method in class java8.util.Comparators: Returns a lexicographic-order comparator with a function that extracts a double sort key.
thenComparingInt(Comparator<? super T>, ToIntFunction<? super T>) - Static method in class java8.util.Comparators: Returns a lexicographic-order comparator with a function that extracts a int sort key.
thenComparingLong(Comparator<? super T>, ToLongFunction<? super T>) - Static method in class java8.util.Comparators: Returns a lexicographic-order comparator with a function that extracts a long sort key.
thenCompose(Function<? super T, ? extends CompletionStage>) - Method in class java8.util.concurrent.CompletableFuture
thenCompose(Function<? super T, ? extends CompletionStage>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed with this stage as the argument to the supplied function.
thenComposeAsync(Function<? super T, ? extends CompletionStage>) - Method in class java8.util.concurrent.CompletableFuture
thenComposeAsync(Function<? super T, ? extends CompletionStage>, Executor) - Method in class java8.util.concurrent.CompletableFuture
thenComposeAsync(Function<? super T, ? extends CompletionStage>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed using this stage's default asynchronous execution facility, with this stage as the argument to the supplied function.
thenComposeAsync(Function<? super T, ? extends CompletionStage>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, is executed using the supplied Executor, with this stage's result as the argument to the supplied function.
thenRun(Runnable) - Method in class java8.util.concurrent.CompletableFuture
thenRun(Runnable) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, executes the given action.
thenRunAsync(Runnable) - Method in class java8.util.concurrent.CompletableFuture
thenRunAsync(Runnable, Executor) - Method in class java8.util.concurrent.CompletableFuture
thenRunAsync(Runnable) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, executes the given action using this stage's default asynchronous execution facility.
thenRunAsync(Runnable, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage that, when this stage completes normally, executes the given action using the supplied Executor.
ThreadLocalRandom - Class in java8.util.concurrent: A random number generator isolated to the current thread.
toArray() - Method in interface java8.util.stream.DoubleStream: Returns an array containing the elements of this stream.
toArray() - Method in interface java8.util.stream.IntStream: Returns an array containing the elements of this stream.
toArray() - Method in interface java8.util.stream.LongStream: Returns an array containing the elements of this stream.
toArray() - Method in interface java8.util.stream.Stream: Returns an array containing the elements of this stream.
toArray(IntFunction<A[]>) - Method in interface java8.util.stream.Stream: Returns an array containing the elements of this stream, using the provided generator function to allocate the returned array, as well as any additional arrays that might be required for a partitioned execution or for resizing.
toCollection(Supplier<C>) - Static method in class java8.util.stream.Collectors: Returns a Collector that accumulates the input elements into a new Collection, in encounter order.
toCompletableFuture() - Method in class java8.util.concurrent.CompletableFuture: Returns this CompletableFuture.
toCompletableFuture() - Method in interface java8.util.concurrent.CompletionStage: Returns a CompletableFuture maintaining the same completion properties as this stage.
toConcurrentMap(Function<? super T, ? extends K>, Function<? super T, ? extends U>) - Static method in class java8.util.stream.Collectors: Returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
toConcurrentMap(Function<? super T, ? extends K>, Function<? super T, ? extends U>, BinaryOperator) - Static method in class java8.util.stream.Collectors: Returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
toConcurrentMap(Function<? super T, ? extends K>, Function<? super T, ? extends U>, BinaryOperator, Supplier<M>) - Static method in class java8.util.stream.Collectors: Returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
ToDoubleBiFunction<T,U> - Interface in java8.util.function: Represents a function that accepts two arguments and produces a double-valued result.
ToDoubleFunction<T> - Interface in java8.util.function: Represents a function that produces a double-valued result.
ToIntBiFunction<T,U> - Interface in java8.util.function: Represents a function that accepts two arguments and produces an int-valued result.
ToIntFunction<T> - Interface in java8.util.function: Represents a function that produces an int-valued result.
toList() - Static method in class java8.util.stream.Collectors: Returns a Collector that accumulates the input elements into a new List.
ToLongBiFunction<T,U> - Interface in java8.util.function: Represents a function that accepts two arguments and produces a long-valued result.
ToLongFunction<T> - Interface in java8.util.function: Represents a function that produces a long-valued result.
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends U>) - Static method in class java8.util.stream.Collectors: Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends U>, BinaryOperator) - Static method in class java8.util.stream.Collectors: Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
toMap(Function<? super T, ? extends K>, Function<? super T, ? extends U>, BinaryOperator, Supplier<M>) - Static method in class java8.util.stream.Collectors: Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
toSet() - Static method in class java8.util.stream.Collectors: Returns a Collector that accumulates the input elements into a new Set.
toString() - Method in class java8.util.concurrent.atomic.DoubleAccumulator: Returns the String representation of the current value.
toString() - Method in class java8.util.concurrent.atomic.DoubleAdder: Returns the String representation of the DoubleAdder.sum().
toString() - Method in class java8.util.concurrent.atomic.LongAccumulator: Returns the String representation of the current value.
toString() - Method in class java8.util.concurrent.atomic.LongAdder: Returns the String representation of the LongAdder.sum().
toString() - Method in class java8.util.concurrent.CompletableFuture: Returns a string identifying this CompletableFuture, as well as its completion state.
toString() - Method in class java8.util.concurrent.ForkJoinPool: Returns a string identifying this pool, as well as its state, including indications of run state, parallelism level, and worker and task counts.
toString() - Method in class java8.util.concurrent.Phaser: Returns a string identifying this phaser, as well as its state.
toString() - Method in class java8.util.DoubleSummaryStatistics: Returns a non-empty string representation of this object suitable for debugging.
toString() - Method in class java8.util.IntSummaryStatistics: Returns a non-empty string representation of this object suitable for debugging.
toString() - Method in class java8.util.LongSummaryStatistics: Returns a non-empty string representation of this object suitable for debugging.
toString(Object) - Static method in class java8.util.Objects: Returns the result of calling toString for a non-null argument and "null" for a null argument.
toString(Object, String) - Static method in class java8.util.Objects: Returns the result of calling toString on the first argument if the first argument is not null and returns the second argument otherwise.
toString() - Method in class java8.util.Optional: Returns a non-empty string representation of this Optional suitable for debugging.
toString() - Method in class java8.util.OptionalDouble: Returns a non-empty string representation of this object suitable for debugging.
toString() - Method in class java8.util.OptionalInt: Returns a non-empty string representation of this object suitable for debugging.
toString() - Method in class java8.util.OptionalLong: Returns a non-empty string representation of this object suitable for debugging.
toString() - Method in class java8.util.StringJoiner: Returns the current value, consisting of the prefix, the values added so far separated by the delimiter, and the suffix, unless no elements have been added in which case, the prefix + suffix or the emptyValue characters are returned
toUnsignedLong(int) - Static method in class java8.lang.Integers: Converts the argument to a long by an unsigned conversion.
tryAdvance(DoubleConsumer) - Method in interface java8.util.Spliterator.OfDouble
tryAdvance(Consumer<? super Double>) - Method in interface java8.util.Spliterator.OfDouble: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(IntConsumer) - Method in interface java8.util.Spliterator.OfInt
tryAdvance(Consumer<? super Integer>) - Method in interface java8.util.Spliterator.OfInt: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(LongConsumer) - Method in interface java8.util.Spliterator.OfLong
tryAdvance(Consumer<? super Long>) - Method in interface java8.util.Spliterator.OfLong: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(T_CONS) - Method in interface java8.util.Spliterator.OfPrimitive: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(Consumer<? super T>) - Method in interface java8.util.Spliterator: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(Spliterator.OfDouble, Consumer<? super Double>) - Static method in class java8.util.Spliterators.OfDouble: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(Spliterator.OfInt, Consumer<? super Integer>) - Static method in class java8.util.Spliterators.OfInt: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(Spliterator.OfLong, Consumer<? super Long>) - Static method in class java8.util.Spliterators.OfLong: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryComplete() - Method in class java8.util.concurrent.CountedCompleter: If the pending count is nonzero, decrements the count; otherwise invokes CountedCompleter.onCompletion(CountedCompleter) and then similarly tries to complete this task's completer, if one exists, else marks this task as complete.
trySplit() - Method in interface java8.util.Spliterator.OfDouble
trySplit() - Method in interface java8.util.Spliterator.OfInt
trySplit() - Method in interface java8.util.Spliterator.OfLong
trySplit() - Method in interface java8.util.Spliterator.OfPrimitive
trySplit() - Method in interface java8.util.Spliterator: If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator.
trySplit() - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator.
trySplit() - Method in class java8.util.Spliterators.AbstractIntSpliterator: If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator.
trySplit() - Method in class java8.util.Spliterators.AbstractLongSpliterator: If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator.
trySplit() - Method in class java8.util.Spliterators.AbstractSpliterator: If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator.
tryUnfork() - Method in class java8.util.concurrent.ForkJoinTask: Tries to unschedule this task for execution.

U

UnaryOperator<T> - Interface in java8.util.function: Represents an operation on a single operand that produces a result of the same type as its operand.
UnaryOperators - Class in java8.util.function: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the UnaryOperator interface.
unordered() - Method in interface java8.util.stream.BaseStream: Returns an equivalent stream that is unordered.

V

valueOf(String) - Static method in enum java8.util.stream.Collector.Characteristics: Returns the enum constant of this type with the specified name.
values() - Static method in enum java8.util.stream.Collector.Characteristics: Returns an array containing the constants of this enum type, in the order they are declared.

W

whenComplete(BiConsumer<? super T, ? super Throwable>) - Method in class java8.util.concurrent.CompletableFuture
whenComplete(BiConsumer<? super T, ? super Throwable>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage with the same result or exception as this stage, that executes the given action when this stage completes.
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>) - Method in class java8.util.concurrent.CompletableFuture
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>, Executor) - Method in class java8.util.concurrent.CompletableFuture
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage with the same result or exception as this stage, that executes the given action using this stage's default asynchronous execution facility when this stage completes.
whenCompleteAsync(BiConsumer<? super T, ? super Throwable>, Executor) - Method in interface java8.util.concurrent.CompletionStage: Returns a new CompletionStage with the same result or exception as this stage, that executes the given action using the supplied Executor when this stage completes.

A B C D E F G H I J L M N O P Q R S T U V W