OCP: Oracle Certified Professional Java Se 8 Programmer II Study Guide: Exam 1Z0-809 9781119067900, 9781119067887, 9781119067894, 2015951679, 1119067901, 111906788X, 1119067898

Table of contents :
Cover......Page 1
Title Page......Page 5
Copyright......Page 6
Acknowledgments......Page 8
About the Authors......Page 9
Contents at a Glance......Page 11
Contents......Page 13
Introduction......Page 21
Assessment Test......Page 40
Answers to Assessment Test......Page 50
Chapter 1 Advanced Class Design......Page 53
Access Modifiers......Page 54
Overloading and Overriding......Page 56
Abstract Classes......Page 57
Imports......Page 58
Using instanceof......Page 59
Understanding Virtual Method Invocation......Page 61
Annotating Overridden Methods......Page 63
toString......Page 65
equals......Page 67
hashCode......Page 70
Working with Enums......Page 72
Using Enums in Switch Statements......Page 73
Adding Constructors, Fields, and Methods......Page 74
Creating Nested Classes......Page 76
Member Inner Classes......Page 77
Local Inner Classes......Page 79
Anonymous Inner Classes......Page 81
Static Nested Classes......Page 83
Summary......Page 85
Exam Essentials......Page 86
Review Questions......Page 88
Chapter 2 Design Patterns and Principles......Page 99
Designing an Interface......Page 100
Purpose of an Interface......Page 103
Introducing Functional Programming......Page 104
Defining a Functional Interface......Page 105
Implementing Functional Interfaces with Lambdas......Page 107
Applying the Predicate Interface......Page 112
Implementing Polymorphism......Page 113
Distinguishing between an Object and a Reference......Page 115
Casting Object References......Page 116
Encapsulating Data......Page 118
Creating JavaBeans......Page 121
Applying the Is-a Relationship......Page 123
Applying the Has-a Relationship......Page 125
Composing Objects......Page 126
Working with Design Patterns......Page 127
Applying the Singleton Pattern......Page 128
Creating Immutable Objects......Page 134
Using the Builder Pattern......Page 138
Creating Objects with the Factory Pattern......Page 141
Exam Essentials......Page 145
Review Questions......Page 147
Chapter 3 Generics and Collections......Page 155
Array and ArrayList......Page 156
Searching and Sorting......Page 157
Wrapper Classes and Autoboxing......Page 158
The Diamond Operator......Page 159
Working with Generics......Page 160
Generic Classes......Page 161
Generic Interfaces......Page 164
Interacting with Legacy Code......Page 166
Bounds......Page 169
Putting It All Together......Page 174
Using Lists, Sets, Maps, and Queues......Page 176
Common Collections Methods......Page 177
Using the List Interface......Page 179
Using the Set Interface......Page 184
Using the Queue Interface......Page 186
Map......Page 190
Comparing Collection Types......Page 192
Comparable......Page 195
Comparator......Page 198
Searching and Sorting......Page 202
Using Method References......Page 204
Removing Conditionally......Page 206
Using New Java 8 Map APIs......Page 207
Summary......Page 211
Exam Essentials......Page 213
Review Questions......Page 214
Chapter 4 Functional Programming......Page 223
Using Variables in Lambdas......Page 224
Working with Built-In Functional Interfaces......Page 225
Implementing Supplier......Page 226
Implementing Consumer and BiConsumer......Page 227
Implementing Predicate and BiPredicate......Page 229
Implementing Function and BiFunction......Page 230
Implementing UnaryOperator and BinaryOperator......Page 232
Checking Functional Interfaces......Page 233
Returning an Optional......Page 234
Using Streams......Page 237
Creating Stream Sources......Page 240
Using Common Terminal Operations......Page 241
Using Common Intermediate Operations......Page 248
Putting Together the Pipeline......Page 252
Printing a Stream......Page 256
Creating Primitive Streams......Page 257
Using Optional with Primitive Streams......Page 260
Learning the Functional Interfaces for Primitives......Page 262
Linking Streams to the Underlying Data......Page 265
Chaining Optionals......Page 266
Collecting Results......Page 269
Summary......Page 275
Exam Essentials......Page 276
Review Questions......Page 278
Chapter 5 Dates, Strings, and Localization......Page 285
Working with Dates and Times......Page 286
Creating Dates and Times......Page 287
Manipulating Dates and Times......Page 293
Working with Periods......Page 296
Working with Durations......Page 299
Accounting for Daylight Savings Time......Page 303
Reviewing the String class......Page 305
Adding Internationalization and Localization......Page 307
Picking a Locale......Page 308
Using a Resource Bundle......Page 310
Formatting Numbers......Page 319
Formatting Dates and Times......Page 322
Summary......Page 325
Exam Essentials......Page 326
Review Questions......Page 328
Chapter 6 Exceptions and Assertions......Page 335
Exceptions Terminology......Page 336
Categories of Exceptions......Page 337
Exceptions on the OCP......Page 338
Try Statement......Page 340
Creating Custom Exceptions......Page 341
Using Multi-catch......Page 343
Using Try-With-Resources......Page 348
Try-With-Resources Basics......Page 350
AutoCloseable......Page 352
Suppressed Exceptions......Page 354
Rethrowing Exceptions......Page 357
The assert Statement......Page 360
Enabling Assertions......Page 361
Using Assertions......Page 362
Summary......Page 366
Exam Essentials......Page 367
Review Questions......Page 368
Chapter 7 Concurrency......Page 377
Introducing Threads......Page 379
Understanding Thread Concurrency......Page 380
Introducing Runnable......Page 382
Creating a Thread......Page 383
Polling with Sleep......Page 386
Introducing the Single-Thread Executor......Page 387
Shutting Down a Thread Executor......Page 389
Submitting Tasks......Page 390
Waiting for Results......Page 392
Scheduling Tasks......Page 397
Increasing Concurrency with Pools......Page 400
Synchronizing Data Access......Page 402
Protecting Data with Atomic Classes......Page 404
Improving Access with Synchronized Blocks......Page 406
Synchronizing Methods......Page 408
Understanding the Cost of Synchronization......Page 409
Introducing Concurrent Collections......Page 410
Understanding Memory Consistency Errors......Page 411
Working with Concurrent Classes......Page 412
Obtaining Synchronized Collections......Page 417
Creating Parallel Streams......Page 418
Processing Tasks in Parallel......Page 419
Processing Parallel Reductions......Page 424
Creating a CyclicBarrier......Page 429
Applying the Fork/Join Framework......Page 433
Understanding Liveness......Page 439
Managing Race Conditions......Page 443
Summary......Page 444
Exam Essentials......Page 445
Review Questions......Page 446
Chapter 8 IO......Page 457
Conceptualizing the File System......Page 458
Introducing the File Class......Page 459
Stream Fundamentals......Page 463
Stream Nomenclature......Page 464
Common Stream Operations......Page 470
The FileInputStream and FileOutputStream Classes......Page 472
The FileReader and FileWriter classes......Page 476
The ObjectInputStream and ObjectOutputStream Classes......Page 478
The PrintStream and PrintWriter Classes......Page 484
Review of Stream Classes......Page 487
The Old Way......Page 489
The New Way......Page 490
Summary......Page 494
Exam Essentials......Page 495
Review Questions......Page 497
Chapter 9 NIO.2......Page 505
Introducing NIO.2......Page 506
Introducing Path......Page 507
Creating Paths......Page 508
Interacting with Paths and Files......Page 512
Providing Optional Arguments......Page 513
Using Path Objects......Page 514
Interacting with Files......Page 523
Discovering Basic File Attributes......Page 530
Improving Access with Views......Page 535
Conceptualizing Directory Walking......Page 539
Walking a Directory......Page 540
Searching a Directory......Page 542
Listing Directory Contents......Page 543
Printing File Contents......Page 544
Comparing Legacy File and NIO.2 Methods......Page 546
Exam Essentials......Page 547
Review Questions......Page 549
Chapter 10 JDBC......Page 557
Introducing Relational Databases and SQL......Page 559
Identifying the Structure of a Relational Database......Page 560
Writing Basic SQL Statements......Page 562
Introducing the Interfaces of JDBC......Page 563
Building a JDBC URL......Page 565
Getting a Database Connection......Page 567
Obtaining a Statement......Page 570
Choosing a ResultSet Type......Page 571
Executing a Statement......Page 572
Reading a ResultSet......Page 576
Getting Data for a Column......Page 578
Scrolling ResultSet......Page 581
Closing Database Resources......Page 585
Dealing with Exceptions......Page 587
Summary......Page 588
Exam Essentials......Page 589
Review Questions......Page 591
Appendix A Answers to Review Questions......Page 599
Chapter 1: Advanced Class Design......Page 600
Chapter 2: Design Patterns and Principles......Page 602
Chapter 3: Generics and Collections......Page 605
Chapter 4: Functional Programming......Page 608
Chapter 5: Dates, Strings, and Localization......Page 610
Chapter 6: Exceptions and Assertions......Page 612
Chapter 7: Concurrency......Page 613
Chapter 8: IO......Page 617
Chapter 9: NIO.2......Page 620
Chapter 10: JDBC......Page 623
Appendix B Study Tips......Page 627
Creating a Study Plan......Page 628
Comparing Previous Exams......Page 630
Creating and Running Sample Applications......Page 631
Understanding the Question......Page 634
Using the Provided Writing Material......Page 639
Choosing the Best Answer......Page 642
Optimizing Your Time......Page 643
Getting a Good Night’s Rest......Page 645
Appendix C Upgrading from Java 6 or Earlier......Page 647
Using the Diamond Operator......Page 648
Creating Literals......Page 649
Making Decisions with Switch......Page 650
Using DateFormat......Page 655
Formatting......Page 656
Parsing......Page 657
Custom Date Formats......Page 658
Understanding the Lock Framework......Page 659
Using a ReentrantLock......Page 662
Understanding Read/Write Locks......Page 666
Using a ReentrantReadWriteLock......Page 667
Working with Directories......Page 669
Traversing Directories......Page 670
Monitoring a Directory for Changes......Page 677
Exam Essentials......Page 685
Review Questions......Page 687
Answers to Practice Test......Page 697
Index......Page 701
Advert......Page 722
EULA......Page 723

