Index

A

abstract classes, Template Method Pattern
accumulators, A Common Pattern Appears
ActionListener class, Your First Lambda Expression
Agile software development, Lambda-Enabled Design Patterns
immutable objects and, The Open/Closed Principle
Amdahls Law, Why Is Parallelism Important?
anonymous inner class, Your First Lambda Expression, Using Lambda Expressions in Code
Answer interface (Mockito), Using Lambda Expressions in Test Doubles
antipatterns, Lambda-Enabled Design Patterns
Apache Camel, Reactive Programming
Apache Maven, Moving Forward
arguments, How to Spot a Lambda in a Haystack
array operations, Parallel Array Operations
parallel performance of, Performance
ArrayList data source, Performance
Arrays class, Parallel Array Operations
parallelPrefix operation, Parallel Array Operations
parallelSetAll operation, Parallel Array Operations
parallelSort operation, Parallel Array Operations
asynchronous I/O (see nonblocking I/O)
averagingInt as downstream collector, Composing Collectors

B

backwards binary compatibility, Binary Interface Compatibility
Beck, Kent, Testing, Debugging, and Refactoring
behavior-driven development (BDD), Lambda-Enabled Domain-Specific Languages
test-driven development vs., Lambda-Enabled Domain-Specific Languages
binary objects, passing between verticals, Message Passing Architectures
BinaryOperator interface, Type Inference, Overload Resolution
blocking I/O, Why Use Nonblocking I/O?
boxed type, Primitives
boxed() method, Primitives
boxing, Primitives
Buffer class (vertx), Message Passing Architectures
build method, What’s Actually Going On
builder pattern, What’s Actually Going On
bun methods, collect(toList())

C

callbacks, Callbacks–Callbacks
combining with Futures, Completable Futures–Completable Futures
Pyramid of Doom and, The Pyramid of Doom–The Pyramid of Doom
Camel (Apache), Reactive Programming
cascading style sheets, as external DSL, Lambda-Enabled Domain-Specific Languages
class cohesion, The Single Responsibility Principle
client class (command pattern), Command Pattern
Closeable interface, @FunctionalInterface
closures, Using Values
code
as data, Your First Lambda Expression
opinions on, Design and Architectural Principles
cohesion, The Single Responsibility Principle
collect(toList()) operation (Stream), collect(toList())
collections, Advanced Collections and Collectors–Key Points
collectors, Enter the Collector–Reduction as a Collector
creating parallel streams from, Parallel Stream Operations
in Java 8, Collection Niceties–Collection Niceties
method references, Method References
stream elements, ordering, Element Ordering–Element Ordering
Collections interface, Binary Interface Compatibility
collectors, Enter the Collector–Reduction as a Collector
composing, Composing Collectors–Composing Collectors
custom, Refactoring and Custom Collectors–Refactoring and Custom Collectors
data partitioning with, Partitioning the Data
grouping data with, Grouping the Data
into other collections, Into Other Collections
reduction as, Reduction as a Collector
refactoring, Refactoring and Custom Collectors–Refactoring and Custom Collectors
strings, Strings
to values, To Values
combining functions, Caveats
command class (command pattern), Command Pattern
command pattern, Command Pattern–Command Pattern
lambda expressions vs., Command Pattern
Comparable interface, @FunctionalInterface
Comparator, max and min
comparing method, max and min
completable futures, Completable Futures–Completable Futures
CompletableFuture API, Moving Forward
complete method, Completable Futures
completeExceptionally, Completable Futures
exceptionally method, Completable Futures
Executor, Completable Futures
isCompletedExceptionally method, Completable Futures
isDone method, Completable Futures
join method, Completable Futures
Streams API vs., Completable Futures
supplyAsync method, Completable Futures
thenAccept method, Completable Futures
thenApply method, Completable Futures
thenCombine method, Completable Futures
thenRun method, Completable Futures
complete method (CompletableFuture), Completable Futures
completeExceptionally (CompletableFuture), Completable Futures
concrete classes, Template Method Pattern
concurrency, Lambda-Enabled Concurrency–Key Points
appropriate use of, When and Where
callbacks and, Callbacks–Callbacks
completable futures, Completable Futures–Completable Futures
futures, Futures–Completable Futures
message passing architecture, Message Passing Architectures
nonblocking I/O, Why Use Nonblocking I/O?
parallelism vs., Parallelism Versus Concurrency–Parallelism Versus Concurrency, Parallelism Versus Concurrency
reactive programming, Reactive Programming–Reactive Programming
concurrent package, Why Did They Need to Change Java Again?
connectHandler method (vertx), Callbacks
Consumer, Completable Futures
continuous integration (CI), Testing, Debugging, and Refactoring
CSS, as external DSL, Lambda-Enabled Domain-Specific Languages

