Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Book Overview & Buying Java Coding Problems
  • Table Of Contents Toc
Java Coding Problems

Java Coding Problems - Second Edition

By : Anghel Leonard
4.5 (13)
Buy this Book
close
close
Java Coding Problems

Java Coding Problems

4.5 (13)
By: Anghel Leonard
Buy this Book

Overview of this book

The super-fast evolution of the JDK between versions 12 and 21 has made the learning curve of modern Java steeper, and increased the time needed to learn it. This book will make your learning journey quicker and increase your willingness to try Java’s new features by explaining the correct practices and decisions related to complexity, performance, readability, and more. Java Coding Problems takes you through Java’s latest features but doesn’t always advocate the use of new solutions — instead, it focuses on revealing the trade-offs involved in deciding what the best solution is for a certain problem. There are more than two hundred brand new and carefully selected problems in this second edition, chosen to highlight and cover the core everyday challenges of a Java programmer. Apart from providing a comprehensive compendium of problem solutions based on real-world examples, this book will also give you the confidence to answer questions relating to matching particular streams and methods to various problems. By the end of this book you will have gained a strong understanding of Java’s new features and have the confidence to develop and choose the right solutions to your problems.
Table of Contents (16 chapters)
close
close
close
Preface
chevron up
Icon
Preface
Icon
Who this book is for
Icon
What this book covers
Icon
To get the most out of this book
Icon
Get in touch
1
Text Blocks, Locales, Numbers, and Math
Icon
Text Blocks, Locales, Numbers, and Math
Icon
Problems
Icon
1. Creating a multiline SQL, JSON, and HTML string
Icon
2. Exemplifying the usage of text block delimiters
Icon
3. Working with indentation in text blocks
Icon
4. Removing incidental white spaces in text blocks
Icon
5. Using text blocks just for readability
Icon
6. Escaping quotes and line terminators in text blocks
Icon
7. Translating escape sequences programmatically
Icon
8. Formatting text blocks with variables/expressions
Icon
9. Adding comments in text blocks
Icon
10. Mixing ordinary string literals with text blocks
Icon
11. Mixing regular expression with text blocks
Icon
12. Checking if two text blocks are isomorphic
Icon
13. Concatenating strings versus StringBuilder
Icon
14. Converting int to String
Icon
15. Introducing string templates
Icon
16. Writing a custom template processor
Icon
17. Creating a Locale
Icon
18. Customizing localized date-time formats
Icon
19. Restoring Always-Strict Floating-Point semantics
Icon
20. Computing mathematical absolute value for int/long and result overflow
Icon
21. Computing the quotient of the arguments and result overflow
Icon
22. Computing the largest/smallest value that is less/greater than or equal to the algebraic quotient
Icon
23. Getting integral and fractional parts from a double
Icon
24. Testing if a double number is an integer
Icon
25. Hooking Java (un)signed integers in a nutshell
Icon
26. Returning the flooring/ceiling modulus
Icon
27. Collecting all prime factors of a given number
Icon
28. Computing the square root of a number using the Babylonian method
Icon
29. Rounding a float number to specified decimals
Icon
30. Clamping a value between min and max
Icon
31. Multiply two integers without using loops, multiplication, bitwise, division, and operators
Icon
32. Using TAU
Icon
33. Selecting a pseudo-random number generator
Icon
34. Filling a long array with pseudo-random numbers
Icon
35. Creating a stream of pseudo-random generators
Icon
36. Getting a legacy pseudo-random generator from new ones of JDK 17
Icon
37. Using pseudo-random generators in a thread-safe fashion (multithreaded environments)
Icon
Summary
Lock Free Chapter
2
Objects, Immutability, Switch Expressions, and Pattern Matching
Icon
Objects, Immutability, Switch Expressions, and Pattern Matching
Icon
Problems
Icon
38. Explain and exemplifying UTF-8, UTF-16, and UTF-32
Icon
39. Checking a sub-range in the range from 0 to length
Icon
40. Returning an identity string
Icon
41. Hooking unnamed classes and instance main methods
Icon
42. Adding code snippets in Java API documentation
Icon
43. Invoking default methods from Proxy instances
Icon
44. Converting between bytes and hex-encoded strings
Icon
45. Exemplify the initialization-on-demand holder design pattern
Icon
46. Adding nested classes in anonymous classes
Icon
47. Exemplify erasure vs. overloading
Icon
48. Xlinting default constructors
Icon
49. Working with the receiver parameter
Icon
50. Implementing an immutable stack
Icon
51. Revealing a common mistake with Strings
Icon
52. Using the enhanced NullPointerException
Icon
53. Using yield in switch expressions
Icon
54. Tackling the case null clause in switch
Icon
55. Taking on the hard way to discover equals()
Icon
56. Hooking instanceof in a nutshell
Icon
57. Introducing pattern matching
Icon
58. Introducing type pattern matching for instanceof
Icon
59. Handling the scope of a binding variable in type patterns for instanceof
Icon
60. Rewriting equals() via type patterns for instanceof
Icon
61. Tackling type patterns for instanceof and generics
Icon
62. Tackling type patterns for instanceof and streams
Icon
63. Introducing type pattern matching for switch
Icon
64. Adding guarded pattern labels in switch
Icon
65. Dealing with pattern label dominance in switch
Icon
66. Dealing with completeness (type coverage) in pattern labels for switch
Icon
67. Understanding the unconditional patterns and nulls in switch expressions
Icon
Summary
3
Working with Date and Time
Icon
Working with Date and Time
Icon
Problems
Icon
68. Defining a day period
Icon
69. Converting between Date and YearMonth
Icon
70. Converting between int and YearMonth
Icon
71. Converting week/year to Date
Icon
72. Checking for a leap year
Icon
73. Calculating the quarter of a given date
Icon
74. Getting the first and last day of a quarter
Icon
75. Extracting the months from a given quarter
Icon
76. Computing pregnancy due date
Icon
77. Implementing a stopwatch
Icon
78. Extracting the count of milliseconds since midnight
Icon
79. Splitting a date-time range into equal intervals
Icon
80. Explaining the difference between Clock.systemUTC() and Clock.systemDefaultZone()
Icon
81. Displaying the names of the days of the week
Icon
82. Getting the first and last day of the year
Icon
83. Getting the first and last day of the week
Icon
84. Calculating the middle of the month
Icon
85. Getting the number of quarters between two dates
Icon
86. Converting Calendar to LocalDateTime
Icon
87. Getting the number of weeks between two dates
Icon
Summary
4
Records and Record Patterns
Icon
Records and Record Patterns
Icon
Problems
Icon
88. Declaring a Java record
Icon
89. Introducing the canonical and compact constructors for records
Icon
90. Adding more artifacts in a record
Icon
91. Iterating what we cannot have in a record
Icon
92. Defining multiple constructors in a record
Icon
93. Implementing interfaces in records
Icon
94. Understanding record serialization
Icon
95. Invoking the canonical constructor via reflection
Icon
96. Using records in streams
Icon
97. Introducing record patterns for instanceof
Icon
98. Introducing record patterns for switch
Icon
99. Tackling guarded record patterns
Icon
100. Using generic records in record patterns
Icon
101. Handling nulls in nested record patterns
Icon
102. Simplifying expressions via record patterns
Icon
103. Hooking unnamed patterns and variables
Icon
104. Tackling records in Spring Boot
Icon
105. Tackling records in JPA
Icon
106. Tackling records in jOOQ
Icon
Summary
5
Arrays, Collections, and Data Structures
Icon
Arrays, Collections, and Data Structures
Icon
Problems
Icon
107. Introducing parallel computations with arrays
Icon
108. Covering the Vector API’s structure and terminology
Icon
109. Summing two arrays via the Vector API
Icon
110. Summing two arrays unrolled via the Vector API
Icon
111. Benchmarking the Vector API
Icon
112. Applying the Vector API to compute FMA
Icon
113. Multiplying matrices via the Vector API
Icon
114. Hooking the image negative filter with the Vector API
Icon
115. Dissecting factory methods for collections
Icon
116. Getting a list from a stream
Icon
117. Handling map capacity
Icon
118. Tackling Sequenced Collections
Icon
119. Introducing the Rope data structure
Icon
120. Introducing the Skip List data structure
Icon
121. Introducing the K-D Tree data structure
Icon
122. Introducing the Zipper data structure
Icon
123. Introducing the Binomial Heap data structure
Icon
124. Introducing the Fibonacci Heap data structure
Icon
125. Introducing the Pairing Heap data structure
Icon
126. Introducing the Huffman Coding data structure
Icon
127. Introducing the Splay Tree data structure
Icon
128. Introducing the Interval Tree data structure
Icon
129. Introducing the Unrolled Linked List data structure
Icon
130. Implementing join algorithms
Icon
Summary
6
Java I/O: Context-Specific Deserialization Filters
Icon
Java I/O: Context-Specific Deserialization Filters
Icon
Problems
Icon
131. Serializing objects to byte arrays
Icon
132. Serializing objects to strings
Icon
133. Serializing objects to XML
Icon
134. Introducing JDK 9 deserialization filters
Icon
135. Implementing a custom pattern-based ObjectInputFilter
Icon
136. Implementing a custom class ObjectInputFilter
Icon
137. Implementing a custom method ObjectInputFilter
Icon
138. Implementing a custom lambda ObjectInputFilter
Icon
139. Avoiding StackOverflowError at deserialization
Icon
140. Avoiding DoS attacks at deserialization
Icon
141. Introducing JDK 17 easy filter creation
Icon
142. Tackling context-specific deserialization filters
Icon
143. Monitoring deserialization via JFR
Icon
Summary
7
Foreign (Function) Memory API
Icon
Foreign (Function) Memory API
Icon
Problems
Icon
144. Introducing Java Native Interface (JNI)
Icon
145. Introducing Java Native Access (JNA)
Icon
146. Introducing Java Native Runtime (JNR)
Icon
147. Motivating and introducing Project Panama
Icon
148. Introducing Panama’s architecture and terminology
Icon
149. Introducing Arena and MemorySegment
Icon
150. Allocating arrays into memory segments
Icon
151. Understanding addresses (pointers)
Icon
152. Introducing the sequence layout
Icon
153. Shaping C-like structs into memory segments
Icon
154. Shaping C-like unions into memory segments
Icon
155. Introducing PaddingLayout
Icon
156. Copying and slicing memory segments
Icon
157. Tackling the slicing allocator
Icon
158. Introducing the slice handle
Icon
159. Introducing layout flattening
Icon
160. Introducing layout reshaping
Icon
161. Introducing the layout spreader
Icon
162. Introducing the memory segment view VarHandle
Icon
163. Streaming memory segments
Icon
164. Tackling mapped memory segments
Icon
165. Introducing the Foreign Linker API
Icon
166. Calling the sumTwoInt() foreign function
Icon
167. Calling the modf() foreign function
Icon
168. Calling the strcat() foreign function
Icon
169. Calling the bsearch() foreign function
Icon
170. Introducing Jextract
Icon
171. Generating native binding for modf()
Icon
Summary
8
Sealed and Hidden Classes
Icon
Sealed and Hidden Classes
Icon
Problems
Icon
172. Creating an electrical panel (hierarchy of classes)
Icon
173. Closing the electrical panel before JDK 17
Icon
174. Introducing JDK 17 sealed classes
Icon
175. Introducing the permits clause
Icon
176. Closing the electrical panel after JDK 17
Icon
177. Combining sealed classes and records
Icon
178. Hooking sealed classes and instanceof
Icon
179. Hooking sealed classes in switch
Icon
180. Reinterpreting the Visitor pattern via sealed classes and type pattern matching for switch
Icon
181. Getting info about sealed classes (using reflection)
Icon
182. Listing the top three benefits of sealed classes
Icon
183. Briefly introducing hidden classes
Icon
184. Creating a hidden class
Icon
Summary
9
Functional Style Programming – Extending APIs
Icon
Functional Style Programming – Extending APIs
Icon
Problems
Icon
185. Working with mapMulti()
Icon
186. Streaming custom code to map
Icon
187. Exemplifying a method reference vs. a lamda
Icon
188. Hooking lambda laziness via Supplier/Consumer
Icon
189. Refactoring code to add lambda laziness
Icon
190. Writing a Function for parsing data
Icon
191. Composing predicates in a Stream’s filters
Icon
192. Filtering nested collections with Streams
Icon
193. Using BiPredicate
Icon
194. Building a dynamic predicate for a custom model
Icon
195. Building a dynamic predicate from a custom map of conditions
Icon
196. Logging in predicates
Icon
197. Extending Stream with containsAll() and containsAny()
Icon
198. Extending Stream with removeAll() and retainAll()
Icon
199. Introducing stream comparators
Icon
200. Sorting a map
Icon
201. Filtering a map
Icon
202. Creating a custom collector via Collector.of()
Icon
203. Throwing checked exceptions from lambdas
Icon
204. Implementing distinctBy() for the Stream API
Icon
205. Writing a custom collector that takes/skips a given number of elements
Icon
206. Implementing a Function that takes five (or any other arbitrary number of) arguments
Icon
207. Implementing a Consumer that takes five (or any other arbitrary number of) arguments
Icon
208. Partially applying a Function
Icon
Summary
10
Concurrency – Virtual Threads and Structured Concurrency
Icon
Concurrency – Virtual Threads and Structured Concurrency
Icon
Problems
Icon
209. Explaining concurrency vs. parallelism
Icon
210. Introducing structured concurrency
Icon
211. Introducing virtual threads
Icon
212. Using the ExecutorService for virtual threads
Icon
213. Explaining how virtual threads work
Icon
214. Hooking virtual threads and sync code
Icon
215. Exemplifying thread context switching
Icon
216. Introducing the ExecutorService invoke all/any for virtual threads – part 1
Icon
217. Introducing the ExecutorService invoke all/any for virtual threads – part 2
Icon
218. Hooking task state
Icon
219. Combining newVirtualThreadPerTaskExecutor() and streams
Icon
220. Introducing a scope object (StructuredTaskScope)
Icon
221. Introducing ShutdownOnSuccess
Icon
222. Introducing ShutdownOnFailure
Icon
223. Combining StructuredTaskScope and streams
Icon
224. Observing and monitoring virtual threads
Icon
Summary
11
Concurrency ‒ Virtual Threads and Structured Concurrency: Diving Deeper
Icon
Concurrency ‒ Virtual Threads and Structured Concurrency: Diving Deeper
Icon
Problems
Icon
225. Tackling continuations
Icon
226. Tracing virtual thread states and transitions
Icon
227. Extending StructuredTaskScope
Icon
228. Assembling StructuredTaskScope
Icon
229. Assembling StructuredTaskScope instances with timeout
Icon
230. Hooking ThreadLocal and virtual threads
Icon
231. Hooking ScopedValue and virtual threads
Icon
232. Using ScopedValue and executor services
Icon
233. Chaining and rebinding scoped values
Icon
234. Using ScopedValue and StructuredTaskScope
Icon
235. Using Semaphore instead of Executor
Icon
236. Avoiding pinning via locking
Icon
237. Solving the producer-consumer problem via virtual threads
Icon
238. Solving the producer-consumer problem via virtual threads (fixed via Semaphore)
Icon
239. Solving the producer-consumer problem via virtual threads (increase/decrease consumers)
Icon
240. Implementing an HTTP web server on top of virtual threads
Icon
241. Hooking CompletableFuture and virtual threads
Icon
242. Signaling virtual threads via wait() and notify()
Icon
Summary
12
Garbage Collectors and Dynamic CDS Archives
Icon
Garbage Collectors and Dynamic CDS Archives
Icon
Problems
Icon
243. Hooking the garbage collector goal
Icon
244. Handling the garbage collector stages
Icon
245. Covering some garbage collector terminology
Icon
246. Tracing the generational GC process
Icon
247. Choosing the correct garbage collector
Icon
248. Categorizing garbage collectors
Icon
249. Introducing G1
Icon
250. Tackling G1 throughput improvements
Icon
251. Tackling G1 latency improvements
Icon
252. Tackling G1 footprint improvements
Icon
253. Introducing ZGC
Icon
254. Monitoring garbage collectors
Icon
255. Logging garbage collectors
Icon
256. Tuning garbage collectors
Icon
257. Introducing Application Class Data Sharing (AppCDS, or Java’s Startup Booster)
Icon
Summary
13
Socket API and Simple Web Server
Icon
Socket API and Simple Web Server
Icon
Problems
Icon
258. Introducing socket basics
Icon
259. Introducing TCP server/client applications
Icon
260. Introducing the Java Socket API
Icon
261. Writing a blocking TCP server/client application
Icon
262. Writing a non-blocking TCP server/client application
Icon
263. Writing UDP server/client applications
Icon
264. Introducing multicasting
Icon
265. Exploring network interfaces
Icon
266. Writing a UDP multicast server/client application
Icon
267. Adding KEM to a TCP server/client application
Icon
268. Reimplementing the legacy Socket API
Icon
269. Quick overview of SWS
Icon
270. Exploring the SWS command-line tool
Icon
271. Introducing the com.sun.net.httpserver API
Icon
272. Adapting request/exchange
Icon
273. Complementing a conditional HttpHandler with another handler
Icon
274. Implementing SWS for an in-memory file system
Icon
275. Implementing SWS for a zip file system
Icon
276. Implementing SWS for a Java runtime directory
Icon
Summary
14
Other Books You May Enjoy
Icon
Other Books You May Enjoy
15
Index
Icon
Index