Citation preview

OCP

Oracle Certified Professional Java SE 8 Programmer II ®

®

Study Guide

OCP

Oracle Certified Professional Java SE 8 Programmer II ®

®

Study Guide

Jeanne Boyarsky Scott Selikoff

Senior Acquisitions Editor: Kenyon Brown Development Editor: Gary Schwartz Technical Editors: Ernest Friedman-Hill and Matt Dalen Production Editor: Dassi Zeidel Copy Editor: Linda Recktenwald Editorial Manager: Mary Beth Wakefield Production Manager: Kathleen Wisor Associate Publisher: Jim Minatel Supervising Producer: Rich Graves Book Designers: Judy Fung and Bill Gibson Proofreader: Josh Chase, Word One New York Indexer: Ted Laux Project Coordinator, Cover: Brent Savage Cover Designer: Wiley Cover Image: ©Getty Images Inc./Jeremy Woodhouse Copyright © 2016 by John Wiley & Sons, Inc., Indianapolis, Indiana Published simultaneously in Canada ISBN: 978-1-119-06790-0 ISBN: 978-1-119-06788-7 (ebk.) ISBN: 978-1-119-06789-4 (ebk.) Manufactured in the United States of America No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, 222 Rosewood Drive, Danvers, MA 01923, (978) 750-8400, fax (978) 646-8600. Requests to the Publisher for permission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) 748-6011, fax (201) 748-6008, or online at http://www.wiley.com/go/ permissions. Limit of Liability/Disclaimer of Warranty: The publisher and the author make no representations or warranties with respect to the accuracy or completeness of the contents of this work and specifically disclaim all warranties, including without limitation warranties of fitness for a particular purpose. No warranty may be created or extended by sales or promotional materials. The advice and strategies contained herein may not be suitable for every situation. This work is sold with the understanding that the publisher is not engaged in rendering legal, accounting, or other professional services. If professional assistance is required, the services of a competent professional person should be sought. Neither the publisher nor the author shall be liable for damages arising herefrom. The fact that an organization or Web site is referred to in this work as a citation and/or a potential source of further information does not mean that the author or the publisher endorses the information the organization or Web site may provide or recommendations it may make. Further, readers should be aware that Internet Web sites listed in this work may have changed or disappeared between when this work was written and when it is read. For general information on our other products and services or to obtain technical support, please contact our Customer Care Department within the U.S. at (877) 762-2974, outside the U.S. at (317) 572-3993 or fax (317) 572-4002. Wiley publishes in a variety of print and electronic formats and by print-on-demand. Some material included with standard print versions of this book may not be included in e-books or in print-on-demand. If this book refers to media such as a CD or DVD that is not included in the version you purchased, you may download this material at http://booksupport.wiley.com. For more information about Wiley products, visit www.wiley.com. Library of Congress Control Number: 2015951679 TRADEMARKS: Wiley, the Wiley logo, and the Sybex logo are trademarks or registered trademarks of John Wiley & Sons, Inc. and/or its affiliates, in the United States and other countries, and may not be used without written permission. Oracle and Java are registered trademarks of Oracle America, Inc. All other trademarks are the property of their respective owners. John Wiley & Sons, Inc. is not associated with any product or vendor mentioned in this book. 10 9 8 7 6 5 4 3 2 1

To the programmers on FIRST robotics team FRC 694 StuyPulse — Jeanne To my newborn daughters Olivia and Sophia, I love you both more and more every day. — Scott

Acknowledgments  Jeanne and Scott would like to thank numerous individuals for their contribution to this book. Thank you, Gary Schwartz, for guiding us through the process and making the book better in so many ways. Thank you, Ernest Friedman-Hill, for being our Technical Editor as we wrote this book. Ernest pointed out many subtle errors in addition to the big ones. And thank you, Matt Dalen, for being our Technical Proofreader and finding the errors that managed to sneak by even Ernest. This book also wouldn’t be possible without many people at Wiley, including Kenyon Brown, Dassi Zeidel, Mary Beth Wakefield, and so many others. Jeanne would personally like to thank Chris Kreussling and Elena Felder for their feedback on early drafts of the trickier material. Elena even helped figure out a good way to explain upper bounds. Roel De Nijs reviewed the Java 8 date/time material for words that native English speakers take for granted, and he responded to lots of posts in the CodeRanch.com OCA forum on our first book. To all of the people at work and at CodeRanch.com who were so excited for me about writing this book, you made it even more exciting when we published our first book. Jeanne would like to thank the members of FIRST robotics FRC team 694 for their support. It was an awesome feeling seeing high school students pore over the book while waiting for dinner the night the hard copy arrived. Go StuyPulse! See if you can find JoeBot in this book. Finally, Jeanne would like to thank Scott for being a great co-author again. Scott could not have reached this point without the help of a small army of people, led by his perpetually understanding wife Patti, the most wonderful mother their twin daughters could ask for. Professor Johannes Gehrke of Cornell University always believed in him and knew he would excel in his career. Jeanne’s patience and striving for excellence was invaluable in creating this second book. A big thanks to fellow new father Matt Dalen, who has been a wonderful friend, sounding board, and technical reviewer over the last year. Joel McNary introduced Scott to CodeRanch.com and encouraged him to post regularly—a step that changed his life. Finally, Scott would like to thank his mother and retired teacher Barbara Selikoff, for teaching him the value of education, and his father Mark Selikoff, for instilling in him the benefits of working hard. Finally, both Jeanne and Scott would like to give a big thank-you to the readers of our OCA 8 book. Hearing from all of you who enjoyed the book and passed the exam was great. We’d also like to thank those who pointed out errors and made suggestions for improvements in our OCA book. As of July 2015, the top three were Mushfiq Mammadov, Elena Felder, and Cédric Georges. Thank you for your attention to detail! We also would like to thank Mathias Bader, Maaike Zijderveld, Vincent Botteman, Edward Rance, Gabriel Jesus, Ilya Danilov, Marc ter Braak, Dominik Bauer, Saad Benbouzid, Evgeny Kapinos, Helen Colson, Alex Lord, and Kevin Abel.