D

data parallelism, Data Parallelism–Key Points
array operations for, Parallel Array Operations
concurrency vs., Parallelism Versus Concurrency–Parallelism Versus Concurrency, Parallelism Versus Concurrency
performance and, Why Is Parallelism Important?
performance for, Performance–Performance
rules of, Caveats
simulations and, Simulations–Caveats
stream operations and, Parallel Stream Operations–Parallel Stream Operations
task parallelism vs., Parallelism Versus Concurrency
data size and performance, Performance
dataHandler method (vertx), Callbacks
debug(String message), Using Lambda Expressions in Code
debugging vs. lazy evaluation, Lazy Evaluation Versus Debugging
default keyword, Default Methods–Default Methods and Subclassing
subclassing and, Default Methods and Subclassing–Default Methods and Subclassing
default methods, Default Methods
deferred objects, Completable Futures
dependency inversion principle, The Dependency Inversion Principle–The Dependency Inversion Principle
describe verb (DSL), A DSL in Java
design patterns, Lambda-Enabled Design Patterns
design principles, Design and Architectural Principles–Further Reading
command pattern, Command Pattern–Command Pattern
domain-specific languages and, Lambda-Enabled Domain-Specific Languages–Evaluation
lambda enabled, Lambda-Enabled Design Patterns–Template Method Pattern
observer pattern, Observer Pattern–Observer Pattern
SOLID principles, Lambda-Enabled SOLID Principles–The Dependency Inversion Principle
strategy pattern, Strategy Pattern–Strategy Pattern
template method pattern, Template Method Pattern–Template Method Pattern
diamond operator, Type Inference
domain model, exposing/hiding elements of, Putting Operations Together
domain-specific languages (DSL), Lambda-Enabled Domain-Specific Languages–Evaluation
describe verb, A DSL in Java
evaluating, Evaluation
expect class, How We Got There
expectation, Lambda-Enabled Domain-Specific Languages
external, Lambda-Enabled Domain-Specific Languages
implementing, How We Got There–How We Got There
in Java, A DSL in Java
spec, Lambda-Enabled Domain-Specific Languages
specifySuite method, How We Got There
suite, Lambda-Enabled Domain-Specific Languages
testing, Evaluation
Domain-Specific Languages (Fowler and Parsons), Further Reading
double type, Primitives

E

eager methods, What’s Actually Going On
Eclipse, Moving Forward
effectively final variables, Using Values
empty method (Optional), Optional
encounter order, Element Ordering
eventbus (vertx), Callbacks
broadcast messages, implementing with, Callbacks
exceptionally method (CompletableFutures), Completable Futures
Executor (CompletableFuture), Completable Futures
ExecutorService, Completable Futures
expect class (DSL), How We Got There
expectation (DSL), Lambda-Enabled Domain-Specific Languages
external DSL, Lambda-Enabled Domain-Specific Languages
external iteration, From External Iteration to Internal Iteration–From External Iteration to Internal Iteration

F

filter method (Observable), Reactive Programming
filter method (Stream), filter
final variables, Using Values
flatMap method (Observable), Reactive Programming
flatmap operation, flatMap
for loops
external iteration vs., From External Iteration to Internal Iteration
refactoring, Refactoring Legacy Code–Refactoring Legacy Code
forEach method (Iterable), Default Methods
Fowler, Martin, Using Lambda Expressions in Test Doubles, Further Reading
Freeman, Steve, Testing, Debugging, and Refactoring
Function objects
flatmap operations and, flatMap
passing lambda expressions as, map
functional interfaces, Functional Interfaces–Functional Interfaces
for DSLs, How We Got There
functional programming, What Is Functional Programming?
higher-order functions and, Higher-Order Functions
@FunctionalInterface annotation, @FunctionalInterface
futures, Futures–Completable Futures
completable, Completable Futures–Completable Futures

