Index

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Previous Chapter

Appendix D. Lambdas and JVM bytecode

List of Figures

Index

[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]

SYMBOL

:: operator ? wildcard _ (underscore) character -> (arrow) <> (diamond) operator, 2^nd

A

abstract classes abstract methods accept method accumulateAndGet method accumulator method, 2^nd addExact method allOf method alternative calendar systems andThen method, 2^nd 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, 2^nd 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

B

backpressure BDD (behavior-driven development) @Before annotation behavior parameterization, 2^nd 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, 2^nd 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, 2^nd build method building blocks bytecode generation byteValueExact method

C

caching, 2^nd calculate method Callable interface, returning results using callback capturing lambdas chain of responsibility design pattern, refactoring characteristics method, 2^nd classification function ClassNotFoundException classpath clicked method climate change closures, 2^nd cohesion collect method, 2^nd collectingAndThen collector Collection API enhancements collection factories ConcurrentHashMap class counting reduce and search operations Set views List factory removeIf method replaceAll method Map factories, 2^nd 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, 2^nd Collectors.maxBy method Collectors.minBy method Collectors.reducing method Collectors.summingDouble method Collectors.summingInt method Collectors.summingLong method Collectors.toList method, 2^nd Color enum combinators, 2^nd, 3^rd combiner method, 2^nd Compact Profiles compact profiles Comparator interface composing lambda expressions chaining comparators reversed order sorting with Comparator.comparing method Comparator.naturalOrder method compare method, 2^nd compareToIgnoreCase method compareUnsigned method compareUsingCustomerId method comparing method comparingDouble method comparingInt method comparingLong method compatibilities, types of CompletableFutures, 2^nd, 3^rd 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, 2^nd computed on demand elements computeIfAbsent method, 2^nd computeIfPresent method, 2^nd 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, 2^nd

D

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, 2^nd 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, 2^nd 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 (<>), 2^nd 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

E

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, 2^nd 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, 2^nd exports-to clause expression-style lambda external domain-specific languages (DSLs) external DSL external iteration extracting data

F

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, 2^nd, 3^rd, 4^th, 5^th 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, 2^nd first-class functions first-class values flatMap method, 2^nd, 3^rd, 4^th floorDiv method floorMod method Flow API, 2^nd creating reactive applications Flow class lack of implementation in Java overview transforming data with Processor folds for-each loop, 2^nd, 3^rd, 4^th forEach method, 2^nd, 3^rd, 4^th 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, 2^nd ForkJoinSumCalculator task free variables fromInstant method function descriptors, 2^nd, 3^rd Function interface, 2^nd composing lambda expressions primitive specializations function sequencing functional interfaces, 2^nd Consumer interface execute-around pattern Function interface Predicate interface same lambda associated with different functional interfaces functional programming, 2^nd 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, 2^nd @FunctionalInterface annotation functions building streams from in Scala anonymous functions closures currying first-class lambdas, 2^nd methods as first-class values fupdate method Future interface Futures CompletableFutures vs. limitations of one-shot future-style APIs

G

generate method generic ? wildcard generics additional syntactic flexibility in generics for function types primitive specializations and reified generics get method, 2^nd 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, 2^nd, 3^rd, 4^th Guava GUI event handling

H

handle method hashcode method hashcodes HashMap hasNext method, 2^nd hello method higher-order functions high-level building blocks HotSpot

I

I/O operations IDENTITY_FINISH operation IDEs (integrated development environments) if-then-else IllegalArgumentException immutable object imperative data processing, refactoring to streams imperative programming, 2^nd 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), 2^nd internal iteration, 2^nd, 3^rd Internet of Things (IoT), 2^nd 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), 2^nd isDisposed method isDone method isEmpty method, 2^nd isHidden method isJavaMentioned method Islamic calendar isLoggable method isLongTweet method isPresent method, 2^nd isPrime method, 2^nd isShortTweet method isValidName method italianFormatter iterate method iterative factorial

J

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, 2^nd 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, 2^nd, 3^rd, 4^th java.util.concurrent.ForkJoinPool.common.parallelism java.util.concurrent.Future interface java.util.concurrent.RecursiveTask java.util.Date class, 2^nd java.util.DateFormat class, 2^nd 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, 2^nd jdeps module JDK (Java Development Kit) jlink module JMH (Java Microbenchmark Harness) Joda-Time join method, 2^nd, 3^rd 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

K

keySet method, 2^nd