About the Authors  Jeanne Boyarsky   has worked as a Java developer for more than 13 years at a bank in New York City, where she develops, mentors, and conducts training. Besides being a senior moderator at CodeRanch.com in her free time, she leads the team that works on the forum’s code base. Jeanne also mentors the programming division of a FIRST robotics team, where she works with students just getting started with Java. Jeanne got her Bachelor of Arts degree in 2002 in Computer Science and her Master’s in Computer Information Technology in 2005. She enjoyed getting her Master’s degree in an online program while working full time. This was before online education was cool! Jeanne is also a Distinguished Toastmaster and a Scrum Master. You can find out more about Jeanne at http://www.coderanch.com/how-to/java/BioJeanneBoyarsky. Scott Selikoff    is a professional software consultant, author, and owner of Selikoff Solutions, LLC, which provides software development solutions to businesses in the tristate New York City area. Skilled in a plethora of software languages and platforms, Scott specializes in database-driven systems, web-based applications, and service-oriented architectures. A native of Toms River, New Jersey, Scott achieved his Bachelor of Arts from Cornell University in Mathematics and Computer Science in 2002, after three years of study. In 2003, he received his Master of Engineering in Computer Science, also from Cornell University. As someone with a deep love of education, Scott has always enjoyed teaching others new concepts. He’s given lectures at Cornell University and Rutgers University, as well as conferences including The Server Side Java Symposium. Scott lives in New Jersey with his loving wife, amazing twin baby girls, and two very playful dogs. You can find out more about Scott at http://www.linkedin.com/in/selikoff. Jeanne and Scott are both moderators on the CodeRanch.com forums, and they can be reached there for questions and comments. They also co-author a technical blog called Down Home Country Coding at http://www.selikoff.net.

Contents at a Glance Introduction

xix

Assessment Test

xxxviii

Chapter 1

Advanced Class Design

Chapter 2

Design Patterns and Principles

Chapter 3

Generics and Collections 

103

Chapter 4

Functional Programming

171

Chapter 5

Dates, Strings, and Localization

233

Chapter 6

Exceptions and Assertions

283

Chapter 7

Concurrency

325

Chapter 8

IO

405

Chapter 9

NIO.2

453

Chapter 10

JDBC 

505

Appendix A

Answers to Review Questions

547

Appendix B

Study Tips

575

Appendix C

Upgrading from Java 6 or Earlier

595

Index

1 47

649

Contents Introduction

xix

Assessment Test Chapter

Chapter

1

2

xxxviii Advanced Class Design

1

Reviewing OCA Concepts Access Modifiers Overloading and Overriding Abstract Classes Static and Final Imports Using instanceof Understanding Virtual Method Invocation Annotating Overridden Methods Coding equals, hashCode, and toString toString equals hashCode Working with Enums Using Enums in Switch Statements Adding Constructors, Fields, and Methods Creating Nested Classes Member Inner Classes Local Inner Classes Anonymous Inner Classes Static Nested Classes Summary Exam Essentials Review Questions

2 2 4 5 6 6 7 9 11 13 13 15 18 20 21 22 24 25 27 29 31 33 34 36

Design Patterns and Principles

47

Designing an Interface Purpose of an Interface Introducing Functional Programming Defining a Functional Interface Implementing Functional Interfaces with Lambdas Applying the Predicate Interface Implementing Polymorphism Distinguishing between an Object and a Reference Casting Object References

48 51 52 53 55 60 61 63 64

xii 

Contents

Understanding Design Principles Encapsulating Data Creating JavaBeans Applying the Is‐a Relationship Applying the Has‐a Relationship Composing Objects Working with Design Patterns Applying the Singleton Pattern Creating Immutable Objects Using the Builder Pattern Creating Objects with the Factory Pattern Summary Exam Essentials Review Questions Chapter

3

66 66 69 71 73 74 75 76 82 86 89 93 93 95

Generics and Collections 

103

Reviewing OCA Collections Array and ArrayList Searching and Sorting Wrapper Classes and Autoboxing The Diamond Operator Working with Generics Generic Classes Generic Interfaces Generic Methods Interacting with Legacy Code Bounds Putting It All Together Using Lists, Sets, Maps, and Queues Common Collections Methods Using the List Interface Using the Set Interface Using the Queue Interface Map Comparing Collection Types Comparator vs. Comparable Comparable Comparator Searching and Sorting Additions in Java 8 Using Method References Removing Conditionally Updating All Elements

104 104 105 106 107 108 109 112 114 114 117 122 124 125 127 132 134 138 140 143 143 146 150 152 152 154 155

Contents 

Chapter

Chapter

4

5

xiii

Looping through a Collection Using New Java 8 Map APIs Summary Exam Essentials Review Questions

155 155 159 161 162

Functional Programming

171

Using Variables in Lambdas Working with Built-In Functional Interfaces Implementing Supplier Implementing Consumer and BiConsumer Implementing Predicate and BiPredicate Implementing Function and BiFunction Implementing UnaryOperator and BinaryOperator Checking Functional Interfaces Returning an Optional Using Streams Creating Stream Sources Using Common Terminal Operations Using Common Intermediate Operations Putting Together the Pipeline Printing a Stream Working with Primitives Creating Primitive Streams Using Optional with Primitive Streams Summarizing Statistics Learning the Functional Interfaces for Primitives Working with Advanced Stream Pipeline Concepts Linking Streams to the Underlying Data Chaining Optionals Collecting Results Summary Exam Essentials Review Questions

172 173 174 175 177 178 180 181 182 185 188 189 196 200 204 205 205 208 210 210 213 213 214 217 223 224 226

Dates, Strings, and Localization Working with Dates and Times Creating Dates and Times Manipulating Dates and Times Working with Periods Working with Durations Accounting for Daylight Savings Time

233 234 235 241 244 247 251

xiv 

Chapter

Contents

6

Reviewing the String class Adding Internationalization and Localization Picking a Locale Using a Resource Bundle Formatting Numbers Formatting Dates and Times Summary Exam Essentials Review Questions

255 256 258 267 270 273 274 276

Exceptions and Assertions

283

Reviewing Exceptions Exceptions Terminology Categories of Exceptions Exceptions on the OCP Try Statement Throw vs. Throws Creating Custom Exceptions Using Multi-catch Using Try-With-Resources Try-With-Resources Basics AutoCloseable Suppressed Exceptions Putting It Together Rethrowing Exceptions Working with Assertions The assert Statement Enabling Assertions Using Assertions Summary Exam Essentials Review Questions Chapter

7

Concurrency Introducing Threads Distinguishing Thread Types Understanding Thread Concurrency Introducing Runnable Creating a Thread Polling with Sleep Creating Threads with the ExecutorService Introducing the Single-Thread Executor

253

284 284 285 286 288 289 289 291 296 298 300 302 305 305 308 308 309 310 314 315 316 325 327 328 328 330 331 334 335 335

Contents 

Shutting Down a Thread Executor Submitting Tasks Waiting for Results Scheduling Tasks Increasing Concurrency with Pools Synchronizing Data Access Protecting Data with Atomic Classes Improving Access with Synchronized Blocks Synchronizing Methods Understanding the Cost of Synchronization Using Concurrent Collections Introducing Concurrent Collections Understanding Memory Consistency Errors Working with Concurrent Classes Obtaining Synchronized Collections Working with Parallel Streams Creating Parallel Streams Processing Tasks in Parallel Processing Parallel Reductions Managing Concurrent Processes Creating a CyclicBarrier Applying the Fork/Join Framework Identifying Threading Problems Understanding Liveness Managing Race Conditions Summary Exam Essentials Review Questions Chapter

8

IO Understanding Files and Directories Conceptualizing the File System Introducing the File Class Introducing Streams Stream Fundamentals Stream Nomenclature Common Stream Operations Working with Streams The FileInputStream and FileOutputStream Classes The FileReader and FileWriter classes The ObjectInputStream and ObjectOutputStream Classes The PrintStream and PrintWriter Classes Review of Stream Classes

xv

337 338 340 345 348 350 352 354 356 357 358 358 359 360 365 366 366 367 372 377 377 381 387 387 391 392 393 394 405 406 406 407 411 411 412 418 420 420 424 426 432 435

xvi 

Contents

Interacting with Users The Old Way The New Way Summary Exam Essentials Review Questions Chapter

9