G

get method (Futures), Using Lambda Expressions in Code, Futures
Optional values and, max and min, Optional
gradle, Moving Forward
group by (SQL), Grouping the Data
groupingBy collector, Grouping the Data, Composing Collectors
Growing Object-Oriented Software, Guided by Tests (Freeman and Pryce), Testing, Debugging, and Refactoring
Guava Library (Google), Completable Futures
GUI Editor example, Command Pattern
gzip algorithm, Strategy Pattern

H

HashSet (Collection), Element Ordering
in parallel processing, Performance
higher-order functions, Higher-Order Functions

I

identity values, Caveats
immutable objects, The Open/Closed Principle
implementation immutability, The Open/Closed Principle
inheritance, Multiple Inheritance
of default methods, Default Methods–Default Methods and Subclassing
rules of, The Three Rules
super syntax and, Multiple Inheritance
int type, Primitives
Intellij, Moving Forward
interfaces
limitations of, Tradeoffs
static methods on, Static Methods on Interfaces
stream as, Static Methods on Interfaces
internal DSL, Lambda-Enabled Domain-Specific Languages
internal iteration, From External Iteration to Internal Iteration–From External Iteration to Internal Iteration
IntStream.range constructor, Performance
invoker class (command pattern), Command Pattern
isCompletedExceptionally method (CompletableFutures), Completable Futures
isDebugEnabled method, In, Out, In, Out, Shake It All About
logging and, Using Lambda Expressions in Code
isDone method (CompletableFutures), Completable Futures
isPresent method (Optional), Optional
Iterable objects, Default Methods
iterate method (Stream), Performance
iteration
external vs. internal, From External Iteration to Internal Iteration–From External Iteration to Internal Iteration
implementing, What’s Actually Going On
iterator method (Streams), From External Iteration to Internal Iteration

J

Jasmine framework, Lambda-Enabled Domain-Specific Languages
Java 6, Moving Forward
Java 7, Moving Forward
type inference in, Type Inference
Java 8, Why Did They Need to Change Java Again?
backwards binary compatibility, Binary Interface Compatibility
collections in, Collection Niceties–Collection Niceties
comparing method, max and min
default keyword, Default Methods–Default Methods and Subclassing
design principles, Design and Architectural Principles–Further Reading
domain, Example Domain
functional programming in, What Is Functional Programming?
@FunctionalInterface annotation, @FunctionalInterface
general patterns in, A Common Pattern Appears
method references, Method References
multiple inheritance, Multiple Inheritance
NIO API, Why Use Nonblocking I/O?
open/closed principle and, The Open/Closed Principle
optional core library, Optional
Jenkins CI system, Moving Forward
JMock, Lambda-Enabled Domain-Specific Languages
Jodatime, Moving Forward
join method (CompletableFuture), Completable Futures
joining method (Collectors), Strings
JOOQ, Lambda-Enabled Domain-Specific Languages
JSON objects and verticals, Message Passing Architectures
JUnit, Lambda-Enabled Domain-Specific Languages

L

