book

Java Coding Problems - Second Edition

by Anghel Leonard

March 2024

Intermediate to advanced

798 pages

18h 48m

English

Packt Publishing

Read now

Unlock full access

Who this book is forWhat this book coversTo get the most out of this bookGet in touch
Problems1. Creating a multiline SQL, JSON, and HTML stringBefore JDK 8Starting with JDK 8Introducing text blocks (JDK 13/15)Hooking text blocks syntax2. Exemplifying the usage of text block delimiters3. Working with indentation in text blocksShifting the closing delimiter and/or the contentUsing indentation methods4. Removing incidental white spaces in text blocks5. Using text blocks just for readability6. Escaping quotes and line terminators in text blocks7. Translating escape sequences programmatically8. Formatting text blocks with variables/expressions9. Adding comments in text blocks10. Mixing ordinary string literals with text blocks11. Mixing regular expression with text blocks12. Checking if two text blocks are isomorphic13. Concatenating strings versus StringBuilderJDK 8JDK 1114. Converting int to String15. Introducing string templates What’s a string template?The STR template processorThe FMT template processor The RAW template processor16. Writing a custom template processor17. Creating a Locale18. Customizing localized date-time formats19. Restoring Always-Strict Floating-Point semantics20. Computing mathematical absolute value for int/long and result overflow21. Computing the quotient of the arguments and result overflow22. Computing the largest/smallest value that is less/greater than or equal to the algebraic quotient23. Getting integral and fractional parts from a double24. Testing if a double number is an integer25. Hooking Java (un)signed integers in a nutshell26. Returning the flooring/ceiling modulus27. Collecting all prime factors of a given number28. Computing the square root of a number using the Babylonian method29. Rounding a float number to specified decimals30. Clamping a value between min and max31. Multiply two integers without using loops, multiplication, bitwise, division, and operators32. Using TAUWhat is TAU?33. Selecting a pseudo-random number generatorChoosing an algorithm by nameChoosing an algorithm by property34. Filling a long array with pseudo-random numbers35. Creating a stream of pseudo-random generators36. Getting a legacy pseudo-random generator from new ones of JDK 1737. Using pseudo-random generators in a thread-safe fashion (multithreaded environments)Summary
Problems38. Explain and exemplifying UTF-8, UTF-16, and UTF-32Introducing ASCII encoding scheme (or single-byte encoding)Introducing multi-byte encodingUnicodeJava and UnicodeJDK 18 defaults the charset to UTF-839. Checking a sub-range in the range from 0 to length40. Returning an identity string41. Hooking unnamed classes and instance main methods42. Adding code snippets in Java API documentationAdding attributesUsing markup comments and regionsHighlightingLinkingModifying the code’s textUsing external snippetsRegions in external snippets43. Invoking default methods from Proxy instancesJDK 8JDK 9+, pre-JDK 16JDK 16+44. Converting between bytes and hex-encoded stringsJDK 17+45. Exemplify the initialization-on-demand holder design patternStatic vs. non-static blocksNested classesTackling the initialization-on-demand holder design patternJDK 16+46. Adding nested classes in anonymous classesJDK 16+47. Exemplify erasure vs. overloadingErasure in a nutshellErasure of generic typesErasure and bridge methodsType erasure and heap pollutionPolymorphic overloading in a nutshellErasure vs. overloading48. Xlinting default constructors49. Working with the receiver parameter50. Implementing an immutable stack51. Revealing a common mistake with Strings52. Using the enhanced NullPointerExceptionWARNING 1! NPE when calling an instance method via a null objectWARNING 2! NPE when accessing (or modifying) the field of a null objectWARNING 3! NPE when null is passed in the method argumentWARNING 4! NPE when accessing the index value of a null array/collectionWARNING 5! NPE when accessing a field via a getter53. Using yield in switch expressions54. Tackling the case null clause in switch55. Taking on the hard way to discover equals()56. Hooking instanceof in a nutshell57. Introducing pattern matchingThe scope of binding variables in pattern matchingGuarded patternsType coverageCurrent status of pattern matching58. Introducing type pattern matching for instanceof59. Handling the scope of a binding variable in type patterns for instanceof60. Rewriting equals() via type patterns for instanceof61. Tackling type patterns for instanceof and generics62. Tackling type patterns for instanceof and streams63. Introducing type pattern matching for switch64. Adding guarded pattern labels in switch65. Dealing with pattern label dominance in switch66. Dealing with completeness (type coverage) in pattern labels for switch67. Understanding the unconditional patterns and nulls in switch expressionsSummary
Problems68. Defining a day periodBefore JDK 16JDK 16+69. Converting between Date and YearMonth70. Converting between int and YearMonth71. Converting week/year to Date72. Checking for a leap year73. Calculating the quarter of a given date74. Getting the first and last day of a quarter75. Extracting the months from a given quarter76. Computing pregnancy due date77. Implementing a stopwatch78. Extracting the count of milliseconds since midnight79. Splitting a date-time range into equal intervals80. Explaining the difference between Clock.systemUTC() and Clock.systemDefaultZone()81. Displaying the names of the days of the week82. Getting the first and last day of the year83. Getting the first and last day of the week84. Calculating the middle of the month85. Getting the number of quarters between two dates86. Converting Calendar to LocalDateTime87. Getting the number of weeks between two datesSummary
Problems88. Declaring a Java record89. Introducing the canonical and compact constructors for recordsHandling validationReassigning componentsDefensive copies of the given components90. Adding more artifacts in a record91. Iterating what we cannot have in a recordA record cannot extend another classA record cannot be extendedA record cannot be enriched with instance fieldsA record cannot have private canonical constructorsA record cannot have setters92. Defining multiple constructors in a record93. Implementing interfaces in records94. Understanding record serializationHow serialization/deserialization worksSerializing/deserializing gacContainer (a typical Java class)Deserializing a malicious streamSerializing/deserializing gacContainerR (a Java record)Deserializing a malicious streamRefactoring legacy serialization95. Invoking the canonical constructor via reflection96. Using records in streams97. Introducing record patterns for instanceofNested records and record patterns98. Introducing record patterns for switch99. Tackling guarded record patterns100. Using generic records in record patternsType argument inferenceType argument inference and nested records101. Handling nulls in nested record patterns102. Simplifying expressions via record patterns103. Hooking unnamed patterns and variablesUnnamed patternsUnnamed variablesIn a catch blockIn a for loopIn an assignment that ignores the resultIn try-with-resourcesIn lambda expressions104. Tackling records in Spring BootUsing records in controllersUsing records with templatesUsing records for configurationRecord and dependency injection105. Tackling records in JPADTO via record constructorDTO via record and JPA constructor expressionDTO via record and result transformerDTO via record and JdbcTemplateTeam up Java records and @Embeddable106. Tackling records in jOOQSummary
Problems107. Introducing parallel computations with arrays108. Covering the Vector API’s structure and terminologyThe vector element typeThe vector shapeThe vector speciesVector lanesVector operationsCreating vectorsCreating vectors of zerosCreating vectors of the same primitive valueCreating vectors from Java arraysCreating vectors from memory segments109. Summing two arrays via the Vector API110. Summing two arrays unrolled via the Vector API111. Benchmarking the Vector API112. Applying the Vector API to compute FMA113. Multiplying matrices via the Vector API114. Hooking the image negative filter with the Vector API115. Dissecting factory methods for collectionsFactory methods for mapsFactory methods for listsFactory methods for sets116. Getting a list from a stream117. Handling map capacity118. Tackling Sequenced CollectionsApplying the Sequenced Collections API to listsApplying the Sequenced Collections API to ArrayList and LinkedListApplying the Sequenced Collections API to setsApplying the Sequenced Collections API to HashSetApplying the Sequenced Collections API to LinkedHashSetApplying the Sequenced Collections API to TreeSetApplying the Sequenced Collections API to mapsApplying the Sequenced Collections API to LinkedHashMapApplying the Sequenced Collections API to SortedMap (TreeMap)119. Introducing the Rope data structureImplementing indexAt(Node node, int index)Implementing concat(Node node1, Node node2)Implementing insert(Node node, int index, String str)Implementing delete(Node node, int start, int end)Implementing split(Node node, int index)120. Introducing the Skip List data structureImplementing contains(Integer data)Implementing insert(Integer data)Implementing delete(Integer data)121. Introducing the K-D Tree data structureInserting into a K-D TreeFinding the nearest neighbor122. Introducing the Zipper data structure123. Introducing the Binomial Heap data structureImplementing insert(int key)Implementing findMin()Implementing extractMin()Implementing decreaseKey(int key, int newKey)Implementing delete(int key)Implementing unionHeap(BinomialHeap heap)124. Introducing the Fibonacci Heap data structure125. Introducing the Pairing Heap data structure126. Introducing the Huffman Coding data structureEncoding the stringDecoding the string127. Introducing the Splay Tree data structure128. Introducing the Interval Tree data structureImplementing insert(Interval interval)129. Introducing the Unrolled Linked List data structure130. Implementing join algorithmsNested Loop JoinHash JoinSort Merge JoinSummary
Problems131. Serializing objects to byte arrays132. Serializing objects to strings133. Serializing objects to XML134. Introducing JDK 9 deserialization filtersPattern-based filtersApplying a pattern-based filter per applicationApplying a pattern-based filter to all applications in a processObjectInputFilter-based filters135. Implementing a custom pattern-based ObjectInputFilter136. Implementing a custom class ObjectInputFilter137. Implementing a custom method ObjectInputFilter138. Implementing a custom lambda ObjectInputFilter139. Avoiding StackOverflowError at deserialization140. Avoiding DoS attacks at deserialization141. Introducing JDK 17 easy filter creation142. Tackling context-specific deserialization filtersApplying a Filter Factory per applicationApplying a Filter Factory to all applications in a processApplying a Filter Factory via ObjectInputFilter.ConfigImplementing a Filter Factory143. Monitoring deserialization via JFRSummary
Problems144. Introducing Java Native Interface (JNI)Generating the header (.h) fileImplementing the modern_challenge_Main.cppCompiling the C source codeGenerating the native shared libraryFinally, run the code145. Introducing Java Native Access (JNA)Implementing the .cpp and .h filesCompiling the C source codeGenerating the native shared libraryFinally, run the code146. Introducing Java Native Runtime (JNR)147. Motivating and introducing Project Panama148. Introducing Panama’s architecture and terminology149. Introducing Arena and MemorySegmentIntroducing memory layouts (ValueLayout)Allocating memory segments of value layoutsSetting/getting the content of a memory segmentWorking with Java strings150. Allocating arrays into memory segments151. Understanding addresses (pointers)152. Introducing the sequence layoutIntroducing PathElementIntroducing VarHandlePutting PathElement and VarHandle togetherWorking with nested sequence layouts153. Shaping C-like structs into memory segmentsIntroducing StructLayout154. Shaping C-like unions into memory segmentsIntroducing UnionLayout155. Introducing PaddingLayoutHooking size, alignment, stride, and paddingHooking sizeHooking alignmentHooking strideHooking paddingAdding implicit extra space (implicit padding) to validate alignmentAdding explicit extra space (explicit padding) to validate alignment156. Copying and slicing memory segmentsCopying a segmentCopying a part of the segment into another segment (1)Copying a segment into an on-heap arrayCopying an on-heap array into a segmentCopying a part of the segment into another segment (2)Slicing a segmentUsing asOverlappingSlice()Using segmentOffset()157. Tackling the slicing allocator158. Introducing the slice handle159. Introducing layout flattening160. Introducing layout reshaping161. Introducing the layout spreader162. Introducing the memory segment view VarHandle163. Streaming memory segments164. Tackling mapped memory segments165. Introducing the Foreign Linker API166. Calling the sumTwoInt() foreign function167. Calling the modf() foreign function168. Calling the strcat() foreign function169. Calling the bsearch() foreign function170. Introducing Jextract171. Generating native binding for modf()Summary
Problems172. Creating an electrical panel (hierarchy of classes)173. Closing the electrical panel before JDK 17Applying the final modifierDefining package-private constructorsDeclaring classes/interfaces as non-publicThrowing everything in a moduleConclusion174. Introducing JDK 17 sealed classes175. Introducing the permits clauseWorking with sealed classes in separate sources (same package)Working with sealed classes in separate packages176. Closing the electrical panel after JDK 17177. Combining sealed classes and records178. Hooking sealed classes and instanceof179. Hooking sealed classes in switch180. Reinterpreting the Visitor pattern via sealed classes and type pattern matching for switch181. Getting info about sealed classes (using reflection)182. Listing the top three benefits of sealed classes 183. Briefly introducing hidden classes184. Creating a hidden classSummary
Problems185. Working with mapMulti()186. Streaming custom code to map187. Exemplifying a method reference vs. a lamdaScenario 1: Calling printReset() Scenario 2: Calling static printNoReset()Conclusion188. Hooking lambda laziness via Supplier/Consumer189. Refactoring code to add lambda lazinessFixing in imperative fashionFixing in functional fashion190. Writing a Function<String, T> for parsing data191. Composing predicates in a Stream’s filters192. Filtering nested collections with Streams193. Using BiPredicate194. Building a dynamic predicate for a custom model195. Building a dynamic predicate from a custom map of conditions196. Logging in predicates197. Extending Stream with containsAll() and containsAny()Exposing containsAll/Any() via a custom interfaceExposing containsAll/Any() via an extension of Stream198. Extending Stream with removeAll() and retainAll()Exposing removeAll()/retainAll() via a custom interfaceExposing removeAll/retainAll() via an extension of Stream199. Introducing stream comparatorsSorting via natural orderReversing the natural orderSorting and nullsWriting custom comparators200. Sorting a map201. Filtering a map202. Creating a custom collector via Collector.of()Writing a custom collector that collects into a TreeSetWriting a custom collector that collects into a LinkedHashSetWriting a custom collector that excludes elements of another collectorWriting a custom collector that collects elements by typeWriting a custom collector for SplayTree203. Throwing checked exceptions from lambdas204. Implementing distinctBy() for the Stream API205. Writing a custom collector that takes/skips a given number of elements206. Implementing a Function that takes five (or any other arbitrary number of) arguments207. Implementing a Consumer that takes five (or any other arbitrary number of) arguments208. Partially applying a FunctionSummary