NIO.2 Introducing NIO.2 Introducing Path Creating Paths Interacting with Paths and Files Providing Optional Arguments Using Path Objects Interacting with Files Understanding File Attributes Discovering Basic File Attributes Improving Access with Views Presenting the New Stream Methods Conceptualizing Directory Walking Walking a Directory Searching a Directory Listing Directory Contents Printing File Contents Comparing Legacy File and NIO.2 Methods Summary Exam Essentials Review Questions

Chapter

10

JDBC  Introducing Relational Databases and SQL Identifying the Structure of a Relational Database Writing Basic SQL Statements Introducing the Interfaces of JDBC Connecting to a Database Building a JDBC URL Getting a Database Connection Obtaining a Statement Choosing a ResultSet Type Choosing a ResultSet Concurrency Mode Executing a Statement Getting Data from a ResultSet Reading a ResultSet

437 437 438 442 443 445 453 454 455 456 460 461 462 471 478 478 483 487 487 488 490 491 492 494 495 495 497 505 507 508 510 511 513 513 515 518 519 520 520 524 524

Contents 

Getting Data for a Column Scrolling ResultSet Closing Database Resources Dealing with Exceptions Summary Exam Essentials Review Questions Appendix

A

Answers to Review Questions Chapter 1: Advanced Class Design Chapter 2: Design Patterns and Principles Chapter 3: Generics and Collections Chapter 4: Functional Programming Chapter 5: Dates, Strings, and Localization Chapter 6: Exceptions and Assertions Chapter 7: Concurrency Chapter 8: IO Chapter 9: NIO.2 Chapter 10: JDBC

Appendix

B

Study Tips Studying for the Test Creating a Study Plan Comparing Previous Exams Creating and Running Sample Applications Taking the Test Understanding the Question Taking Advantage of the Exam Software Using the Provided Writing Material Choosing the Best Answer Optimizing Your Time Getting a Good Night’s Rest

Appendix

C

Upgrading from Java 6 or Earlier Enhancing the Java Language Using the Diamond Operator Creating Literals Making Decisions with Switch Formatting and Parsing Using DecimalFormat Flags Using DateFormat Formatting Parsing

xvii

526 529 533 535 536 537 539 547 548 550 553 556 558 560 561 565 568 571 575 576 576 578 579 582 582 587 587 590 591 593 595 596 596 597 598 603 603 603 604 605

xviii 

Contents

Custom Date Formats Applying Locks Understanding the Lock Framework Using a ReentrantLock Understanding Read/Write Locks Using a ReentrantReadWriteLock Working with Directories Traversing Directories Monitoring a Directory for Changes Summary Exam Essentials Review Questions Answers to Practice Test Index

606 607 607 610 614 615 617 618 625 633 633 635 645 649

Introduction  Java recently celebrated its 20th birthday, since it was “born” in 1995. As with anything 20 years old, there is a good amount of history and variation between different versions of Java. Over the years, the certification exams have changed to cover different topics. The names of the exams have even changed. This book covers the Java 8 OCP exam along with the upgrade exams to Java 8. If you read about the exam on the web, you may see information about the older names for the exam. The name changes are shown in Figure I.1. Here’s what happened. Back when Sun Microsystems owned Java, they used to have two exams. The SCJA (Sun Certified Java Associate) was meant for new programmers and the SCJP (Sun Certified Java Programmer) was meant for those who wanted broader knowledge. When Oracle bought Sun Microsystems, they renamed all of the exams from Sun to Oracle, giving us the OCJA (Oracle Certified Java Associate) and OCJP (Oracle Certified Java Programmer).

F i g u r e   I .1     Names for the exam

SCJA 5−6

Renamed

OCJA 6

SCJP 1−6

Renamed

OCJP 6

OCA 7−8

OCP 7−8

Then Oracle made two strategic decisions with Java 7. They decided to stop updating the OCJA exam. They also decided to cover more in the programmer space, and they split it into two exams. Now you first take the OCAJP (Oracle Certified Associate Java Programmer), also known as Java Programmer I or OCA. Then you take the OCPJP (Oracle Certified Professional Java Programmer), also known as Java Programmer II or OCP, and that’s what this book is about. Most people refer to the current exams as OCA 8 and OCP 8.

xx 

Introduction

Oracle also has upgrade exams in case you took an older version of the SCJP or OCPJP and you want to upgrade. While most people refer to them as the Java 8 upgrade exam, there are really two exams, and you choose the correct one based on the certification you currently hold. Table I.1 describes the exams that this book covers, while Figure I.2 helps you decide what exam to take next, assuming that you have passed a prior Java certification exam. Our book is designed to help you prepare for any of these three exams, all of which result in you being OCP 8 certified. Ta b l e   I .1     Exams this book covers Exam Code

Name

Who Should Take

1Z0–809

Java Programmer II

Holders of the OCA 8 certification

1Z0–810

Upgrade Java SE 7 to Java SE 8 OCP Programmer

Holders of the OCPJP 7 certification

1Z0–813

Upgrade to Java SE 8 OCP (Java SE 6 and all prior versions)

Holders of any of the following certifications: ■■

SCJP/OCJP 6

■■

SCJP/OCJP 5

■■

SCJP 1.4

■■

Any older SCJP certs

F i g u r e   I . 2     Exam prerequisites Then take... OCA 8 Exam [1Z0−808]

OCP 8 Exam [1Z0−809]

OCP 7 Exam [1Z0−804] If you have passed...

OCP 8 Upgrade Exam [1Z0−810] OCP 7 Upgrade Exam [1Z0−805]

Any SCJP/OCJP Exam Java 6 and Earlier

OCP 8 Upgrade Exam [1Z0−813]

Introduction 

xxi

We try to keep the history to a minimum in this book. There are some places on the exam where you need to know both an old way and a new way of doing things. When that happens, we will be sure to tell you what version of Java introduced which way. We will also let you know about topics that are not on the exam anymore, in case you see questions on them in the older free online mock exams.

The OCP Exam All you need to do to become an Oracle Certified Professional for Java 8 is to pass an exam! That’s it. Oracle has a tendency to fiddle with the length of the exam and the passing score once it comes out. Since it’s pretty much guaranteed that whatever we tell you here will become obsolete, we will instead give you a feel for the range. The OCP exam has varied between 60 and 90 questions since it was first introduced. The score to pass the exam has varied between 60 percent and 80 percent. The time allowed to take the exam has varied from two hours to two-and-a-half hours. Oracle has a tendency to tweak the exam objectives over time as well. They do make minor additions and deletions from what is covered on the exam. For example, serialization has been added and removed from the objectives many times over the life of the OCP. As of this writing, it is on the exam. While there will likely be minor changes to the scope of the exam, they certainly aren’t a secret. We’ve created a book page on our blog: http://www.selikoff.net/ocp. If there are any changes to the topics on the exam after this book is published, we will note them there. That book page also contains a link to the official exam page, so you can check the length and passing score that Oracle has chosen for the moment. Finally, all known errata and links to discussion can be found at http://www.coderanch.com.

Scheduling the Exam Pearson VUE administers the exam, and it can be taken at any Pearson VUE testing center. To find a testing center or to register for the exam, go to http://pearsonvue.com. Choose IT and then Oracle. If you haven’t been to the test center before, we recommend visiting in advance. Some testing centers are nice and professionally run. Others stick you in a closet with lots of people talking around you. You don’t want to be taking the test with someone complaining about his or her broken laptop nearby! At this time, you can reschedule the exam without penalty until up to 24 hours in advance. This means that you can register for a convenient time slot well in advance knowing that you can delay taking the exam if you aren’t ready by that time. Rescheduling is easy and can be done completely on the Pearson VUE website. This may change, so check the rules before paying.

xxii 

Introduction

