Master class in Java in 2018

@mirocupak
Miro Cupak
VP Engineering, DNAstack
18/11/2018
Master class in Java
in 2018

@mirocupak
Lessons
!2
• Lesson 1: JShell.
• Lesson 2: Convenience factory methods for collections.
• Lesson 3: Improved try-with-resources.
• Lesson 4: Stream API enhancements.
• Lesson 5: Extensions to Optional.
• Lesson 6: CompletableFuture updates.
• Lesson 7: Reactive streams.
• Lesson 8: Process API.
• Lesson 9: HTTP/2 client.
• Lesson 10: Local variable type inference.

@mirocupak
Organization
!3
• 10 independent lessons
• lesson structure:
• theory
• demo
• exercises
• solutions
• best practices
• (optional) reading
• environment: JShell

@mirocupak
Setup
!4
• Prerequisites:
• JDK 11: https://jdk.java.net/11/
• Familiarity with Java 8.
• These slides.
Task 0.1
Verify you have JDK 11 with java -version.

@mirocupak
Lesson 1: JShell
!6
Task 1.1
Start and exit JShell.

@mirocupak
Lesson 1: JShell
!7
Task 1.2
Create a variable containing a string. Redeﬁne the variable to contain an
integer.

@mirocupak
Lesson 1: JShell
!8
Task 1.3
Call a method that might throw a (checked) exception. How is it handled?
What happens when an exception is thrown? How is a location in JShell
referenced in a stacktrace?

@mirocupak
Lesson 1: JShell
!9
Task 1.4
Create a simple method and call it. Create a class containing a method
and call it.

@mirocupak
Lesson 1: JShell
!10
Task 1.5
Modify your method to call another method that you haven’t implemented
yet. What happens?

@mirocupak
Lesson 1: JShell
!11
Task 1.6
Show the current time.

@mirocupak
Lesson 1: JShell
!12
Task 1.7
Find what keyboard shortcuts JShell supports. Try them out. How do you
view Javadoc?

@mirocupak
Lesson 1: JShell
!13
Task 1.8
What are the possible arguments for the /list and /edit commands?

@mirocupak
Lesson 1: JShell
!14
Task 1.9
Save your current snippets, restart JShell, and load the snippets you
saved. Save all the commands and snippets for later use.

@mirocupak
Lesson 1: JShell
!15
Task 1.10
Explore the /env command. Load an external library and use it from
JShell. Unload it when done.

@mirocupak
Lesson 1: JShell
!16
Task 1.11
Set the feedback mode and editor to whatever you’re comfortable with.

@mirocupak
Lesson 1: JShell
!17
Task 1.12
Use JShell to explore its own API. Use the API to process a snippet of
your choice and read the results.

@mirocupak
Lesson 1: JShell
!18
• Useful tool for whenever you need to try out something small quickly.
• Not a debugging tool.
• Prefer IDEs for any larger tasks.
• Use /help for more information about commands.
• Conﬁgure your own editor.
• More info: JEP 222: jshell: The Java Shell (Read-Eval-Print Loop).

@mirocupak !19
Convenience factory
methods for collections
Lesson 2

@mirocupak
Lesson 2: Convenience factory
!20
Task 2.1
How would you create an immutable set in Java 8? What are the
problems with this approach? Are there any alternatives?

@mirocupak
!21
Task 2.2
What is the type of the return value of the of method?

@mirocupak
!22
Task 2.3
What’s the API for creating immutable collections for Set and Map? Does
it differ from List?

@mirocupak
!23
Task 2.4
What’s the API for creating immutable copies of collections for a Map?
How does it differ from the respective API in List and Set?

@mirocupak
!24
Task 2.5
How do you get the output of a stream into an immutable collection?

@mirocupak !25
• Obtain immutable collections via of/ofEntries methods.
• Create immutable copies of collections via copyOf (Java 10).
• Static import java.util.Map.entry.
• Less verbose, no static initializer blocks.
• Don’t use Arrays.asList or Stream.of as shortcuts for creating
collections.
• Don’t use external libraries if you only need immutable collections
(Guava).
• No need to worry about leaving references to underlying collections.
• Thread-safe and can be shared freely (no need for defensive copies).

@mirocupak !26
• Good performance.
• Don’t create mutable collections unless necessary.
• More info: JEP 269: Convenience Factory Methods for Collections.