L

lambda calculus lambda expressions, 2^nd, 3^rd, 4^th, 5^th creating DSLs examining stack trace execute-around pattern behavior parameterization executing behavior passing lambdas using functional interfaces to pass behaviors function descriptors functional interfaces, 2^nd 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, 2^nd, 3^rd 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)

M

main method, 2^nd Map factories, 2^nd compute patterns forEach method getOrDefault method merging values remove patterns replacement patterns sorting Map interface map method, 2^nd, 3^rd, 4^th Map.ofEntries method mapping method mapping streams applying functions to each element flattening streams using flatMap using map and Arrays.stream mappingCount method, 2^nd mapToDouble method mapToInt method mapToLong method mapToObj method marble diagram mashup application Math class mathematical functions maxBy method memoization, 2^nd merge method mergeDelayError function message-driven method chaining method references, 2^nd, 3^rd 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, 2^nd modules, 2^nd 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

N

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, 2^nd nextDown method NIO API (non-blocking I/O) n-level nested map nonblocking call noneMatch method, 2^nd @NonNull annotation nonstrict evaluation NoSuchElementException, 2^nd 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, 2^nd 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

O

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, 2^nd onSubscribe method open clause Open Service Gateway initiative (OSGi) opens-to clause Option data structure Optional class, 2^nd, 3^rd Optional.empty method, 2^nd, 3^rd OptionalInt primitive specialization Optional.ofNullable method, 2^nd Optionals, 2^nd 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, 2^nd ORM (object-relational mapping) orTimeout method OSGi (Open Service Gateway initiative) @Override annotation

P

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, 2^nd 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, 2^nd parallelPrefix method parallelSetAll method parallelSort method parallelStream method, 2^nd, 3^rd Parameter class Parser interface parseUnsignedInt method partially applied partitioning advantages of of numbers into prime and nonprime partitioningBy method, 2^nd partitionPrimesWithCustomCollector pattern matching, 2^nd patternMatchExpr method peek method performance, improving with HashMap persistent, 2^nd persistent data structures destructive updates vs. functional search tree updates pipelining Point class polyglot domain-specific languages (DSLs) portNumber variable Predicate interface, 2^nd predicates, 2^nd 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, 2^nd private keyword PrivilegedAction interface process method processFile method Processors Properties.getProperty(String) method provides clause, 2^nd 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

Q

R

randomDelay method Random.nextInt method rangeClosed method Reactive Extensions (Rx) project Reactive Manifesto reactive at application level reactive at system level reactive programming, 2^nd 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, 2^nd finding maximum and minimum generalized summarization with reduction joining strings maximum and minimum summarization summing elements reduction operations, 2^nd 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, 2^nd referentially transparent Reflection API reified model of generic polymorphism remainderUnsigned method remove method, 2^nd removeIf method, 2^nd, 3^rd repeated annotations replace method, 2^nd replaceAll method, 2^nd, 3^rd, 4^th request method requires clause, 2^nd 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, 2^nd Rx (Reactive Extensions) project RxJava reactive library creating and using Observables transforming and combining Observables

S

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, 2^nd, 3^rd 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, 2^nd, 3^rd 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, 2^nd stateless lambda expressions static methods, 2^nd strategy design pattern, 2^nd Stream data structure Stream interface, 2^nd stream method, 2^nd, 3^rd stream of lines Stream operations StreamForker Stream.generate method Stream.iterate method streams, 2^nd 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, 2^nd 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, 2^nd 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, 2^nd strict fork/join String class, 2^nd 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, 2^nd 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

T

tail-call optimization, 2^nd takeWhile element, 2^nd 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, 2^nd thenComparingDouble method thenComparingInt method thenComparingLong method thenCompose method, 2^nd 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, 2^nd, 3^rd ToListCollector class toSet method toString method, 2^nd toUnsignedInt method toUnsignedLong method toUnsignedString method transitively_final keyword transparently TriFunction interface truncating streams tryAdvance method, 2^nd trySplit method tuple literals tuples series, Fibonacci type annotations type checking type inference

U

UnaryOperator unbounded operations unboxing underscore (_) character unique characters UNORDERED operation UnsupportedModificationException UnsupportedOperationException, 2^nd UnsupportedTemporalTypeException updateAndGet method upstream uses clause, 2^nd

V

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

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

Z

ZoneId class ZoneOffset class ZoneRules class

..................Content has been hidden....................

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

18.116.60.62