The Day of the Exam When you go to take the exam, remember to bring two forms of ID, including one that is government issued. See Pearson’s list of what is an acceptable ID at http://www. pearsonvue.com/policies/1S.pdf. Try not to bring too much extra with you, because it will not be allowed into the exam room. While you will be allowed to check your belongings, it is better to leave extra items at home or in your car. You will not be allowed to bring paper, your phone, and so on into the exam room with you. Some centers are stricter than others. At one center, tissues were even taken away from us! Most centers allow you to keep your ID and money. They watch you taking the exam, though, so don’t even think about writing notes on money. Some centers place these articles in a locker and give you the key, whereas others just throw them in an administrator’s desk drawer. Suffice it to say, if you have something that you really don’t want to lose, we recommend that you leave it at home. The exam center will give you writing materials to use during the exam. These are to be used as scratch paper during the exam to figure out answers and to keep track of your thought process. The exam center will dispose of them at the end. Notice how we said “writing materials” rather than “pen and paper.” Actually getting pen and paper is rare. Most centers provide a small erasable board and a dry erase marker. Before going into the exam room, we recommend testing that the marker writes and erases. As we alluded to earlier, some exam centers are more professionally run than others, so we recommend visiting your local exam center before scheduling the exam if you have never been there before. Some exam centers also have problems keeping the temperature at a comfortable level. Regardless of whether it is winter or summer, when you take the exam, we strongly recommend that you dress in layers, such as a long-sleeve shirt or sweatshirt over a short-sleeve shirt. This way, you can add/remove layers of clothing to adjust for your own comfort.  Some exam centers are located in quiet suburban areas while others are near busy city streets with noisy traffic. Furthermore, you might get lucky and be the only person in your exam room the day you show up, or you might be unlucky and have 10 other people in the room coming and going at different times. If you are someone who gets easily distracted by noise and other people moving around, we recommend that you bring a pair of earplugs for the exam. Some exam centers will even offer you a pair of sterile earplugs if you ask. Double-check with your test administrator before using your own, so that they don’t think you’re trying to cheat! While many exam centers permit bathroom breaks during the exam with permission, very few allow you to bring drinks inside. Since these exams are at least two hours long, make sure that you are well hydrated before you arrive. Just be aware that if you do need to use the facilities, your exam clock will not be paused. Finally, if you have any issues like it being unbearably hot, cold, or noisy in your exam room, you should contact Oracle after you finish taking the exam to let them know

Introduction 

xxiii

the quality of the particular testing center was poor. Some exam centers have shown improvement after receiving such reports.

Finding Out Your Score In the past, you would find out whether you passed or not right after finishing the exam. Now you have to wait nervously until you can check your score online. If you go to the Pearson VUE website, it will just show a status of “Taken” rather than your result. Oracle uses a separate system for scores. You’ll need to go to http:// certview.oracle.com to find out whether you passed and your score. It doesn’t update immediately upon taking the test, but we haven’t heard of it taking more than an hour. In addition to your score, you’ll also see objectives for which you got a question wrong and instructions on how to get a hardcopy certificate. At some point, you’ll get an electronic certificate, and some more time after that, you’ll receive a printed certificate. Sound vague? It is. The times reported to receive certificates vary widely.

Exam Questions The OCP exam consists of multiple-choice questions. There are typically four to six possible answers for each question. If a question has more than one correct answer, the question specifically states exactly how many correct answers there are. This book does not do that. We say “choose all that apply” if there might be more than one correct answer to make the questions harder. This means that the questions in this book are generally harder than those on the exam. The idea is to give you more practice so that you can spot the correct answer more easily on the real exam. You can right-click questions to cross out answers. This lets you mark answers as incorrect as you go so that you have less to think about as you read. It also helps you remember what you’ve eliminated when you go back to questions. The exam uses two different formats for identifying line numbers. We use both approaches in this book to get you prepared. The first approach is a comment at the end of a line such as this: list.stream() .map(s-> s.length()) // k1 .forEach(System.out::println);

One or more answer choices will refer to k1. With this approach, imports will be provided for any class definitions. For code snippets, you can assume that all necessary

xxiv 

Introduction

surrounding code is implied. The other approach is placing line numbers at the beginning of each line, like so: 4: 5: 6:

list.stream() .map(s-> s.length()) .forEach(System.out::println);

With this approach, the line numbers often begin with numbers higher than 1. This is to indicate that you are looking at a code snippet rather than a complete class. If you read about older versions of the exam online, you might see references to dragand-drop questions. These questions had you do a puzzle on how to complete a piece of code. There was also a bug in the exam software that caused your answers to be lost if you reviewed them. Luckily, these are no longer on the exam.

Getting Started We recommend reading Appendix B, “Study Tips,” before diving into the technical material in this book. Knowing how to approach studying will help you make better use of your study time. Next, make sure that you have downloaded version 8 of the JDK. If you learned Java some time ago, you might have version 7 or even earlier. Many of the examples won’t even compile in Java 7. Also, please check our book page to make sure that Oracle hasn’t changed the objectives. For example, if Oracle changed their mind on whether to include serialization yet again, you’d want to know that before studying. We will post any updates that you should know about at http://www.selikoff.net/ocp.

Getting Help Both of the authors are moderators at CodeRanch.com, a very large and active programming forum that is very friendly toward Java beginners. It has a forum just for this exam called “SCJP/OCPJP.” It also has a forum called “Java in General” for non-exam-specific questions. As you read the book, feel free to ask your questions in either of those forums. It could be that you are having trouble compiling a class or that you are just plain confused about something. You’ll get an answer from a knowledgeable Java programmer. It might even be one of us.

Who Should Buy This Book If you want to become Oracle Certified Java Programmer, this book is definitely for you. If you want to acquire a solid foundation in Java, and your goal is to prepare for the exam, this book is also for you. You’ll find clear explanations of the concepts you need to grasp

Introduction 

xxv

and plenty of help to achieve the high level of professional competency you need in order to succeed in your chosen field. This book is intended to be understandable to anyone who knows basic Java. Since the exam has a prerequisite of the Associate exam, we assume that you have a good handle on that much Java. We don’t assume that you know the Java 8–specific parts of the Associate exam, since some readers are taking the upgrade exam and are new to Java 8. This book is for anyone from high school students to those beginning their programming journey to experienced professionals who need a review for the certification.

How This Book Is Organized This book consists of 10 chapters plus supplementary information: a glossary, this introduction, four appendices, and the assessment test after this introduction. You might have noticed that there are more than 10 exam objectives. We split up what you need to know to make it easy to learn and remember. Each chapter begins with a list of the objectives that are covered in that chapter. Java 8 lambdas and functional programming streams are prevalent throughout the exam and appear in questions on many topics. You have to know this topic as well as you knew loops on the OCA exam. We’ve made sure to use them in many chapters so that you will be ready. For example, Chapter 2 reviews functional interfaces and Chapter 3 introduces method references. Chapter 4 covers the Streams API in detail. Later chapters use “the new approach” to writing code often so that you keep using it and become fluent. The chapters are organized as follows: Chapter 1: Advanced Class Design    This chapter covers inheritance, including abstract classes and the final keyword. It also discusses inner classes and enums. Chapter 2: Design Patterns and Principles    This chapter teaches you best practices for designing and writing applications that lead to code that is easier to understand and more maintainable. Chapter 3: Generics and Collections    This chapter goes beyond ArrayList and shows Sets, Maps, and Queues. It also shows new methods in Java 8 on these classes. Chapter 4: Functional Programming    This chapter explains lambdas and stream pipelines in detail. It also covers the built-in functional interfaces and the Optional class. Chapter 5: Dates, Strings, and Localization    This chapter shows the improved date and time classes in Java 8. It also covers more advanced String concepts that you need to know and how to make your application work in multiple languages. Chapter 6: Exceptions and Assertions    This chapter shows more advanced syntax for exceptions than what appears on the OCA. It also covers how to use assertions to verify the state of your program.

xxvi

Introduction

Chapter 7: Concurrency This chapter introduces the concept of thread management, and it teaches you how to write multi-threaded programs using the Concurrency API. Chapter 8: IO This chapter introduces you to managing fi les and directories using the java.io API. It also instructs you on how to read and write fi le data using I/O streams. Chapter 9: NIO.2 This chapter shows you how to manage fi les and directories using the newer NIO.2 API. It includes techniques for reading and writing fi le attributes, as well as traversing and searching for fi les using lambdas and streams. Chapter 10: JDBC This chapter provides the basics of working with databases in Java including different types of ResultSets. Appendix A: Answers to Review Questions Questions along with explanations. Appendix B: Study Tips

This appendix lists the answers to the Review

This appendix covers how to approach studying for the exam.