@mirocupak !27
Improved try-with-resources
Lesson 3

@mirocupak
Lesson 3: Improved try-with-
resources
!28
Task 3.1
Read a ﬁle from disk to standard output (copy to standard output). Make
sure you clean up the resources as needed.

@mirocupak
resources
!29
Task 3.2
Refactor your previous example to take advantage of effectively ﬁnal
variables.

@mirocupak
resources
!30
Task 3.3
Can we make the code even simpler?
Hint: Check out the InputStream API for useful methods.

@mirocupak !31
• Always prefer try-with-resources, don’t use try-finally and definitely
don’t use finalizers to close resources.
• Be aware of convenience methods, such as
InputStream.transferTo.
• Don’t create unnecessary helper objects.
• More info: JEP 213: Milling Project Coin.
resources

@mirocupak !32
Stream API enhancements
Lesson 4

@mirocupak
Lesson 4: Stream API enhancements
!33
Task 4.1
Modify the stream below to only print the numbers <5 (>5).
IntStream.range(0,10).forEach(System.out::println)

@mirocupak
!34
Task 4.2
Demonstrate a difference between filter and takeWhile
(dropWhile).
Hint: Print even numbers <100.

@mirocupak
!35
Task 4.3
Improve the code from the previous task.

@mirocupak
!36
Task 4.4
Come up with a scenario where ofNullable helps.

@mirocupak
!37
Task 4.5
Suppose we have the following list of numbers:
List.of(2, 3, 4, 7, 9, 11)
Count the numbers >5 by parity.
Hint: filtering.

@mirocupak
!38
Task 4.6
Explore how the pattern matching API plays nicely with streams.
Hint: Use Matcher to obtain all results of a match.

@mirocupak
!39
Task 4.7
Explore how the date-time API plays nicely with streams.
Hint: Use LocalDate to obtain list of dates between now and Christmas.

@mirocupak !40
• Be aware of new stream methods: takeWhile, dropWhile,
iterate.
• Familiarize yourself with various collectors available out of the box.
• Prefer collecting into immutable collections using
toUnmodifiableList, toUnmodifiableSet,
toUnmodifiableMap.
• Check for convenience stream methods before converting to streams
manually (e.g. LocalDate, Matcher).
• Avoid unnecessary null checks with ofNullable.
• Streams are suitable for more use cases now, but not all use cases.
• Don’t overuse streams as they can make code hard to read and
difﬁcult to maintain.

@mirocupak !41
Extensions to Optional
Lesson 5

@mirocupak
Lesson 5: Extensions to Optional
!42
Task 5.1
Given an Optional, print its value if the value is present, otherwise print
“empty”.

@mirocupak
!43
Task 5.2
What other methods in the Optional API are similar to or?

@mirocupak
!44
Task 5.3
Another 2 methods in the same family were added in Java 10. Can you
ﬁnd them?

@mirocupak
!45
Task 5.4
Filter out empty values from a given collection of Optionals, e.g.:
List.of(Optional.of(1), Optional.empty(),
Optional.of(2))
Hint: flatMap.

@mirocupak !46
• Use ifPresentOrElse instead of if-isPresent construct.
• or provides a clean ﬂuent way of chaining behaviour on Optionals.
• Be aware of orElse* methods, e.g. the new orElseThrow (Java 10).
• Use stream to take advantage of the lazy nature of streams and
handle streams of Optionals.
• Remember that isPresent is rarely the answer.

@mirocupak !47
CompletableFuture updates
Lesson 6

@mirocupak
Lesson 6: CompletableFuture updates
!48
Task 6.1
completeOnTimeout is great for completing a future normally based on
a timeout. How do I complete a future exceptionally based on a timeout?

@mirocupak
!49
Task 6.2
Inspect the contract of the copy method. Demonstrate the one-way
synchronization it provides.

@mirocupak
!50
Task 6.3
Take some time to explore other new additions to the
CompletableFuture API we haven’t talked about.

@mirocupak !51
• With Java 9+, you can complete CompletableFutures normally and
exceptionally based on a timeout (completeOnTimeout,
orTimeout).
• copy provides an easy method for building asynchronous APIs.
• It’s usually a good idea to make copies before exposing
CompletableFuture in APIs.
• Be aware of the various utility methods in the CompletableFuture
API.
• More info: JEP 266: More Concurrency Updates.