Problems209. Explaining concurrency vs. parallelism210. Introducing structured concurrency211. Introducing virtual threadsWhat’s the problem with platform (OS) threads?What are virtual threads?Creating a virtual threadHow many virtual threads we can startBackward compatibilityAvoiding fake conclusions (potentially myths)212. Using the ExecutorService for virtual threads213. Explaining how virtual threads workCapturing virtual threadsPinning virtual threads214. Hooking virtual threads and sync code215. Exemplifying thread context switchingExample 1Example 2Example 3216. Introducing the ExecutorService invoke all/any for virtual threads – part 1Working with invokeAll()Working with invokeAny()217. Introducing the ExecutorService invoke all/any for virtual threads – part 2218. Hooking task state219. Combining newVirtualThreadPerTaskExecutor() and streams220. Introducing a scope object (StructuredTaskScope)ExecutorService vs. StructuredTaskScope221. Introducing ShutdownOnSuccess222. Introducing ShutdownOnFailure223. Combining StructuredTaskScope and streams224. Observing and monitoring virtual threadsUsing JFRUsing Java Management Extensions (JMX)Running 10,000 tasks via the cached thread pool executorRunning 10,000 tasks via the fixed thread pool executorRunning 10,000 tasks via the virtual thread per task executorSummary
Problems225. Tackling continuationsIntroducing continuations Continuations and virtual threads226. Tracing virtual thread states and transitionsNEWSTARTEDRUNNINGPARKINGPARKED/PINNEDYIELDINGRUNNABLETERMINATED227. Extending StructuredTaskScope228. Assembling StructuredTaskScope229. Assembling StructuredTaskScope instances with timeout230. Hooking ThreadLocal and virtual threads231. Hooking ScopedValue and virtual threadsThread-local variables’ shortcomingsIntroducing scoped values232. Using ScopedValue and executor services233. Chaining and rebinding scoped valuesChanging scoped valuesRebinding scoped values234. Using ScopedValue and StructuredTaskScope235. Using Semaphore instead of Executor236. Avoiding pinning via locking237. Solving the producer-consumer problem via virtual threads238. Solving the producer-consumer problem via virtual threads (fixed via Semaphore)239. Solving the producer-consumer problem via virtual threads (increase/decrease consumers)240. Implementing an HTTP web server on top of virtual threads241. Hooking CompletableFuture and virtual threads242. Signaling virtual threads via wait() and notify()Summary
Problems243. Hooking the garbage collector goal244. Handling the garbage collector stages245. Covering some garbage collector terminologyEpoch Single and multiple passesSerial and parallelStop-the-World (STW) and concurrentLive setAllocation rateNUMA Region-basedGenerational garbage collection246. Tracing the generational GC process247. Choosing the correct garbage collector248. Categorizing garbage collectorsSerial garbage collectorParallel garbage collectorGarbage-First (G1) collectorZ Garbage Collector (ZGC)Shenandoah Garbage CollectorConcurrent Mark Sweep (CMS) collector (deprecated)249. Introducing G1Design principles250. Tackling G1 throughput improvementsDelaying the start of the Old generationFocusing on easy pickingsImproving NUMA-aware memory allocationParallelized full-heap collectionsOther improvements251. Tackling G1 latency improvementsMerge parallel phases into a larger oneReduction of metadataBetter work balancingBetter parallelizationBetter reference scanningOther improvements252. Tackling G1 footprint improvementsMaintain only the needed metadataRelease memory253. Introducing ZGCZGC is concurrentZGC and colored pointersZGC and load barriersZGC is region-based254. Monitoring garbage collectors255. Logging garbage collectors256. Tuning garbage collectorsHow to tuneTuning the serial garbage collectorTunning the parallel garbage collectorTuning the G1 garbage collectorTuning Z Garbage CollectorTuning Metaspace (Metadata space)257. Introducing Application Class Data Sharing (AppCDS, or Java’s Startup Booster)Tackling a JDK class data archiveJDK 10/JDK 11JDK 12+Tackling application class data archiveBefore JDK 13JDK 13+JDK 19+Summary
Problems258. Introducing socket basics259. Introducing TCP server/client applicationsBlocking vs. non-blocking mechanisms260. Introducing the Java Socket APIIntroducing NetworkChannelTackling socket options261. Writing a blocking TCP server/client applicationWriting a single-thread blocking TCP echo serverCreating a new server socket channelConfiguring the blocking mechanismSetting server socket channel optionsBinding the server socket channelAccepting connectionsTransmitting data over a connectionClosing the channelPutting it all together into the echo serverWriting a single-thread blocking TCP clientCreating a new (client) socket channelConfiguring the blocking mechanismSetting client socket channel optionsConnecting the client socket channelTransmitting data over a connectionClosing the channelPutting it all together into the clientTesting the blocking echo application262. Writing a non-blocking TCP server/client applicationUsing the SelectionKey classUsing the Selector methodsWriting the non-blocking serverWriting the non-blocking clientTesting the non-blocking echo application263. Writing UDP server/client applicationsWriting a single-thread blocking UDP echo serverCreating a server datagram-oriented socket channelSetting datagram-oriented socket channel optionsBinding the server datagram-oriented socket channelTransmitting data packetsClosing the channelPutting it all together into the clientWriting a connectionless UDP clientTesting the UDP connectionless echo applicationWriting a connected UDP client264. Introducing multicastingA brief overview of MembershipKey265. Exploring network interfaces266. Writing a UDP multicast server/client applicationWriting a UDP multicast serverWriting a UDP multicast clientBlocking/unblocking datagramsTesting the multicasting server/client application267. Adding KEM to a TCP server/client applicationGenerating a public-private keypair by the receiverTransmitting the public key to the senderGenerating the common secret key by the senderSending the encapsulation message to the receiverUsing the secret key to encrypt/decrypt messages268. Reimplementing the legacy Socket API269. Quick overview of SWSKey abstractions of SWS270. Exploring the SWS command-line toolStarting SWS from the command lineConfiguring SWS from the command lineStopping SWS from the command line271. Introducing the com.sun.net.httpserver APIUsing a custom HttpHandlerUsing a custom filterUsing a custom executor272. Adapting request/exchange273. Complementing a conditional HttpHandler with another handler274. Implementing SWS for an in-memory file system275. Implementing SWS for a zip file system276. Implementing SWS for a Java runtime directorySummary