Appendix C: Upgrading from Java 6 or Earlier This appendix covers topics that are on the upgrade exam for those holding a Java 6 or earlier programmer certification. These topics are not on the main OCP 8 exam, nor are they on the upgrade exam for holders of the OCP 7 certification. At the end of each chapter, you’ll fi nd a few elements that you can use to prepare for the exam: Summary This section reviews the most important topics that were covered in the chapter, and it serves as a good review. Exam Essentials This section summarizes the main points that were covered in the chapter. You should be able to convey the information requested. Review Questions Each chapter concludes with at least 20 Review Questions. You should answer these questions and check your answers against the ones provided after the questions. If you can’t answer at least 80 percent of these questions correctly, go back and review the chapter, or at least review those sections that seem to be giving you diffi culty. The Review Questions, Assessment Test, and other testing elements included in this book are not derived from the real exam questions, so don’t memorize the answers to these questions and assume that doing so will enable you to pass the exam. You should learn the underlying topic, as described in the text of the book. This will let you answer the questions provided with this book and pass the exam. Learning the underlying topic is also the approach that will serve you best in the workplace—the ultimate goal of a certification.

To get the most out of this book, you should read each chapter from start to fi nish before going to the end-of-chapter elements. They are most useful for checking and

Introduction

xxvii

reinforcing your understanding. Even if you’re already familiar with a topic, you should at least skim the chapter. There are a number of subtleties to Java that you may not encounter even when working with Java for years.

Interactive Online Learning Environment and Test Bank The interactive online learning environment that accompanies OCP Oracle Certifi ed Professional SE 8 Programmer II: Exam 1Z0-809 provides a test bank with study tools to help you prepare for the certification exam, and it increases your chances of passing it the fi rst time! The test bank includes the following: Sample Tests All of the questions in this book are provided, including the Assessment Test, which you’ll fi nd at the end of this introduction, and the Chapter Tests, which include the Review Questions at the end of each chapter. In addition, there are three Practice Exams—180 questions in total! Use these questions to test your knowledge of the study guide material. The online test bank runs on multiple devices. Flashcards Over 250 questions are provided in digital flashcard format (a question followed by a single correct answer). You can use the flashcards to reinforce your learning and provide last-minute test prep before the exam. Other Study Tools Several bonus study tools are included: Glossary A glossary of key terms from this book and their defi nitions is available as a fully searchable PDF. Nashorn Materials Early drafts of the exam objectives had Nashorn on the exam for using JavaScript with Java. Since it isn’t on the exam anymore, this topic isn’t in the printed book. The appendix is available in the bonus contents in case you want to learn about this topic, independent of the exam. Go to http://sybextestbanks.wiley.com to register and gain access to this interactive online learning environment and test bank with study tools.

Conventions Used in This Book This book uses certain typographic styles in order to help you quickly identify important information and to avoid confusion over the meaning of words such as on-screen prompts. In particular, look for the following styles: ■

Italicized text indicates key terms that are described at length for the first time in a chapter. (Italics are also used for emphasis.)

■

A monospaced font indicates code or command-line text.

■

Italicized monospaced text indicates a variable.

xxviii

Introduction

In addition to these text conventions, which can apply to individual words or entire paragraphs, a few conventions highlight segments of text: A note indicates information that’s useful or interesting. It is often something to which you should pay special attention for the exam.

Sidebars A sidebar is like a note but longer. The information in a sidebar is useful, but it doesn’t fit into the main flow of the text.

real World Scenario A real world scenario is a type of sidebar that describes a task or an example that’s particularly grounded in the real world. This is something that is useful in the real world but is not going to show up on the exam.

OCP Exam Objectives This book has been written to cover every objective on the OCP 8 exam along with both upgrade exams.

OCP 8 (1Z0–809) The following table provides a breakdown of this book’s exam coverage for the OCP 8 (1Z0–809) exam, showing you the chapter where each objective or sub-objective is covered: Exam Objective

Chapter

Java Class Design Implement encapsulation

2

Implement inheritance including visibility modifiers and composition

1,2

Implement polymorphism

2

Introduction 

xxix

Exam Objective

Chapter

Override hashCode, equals, and toString methods from Object class

1

Create and use singleton classes and immutable classes

2

Develop code that uses static keyword on initialize blocks, variables, methods, and classes

1

Advanced Java Class Design Develop code that uses abstract classes and methods

1

Develop code that uses final keyword

1

Create inner classes including static inner class, local class, nested class, and anonymous inner class

1

Use enumerated types including methods and constructors in an enum type

1

Develop code that declares, implements and/or extends interfaces and use the @Override annotation.

1,2

Create and use Lambda expressions

2,3

Generics and Collections Create and use a generic class

3

Create and use ArrayList, TreeSet, TreeMap, and ArrayDeque objects

3

Use java.util.Comparator and java.lang.Comparable interfaces

3

Collections Streams and Filters

4

Iterate using forEach methods of Streams and List

3,4

Describe Stream interface and Stream pipeline

4

Filter a collection by using lambda expressions

3

Use method references with Streams

3,4

Lambda Built-in Functional Interfaces Use the built-in interfaces included in the java.util.function package such as Predicate, Consumer, Function, and Supplier

2,4

xxx 

Introduction

Exam Objective

Chapter

Develop code that uses primitive versions of functional interfaces

4

Develop code that uses binary versions of functional interfaces

4

Develop code that uses the UnaryOperator interface

4

Java Stream API Develop code to extract data from an object using peek() and map() methods including primitive versions of the map() method

4

Search for data by using search methods of the Stream classes including findFirst, findAny, anyMatch, allMatch, noneMatch

4

Develop code that uses the Optional class

4

Develop code that uses Stream data methods and calculation methods

4

Sort a collection using Stream API

4

Save results to a collection using the collect method and group/partition data using the Collectors class

4

Use of merge() and flatMap() methods of the Stream API

3,4

Exceptions and Assertions Use try-catch and throw statements

6

Use catch, multi-catch, and finally clauses

6

Use Autoclose resources with a try-with-resources statement

6

Create custom exceptions and AutoCloseable resources

6

Test invariants by using assertions

6

Use Java SE 8 Date/Time API Create and manage date-based and time-based events including a combination of date and time into a single object using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration

5

Work with dates and times across time zones and manage changes resulting from daylight savings including Format date and times values

5

Introduction 

xxxi

Exam Objective

Chapter

Define and create and manage date-based and time-based events using Instant, Period, Duration, and TemporalUnit

5

Java I/O Fundamentals Read and write data from the console

8

Use BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, ObjectOutputStream, ObjectInputStream, and PrintWriter in the java.io package.

8

Java File I/O (NIO.2) Use Path interface to operate on file and directory paths

9

Use Files class to check, read, delete, copy, move, manage metadata of a file or directory 9 Use Stream API with NIO.2

9

Java Concurrency Create worker threads using Runnable, Callable, and use an ExecutorService to concurrently execute tasks

7

Identify potential threading problems among deadlock, starvation, livelock, and race conditions

7

Use synchronized keyword and java.util.concurrent.atomic package to control the order of thread execution

7

Use java.util.concurrent collections and classes including CyclicBarrier and CopyOnWriteArrayList

7

Use parallel Fork/Join Framework

7

Use parallel Streams including reduction, decomposition, merging processes, pipelines and performance.

7

Building Database Applications with JDBC Describe the interfaces that make up the core of the JDBC API including the Driver, Connection, Statement, and ResultSet interfaces and their relationship to provider implementations

10

Identify the components required to connect to a database using the DriverManager class (including the JDBC URL)

10

xxxii 

Introduction

Exam Objective

Chapter

Submit queries and read results from the database (including creating statements, 10 returning result sets, iterating through the results, and properly closing result sets, statements, and connections) Localization Read and set the locale by using the Locale object

5

Create and read a Properties file

5

Build a resource bundle for each locale and load a resource bundle in an application

5

Upgrade from Java 7 (1Z0–810) This table shows the chapter where each objective or sub-objective is covered for the upgrade exam from Java 7 to Java 8 OCP (1Z0–810): Exam Objective

Chapter

Lambda Expressions Describe and develop code that uses Java inner classes, including nested class, static class, local class, and anonymous classes

1

Describe and write functional interfaces

2

Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing

4

Using Built-in Lambda Types Describe the interfaces of the java.util.function package

4