lambda expressions, Lambda Expressions–Key Points
best practices for, Good Use of Lambda Expressions
collections, Advanced Collections and Collectors–Key Points
command pattern vs., Command Pattern
concurrency, Lambda-Enabled Concurrency–Key Points
design principles, Design and Architectural Principles–Further Reading
domain-specific languages and, Lambda-Enabled Domain-Specific Languages–Evaluation
format of, How to Spot a Lambda in a Haystack–How to Spot a Lambda in a Haystack
functional interfaces and, Functional Interfaces–Functional Interfaces
iteration, From External Iteration to Internal Iteration–From External Iteration to Internal Iteration
libraries, Libraries–Optional
observer pattern vs., Observer Pattern
reading, How to Spot a Lambda in a Haystack
refactoring, Lambda Refactoring Candidates–Unit Testing Lambda Expressions
strategy pattern vs., Strategy Pattern
streams and, Streams–Key Points
template method pattern vs., Template Method Pattern
test doubles, using, Using Lambda Expressions in Test Doubles–Using Lambda Expressions in Test Doubles
type inference, Type Inference–Type Inference
unit testing, Unit Testing Lambda Expressions–Unit Testing Lambda Expressions
usage, Using Lambda Expressions in Code
values and, Using Values
lambdifiers, Lambda Refactoring Candidates
lazy evaluation vs. debugging, Lazy Evaluation Versus Debugging
lazy methods, What’s Actually Going On
libraries, Libraries–Optional
@FunctionalInterface annotation, @FunctionalInterface
optional core, Optional
overloading methods, Overload Resolution–Overload Resolution
primitive types and, Primitives–Primitives
lines method (BufferedReader), Performance
LinkedList, Performance
List (Collection), Element Ordering
ListenableFuture, Completable Futures
locking data structures, Caveats
log4j logging system, Using Lambda Expressions in Code, The Solution: peek
logging, Logging and Printing
speeding up with lambda expressions, Using Lambda Expressions in Code
logging (Util), The Solution: peek
long type, Primitives
LongStream function, Primitives
LongUnaryOperator function, Primitives

M

macro functionality, Command Pattern
macros, Command Pattern
Map collectors, Collection Niceties
map method (Observable), Reactive Programming
map operation (Stream), map
for specialized primitives, Primitives
mapping collector, Composing Collectors
mapToLong function, Primitives
mapToObj method, Primitives
Martin, Bob, Further Reading
Maven (Apache), Moving Forward
max operation (Stream), max and min
maxBy collector, To Values
Message object (vertx), Callbacks
message passing architecture, Message Passing Architectures
method references, Method References
unit testing and, Unit Testing Lambda Expressions
Meyer, Bertrand, The Open/Closed Principle
midstream breakpoints, Midstream Breakpoints
min operation (Stream), max and min
minBy collector, To Values
mocking libraries, Lambda-Enabled Domain-Specific Languages
Mockito framework, Using Lambda Expressions in Test Doubles, Lambda-Enabled Domain-Specific Languages
mocks, Using Lambda Expressions in Test Doubles
Mocks Arent Stubs (Fowler), Using Lambda Expressions in Test Doubles
Monte Carlo simulations, Simulations–Caveats
multicore CPUs, Why Did They Need to Change Java Again?, Why Is Parallelism Important?
multiple inheritance, Multiple Inheritance
rules of, The Three Rules

N

New I/O (see nonblocking I/O)
newline (Pattern class), Callbacks
NIO (see nonblocking I/O)
nonblocking I/O, Why Use Nonblocking I/O?
blocking I/O vs., Why Use Nonblocking I/O?
Java API for, Why Use Nonblocking I/O?
null value, Optional
NullPointerException, Optional

O

Object Mentor website, Further Reading
Observable (RxJava), Reactive Programming
filter method, Reactive Programming
flatMap method, Reactive Programming
map method, Reactive Programming
onCompleted method, Reactive Programming
onError method, Reactive Programming
onNext method, Reactive Programming
Stream vs., Reactive Programming
take method, Reactive Programming
observable immutability, The Open/Closed Principle
observer pattern, Observer Pattern–Observer Pattern
designing APIs for, Observer Pattern
lambda expressions vs., Observer Pattern
ofNullable method (Optional), Optional
onCompleted method (Observable), Reactive Programming
onError method (Observable), Reactive Programming
onNext method (Observable), Reactive Programming
open/closed principle, The Open/Closed Principle–The Open/Closed Principle
immutable objects, The Open/Closed Principle
operations
chaining, Putting Operations Together
parallel array, Parallel Array Operations
parallel stream, Parallel Stream Operations–Parallel Stream Operations
refactoring legacy code, Refactoring Legacy Code–Refactoring Legacy Code
optional core library, Optional
Optional values, max and min
empty method, Optional
isPresent method, Optional
ofNullable method, Optional
Oracle, Composing Collectors
orElse method, Optional
orElseGet method, Optional
overloading methods, Overload Resolution–Overload Resolution
default methods and, Default Methods and Subclassing–Default Methods and Subclassing
ThreadLocal and, The Lonely Override

