2017 Modern Java Recipes Simple Solutions to Difficult Problems in Java 8 and 9
Documento: pdf (321 páginas) 2.2 MB
Ken Kousen Modern Java Recipes Simple Solutions to Difficult Problems in Java 8 and 9 978-1-491-97317-2 [LSI] Modern Java Recipes by Ken Kousen Copyright © 2017 Ken Kousen. All rights reserved. Printed in the United States of America. Published by O'Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O'Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://oreilly.com/safari). For more information, contact our corporate/insti‐ tutional sales department: 800-998-9938 or corporate@oreilly.com. Editors: Brian Foster and Jeff Bleiel Production Editor: Justin Billing Copyeditor: Kim Cofer Proofreader: Jasmine Kwityn Indexer: Ellen Troutman-Zaig Interior Designer: David Futato Cover Designer: Karen Montgomery Illustrator: Rebecca Demarest August 2017: First Edition Revision History for the First Edition 2017-08-04: First Release See http://oreilly.com/catalog/errata.csp?isbn=9781491973172 for release details. The O'Reilly logo is a registered trademark of O'Reilly Media, Inc. Modern Java Recipes, the cover image, and related trade dress are trademarks of O'Reilly Media, Inc. While the publisher and the authors have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the authors disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights. Hey Xander, this one's yours. Surprise! Table of Contents Foreword. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi 1. The Basics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.1 Lambda Expressions 2 1.2 Method References 6 1.3 Constructor References 10 1.4 Functional Interfaces 15 1.5 Default Methods in Interfaces 18 1.6 Static Methods in Interfaces 21 2. The java.util.function Package. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 2.1 Consumers 26 2.2 Suppliers 28 2.3 Predicates 31 2.4 Functions 35 3. Streams. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.1 Creating Streams 39 3.2 Boxed Streams 43 3.3 Reduction Operations Using Reduce 46 3.4 Check Sorting Using Reduce 55 3.5 Debugging Streams with peek 57 3.6 Converting Strings to Streams and Back 60 3.7 Counting Elements 63 3.8 Summary Statistics 65 3.9 Finding the First Element in a Stream 68 v 3.10 Using anyMatch, allMatch, and noneMatch 73 3.11 Stream flatMap Versus map 75 3.12 Concatenating Streams 79 3.13 Lazy Streams 83 4. Comparators and Collectors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 4.1 Sorting Using a Comparator 87 4.2 Converting a Stream into a Collection 91 4.3 Adding a Linear Collection to a Map 94 4.4 Sorting Maps 97 4.5 Partitioning and Grouping 100 4.6 Downstream Collectors 102 4.7 Finding Max and Min Values 104 4.8 Creating Immutable Collections 107 4.9 Implementing the Collector Interface 109 5. Issues with Streams, Lambdas, and Method References. . . . . . . . . . . . . . . . . . . . . . . . . 115 5.1 The java.util.Objects Class 115 5.2 Lambdas and Effectively Final 117 5.3 Streams of Random Numbers 120 5.4 Default Methods in Map 122 5.5 Default Method Conflict 127 5.6 Iterating Over Collections and Maps 130 5.7 Logging with a Supplier 132 5.8 Closure Composition 134 5.9 Using an Extracted Method for Exception Handling 138 5.10 Checked Exceptions and Lambdas 141 5.11 Using a Generic Exception Wrapper 144 6. The Optional Type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 6.1 Creating an Optional 148 6.2 Retrieving Values from an Optional 150 6.3 Optional in Getters and Setters 154 6.4 Optional flatMap Versus map 156 6.5 Mapping Optionals 160 7. File I/O. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 7.1 Process Files 166 7.2 Retrieving Files as a Stream 169 7.3 Walking the Filesystem 170 7.4 Searching the Filesystem 172 vi | Table of Contents 8. The java.time Package. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 8.1 Using the Basic Date-Time Classes 176 8.2 Creating Dates and Times from Existing Instances 180 8.3 Adjusters and Queries 185 8.4 Convert from java.util.Date to java.time.LocalDate 190 8.5 Parsing and Formatting 194 8.6 Finding Time Zones with Unusual Offsets 197 8.7 Finding Region Names from Offsets 200 8.8 Time Between Events 202 9. Parallelism and Concurrency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 9.1 Converting from Sequential to Parallel Streams 206 9.2 When Parallel Helps 209 9.3 Changing the Pool Size 215 9.4 The Future Interface 217 9.5 Completing a CompletableFuture 220 9.6 Coordinating CompletableFutures, Part 1 225 9.7 Coordinating CompletableFutures, Part 2 231 10. Java 9 Additions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 10.1 Modules in Jigsaw 240 10.2 Private Methods in Interfaces 245 10.3 Creating Immutable Collections 247 10.4 Stream: ofNullable, iterate, takeWhile, and dropWhile 252 10.5 Downstream Collectors: filtering and flatMapping 255 10.6 Optional: stream, or, ifPresentOrElse 259 10.7 Date Ranges 262 A. Generics and Java 8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 Table of Contents | vii Foreword There's no doubt that the new features in Java 8, particularly lambda expressions and the Streams API, are a huge step forward for the Java language. I've been using Java 8 and telling developers about the new features at conferences, in workshops, and via blog posts for a several years now. What's clear to me is that although lambdas and streams bring a more functional style of programming to Java (and also allow us to seamlessly make use of parallel processing power), it's not these attributes that make them so appealing to developers once they start using them—it's how much easier it is to solve certain types of problems using these idioms, and how much more produc‐ tive they make us. My passion as a developer, presenter, and writer is not just to make other developers aware of the evolution of the Java language, but to show how this evolution helps make our lives as developers easier—how we have options for simpler solutions to problems, or even solve different types of problems. What I love about Ken's work is that he focuses on exactly this—helping you learn something new without having to wade through details you already know or don't need, focusing on the parts of a tech‐ nology that are valuable to real world developers. I first came across Ken's work when he presented "Making Java Groovy" at JavaOne. At the time, the team I was working on was struggling with writing readable and use‐ ful tests, and one of the solutions we were contemplating was Groovy. As a long-time Java programmer, I was reluctant to learn a whole new language just to write tests, especially when I thought I knew how to write tests. But seeing Ken talk about Groovy for Java programmers taught me a lot of what I needed to know without repeating things I already understood. It made me realise that with the right learning material I didn't need to wade through all the details of a language just to learn the bits I cared about. I bought his book immediately. This new book on Modern Java Recipes follows a similar theme—as experienced developers, we don't need to learn everything about all the new features in Java 8 and 9 as if we're new to the language, nor do we have the time to do that. What we need is ix a guide that quickly makes the relevant features available to us, that gives us real examples that apply to our jobs. This book is that guide. By presenting recipes based on the sorts of problems we encounter daily, and showing how to solve those using new features in Java 8 and 9, we become familiar with the updates to the language in a way that's much more natural for us. We can evolve our skills. Even those who've been using Java 8 and 9 can learn something. The section on Reduction Operators really helped me understand this functional-style programming without having to reprogram my brain. The Java 9 features that are covered are exactly the ones that are useful to us as developers, and they are not (yet) well known. This is an excellent way to get up to speed on the newest version of Java in a quick and effective fashion. There's something in this book for every Java developer who wants to level up their knowledge. —Trisha Gee Java Champion & Java Developer Advocate for JetBrains July 2017 x | Foreword 1 Yes, it's actually been over three years since the first release of Java SE 8. I can't believe it either. Preface Modern Java Sometimes it's hard to believe that a language with literally 20 years of backward compatibility could change so drastically. Prior to the release of Java SE 8 in March of 2014,1 for all of its success as the definitive server-side programming language, Java had acquired the reputation of being "the COBOL of the 21st century." It was stable, pervasive, and solidly focused on performance. Changes came slowly when they came at all, and companies felt little urgency to upgrade when new versions became avail‐ able. That all changed when Java SE 8 was released. Java SE 8 included "Project Lambda," the major innovation that introduced functional programming concepts into what was arguably the world's leading object-oriented language. Lambda expressions, method references, and streams fundamentally changed the idioms of the language, and developers have been trying to catch up ever since. The attitude of this book is not to judge whether the changes are good or bad or could have been done differently. The goal here is to say, "this is what we have, and this is how you use it to get your job done." That's why this book is designed as a rec‐ ipes book. It's all about what you need to do, and how the new features in Java help you do it. That said, there are a lot of advantages to the new programming model, once you get used to them. Functional code tends to be simpler and easier to both write and understand. The functional approach favors immutability, which makes writing con‐ current code cleaner and more likely to be successful. Back when Java was created, you could still rely on Moore's law to double your processor speed roughly every 18 xi months. These days performance improvements come from the fact that even most phones have multiple processors. Since Java has always been sensitive to backward compatibility, many companies and developers have moved to Java SE 8 without adopting the new idioms. The platform is more powerful even so, and is worth using, not to mention the fact that Oracle for‐ mally declared Java 7 end-of-life in April 2015. It has taken a couple of years, but most Java developers are now working with the Java 8 JDK, and it's time to dig in and understand what that means and what consequences it has for your future development. This book is designed to make that process easier. Who Should Read This Book The recipes in this book assume that the typical reader already is comfortable with Java versions prior to Java SE 8. You don't need to be an expert, and some older con‐ cepts are reviewed, but the book is not intended to be a beginner's guide to Java or object-oriented programming. If you have used Java on a project before and you are familiar with the standard library, you'll be fine. This book covers almost all of Java SE 8, and includes one chapter focused on the new changes coming in Java 9. If you need to understand how the new functional idioms added to the language will change the way you write code, this book is a use-case- driven way of accomplishing that goal. Java is pervasive on the server side, with a rich support system of open source libra‐ ries and tools. The Spring Framework and Hibernate are two of the most popular open source frameworks, and both either require Java 8 as a minimum or will very soon. If you plan to operate in this ecosystem, this book is for you. How This Book Is Organized This book is organized into recipes, but it's difficult to discuss recipes containing lambda expressions, method references, and streams individually without referring to the others. In fact, the first six chapters discuss related concepts, though you don't have to read them in any particular order. The chapters are organized as follows: • Chapter 1, The Basics, covers the basics of lambda expressions and method refer‐ ences, and follows with the new features of interfaces: default methods and static methods. It also defines the term "functional interface" and explains how it is key to understanding lambda expressions. • Chapter 2, The java.util.function Package, presents the new java.util.function package, which was added to the language in Java 8. The interfaces in that pack‐ xii | Preface age fall into four special categories (consumers, suppliers, predicates, and func‐ tions) that are used throughout the rest of the standard library. • Chapter 3, Streams, adds in the concept of streams, and how they represent an abstraction that allows you to transform and filter data rather than process it iter‐ atively. The concepts of "map," "filter," and "reduce" relate to streams, as shown in the recipes in this chapter. They ultimately lead to the ideas of parallelism and concurrency covered in Chapter 9. • Chapter 4, Comparators and Collectors, involves the sorting of streaming data, and converting it back into collections. Partitioning and grouping is also part of this chapter, which turns what are normally considered database operations into easy library calls. • Chapter 5, Issues with Streams, Lambdas, and Method References, is a miscellane‐ ous chapter; the idea being that now that you know how to use lambdas, method references, and streams, you can look at ways they can be combined to solve interesting problems. The concepts of laziness, deferred execution, and closure composition are also covered, as is the annoying topic of exception handling. • Chapter 6, The Optional Type, discusses one of the more controversial additions to the language—the Optional type. Recipes in this chapter describe how the new type is intended to be used and how you can both create instances and extract values from them. This chapter also revisits the functional idea of map and flat-map operations on Optionals, and how they differ from the same opera‐ tions on streams. • Chapter 7, File I/O, switches to the practical topic of input/output streams (as opposed to functional streams), and the additions made to the standard library to incorporate the new functional concepts when dealing with files and directo‐ ries. • Chapter 8, The java.time Package, shows the basics of the new Date-Time API, and how (at long last) they replace the legacy Date and Calendar classes. The new API is based on the Joda-Time library, which is backed by many developer- years of experience and use and has been rewritten to form the java.time pack‐ age. Frankly, if this had been the only addition to Java 8, it would have been worth the upgrade. • Chapter 9, Parallelism and Concurrency, addresses one of the implicit promises of the stream model: that you can change a sequential stream to a parallel one with a single method call, and thereby take advantage of all the processors available on your machine. Concurrency is a big topic, but this chapter presents the additions to the Java library that make it easy to experiment with and assess when the costs and benefits are worth the effort. • Chapter 10, Java 9 Additions, covers many of the changes coming in Java 9, which is currently scheduled to be released September 21, 2017. The details of Jigsaw Preface | xiii 2 Yes, I too wish that the Java 9 chapter had been Chapter 9, but it didn't seem right to reorder the chapters just for that accidental symmetry. This footnote will have to suffice. can fill an entire book by themselves, but the basics are clear and are described in this chapter. Other recipes cover private methods in interfaces, the new methods added to streams, collectors, and Optional, and how to create a stream of dates.2 • Appendix A, Generics and Java 8, is about the generics capabilities in Java. While generics as a technology was added back in 1.5, most developers only learned the minimum they needed to know to make them work. One glance at the Javadocs for Java 8 and 9 shows that those days are over. The goal of the appendix is to show you how to read and interpret the API so you understand the much more complex method signatures involved. The chapters, and indeed the recipes themselves, do not have to be read in any partic‐ ular order. They do complement each other and each recipe ends with references to others, but you can start reading anywhere. The chapter groupings are provided as a way to put similar recipes together, but it is expected that you will jump from one to another to solve whatever problem you may have at the moment. Conventions Used in This Book The following typographical conventions are used in this book: Italic Indicates new terms, URLs, email addresses, filenames, and file extensions. Constant width Used for program listings, as well as within paragraphs to refer to program ele‐ ments such as variable or function names, databases, data types, environment variables, statements, and keywords. Constant width bold Shows commands or other text that should be typed literally by the user. Constant width italic Shows text that should be replaced with user-supplied values or by values deter‐ mined by context. This element signifies a tip or suggestion. xiv | Preface This element signifies a general note. This element indicates a warning or caution. Using Code Examples The source code for the book is located in three GitHub repositories: one for the Java 8 recipes (everything but Chapter 10) at https://github.com/kousen/java_8_recipes, one for the Java 9 recipes at https://github.com/kousen/java_9_recipes, and a special one for the larger CompletableFuture example in Recipe 9.7 at https://github.com/kousen/ cfboxscores. All are configured as Gradle projects with tests and a build file. This book is here to help you get your job done. In general, if example code is offered with this book, you may use it in your programs and documentation. You do not need to contact us for permission unless you're reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O'Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a signifi‐ cant amount of example code from this book into your product's documentation does require permission. We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: "Modern Java Recipes by Ken Kousen (O'Reilly). Copyright 2017 Ken Kousen, 978-0-491-97317-2." If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at permissions@oreilly.com. O'Reilly Safari Safari (formerly Safari Books Online) is a membership-based training and reference platform for enterprise, government, educators, and individuals. Members have access to thousands of books, training videos, Learning Paths, interac‐ tive tutorials, and curated playlists from over 250 publishers, including O'Reilly Preface | xv Media, Harvard Business Review, Prentice Hall Professional, Addison-Wesley Profes‐ sional, Microsoft Press, Sams, Que, Peachpit Press, Adobe, Focal Press, Cisco Press, John Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, and Course Technology, among others. For more information, please visit http://oreilly.com/safari. How to Contact Us Please address comments and questions concerning this book to the publisher: O'Reilly Media, Inc. 1005 Gravenstein Highway North Sebastopol, CA 95472 800-998-9938 (in the United States or Canada) 707-829-0515 (international or local) 707-829-0104 (fax) To comment or ask technical questions about this book, send email to bookques‐ tions@oreilly.com. For more information about our books, courses, conferences, and news, see our web‐ site at http://www.oreilly.com. Find us on Facebook: http://facebook.com/oreilly Follow us on Twitter: http://twitter.com/oreillymedia Watch us on YouTube: http://www.youtube.com/oreillymedia Acknowledgments This book is the unexpected result of a conversation I had with Jay Zimmerman back in late July 2015. I was (and still am) a member of the No Fluff, Just Stuff conference tour, and that year several Java 8 talks were being given by Venkat Subramaniam. Jay told me that Venkat had decided to scale back his activity in the coming year and Jay was wondering whether I would be willing to do similar talks in the new season start‐ ing in early 2016. I had been coding in Java since the mid-'90s (I started with Java 1.0.6) and had been planning to learn the new APIs anyway, so I agreed. xvi | Preface 3 Gradle Recipes for Android, also from O'Reilly Media, all about the Gradle build tool as it is applied to Android projects. I have now been giving presentations on the new functional features of Java for a cou‐ ple of years. By the Fall of 2016 I had completed my last book,3 and since the idea was to write another recipes book for the same publisher I foolishly thought the project would be easy. Noted science fiction author Neil Gaiman famously once said that after finishing American Gods he thought he knew how to write a novel. His friend corrected him, saying he now knew how to write this novel. I now understand what he meant. The original proposal for this book anticipated about 25 to 30 recipes spanning about 150 pages. The final result you hold in your hand has more than 70 recipes filling nearly 300 pages, but the larger scope and greater detail has produced a much more valuable book than I intended. Of course, that's because I had lots of help. The aforementioned Venkat Subramaniam has been extremely helpful, both through his talks, his other books, and private dis‐ cussions. He also was kind enough to be a technical reviewer on this book, so any remaining errors are all his fault. (No, they're mine, but please don't tell him I admit‐ ted that.) I also am very grateful to have had the frequent assistance of Tim Yates, who is one of the best coders I've ever met. I knew him from his work in the Groovy community, but his versatility goes well beyond that, as his Stack Overflow rating will show. Rod Hilton, who I met while giving Java 8 presentations on the NFJS tour, was also kind enough to offer a review. Both of their recommendations have been invaluable. I have been fortunate enough to work with the excellent editors and staff at O'Reilly Media over the course of two books, over a dozen video courses, and many online training classes delivered on their Safari online platform. Brian Foster has been a con‐ stant source of support, not to mention his almost magical ability to cut through bureaucracy. I met him while writing my previous book, and though he wasn't the editor of this one, his help and friendship have been very valuable to me throughout the process. My editor, Jeff Bleiel, was very understanding as the book doubled in length, and pro‐ vided the structure and organization needed to keep making progress. I'm very glad we got to work together and hope we will continue to do so in the future. I need to acknowledge many of my fellow speakers on the NFJS tour, including Nate Schutta, Michael Carducci, Matt Stine, Brian Sletten, Mark Richards, Pratik Patel, Neal Ford, Craig Walls, Raju Gandhi, Kirk Knoernschild, Dan "the Man" Hinojosa, and Janelle Klein for their constant perspective and encouragement. Both writing books and teaching training classes (my actual day job) are solitary pursuits. It's great Preface | xvii having a community of friends and colleagues that I can rely on for perspective, advice, and various forms of entertainment. Finally, I need to express all my love to my wife Ginger and my son Xander. Without the support and kindness of my family I would not be the person I am today, a fact that grows more obvious to me with each passing year. I can never express what you both mean to me. xviii | Preface 1 Coined by Gordon Moore, one of the co-founders of Fairchild Semiconductor and Intel, based on the obser‐ vation that the number of transistors that could be packed into an integrated circuit doubled roughly every 18 months. See Wikipedia's Moore's law entry for details. CHAPTER 1 The Basics The biggest change in Java 8 is the addition of concepts from functional program‐ ming to the language. Specifically, the language added lambda expressions, method references, and streams. If you haven't used the new functional features yet, you'll probably be surprised by how different your code will look from previous Java versions. The changes in Java 8 represent the biggest changes to the language ever. In many ways, it feels like you're learning a completely new language. The question then becomes: Why do this? Why make such drastic changes to a lan‐ guage that's already twenty years old and plans to maintain backward compatibility? Why make such dramatic revisions to a language that has been, by all accounts, extremely successful? Why switch to a functional paradigm after all these years of being one of the most successful object-oriented languages ever? The answer is that the software development world has changed, so languages that want to be successful in the future need to adapt as well. Back in the mid-'90s, when Java was shiny and new, Moore's law1 was still fully in force. All you had to do was wait a couple of years and your computer would double in speed. Today's hardware no longer relies on increasing chip density for speed. Instead, even most phones have multiple cores, which means software needs to be written expect‐ ing to be run in a multiprocessor environment. Functional programming, with its emphasis on "pure" functions (that return the same result given the same inputs, with no side effects) and immutability simplifies programming in parallel environments. If 1 you don't have any shared, mutable state, and your program can be decomposed into collections of simple functions, it is easier to understand and predict its behavior. This, however, is not a book about Haskell, or Erlang, or Frege, or any of the other functional programming languages. This book is about Java, and the changes made to the language to add functional concepts to what is still fundamentally an object- oriented language. Java now supports lambda expressions, which are essentially methods treated as though they were first-class objects. The language also has method references, which allow you to use an existing method wherever a lambda expression is expected. In order to take advantage of lambda expressions and method references, the language also added a stream model, which produces elements and passes them through a pipeline of transformations and filters without modifying the original source. The recipes in this chapter describe the basic syntax for lambda expressions, method references, and functional interfaces, as well the new support for static and default methods in interfaces. Streams are discussed in detail in Chapter 3. 1.1 Lambda Expressions Problem You want to use lambda expressions in your code. Solution Use one of the varieties of lambda expression syntax and assign the result to a refer‐ ence of functional interface type. Discussion A functional interface is an interface with a single abstract method (SAM). A class implements any interface by providing implementations for all the methods in it. This can be done with a top-level class, an inner class, or even an anonymous inner class. For example, consider the Runnable interface, which has been in Java since version 1.0. It contains a single abstract method called run, which takes no arguments and returns void. The Thread class constructor takes a Runnable as an argument, so an anonymous inner class implementation is shown in Example 1-1. Example 1-1. Anonymous inner class implementation of Runnable public class RunnableDemo { public static void main(String[] args) { 2 | Chapter 1: The Basics new Thread(new Runnable() { @Override public void run() { System.out.println( "inside runnable using an anonymous inner class"); } }).start(); } } Anonymous inner class The anonymou...
Comentarios a: 2017 Modern Java Recipes Simple Solutions to Difficult Problems in Java 8 and 9
Posted by: shadinguardsene0194265.blogspot.com
Source: https://docer.com.ar/doc/xxve10c