Develop code that uses the Function interface

4

Develop code that uses the Consumer interface

4

Develop code that uses the Supplier interface

4

Develop code that uses the UnaryOperator interface

4

Develop code that uses the Predicate interface

4

Introduction 

xxxiii

Exam Objective

Chapter

Develop code that uses the primitive and binary variations of the base interfaces of the java.util.function package

4

Develop code that uses a method reference, including refactoring a lambda expression to a method reference

3,4

Filtering Collections with Lambdas Develop code that iterates a collection by using the forEach() method and method chaining

3

Describe the Stream interface and pipelines

4

Filter a collection by using lambda expressions

3

Identify the lambda operations that are lazy

4

Collection Operations with Lambda Develop code to extract data from an object by using the map() method

3

Search for data by using methods such as findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch()

4

Describe the unique characteristics of the Optional class

4

Perform calculations by using Java Stream methods, such as count(), max(), min(), average(), and sum()

4

Sort a collection by using lambda expressions

4

Develop code that uses the Stream.collect() method and Collectors class methods, 4 such as averagingDouble(), groupingBy(), joining(), and partitioningBy() Parallel Streams Develop code that uses parallel streams

7

Implement decomposition and reduction in streams

4,7

Lambda Cookbook Develop code that uses Java SE 8 collection improvements, including Collection.removeIf(), List.replaceAll(), Map.computeIfAbsent(), and Map. computeIfPresent() methods

3

xxxiv 

Introduction

Exam Objective

Chapter

Develop code that uses Java SE 8 I/O improvements, including Files.find(), Files. walk(), and lines() methods

9

Use the merge() and flatMap() methods

3,4

Develop code that creates a stream by using the Arrays.stream() and IntStream. range() methods Method Enhancements Add static methods to interfaces

2

Define and use a default method of an interface and describe the inheritance rules for the default method

2

Use Java SE 8 Date/Time API Create and manage date- and time-based events, including a combination of date and time in a single object, by using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration

5

Work with dates and times across time zones and manage changes resulting from daylight savings, including Format date and times values

5

Define, create, and manage date- and time-based events using Instant, Period, Duration, and TemporalUnit

5

Upgrade from Java 6 or lower (1Z0–813) If you are studying for the 1Z0–813 exam, you must read Appendix C. It covers topics that are on your exam but not the other exams covered by the book. This table shows the chapter where each objective or sub-objective is covered for the upgrade exam from a Java 6 or lower certification to Java 8 OCP (1Z0–813). Exam Objective

Chapter

Language Enhancements Develop code that uses String objects in the switch statement, binary literals, and numeric literals, including underscores in literals

Appendix C

Develop code that uses try-with-resources statements, including using classes that implement the AutoCloseable interface

6

Introduction 

Exam Objective

xxxv

Chapter

Develop code that handles multiple Exception types in a single catch block 6 Use static and default methods of an interface including inheritance rules for a default method

2

Concurrency Use collections from the java.util.concurrent package with a focus on the advantages over and differences from the traditional java.util collections

7

Use Lock, ReadWriteLock, and ReentrantLock classes in the java.util. concurrent.locks and java.util.concurrent.atomic packages to support lock-free thread-safe programming on single variables

Appendix C

Use Executor, ExecutorService, Executors, Callable, and Future to execute tasks using thread pools

7

Use the parallel Fork/Join Framework

7

Localization Describe the advantages of localizing an application and developing code that defines, reads, and sets the locale with a Locale object

5

Build a resource bundle for a locale and call a resource bundle from an application

5

Create and manage date- and time-based events by using LocalDate, LocalTime, LocalDateTime, Instant, Period, and Duration, including a combination of date and time in a single object

5

Format dates, numbers, and currency values for localization with the NumberFormat and DateFormat classes, including number and date format patterns

5, Appendix C

Work with dates and times across time zones and manage changes resulting from daylight savings

5

Java File I/O (NIO.2) Operate on file and directory paths by using the Path class

9

Check, delete, copy, or move a file or directory by using the Files class

9

Recursively access a directory tree by using the DirectoryStream and FileVisitor interfaces

Appendix C

xxxvi 

Introduction

Exam Objective

Chapter

Find a file by using the PathMatcher interface, and use Java SE 8 I/O improvements, including Files.find(), Files.walk(), and lines() methods

9

Observe the changes in a directory by using the WatchService interface

Appendix C

Lambda Define and write functional interfaces and describe the interfaces of the java.util.function package

3,4

Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing

3,4

Develop code that uses the built-in interfaces included in the java.util. function package, such as Function, Consumer, Supplier, UnaryOperator, Predicate, and Optional APIs, including the primitive and binary variations of the interfaces

4

Develop code that uses a method reference, including refactoring a lambda expression to a method reference

3

Java Collections Develop code that uses diamond with generic declarations

Appendix C

Develop code that iterates a collection, filters a collection, and sorts a collection by using lambda expressions

3

Search for data by using methods, such as findFirst(), findAny(), anyMatch(), allMatch(), and noneMatch()

4

Perform calculations on Java Streams by using count, max, min, average, and sum methods and save results to a collection by using the collect method and Collector class, including the averagingDouble, groupingBy, joining, partitioningBy methods

4

Develop code that uses Java SE 8 collection improvements, including the Collection.removeIf(), List.replaceAll(), Map.computeIfAbsent(), and Map.computeIfPresent() methods

3

Develop code that uses the merge(), flatMap(), and map() methods on Java 4 Streams

Introduction 

Exam Objective

Chapter

Java Streams Describe the Stream interface and pipelines; create a stream by using the Arrays.stream() and IntStream.range() methods; identify the lambda operations that are lazy

4

Develop code that uses parallel streams, including decomposition operation and reduction operation in streams

7

xxxvii

xxxviii 

Assessment Test