P

parallel method (Stream), Parallel Stream Operations
parallelPrefix operation (Arrays), Parallel Array Operations
parallelSetAll operation (Arrays), Parallel Array Operations
parallelSort operation (Arrays), Parallel Array Operations
parallelStream method (Collection), Parallel Stream Operations
parameter types, Functional Interfaces
Parsons, Rebecca, Further Reading
partitioningBy collector, Partitioning the Data
Pattern class (Regex), Callbacks
peek operation, The Solution: peek
performance
boxed types and, Primitives
Futures and, Futures
logging and, Using Lambda Expressions in Code
parallelism and, Why Is Parallelism Important?, Performance–Performance
primitive specialized functions and, Primitives
sequential vs. parallel processing and, Parallel Stream Operations
point lambdafication, Lambda Refactoring Candidates
Predicate, Type Inference
filter method with, filter
overloaded methods and, Overload Resolution
stream partitioning with, Partitioning the Data
primitive specialization, Primitives
primitive types, Primitives–Primitives
Stream specialization for, Primitives
promise, Completable Futures
Pryce, Nat, Testing, Debugging, and Refactoring
Pyramid of Doom, The Pyramid of Doom–The Pyramid of Doom

Q

Querydsl, Lambda-Enabled Domain-Specific Languages

R

Reactive Manifesto website, When and Where
reactive programming, Reactive Programming–Reactive Programming
readability of code, Why Did They Need to Change Java Again?
final values and, Using Values
method references and, Method References
receiver class (command pattern), Command Pattern
reduce operation (Stream), reduce–reduce
in parallel, Caveats
reduction, collectors as, Reduction as a Collector
refactoring code, Lambda Refactoring Candidates–Unit Testing Lambda Expressions
logging, In, Out, In, Out, Shake It All About
overriding single methods, The Lonely Override
WET pattern and, Behavioral Write Everything Twice–Unit Testing Lambda Expressions
with collectors, Refactoring and Custom Collectors–Refactoring and Custom Collectors
refactoring legacy code, Refactoring Legacy Code–Refactoring Legacy Code
regular expressions, as external DSL, Lambda-Enabled Domain-Specific Languages
Runnable, Command Pattern
CompletableFutures and, Completable Futures
RxJava framework, Lambda-Enabled Concurrency, Moving Forward
documentation, Reactive Programming
reactive programming with, Reactive Programming

S

Selectors, Why Use Nonblocking I/O?
sequential method (Stream), Caveats
Servlets vs. Verticals, Callbacks
side effect-free functions, Good Use of Lambda Expressions
single responsibility principle, The Single Responsibility Principle–The Single Responsibility Principle
singleton pattern, Lambda-Enabled Design Patterns
slf4j logging system, Using Lambda Expressions in Code, The Solution: peek
SOLID principles, Lambda-Enabled SOLID Principles–The Dependency Inversion Principle
dependency inversion principle, The Dependency Inversion Principle–The Dependency Inversion Principle
open/closed principle, The Open/Closed Principle–The Open/Closed Principle
single responsibility principle, The Single Responsibility Principle–The Single Responsibility Principle
spec (DSL), Lambda-Enabled Domain-Specific Languages
specifySuite method (DSL), How We Got There
splitAsStream (Pattern class), Callbacks
Spring, Moving Forward
Spring Framework, Completable Futures
SQL builder APIs, Lambda-Enabled Domain-Specific Languages
state
sharing between verticals, avoiding, Message Passing Architectures
streams and, Performance
stateful stream operations, Performance
stateless stream operations, Performance
static methods, Static Methods on Interfaces
strategy pattern, Strategy Pattern–Strategy Pattern
lambda expressions vs., Strategy Pattern
Stream API, Common Stream Operations–Putting Operations Together
collect(toList()) operation, collect(toList())
CompletableFuture API vs., Completable Futures
filter method, filter
iterate method, Performance
map operation, map, Primitives
max operation, max and min
min operation, max and min
parallel method, Parallel Stream Operations
peek, The Solution: peek
reduce operation, reduce–reduce, Caveats
RxJava vs., Reactive Programming
sequential method, Caveats
unordered() method, Element Ordering
stream method, backwards compatibility of, Binary Interface Compatibility
streams, Streams–Key Points
chaining operations on, Putting Operations Together
filter method, filter
flatmap operation, flatMap
implementing, What’s Actually Going On
iterating over, From External Iteration to Internal Iteration–From External Iteration to Internal Iteration
legacy code and, Refactoring Legacy Code–Refactoring Legacy Code
multiple calls to, Multiple Stream Calls
operations, Common Stream Operations–Putting Operations Together
ordering elements in, Element Ordering–Element Ordering
specialized versions of, Primitives
stateful operations, Performance
stateless operations, Performance
String objects
as immutable code, The Open/Closed Principle
splitting with splitAsStream, Callbacks
strings, Strings
stubs, Using Lambda Expressions in Test Doubles
subclassing, Default Methods and Subclassing–Default Methods and Subclassing
subject (observer pattern), Observer Pattern
suite (DSL), Lambda-Enabled Domain-Specific Languages
summarizingInt collector, To Values
summarizingLong, as downstream collector, Composing Collectors
summaryStatistics method, Primitives
summarizingInt collector, To Values
summingInt collector, To Values
super syntax, Multiple Inheritance
supplyAsync method (CompletableFuture), Completable Futures
Swing, Your First Lambda Expression

