[SYMBOL][A][B][C][D][E][F][G][H][I][J][K][L][M][N][O][P][Q][R][S][T][U][V][W][Z]
:: operator
? wildcard
_ (underscore) character
-> (arrow)
<> (diamond) operator, 2nd
abstract classes
abstract methods
accept method
accumulateAndGet method
accumulator method, 2nd
addExact method
allOf method
alternative calendar systems
andThen method, 2nd
annotations
overview
repeated annotations
type annotations
anonymous classes
JVM and
method references
overview
refactoring to lambda expressions
anonymous functions, in Scala
anyMatch method
Apache Commons Collections library
apply method
applyAsDouble method
applyAsInt method
ArrayList class, 2nd
arrays
parallelPrefix method
parallelSetAll method
parallelSort method
setAll method
arrays, building streams from
Arrays.asList method
Arrays.asSet method
Arrays.stream method
arrow (->)
asynchronous API
asynchronous programming
CompletableFutures
Futures
CompletableFutures vs.
limitations of
implementing asynchronous APIs
converting synchronous methods
errors
nonblocking code
custom Executor
parallelizing requests
solutions that scale better
with CompletableFutures
pipelining asynchronous tasks
combining two CompletableFutures
composing synchronous and asynchronous operations
implementing Discount service
timeouts
using Discount service
reacting to CompletableFuture completion
at method
atomic package
authorsToAge variable
autoboxing
availableProcessors method
backpressure
BDD (behavior-driven development)
@Before annotation
behavior parameterization, 2nd
execute-around pattern
filtering with
abstract criteria
abstracting over List type
anonymous classes
lambda expressions
filtering without
parameterizing attributes
with every possible attribute
with one attribute
overview, 2nd
real-world examples
executing block of code with Runnable interface
GUI event handling
returning results using Callable interface
sorting with Comparator object
verbosity
behavioral compatibility
behavior-driven development (BDD)
@Benchmark annotation
between method
BiFunction interface
big data
binary compatibility
BinaryOperator
BlockingQueueSpliterator
BlockingQueueSpliterator class
blockingSubscribe method
block-style lambda
boolean flag
box-and-channel model
boxing
BufferedReader object, 2nd
build method
building blocks
bytecode generation
byteValueExact method
caching, 2nd
calculate method
Callable interface, returning results using
callback
capturing lambdas
chain of responsibility design pattern, refactoring
characteristics method, 2nd
classification function
ClassNotFoundException
classpath
clicked method
climate change
closures, 2nd
cohesion
collect method, 2nd
collectingAndThen collector
Collection API enhancements
collection factories
ConcurrentHashMap class
counting
reduce and search operations
Set views
List factory
removeIf method
replaceAll method
Map factories, 2nd
compute patterns
forEach method
getOrDefault method
merging values
remove patterns
replacement patterns
sorting
Set factory
removeIf method
replaceAll method
collection framework flexibility
collection literals
collections
Collections class
Comparator interface
in Scala
creating
immutable vs. mutable
working with
Map interface
new methods
removeIf method
replaceAll method
streams vs.
external vs. internal iteration
traversable only once
Collections class
Collections.emptyList method
Collections.sort method
Collector interface
as small DSL
custom collect without creating Collector implementation
methods declared by
accumulator method
characteristics method
combiner method
finisher method
supplier method
collectors
as advanced reductions
predefined
Collectors.averagingInt method
Collectors.collectingAndThen method
Collectors.groupingBy method, 2nd
Collectors.maxBy method
Collectors.minBy method
Collectors.reducing method
Collectors.summingDouble method
Collectors.summingInt method
Collectors.summingLong method
Collectors.toList method, 2nd
Color enum
combinators, 2nd, 3rd
combiner method, 2nd
Compact Profiles
compact profiles
Comparator interface
composing lambda expressions
chaining comparators
reversed order
sorting with
Comparator.comparing method
Comparator.naturalOrder method
compare method, 2nd
compareToIgnoreCase method
compareUnsigned method
compareUsingCustomerId method
comparing method
comparingDouble method
comparingInt method
comparingLong method
compatibilities, types of
CompletableFutures, 2nd, 3rd
combining
creating with supplyAsync factory method
Futures vs.
making asynchronous requests with
reacting to completion
complete method
completeOnTimeout method
composable asynchronous programming
CompletableFutures
Futures
CompletableFutures vs.
limitations of
implementing asynchronous APIs
converting synchronous methods
errors
nonblocking code
custom Executor
parallelizing requests
solutions that scale better
with CompletableFutures
pipelining asynchronous tasks
combining two CompletableFutures
composing synchronous and asynchronous operations
implementing Discount service
timeouts
using Discount service
reacting to CompletableFuture completion
compose method
compute method, 2nd
computed on demand elements
computeIfAbsent method, 2nd
computeIfPresent method, 2nd
computeNumberOfNodes method
computeNumberOfNodesUsingCache method
computing clusters
concat method
concurrency
adders and accumulators
atomic package
box-and-channel model
CompletableFuture and combinators for
ConcurrentHashMap class
keySet method
mappingCount method
performance
stream-like operations
reactive programming
backpressure
reactive systems vs.
simple form of real backpressure
summing two flows
synchronous and asynchronous APIs
blocking operations
exceptions and
future-style APIs
reactive-style APIs
threads
executors and thread pools
higher-level abstractions
non-nested with method calls
CONCURRENT operation
ConcurrentHashMap class
counting
keySet method
mappingCount method
performance
reduce and search operations
Set views
stream-like operations
ConcurrentModificationException
conditional deferred execution
constructor references
Consumer interface
converter method
cores
countWords method
countWordsIteratively method
coupling
Cucumber
currying, 2nd
Daemon thread
data processing
fork/join framework
best practices for
RecursiveTask class
work stealing
parallel streams
measuring performance
turning sequential streams into
using correctly
using effectively
using specialized methods
Spliterator interface
characteristics of
splitting process
WordCounterSpliterator example
data source
data-processing operations
Date and Time API
alternative calendar systems
Duration class
Instant class
LocalDate class
LocalTime class
manipulating dates
printing and parsing date-time objects
TemporalAdjusters class
Period class
time zones
DateFormat
DateTimeFormatter class, 2nd
DateTimeFormatterBuilder class
debugging
examining stack trace
logging information
declaration-site variance
declarative programming
decoupled in space
decoupled in time
decrementExact method
default keyword
default methods, 2nd
evolving APIs and
overview
resolution rules
conflicts and explicit disambiguation
diamond problem
most specific default-providing interface wins
overview
usage patterns for
multiple inheritance of behavior
optional methods
delegation
@Deprecated annotation
design patterns
diamond operator (<>), 2nd
diamond problem
disc allocation
distinct method
divideByZero method
divideUnsigned method
don’t repeat yourself principle (DRY)
dotless notation
DoubleAccumulator class
DoubleAdder class
DoubleUnaryOperator
downstream
dropWhile element
DRY (don’t repeat yourself) principle
DSLs (domain-specific languages)
patterns and techniques to create
function sequencing with lambda expressions
method chaining
nested functions
pros and cons of
real-world examples
Cucumber
jOOQ
Spring Integration
small DSLs in modern Java APIs
Collector interface
Stream interface
solutions available on JVM
external DSLs
internal DSLs
polyglot DSLs
using method references in
elasticity
elements, computed on demand
empty Optionals
emptyList method
encapsulation
endpoints
Entry.comparingByKey
Entry.comparingByValue
equals method
erasure model of generic polymorphism
errorCount variable
estimatedSize
event-driven
events
evolvable interfaces
exceptionally method
Executable class
execute-around pattern, 2nd
behavior parameterization
executing behavior
passing lambdas
using functional interfaces to pass behaviors
Executors, custom
ExecutorService interface
expenses.application module
expenses.readers module
expenses.statistics module
explicit disambiguation
exports clause, 2nd
exports-to clause
expression-style lambda
external domain-specific languages (DSLs)
external DSL
external iteration
extracting data
factorialHelper function
factorialRecursive function
factory design pattern, refactoring
Fibonacci tuples series
File class
FileFilter class
Files class
files, building streams from
Files.lines method
Files.readAllLines
filter method, 2nd, 3rd, 4th, 5th
filter method, rejecting certain values with
filtering
abstracting over List type
anonymous classes
lambda expressions
parameterizing attributes
streams
unique elements
with predicates
with abstract criteria
with every possible attribute
with one attribute
find method
findAny method
findFirst method
finish method
finisher method, 2nd
first-class functions
first-class values
flatMap method, 2nd, 3rd, 4th
floorDiv method
floorMod method
Flow API, 2nd
creating reactive applications
Flow class
lack of implementation in Java
overview
transforming data with Processor
folds
for-each loop, 2nd, 3rd, 4th
forEach method, 2nd, 3rd, 4th
forEachRemaining method
fork method
fork/join framework
best practices for
RecursiveTask class
work stealing
forking step
forking streams
BlockingQueueSpliterator
example of
ForkingStreamConsumer
overview
performance
ForkingStreamConsumer
ForkJoinPool, 2nd
ForkJoinSumCalculator task
free variables
fromInstant method
function descriptors, 2nd, 3rd
Function interface, 2nd
composing lambda expressions
primitive specializations
function sequencing
functional interfaces, 2nd
Consumer interface
execute-around pattern
Function interface
Predicate interface
same lambda associated with different functional interfaces
functional programming, 2nd
caching or memoization
combinators
concepts behind
declarative programming
shared mutable data
currying
functional style in practice
functional-style Java
higher-order functions
lazy evaluation with streams
creating lazy lists
self-defining streams
object-oriented vs. functional-style programming
pattern matching
faking in Java
visitor design pattern
persistent data structures
destructive updates vs. functional
search tree updates
reasons for
recursion vs. iteration
referential transparency, 2nd
@FunctionalInterface annotation
functions
building streams from
in Scala
anonymous functions
closures
currying
first-class
lambdas, 2nd
methods as first-class values
fupdate method
Future interface
Futures
CompletableFutures vs.
limitations of
one-shot
future-style APIs
generate method
generic ? wildcard
generics
additional syntactic flexibility in generics for function types
primitive specializations and
reified generics
get method, 2nd
getAndAccumulate method
getAndUpdate method
getAnnotationsByType method
getAsInt method
getColor method
getName method
getOperationResult method
getOrDefault method
getOrElse method
getResults method
getRotationAngle method
getters
grouping
collecting data in subgroups
manipulating grouped elements
multilevel grouping
groupingBy method, 2nd, 3rd, 4th
Guava
GUI event handling
handle method
hashcode method
hashcodes
HashMap
hasNext method, 2nd
hello method
higher-order functions
high-level building blocks
HotSpot
I/O operations
IDENTITY_FINISH operation
IDEs (integrated development environments)
if-then-else
IllegalArgumentException
immutable object
imperative data processing, refactoring to streams
imperative programming, 2nd
incrementExact method
inference of generic arguments
infinite streams
information hiding
inheritance
insertAll method
instance method
Integer class
integrate method
integrated development environments (IDEs)
IntegrationFlows class
interfaces
intermediate operations
internal domain-specific languages (DSLs), 2nd
internal iteration, 2nd, 3rd
Internet of Things (IoT), 2nd
IntPredicate
IntStream.concat method
IntStream.iterate method
IntSummaryStatistics class
IntUnaryOperator
intValueExact method
inventory variable
invoke method
invokedynamic instruction
IOException
io.reactivex.Flowable class
io.reactivex.Observable class
IoT (Internet of Things), 2nd
isDisposed method
isDone method
isEmpty method, 2nd
isHidden method
isJavaMentioned method
Islamic calendar
isLoggable method
isLongTweet method
isPresent method, 2nd
isPrime method, 2nd
isShortTweet method
isValidName method
italianFormatter
iterate method
iterative factorial
JAR (Java Archive) file
Java
avoiding null
behavior parameterization
changes to
default methods
functions
lambda expressions, 2nd
methods as first-class values
future for
declaration-site variance
deeper support for immutability
generics
moving forward faster
pattern matching
value types
modules
need for evolution
parallelism and shared mutable data
place in programming language ecosystem
stream processing
streams
structural pattern matching
success of
Java Archive (JAR) file
Java Development Kit (JDK)
Java Enhancement Proposal
Java Microbenchmark Harness (JMH)
Java module system, 2nd
automatic modules
compiling and packaging
declaration and clauses
exports clause
exports-to clause
open clause
opens-to clause
provides clause
requires clause
requires transitive clause
uses clause
developing applications with
basics for
fine-grained and coarse-grained modularization
setting up
driving force behind
information hiding
Java software
separation of concerns
multiple modules
exports clause
naming conventions
requires clause
overview
reasons for
comparison with OSGi
modularity limitations
monolithic JDK
java.lang.UnsupportedOperationException
java.time.format package
java.time.Instant class
java.util.Calendar class
java.util.Comparator.comparing
java.util.concurrency.Flow interface
java.util.concurrent package
java.util.concurrent.Flow class, 2nd, 3rd, 4th
java.util.concurrent.ForkJoinPool.common.parallelism
java.util.concurrent.Future interface
java.util.concurrent.RecursiveTask
java.util.Date class, 2nd
java.util.DateFormat class, 2nd
java.util.function package
java.util.function.Consumer interface
java.util.function.Function interface
java.util.function.Predicate interface
java.util.Optional class
java.util.stream.Stream, 2nd
jdeps module
JDK (Java Development Kit)
jlink module
JMH (Java Microbenchmark Harness)
Joda-Time
join method, 2nd, 3rd
joining strings
jOOQ
JSONParser class
JVM (Java Virtual Machine)
anonymous classes and
bytecode generation
DSL solutions available on
external DSLs
internal DSLs
polyglot DSLs
invokedynamic instruction
lambda expressions and
lambda calculus
lambda expressions, 2nd, 3rd, 4th, 5th
creating DSLs
examining stack trace
execute-around pattern
behavior parameterization
executing behavior
passing lambdas
using functional interfaces to pass behaviors
function descriptors
functional interfaces, 2nd
Consumer interface
Function interface
Predicate interface
same lambda associated with different functional interfaces
JVM and
local variables
method references
constructing
constructor references
overview
steps for using
methods for composing
Comparator interface
Function interface
Predicate interface
overview
refactoring design patterns
chain of responsibility design pattern
factory design pattern
observer design pattern
strategy design pattern
template method design pattern
similar ideas from mathematics
connecting to Java, 2nd
integration
testing
behavior of method
behavior of visible lambda
high-order functions
pulling complex lambdas into separate methods
type checking
type inference
where to use
late-binding Spliterator
laziness
lazy evaluation
creating lazy lists
creating basic lazy lists
creating basic linked lists
generating primes again
implementing lazy filter
self-defining streams
limit method, 2nd, 3rd
List factory
removeIf method
replaceAll method
List interface
list method
List type, abstracting over
List.add function
listFiles method
local variable type inference
local variables, lambda expressions and
log method
logicalAnd method
logicalOr method
logicalXor method
LongAccumulator class
LongAdder class
Long.MAX_VALUE
LongStream.rangeClosed method
long-term support (LTS)
longValueExact method
loop fusion
LTS (long-term support)
main method, 2nd
Map factories, 2nd
compute patterns
forEach method
getOrDefault method
merging values
remove patterns
replacement patterns
sorting
Map interface
map method, 2nd, 3rd, 4th
Map.ofEntries method
mapping method
mapping streams
applying functions to each element
flattening streams
using flatMap
using map and Arrays.stream
mappingCount method, 2nd
mapToDouble method
mapToInt method
mapToLong method
mapToObj method
marble diagram
mashup application
Math class
mathematical functions
maxBy method
memoization, 2nd
merge method
mergeDelayError function
message-driven
method chaining
method references, 2nd, 3rd
constructing
constructor references
overview
refactoring from lambda expressions
steps for using
anonymous classes
lambda expressions
method references
passing code
using in DSLs
methods
as first-class values
default
passing code to with behavior parameterization
microbenchmarks
modifying variables
modular code
module descriptor
module name
module-info.java file, 2nd
modules, 2nd
multicore computers
multilevel grouping
multiple inheritance of behavior
composing interfaces
minimal interfaces with orthogonal functionalities
multiple inheritance of types
multiplyCurry function
multiplyExact method
multithreading
mutable state
mvn clean package command
MyLinkedList class
MyMathsUtils class
naming schemes
Nashorn
naturalOrder method
NavigableMap class
NavigableSet class
n-dimensional classification table
negateExact method
nested functions
NestedFunctionOrderBuilder
Netty
newFixedThreadPool method
newNumbers variable
next method, 2nd
nextDown method
NIO API (non-blocking I/O)
n-level nested map
nonblocking call
noneMatch method, 2nd
@NonNull annotation
nonstrict evaluation
NoSuchElementException, 2nd
notify method
notifyAllSubscribers method
null values
alternatives to, in other languages
avoiding
Optionals from
problems with
wrapping potentially null values in Optionals
nullable objects, building streams from
NullPointerExceptions, 2nd
nullsFirst method
nullsLast method
Number class
numeric streams
numeric ranges
primitive specializations
converting back to stream of objects
default values
mapping to numeric stream
Pythagorean triples
defined
filtering good combinations
generating a values
generating b values
generating tuples
representing
running code
object reference
object-oriented design patterns
chain of responsibility design pattern
factory design pattern
observer design pattern
strategy design pattern
template method design pattern
object-relational mapping (ORM)
Observables
creating and using
transforming and combining
observer design pattern
ofEpochSecond method
ofPattern method
on method
onComplete method
onError method
one-shot Futures
onNext method, 2nd
onSubscribe method
open clause
Open Service Gateway initiative (OSGi)
opens-to clause
Option data structure
Optional class, 2nd, 3rd
Optional.empty method, 2nd, 3rd
OptionalInt primitive specialization
Optional.ofNullable method, 2nd
Optionals, 2nd
chaining Optional objects with flatMap
combining two Optionals
creating Optional objects
empty Optionals
Optionals from non-null values
Optionals from null
default actions and unwrapping Optionals
extracting and transforming values from Optionals with map
manipulating stream of Optionals
modeling the absence of value
alternatives to null in other languages
problems with null
reducing NullPointerExceptions with defensive checking
overview
practical examples
exceptions vs. Optional
primitive Optionals
wrapping potentially null values in Optionals
rejecting certain values with filter
OptionalUtility method
OptionalUtility.stringToInt method, 2nd
ORM (object-relational mapping)
orTimeout method
OSGi (Open Service Gateway initiative)
@Override annotation
package name
parallel data processing
fork/join framework
best practices for
RecursiveTask class
work stealing
parallel streams
measuring performance
turning sequential streams into
using correctly
using effectively
using specialized methods
Spliterator interface
characteristics of
splitting process
WordCounterSpliterator example
parallel method, 2nd
parallel operations
forking stream
BlockingQueueSpliterator
example of
ForkingStreamConsumer
overview
performance considerations
parallel streams
measuring performance
turning sequential streams into
using correctly
using effectively
using specialized methods
parallel transparently
parallelism, 2nd
parallelPrefix method
parallelSetAll method
parallelSort method
parallelStream method, 2nd, 3rd
Parameter class
Parser interface
parseUnsignedInt method
partially applied
partitioning
advantages of
of numbers into prime and nonprime
partitioningBy method, 2nd
partitionPrimesWithCustomCollector
pattern matching, 2nd
patternMatchExpr method
peek method
performance, improving with HashMap
persistent, 2nd
persistent data structures
destructive updates vs. functional
search tree updates
pipelining
Point class
polyglot domain-specific languages (DSLs)
portNumber variable
Predicate interface, 2nd
predicates, 2nd
checking to see if predicate matches all elements
checking to see if predicate matches at least one element
filtering streams with
slicing streams using
using dropWhile element
using takeWhile element
pressure
PrimeNumbersCollector
primitive Optionals
primitive specializations
converting back to stream of objects
default values
generics and
mapping to numeric stream
printAll method
println method, 2nd
private keyword
PrivilegedAction interface
process method
processFile method
Processors
Properties.getProperty(String) method
provides clause, 2nd
publisher-subscriber interaction
publish-subscribe model
publish-subscribe protocol
pure functions
putAll method
putIfAbsent method
Pythagorean triples
defined
filtering good combinations
generating a values
generating b values
generating tuples
representing
running code
randomDelay method
Random.nextInt method
rangeClosed method
Reactive Extensions (Rx) project
Reactive Manifesto
reactive at application level
reactive at system level
reactive programming, 2nd
backpressure
Reactive Manifesto
reactive at application level
reactive at system level
reactive streams and Flow API
creating reactive applications
Flow class
lack of implementation in Java
transforming data with Processor
reactive systems vs.
RxJava reactive library
creating and using Observables
transforming and combining Observables
simple form of real backpressure
summing two flows
reactive pull-based backpressure
reactive streams
creating reactive applications
Flow class
lack of implementation in Java
transforming data with Processor
reactive-style APIs
readability
readDuration method
recursive factorial
RecursiveAction
RecursiveTask class
reduce method
reduceKeysToLong
reduceValuesToInt
reducing streams, 2nd
finding maximum and minimum
generalized summarization with reduction
joining strings
maximum and minimum
summarization
summing elements
reduction operations, 2nd
refactoring
for improved flexibility
adopting functional interfaces
conditional deferred execution
execute around
for improved readability
from anonymous classes to lambda expressions
from imperative data processing to Streams
from lambda expressions to method references
object-oriented design patterns
chain of responsibility design pattern
factory design pattern
observer design pattern
strategy design pattern
template method design pattern
referential transparency, 2nd
referentially transparent
Reflection API
reified model of generic polymorphism
remainderUnsigned method
remove method, 2nd
removeIf method, 2nd, 3rd
repeated annotations
replace method, 2nd
replaceAll method, 2nd, 3rd, 4th
request method
requires clause, 2nd
requires-transitive clause
resilience
resolution rules
conflicts and explicit disambiguation
diamond problem
most specific default-providing interface wins
overview
Results interface
reversed method
reverseOrder method
run method
Runnable interface
Runtime.availableProcessors method
Runtime.getRuntime method, 2nd
Rx (Reactive Extensions) project
RxJava reactive library
creating and using Observables
transforming and combining Observables
Scala
classes
getters and setters
verbosity
collections
creating
immutable vs. mutable
working with
functions
anonymous functions
closures
currying
first-class
Hello beer example
functional-style Scala
imperative-style Scala
Option data structure
Stream data structure
traits
tuples
scala.collection.mutable package
self-managing
sequenced values
sequentialSum method
Serializable interface
Set factory
removeIf method
replaceAll method
views
set method
setAll method
setDaemon method
setOnAction method
setRelativeSize method
setRotationAngle method
setters
shadow variables
short-circuiting, 2nd, 3rd
shortValueExact method
side effects
side-effect-free functions
SimplifyExprVisitor
SIZED stream
skip(n) method
sleep method
slicing streams
skipping elements
truncating streams
using predicates
using dropWhile element
using takeWhile element
SMP (symmetric multiprocessing)
SoC (separation of concerns)
sort method, 2nd, 3rd
source compatibility
split method
Spliterator interface
characteristics of
splitting process
WordCounterSpliterator example
putting to work
rewriting in functional style
running in parallel
spliterator method
Spring Integration
StackOverflowError
stand-alone DSL
standard input (stdin)
standard output (stdout)
stateful operations
stateless functions, 2nd
stateless lambda expressions
static methods, 2nd
strategy design pattern, 2nd
Stream data structure
Stream interface, 2nd
stream method, 2nd, 3rd
stream of lines
Stream operations
StreamForker
Stream.generate method
Stream.iterate method
streams, 2nd
building
from arrays
from files
from functions
from nullable
from values
collections vs.
external vs. internal iteration
traversable only once
Collector interface
custom collect without creating Collector implementation
methods declared by
collectors
as advanced reductions
predefined
custom collector for better performance
comparing performance
dividing only by prime numbers
defined
encounter order
filtering
unique elements
with predicates
finding and matching
checking if predicate matches all elements
checking if predicate matches one element
finding elements
finding first element
forking
BlockingQueueSpliterator
example of
ForkingStreamConsumer
overview
performance
grouping
manipulating grouped elements
multilevel grouping
subgroups
lazy evaluation with
creating lazy lists
self-defining streams
manipulating streams of Optionals
mapping
applying functions to each element
flattening streams
multithreading
numeric
numeric ranges
primitive specializations
Pythagorean triples
operations
intermediate operations
terminal operations
overview, 2nd
parallel
measuring performance
turning sequential streams into
using correctly
using effectively
using specialized methods
parallelizing requests using parallel streams
partitioning
advantages of
partitioning numbers into prime and nonprime
practice example
reactive
creating reactive applications
Flow class
lack of implementation in Java
transforming data with Processor
reducing, 2nd
finding maximum and minimum in stream of values
generalized summarization with reduction
joining strings
maximum and minimum
summarization
summing elements
refactoring from imperative data processing
slicing
skipping elements
truncating streams
using predicates
stream-like operations using ConcurrentHashMap class
StreamSupport.stream method, 2nd
strict fork/join
String class, 2nd
string interpolation
strings, joining
structural pattern matching
faking in Java
overview
visitor design pattern
subgroups
Subscriber interface
Subscription.cancel method
substreams
subtractExact method
sum method, 2nd
summarization
summarizingDouble method
summarizingInt method
summarizingLong method
SummaryCalculator class
sun.misc.Unsafe API
super-calls
supplier method
supplyAsync factory method
symmetric multiprocessing (SMP)
synchronized keyword
synchronous API
syntactic metadata
System.getProperty method
System.out.println method
tail-call optimization, 2nd
takeWhile element, 2nd
target typing
target-type inference
TempInfo method
template method design pattern
TemporalAdjusters class
terminal operations
@Test annotation
thenAccept method
thenApply method
thenCombine method
thenComparing method, 2nd
thenComparingDouble method
thenComparingInt method
thenComparingLong method
thenCompose method, 2nd
thread pools
threads
executors and thread pools
advantages of thread pools
disadvantages of thread pools
problems with threads
higher-level abstractions
non-nested with method calls
Thread.setDaemon method
time zones
TimeoutException
timeouts
times function
toInstant method
toIntExact method
toList method, 2nd, 3rd
ToListCollector class
toSet method
toString method, 2nd
toUnsignedInt method
toUnsignedLong method
toUnsignedString method
transitively_final keyword
transparently
TriFunction interface
truncating streams
tryAdvance method, 2nd
trySplit method
tuple literals
tuples series, Fibonacci
type annotations
type checking
type inference
UnaryOperator
unbounded operations
unboxing
underscore (_) character
unique characters
UNORDERED operation
UnsupportedModificationException
UnsupportedOperationException, 2nd
UnsupportedTemporalTypeException
updateAndGet method
upstream
uses clause, 2nd
val keyword
value parameterization
value types
interdependency problem
primitives and objects
treating integer and int identically
values, building streams from
varargs
verbosity
abstracting over List type
anonymous classes
in Scala
lambda expressions
visitor design pattern
void method invocation
void-compatibility rule
W/C (wait/compute) ratio
walk method
while loop
wildcard notation
with method
withAttribute method
withVariant method
WordCounter class
WordCounterSpliterator example
putting to work
rewriting in functional style
running in parallel
work stealing
worker threads