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

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

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.
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 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.
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.
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.
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.
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.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.
checkFromIndexSize(int, int, int) - Static method in class java8.util.Objects: Checks if the sub-range from fromIndex (inclusive) to fromIndex + size (exclusive) is within the bounds of range from 0 (inclusive) to length (exclusive).
checkFromIndexSize(int, int, int, BiFunction<String, List<Integer>, X>) - Static method in class java8.util.Objects: Checks if the sub-range from fromIndex (inclusive) to fromIndex + size (exclusive) is within the bounds of range from 0 (inclusive) to length (exclusive).
checkFromToIndex(int, int, int) - Static method in class java8.util.Objects: Checks if the sub-range from fromIndex (inclusive) to toIndex (exclusive) is within the bounds of range from 0 (inclusive) to length (exclusive).
checkFromToIndex(int, int, int, BiFunction<String, List<Integer>, X>) - Static method in class java8.util.Objects: Checks if the sub-range from fromIndex (inclusive) to toIndex (exclusive) is within the bounds of range from 0 (inclusive) to length (exclusive).
checkIndex(int, int) - Static method in class java8.util.Objects: Checks if the index is within the bounds of the range from 0 (inclusive) to length (exclusive).
checkIndex(int, int, BiFunction<String, List<Integer>, X>) - Static method in class java8.util.Objects: Checks if the index is within the bounds of the range from 0 (inclusive) to length (exclusive).
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.
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.
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.
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(ConcurrentMap<K, V>, K, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.concurrent.ConcurrentMaps: Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
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(ConcurrentMap<K, V>, K, Function<? super K, ? extends V>) - Static method in class java8.util.concurrent.ConcurrentMaps: 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.
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.
computeIfPresent(ConcurrentMap<K, V>, K, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.concurrent.ConcurrentMaps: 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.
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.
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.
ConcurrentMaps - Class in java8.util.concurrent: A place for static default implementations of the new Java 8 default interface methods and static interface methods in the ConcurrentMap interface.
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

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.
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.
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.
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.
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, returns an Optional describing the value, otherwise returns 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.
filtering(Predicate<? super T>, Collector<? super T, A, R>) - Static method in class java8.util.stream.Collectors: Adapts a Collector to one accepting elements of the same type T by applying the predicate to each input element and only accumulating if the predicate returns true.
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, returns the result of applying the given Optional-bearing mapping function to the value, otherwise returns 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.
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(ConcurrentMap<K, V>, BiConsumer<? super K, ? super V>) - Static method in class java8.util.concurrent.ConcurrentMaps: Performs the given action for each entry in the map until all entries 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.
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.
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, 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, 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, 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, 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.
getOrDefault(ConcurrentMap<K, V>, Object, V) - Static method in class java8.util.concurrent.ConcurrentMaps: Returns the value to which the specified key is mapped, or defaultValue if the map contains no mapping for the key.
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.
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 thread, or null if the current thread 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.
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

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 of the value, if present, otherwise 0 (zero) if no value is present.
hashCode() - Method in class java8.util.OptionalDouble: Returns the hash code of the value, if present, otherwise 0 (zero) if no value is present.
hashCode() - Method in class java8.util.OptionalInt: Returns the hash code of the value, if present, otherwise 0 (zero) if no value is present.
hashCode() - Method in class java8.util.OptionalLong: Returns the hash code of the value, if present, otherwise 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, performs the given action with the value, otherwise does nothing.
ifPresent(DoubleConsumer) - Method in class java8.util.OptionalDouble: If a value is present, performs the given action with the value, otherwise does nothing.
ifPresent(IntConsumer) - Method in class java8.util.OptionalInt: If a value is present, performs the given action with the value, otherwise does nothing.
ifPresent(LongConsumer) - Method in class java8.util.OptionalLong: If a value is present, performs the given action with the value, otherwise does nothing.
ifPresentOrElse(Consumer<? super T>, Runnable) - Method in class java8.util.Optional: If a value is present, performs the given action with the value, otherwise performs the given empty-based action.
ifPresentOrElse(DoubleConsumer, Runnable) - Method in class java8.util.OptionalDouble: If a value is present, performs the given action with the value, otherwise performs the given empty-based action.
ifPresentOrElse(IntConsumer, Runnable) - Method in class java8.util.OptionalInt: If a value is present, performs the given action with the value, otherwise performs the given empty-based action.
ifPresentOrElse(LongConsumer, Runnable) - Method in class java8.util.OptionalLong: If a value is present, performs the given action with the value, otherwise performs 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.
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.
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.ForkJoinTask
isCompletedAbnormally() - Method in class java8.util.concurrent.ForkJoinTask: Returns true if this task threw an exception or was cancelled.
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.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: If a value is present, returns true, otherwise false.
isPresent() - Method in class java8.util.OptionalDouble: If a value is present, returns true, otherwise false.
isPresent() - Method in class java8.util.OptionalInt: If a value is present, returns true, otherwise false.
isPresent() - Method in class java8.util.OptionalLong: If a value is present, returns true, 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(double, DoublePredicate, DoubleUnaryOperator) - Static method in class java8.util.stream.DoubleStreams: Returns a sequential ordered DoubleStream produced by iterative application of a function to an initial element, conditioned on satisfying the supplied predicate.
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(int, IntPredicate, IntUnaryOperator) - Static method in class java8.util.stream.IntStreams: Returns a sequential ordered IntStream produced by iterative application of a function to an initial element, conditioned on satisfying the supplied predicate.
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(long, LongPredicate, LongUnaryOperator) - Static method in class java8.util.stream.LongStreams: Returns a sequential ordered LongStream produced by iterative application of a function to an initial element, conditioned on satisfying the supplied predicate.
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, Predicate<S>, UnaryOperator<S>) - Static method in class java8.util.stream.RefStreams: Returns a sequential ordered Stream produced by iterative application of a function to an initial element, conditioned on satisfying the supplied predicate.
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.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.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.
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.

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, returns an Optional describing (as if by Optional.ofNullable(T)) the result of applying the given mapping function to the value, otherwise returns an empty Optional.
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 interface.
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(ConcurrentMap<K, V>, K, V, BiFunction<? super V, ? super V, ? extends V>) - Static method in class java8.util.concurrent.ConcurrentMaps: 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(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.
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, or checking certain conditions before operation.
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.
of(T) - Static method in class java8.util.Optional: Returns an Optional describing the given non-null value.
of(double) - Static method in class java8.util.OptionalDouble: Returns an OptionalDouble describing the given value.
of(int) - Static method in class java8.util.OptionalInt: Returns an OptionalInt describing the given value.
of(long) - Static method in class java8.util.OptionalLong: Returns an OptionalLong describing the given value.
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.
ofNullable(T) - Static method in class java8.util.Optional: Returns an Optional describing the given 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.
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 an 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.
or(Supplier<Optional<S>>) - Method in class java8.util.Optional: If a value is present, returns an Optional describing the value, otherwise returns an Optional produced by the supplying function.
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: If a value is present, returns the value, otherwise returns other.
orElse(double) - Method in class java8.util.OptionalDouble: If a value is present, returns the value, otherwise returns other.
orElse(int) - Method in class java8.util.OptionalInt: If a value is present, returns the value, otherwise returns other.
orElse(long) - Method in class java8.util.OptionalLong: If a value is present, returns the value, otherwise returns other.
orElseGet(Supplier<? extends T>) - Method in class java8.util.Optional: If a value is present, returns the value, otherwise returns the result produced by the supplying function.
orElseGet(DoubleSupplier) - Method in class java8.util.OptionalDouble: If a value is present, returns the value, otherwise returns the result produced by the supplying function.
orElseGet(IntSupplier) - Method in class java8.util.OptionalInt: If a value is present, returns the value, otherwise returns the result produced by the supplying function.
orElseGet(LongSupplier) - Method in class java8.util.OptionalLong: If a value is present, returns the value, otherwise returns the result produced by the supplying function.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.Optional: If a value is present, returns the value, otherwise throws an exception produced by the exception supplying function.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.OptionalDouble: If a value is present, returns the value, otherwise throws an exception produced by the exception supplying function.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.OptionalInt: If a value is present, returns the value, otherwise throws an exception produced by the exception supplying function.
orElseThrow(Supplier<? extends X>) - Method in class java8.util.OptionalLong: If a value is present, returns the value, otherwise throws an exception produced by the exception supplying function.
outOfBoundsExceptionFormatter(Function<String, X>) - Static method in class java8.util.Objects: Returns an out-of-bounds exception formatter from an given exception factory.

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.
pollSubmission() - Static method in class java8.util.concurrent.ForkJoinTask: If the current thread is operating in a ForkJoinPool, unschedules and returns, without executing, a task externally submitted to the pool, 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(ConcurrentMap<K, V>, BiFunction<? super K, ? super V, ? extends V>) - Static method in class java8.util.concurrent.ConcurrentMaps: 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.
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.
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.
requireNonNullElse(T, T) - Static method in class java8.util.Objects: Returns the first argument if it is non-null and otherwise returns the non-null second argument.
requireNonNullElseGet(T, Supplier<? extends T>) - Static method in class java8.util.Objects: Returns the first argument if it is non-null and otherwise returns the non-null value of supplier.get().
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.

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 and returns the old value.
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, returns a sequential Stream containing only that value, otherwise returns an empty Stream.
stream() - Method in class java8.util.OptionalDouble: If a value is present, returns a sequential DoubleStream containing only that value, otherwise returns an empty DoubleStream.
stream() - Method in class java8.util.OptionalInt: If a value is present, returns a sequential IntStream containing only that value, otherwise returns an empty IntStream.
stream() - Method in class java8.util.OptionalLong: If a value is present, returns a sequential LongStream containing only that value, otherwise returns 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 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.
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.

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.
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.
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.
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.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 OptionalDouble suitable for debugging.
toString() - Method in class java8.util.OptionalInt: Returns a non-empty string representation of this OptionalInt suitable for debugging.
toString() - Method in class java8.util.OptionalLong: Returns a non-empty string representation of this OptionalLong 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(Consumer<? super Double>) - Method in class java8.util.Spliterators.AbstractDoubleSpliterator: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(Consumer<? super Integer>) - Method in class java8.util.Spliterators.AbstractIntSpliterator: If a remaining element exists, performs the given action on it, returning true; else returns false.
tryAdvance(Consumer<? super Long>) - Method in class java8.util.Spliterators.AbstractLongSpliterator: 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.

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