Assessment Test 1. What is the result of executing the following application? (Choose all that apply.) import java.util.concurrent.*; import java.util.stream.*; public class BabyPandaBathManager { public static void await(CyclicBarrier cb) { try { cb.await(); } catch (InterruptedException | BrokenBarrierException e) { // Handle exception } } public static void main(String[] args) { final CyclicBarrier cb = new CyclicBarrier(3,()-> System.out.  println("Clean!"));// u1 ExecutorService service = Executors.newScheduledThreadPool(2); IntStream.iterate(1, i-> 1) // u2 .limit(12) .forEach(i-> service.submit( // u3 ()-> await(cb))); // u4 service.shutdown(); } }

A. B. C. D. E. F. G. H.

It outputs Clean! at least once. It outputs Clean! four times. The code will not compile because of line u1. The code will not compile because of line u2. The code will not compile because of line u3. The code will not compile because of line u4. It compiles but throws an exception at runtime. It compiles but waits forever at runtime.

2. What is the result of the following program? 1: 2: 3: 4:

public abstract class Message { public String recipient; public abstract final void sendMessage(); public static void main(String[] args) {

Assessment Test 

5: 6: 7: 8: 9: 10: 11: 12:

xxxix

Message m = new TextMessage(); m.recipient = "1234567890"; m.sendMessage(); } static class TextMessage extends Message { public final void sendMessage() { System.out.println("Text message to " + recipient); } } }

A. Text message to null. B. Text message to 1234567890. C. A compiler error occurs on line 1. D. A compiler error occurs on line 3. E. A compiler error occurs on line 7. F. A compiler error occurs on another line. 3. What is the result of executing the following code? (Choose all that apply.) 1: import java.io.*; 2: public class Tail {} 3: public class Bird implements Serializable { 4: private String name; 5: private transient int age; 6: private Tail tail; 7: 8: public String getName() { return name; } 9: public Tail getTail() { return tail; } 10: public void setName(String name) { this.name = name; } 11: public void setTail(Tail tail) { this.tail = tail; } 12: public int getAge() { return age; } 13: public void setAge(int age) { this.age = age; } 14: 15: public void main(String[] args) { 16: try(InputStream is = new ObjectInputStream( 17: new BufferedInputStream(new FileInputStream("birds.dat")))) { 18: Bird bird = is.readObject(); 19: } 20: } 21: }

xl 

Assessment Test

A. It compiles and runs without issue. B. The code will not compile because of line 3. C. The code will not compile because of line 5. D. The code will not compile because of lines 16–17. E. The code will not compile because of line 18. F. It compiles but throws an exception at runtime. 4. What is the result of the following class? 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15:

public class Box { T value; public Box(T value) { this.value = value; } public T getValue() { return value; } public static void main(String[] args) { Box one = new Box("a string"); Box two = new Box(123); System.out.print(one.getValue()); System.out.print(two.getValue()); } }

A. Compiler error on line 1. B. Compiler error on line 2. C. Compiler error on line 11. D. Compiler error on line 12. E. a string123 F. An exception is thrown. 5. What is the result of executing the following code snippet? List source = new ArrayList(Arrays.asList(1,2,3,4)); List fish = new CopyOnWriteArrayList(source); List mammals = Collections.synchronizedList(source); Set birds = new ConcurrentSkipListSet(); birds.addAll(source);   synchronized(new Integer(10)) { for(Integer f: fish) fish.add(4); // c1

Assessment Test 

xli

for(Integer m: mammals) mammals.add(4); // c2 for(Integer b: birds) birds.add(5); // c3 System.out.println(fish.size()+" "+mammals.size()+" "+birds.size()); }

A. It outputs 4 8 5. B. It outputs 8 4 5. C. It outputs 8 8 8. D. The code does not compile. E. It compiles but throws an exception at runtime on line c1. F. It compiles but throws an exception at runtime on line c2. G. It compiles but throws an exception at runtime on line c3. H. It compiles but enters an infinite loop at runtime. 6. What changes would need to be made to make the following immutable object pattern correct? (Choose all that apply.) import java.util.List; public class Duck { private String name; private List ducklings; public Duck(String name, List ducklings) { this.name = name; this.ducklings = new ArrayList(ducklings); } public String getName() { return name; } public List getDucklings() { return ducklings; } public String hasDucklings(Predicate p) { return p.test(this) ? "Quack Quack": ""; } }

A. None, the immutable object pattern is properly implemented. B. Mark name and ducklings final. C. Mark the Duck class final. D. Have Duck implement the Immutable interface. E. Remove the hasDucklings() method since any lambda expressions passed to it could modify the Duck object. F. Replace the getDucklings() with a method (or methods) that do not give the caller direct access to the List ducklings. G. Change the type of List to be List.

xlii 

Assessment Test

7. Assuming the current directory /bats/day and all of the files and directories referenced here exist and are available within the file system, what is the result of executing the following code? Path path1 = Paths.get("/bats/night","../").resolve(Paths.get( "./sleep.txt")).normalize(); Path path2 = new File("../sleep.txt").toPath().toRealPath(); System.out.print(Files.isSameFile(path1,path2)); System.out.print(" "+path1.equals(path2));

A. true true B. false false C. true false D. false true E. The code does not compile. F. The code compiles but throws an exception at runtime. 8. What statements are true about the following code? (Choose all that apply.) public class Tail {} public class Animal { public String name; } public class Canine extends Animal { public Tail tail; } public class Wolf extends Canine {}

A. Wolf has-a name. B. Wolf has-a Tail. C. Wolf is-a Tail. D. Wolf is-a Animal. E. Canine is-a Wolf. F. Animal has-a Tail. 9. Which of the following can fill in the blank? (Choose all that apply.) public void stmt(Connection conn, int a) throws SQLException { Statement stmt = conn.createStatement(a, __________________________); }

A. ResultSet.CONCUR_READ_ONLY B. ResultSet.CONCUR_INSERTABLE

Assessment Test 

xliii

C. ResultSet.CONCUR_UPDATABLE D. ResultSet.TYPE_FORWARD_ONLY E. ResultSet.TYPE_SCROLL_INSENSITIVE F. ResultSet.TYPE_SCROLL_SENSITIVE 10. Which of the following statements is true when the code is run with java AssertDemo? 1: 2: 3: 4: 5: 6: 7: 8:

public class AssertDemo { public static void main(String [] args) { Integer x = 10; x++; assert x == null && x >= 0; System.out.println(x); } }

A. Line 3 generates a compiler error. B. Line 4 generates a compiler error. C. Line 5 generates a compiler error. D. Line 5 throws an AssertionError at runtime. E. The output is 10. F. The output is 11. 11. Which of the following are true? (Choose all that apply.) private static void magic(Stream s) { Optional o = s.filter(x -> x < 5).limit(3).max((x, y) -> x—y); System.out.println(o.get()); }

A. magic(Stream.empty()); runs infinitely. B. magic(Stream.empty()); throws an exception. C. magic(Stream.iterate(1, x ->> x++)); runs infinitely. D. magic(Stream.iterate(1, x ->> x++)); throws an exception. E. magic(Stream.of(5, 10)); runs infinitely. F. magic(Stream.of(5, 10)); throws an exception. G. The method does not compile. 12. Suppose that we have the following property files and code. Which bundle is used on lines 7 and 8, respectively? Dolphins.properties name=The Dolphin

xliv 

Assessment Test

age=0   Dolphins_fr.properties name=Dolly   Dolphins_fr_CA.properties name=Dolly age=4   5: Locale fr = new Locale("fr"); 6: ResourceBundle b = ResourceBundle.getBundle("Dolphins", fr); 7: b.getString("name"); 8: b.getString("age");

A. Dolphins.properties and Dolphins.properties B. Dolphins.properties and Dolphins_fr.properties C. Dolphins_fr.properties and Dolphins_fr.properties D. Dolphins_fr.properties and Dolphins.properties E. Dolphins_fr.properties and Dolphins_fr_CA.properties F. Dolphins_fr_CA.properties and Dolphins_fr.properties 13. What is the result of executing the following code? (Choose all that apply.) String line; Console c = System.console(); if ((line = c.readLine()) != null) System.out.println(line);

A. The code runs without error but prints nothing. B. The code prints what was entered by the user. C. An ArrayIndexOutOfBoundsException might be thrown. D. A NullPointerException might be thrown. E. An IOException might be thrown. F. The code does not compile. 14. How many compilation issues are in the following code? 1: 2: 3: 4: 5:

public class Compiles { class RainException extends Exception {} public static void main(String[] args) { try(Scanner s = new Scanner("rain"); String line = "";) {

Assessment Test 

6: 7: 8: 9: 10:

if (s.nextLine().equals("rain")) throw new RainException(); } finally { s.close(); } } }

A. 0 B. 1 C. 2 D. 3 E. 4 F. 5 15. What is the result of the following code? 1: 2: 3: 4: 5: 6: 7: 8:

public class VisitPark { enum AnimalsInPark { SQUIRREL, CHIPMUNK, SPARROW; } public static void main(String[] args) { AnimalsInPark[] animals = AnimalsInPark.values(); System.out.println(animals[1]); } }

A. CHIPMUNK B. SQUIRREL C. The code compiles, but the output is indeterminate. D. A compiler error occurs on line 2. E. A compiler error occurs on line 6. F. A compiler error occurs on line 7. 16. Which of the answer choices is printed out by the following code? String d = Duration.ofDays(1).toString(); String p = Period.ofDays(1).toString();   boolean b1 = d == p; boolean b2 = d.equals(p); System.out.println(b1 + " " + b2);

A. false false B. false true

xlv

xlvi 

Assessment Test

C. true false D. true true E. The code does not compile. F. A runtime exception is thrown. 17. Assuming that the directory /gorilla exists within the file system with the numerous files including signed-words.txt, what is the result of executing the following code? (Choose all that apply.) Path path = Paths.get("/gorilla/signed-words.txt");   Files.find(path.getParent(),10.0, // k1 (Path p) -> p.toString().endsWith(".txt") && Files.isDirectory(p)) // k2 .collect(Collectors.toList()) .forEach(System.out::println);   Files.readAllLines(path) // k3 .flatMap(p -> Stream.of(p.split(" "))) // k4 .map(s -> s.toLowerCase()) // k5 .forEach(System.out::println);

A. The code compiles but does not produce any output at runtime. B. It does not compile because of line k1. C. It does not compile because of line k2. D. It does not compile because of line k3. E. It does not compile because of line k4. F. The code prints all of the .txt files in the directory tree. G. The code prints all of the words in the signed-words.txt file, each on a different line. 18. Which of the following statements can fill in the blank to make the code compile successfully? (Choose all that apply.) Set