T

take method (Observable), Reactive Programming
target types of lambda expressions, How to Spot a Lambda in a Haystack, Overload Resolution
task parallelism, Parallelism Versus Concurrency
template method pattern, Template Method Pattern–Template Method Pattern
lambda expressions vs., Template Method Pattern
test doubles, Using Lambda Expressions in Test Doubles–Using Lambda Expressions in Test Doubles
Test-Driven Development (Beck), Testing, Debugging, and Refactoring
test-driven development (TDD), Testing, Debugging, and Refactoring
behavior-driven development vs., Lambda-Enabled Domain-Specific Languages
testing
concurrent systems with verticals, Message Passing Architectures
logging, Logging and Printing
midstream breakpoints, Midstream Breakpoints
verticals, Message Passing Architectures
thenAccept method (CompletableFutures), Completable Futures
thenApply method (CompletableFutures), Completable Futures
thenCombine method (CompletableFuture), Completable Futures
thenRun method (CompletableFutures), Completable Futures
ThreadLocal class, The Open/Closed Principle
lonely overrides and, The Lonely Override
toCollection collector, Into Other Collections
toList collector, Into Other Collections
ToLongFunction method, Primitives
toSet collector, Into Other Collections
TreeSet, Into Other Collections
in parallel processing, Performance
Twitter, When and Where
type inference, Type Inference
types
inferring, Type Inference–Type Inference
parameter, Functional Interfaces
Predicates and, Type Inference
primitive, Primitives–Primitives

U

unboxing, Primitives
unit testing, Unit Testing Lambda Expressions–Unit Testing Lambda Expressions
challenges of, Unit Testing Lambda Expressions
test doubles and, Using Lambda Expressions in Test Doubles–Using Lambda Expressions in Test Doubles
unordered method (Stream), Element Ordering
user connections, handling, Callbacks
utility code, Static Methods on Interfaces

V

values
final, Using Values
variables vs., Using Values
variables vs. values, Using Values
verbosity of code, Why Did They Need to Change Java Again?
vertical (vertx), Callbacks
vertx framework, Lambda-Enabled Concurrency
broadcast messages, implementing within, Callbacks
Buffer class, Message Passing Architectures
CompletableFutures in, Completable Futures
connectHandler method, Callbacks
dataHandler method, Callbacks
eventbus, Callbacks, Callbacks
implementing code within, Callbacks
integrating with RxJava, Reactive Programming
Message object, Callbacks
verticals, Callbacks
virtual methods, Default Methods and Subclassing

W

with method, The Pyramid of Doom
Write Everything Twice (WET), Behavioral Write Everything Twice–Unit Testing Lambda Expressions

Z

zip algorithm, Strategy Pattern
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.138.34.226