Preface

The super-fast evolution of the JDK between versions 12 and 21 means two things: first, Java now has a host of powerful new features that you can adopt to solve a variety of modern-day problems; second, the learning curve of modern Java is becoming very steep.

This book enables you to take an objective approach to solving common problems by explaining the correct practices and decisions you need to make with respect to complexity, performance, readability, and more.

Java Coding Problems, Second Edition, will help you complete your daily tasks and meet deadlines, all while becoming a more proficient and self-sufficient Java developer. You can count on the 270+ (all brand-new for this edition) problems in this book to cover the most common and fundamental areas of interest: strings, numbers, arrays, collections, the Foreign Function and Memory API, data structures, date and time, pattern matching, sealed/hidden classes, functional programming, virtual threads, Structured Concurrency, Garbage Collectors, Dynamic CDS Archives, the Socket API, and Simple Web Server.

Put your skills on steroids with problems that have been carefully crafted to highlight and teach the core knowledge needed for daily work. In other words (no matter if your task is simple, middling, or complex), having this knowledge in your tool belt is a must, not an option.

By the end of this book, you will have gained a strong understanding of Java concepts, and you’ll have the confidence to develop and choose the right solutions to all your Java problems.

While this book is entirely stand-alone, and you do not need anything else to get the most out of it, many of the topics covered in this book are also explored in Java Coding Problems, First Edition. If you haven’t already read it, and you wish to get even more practice in, then consider picking that book up for a completely different set of Java problems.

CONTINUE READING
83
Tech Concepts
36
Programming languages
73
Tech Tools
Icon Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.
Icon Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.
Icon 50+ new titles added per month and exclusive early access to books as they are being written.
Java Coding Problems
Next Section
notes
bookmark Notes and Bookmarks search Search in title playlist Add to playlist download Download options
font-size Font size

Change the font size

margin-width Margin width

Change margin width

day-mode Day/Sepia/Night Modes

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Confirmation

Modal Close icon
claim successful
Order Page Read Now

Buy this book with your credits?

Modal Close icon
Are you sure you want to buy this book with one of your credits?
Close
YES, BUY

Submit Your Feedback

Modal Close icon
Modal Close icon
Modal Close icon