Overview

Java Coding Problems invites you to enhance your expertise in Java programming through the exploration of over 250 modern, real-world problems. By utilizing the latest features of Java 21, you will develop a deeper comprehension of Java and learn to apply best practices to solve everyday challenges.

What this Book will help me do

Master Java 21, its new features, and its implications for real-world applications.
Improve problem-solving skills through targeted coding exercises and challenges.
Build proficiency in advanced Java topics such as concurrency and data structures.
Enhance your knowledge of modern Java APIs, including socket programming and serialization.
Blend theoretical knowledge with practical expertise for improved problem-solving.

Author(s)

Anghel Leonard is a seasoned Java expert with years of professional programming experience and a knack for breaking down complex technical concepts into digestible parts. As an author of several successful Java books, he combines a hands-on approach with deep technical insight, ensuring that every reader can follow along and gain practical value from his writings. With this book, Anghel continues to inspire and teach Java developers worldwide.

Who is it for?

This book is perfect for Java developers who already have foundational knowledge and are aiming to broaden their skillset. Whether you're a seasoned programmer or transitioning to intermediate/advanced levels, this book will provide real-world problems and modern techniques to solve them efficiently. Ideal for readers aspiring to prepare for Java programming interviews or seeking to better understand and utilize the capabilities of Java 21 in their projects.