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
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
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
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
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
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.