@mirocupak !52
Reactive streams
Lesson 7

@mirocupak
Lesson 7: Reactive streams
!53
Task 7.1
Implement a subscriber echoing messages from the publisher.
Hint: Request new message in onSubscribe and onNext.

@mirocupak
!54
Task 7.2
What happens if we request 2 messages in onNext every time? How
about Long.MAX_VALUE?

@mirocupak
!55
Task 7.3
What happens if we request 0 messages in onNext every time?

@mirocupak
!56
Task 7.4
What happens if we subscribe a subscriber twice to a publisher?

@mirocupak
!57
Task 7.5
What happens if we subscribe a subscriber to 2 publishers?

@mirocupak
!58
Task 7.6
What happens if we submit a message after closing the publisher?

@mirocupak !59
• The right approach for asynchronous stream processing with
nonblocking back pressure.
• Don’t implement yourself, use a library.
• More info: JEP 266: More Concurrency Updates.

@mirocupak !60
Process API
Lesson 8

@mirocupak
Lesson 8: Process API
!61
Task 8.1
Launch an external process from Java. What are the problems with this
API?

@mirocupak
!62
Task 8.2
List all the commands running in your OS visible to you.
Hint: allProcesses.

@mirocupak
!63
Task 8.3
Launch an external process that runs for 3 seconds. Print the PID of the
(now dead) process as soon as it ﬁnishes.
Hint: sleep 3.

@mirocupak
!64
Task 8.4
List your currently running Java processes with jps. Use grep to ﬁnd
JShell in the list.
Hint: startPipeline.

@mirocupak !65
• ProcessHandle is a clean way of obtaining information about
processes.
• Don’t implement yourself. Don’t use MXBeans or OS utilities.
• Take advantage of convenience methods: pid, info, command…
• Trigger actions on process termination via onExit.
• Connect ProcessBuilder with ProcessHandle via toHandle.
• Create pipelines via ProcessBuilder.startPipeline.
• More info: JEP 102: Process API Updates.

@mirocupak !66
HTTP/2 client
Lesson 9

@mirocupak !67
Task 9.1
Use the new HTTP/2 client API to execute a request against a server.
Read the response.
Lesson 9: HTTP/2 client

@mirocupak !68
Task 9.2
Use the new HTTP/2 client API to execute a request against a server
asynchronously. Read the response.

@mirocupak
!69
• Clean separation: HttpClient, HttpRequest, HttpResponse.
• HttpURLConnection is not pleasant to use.
• Avoid APIs with side effects.
• The new client API is versatile, ﬂexible and clean.
• Prefer functionality in the JDK to external libraries.
• But aware it’s an incubator module.
• More info: JEP 110: HTTP 2 Client.

@mirocupak !70
Local variable type
inference
Lesson 10

@mirocupak
Lesson 10: Local variable type inference
!71
• Does not replace static typing.
• Generally good.
• Reduces boilerplate and improves readability.
• Helps with maintenance and refactoring.
• Use for local variables with initializers (especially constructors) and for
loops.
• Can’t use for method formals, constructor formals, method return types,
ﬁelds, catch formals, null or array initializers, lambdas, method references,
or any other kind of variable declaration.
• Consider whether to use when the generated type is not obvious.
• But use for complex types when breaking chained or nested expressions
with local variables.
• Primitive types might surprise you, be careful (e.g. byte, short, long all
inferred as int).

@mirocupak !72
• Be very careful about combining with <> and generic methods (e.g. var list
= new ArrayList<>()).
• Probably not the best idea to use with anonymous classes.
• Use carefully chosen and expressive variable names.
• Don’t use Hungarian notation.
• Don’t rely on IDEs.
• Minimize the scope of local variables.
• Declare variable when it’s ﬁrst used.
• Declaration not containing an initializer (i.e. you can’t use var) often indicates
the scope is not minimal.
• Prefer for loops to while loops.
• Keep methods small and focused.
• Code to the interface pattern does not work, but that’s kind of OK.
• More info: JEP 286: Local-Variable Type Inference.
Lesson 10: Local variable type inference

Master class in Java in 2018

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (12)

Similaire à Master class in Java in 2018

Similaire à Master class in Java in 2018 (20)

Plus de Miro Cupak

Plus de Miro Cupak (20)

Dernier

Dernier (20)

Master class in Java in 2018