
- •Contents at a Glance
- •Contents
- •About the Authors
- •About the Technical Reviewer
- •Acknowledgments
- •Introduction
- •Oracle Java Certifications: Overview
- •FAQ 1. What are the different levels of Oracle Java certification exams?
- •FAQ 4. Is OCPJP 7 prerequisite for other Oracle certification exams?
- •FAQ 5. Should I take the OCPJP 7 or OCPJP 6 exam?
- •The OCPJP 7 Exam
- •FAQ 7. How many questions are there in the OCPJP 7 exam?
- •FAQ 8. What is the duration of the OCPJP 7 exam?
- •FAQ 9. What is the cost of the OCPJP 7 exam?
- •FAQ 10. What are the passing scores for the OCPJP 7 exam?
- •FAQ 11. What kinds of questions are asked in the OCPJP 7 exam?
- •FAQ 12. What does the OCPJP 7 exam test for?
- •FAQ 13. I’ve been a Java programmer for last five years. Do I have to prepare for the OCPJP 7 exam?
- •FAQ 14. How do I prepare for the OCPJP 7 exam?
- •FAQ 15. How do I know when I’m ready to take the OCPJP 7 exam?
- •Taking the OCPJP 7 Exam
- •FAQ 16. What are my options to register for the exam?
- •FAQ 17. How do I register for the exam, schedule a day and time for taking the exam, and appear for the exam?
- •The OCPJP 7 Exam: Pretest
- •Answers with Explanations
- •Post-Pretest Evaluation
- •Essentials of OOP
- •FunPaint Application: An Example
- •Foundations of OOP
- •Abstraction
- •Encapsulation
- •Inheritance
- •Polymorphism
- •Class Fundamentals
- •Object Creation
- •Constructors
- •Access Modifiers
- •Public Access Modifier
- •Private Access Modifier
- •Protected and Default Access Modifier
- •Overloading
- •Method Overloading
- •Constructor Overloading
- •Overload resolution
- •Points to Remember
- •Inheritance
- •Runtime Polymorphism
- •An Example
- •Overriding Issues
- •Overriding: Deeper Dive
- •Invoking Superclass Methods
- •Type Conversions
- •Upcasts and Downcasts
- •Casting Between Inconvertible Types
- •Using “instanceof” for Safe Downcasts
- •Java Packages
- •Working with Packages
- •Static Import
- •Summary
- •Abstract Classes
- •Points to Remember
- •Using the “final” Keyword
- •Final Classes
- •Final Methods and Variables
- •Points to Remember
- •Using the “static” Keyword
- •Static Block
- •Points to Remember
- •Flavors of Nested Classes
- •Static Nested Classes (or Interfaces)
- •Points to Remember
- •Inner Classes
- •Points to Remember
- •Local Inner Classes
- •Points to Remember
- •Anonymous Inner Classes
- •Points to Remember
- •Enum Data Types
- •Points to Remember
- •Summary
- •Interfaces
- •Declaring and Using Interfaces
- •Points to Remember
- •Abstract Classes vs. Interfaces
- •Choosing Between an Abstract Class and an Interface
- •Object Composition
- •Composition vs. Inheritance
- •Points to Remember
- •Design Patterns
- •The Singleton Design Pattern
- •Ensuring That Your Singleton Is Indeed a Singleton
- •The Factory Design Pattern
- •Differences Between Factory and Abstract Factory Design Patterns
- •The Data Access Object (DAO) Design Pattern
- •Points to Remember
- •Summary
- •Generics
- •Using Object Type and Type Safety
- •Using the Object Class vs. Generics
- •Container Implementation Using the Object Class
- •Container Implementation Using Generics
- •Creating Generic Classes
- •Diamond Syntax
- •Interoperability of Raw Types and Generic Types
- •Generic Methods
- •Generics and Subtyping
- •Wildcard Parameters
- •Limitations of Wildcards
- •Bounded Wildcards
- •Wildcards in the Collections Class
- •Points to Remember
- •The Collections Framework
- •Why Reusable Classes?
- •Basic Components of the Collections Framework
- •Abstract Classes and Interfaces
- •Concrete Classes
- •List Classes
- •ArrayList Class
- •The ListIterator Interface
- •The LinkedList Class
- •The Set Interface
- •The HashSet Class
- •The TreeSet Class
- •The Map Interface
- •The HashMap Class
- •Overriding the hashCode() Method
- •The NavigableMap Interface
- •The Queue Interface
- •The Deque Interface
- •Comparable and Comparator Interfaces
- •Algorithms (Collections Class)
- •The Arrays Class
- •Methods in the Arrays Class
- •Array as a List
- •Points to Remember
- •Summary
- •Generics
- •Collections Framework
- •Processing Strings
- •String Searching
- •The IndexOf() Method
- •The regionMatches() Method
- •String Parsing
- •String Conversions
- •The Split() Method
- •Regular Expressions
- •Understanding regex Symbols
- •Regex Support in Java
- •Searching and Parsing with regex
- •Replacing Strings with regex
- •String Formatting
- •Format Specifiers
- •Points to Remember
- •Summary
- •Reading and Writing from Console
- •Understanding the Console Class
- •Formatted I/O with the Console Class
- •Special Character Handling in the Console Class
- •Using Streams to Read and Write Files
- •Character Streams and Byte Streams
- •Character Streams
- •Reading Text Files
- •Reading and Writing Text Files
- •“Tokenizing” Text
- •Byte Streams
- •Reading a Byte Stream
- •Data Streams
- •Writing to and Reading from Object Streams: Serialization
- •Serialization: Some More Details
- •Points to Remember
- •Summary
- •A Quick History of I/O APIs
- •Using the Path Interface
- •Getting Path Information
- •Comparing Two Paths
- •Using the Files Class
- •Checking File Properties and Metadata
- •Copying a File
- •Moving a File
- •Deleting a File
- •Walking a File Tree
- •Revisiting File Copy
- •Finding a File
- •Watching a Directory for Changes
- •Points to Remember
- •Summary
- •Introduction to JDBC
- •The Architecture of JDBC
- •Two-Tier and Three-Tier JDBC Architecture
- •Types of JDBC Drivers
- •Setting Up the Database
- •Connecting to a Database Using a JDBC Driver
- •The Connection Interface
- •Connecting to the Database
- •Statement
- •ResultSet
- •Querying the Database
- •Updating the Database
- •Getting the Database Metadata
- •Points to Remember
- •Querying and Updating the Database
- •Performing Transactions
- •Rolling Back Database Operations
- •The RowSet Interface
- •Points to Remember
- •Summary
- •Define the Layout of the JDBC API
- •Connect to a Database by Using a JDBC driver
- •Update and Query a Database
- •Customize the Transaction Behavior of JDBC and Commit Transactions
- •Use the JDBC 4.1 RowSetProvider, RowSetFactory, and RowSet Interfaces
- •Introduction to Exception Handling
- •Throwing Exceptions
- •Unhandled Exceptions
- •Try and Catch Statements
- •Programmatically Accessing the Stack Trace
- •Multiple Catch Blocks
- •Multi-Catch Blocks
- •General Catch Handlers
- •Finally Blocks
- •Points to Remember
- •Try-with-Resources
- •Closing Multiple Resources
- •Points to Remember
- •Exception Types
- •The Exception Class
- •The RuntimeException Class
- •The Error Class
- •The Throws Clause
- •Method Overriding and the Throws Clause
- •Points to Remember
- •Custom Exceptions
- •Assertions
- •Assert Statement
- •How Not to Use Asserts
- •Summary
- •Introduction
- •Locales
- •The Locale Class
- •Getting Locale Details
- •Resource Bundles
- •Using PropertyResourceBundle
- •Using ListResourceBundle
- •Loading a Resource Bundle
- •Naming Convention for Resource Bundles
- •Formatting for Local Culture
- •The NumberFormat Class
- •The Currency Class
- •The DateFormat Class
- •The SimpleDateFormat Class
- •Points to Remember
- •Summary
- •Introduction to Concurrent Programming
- •Important Threading-Related Methods
- •Creating Threads
- •Extending the Thread Class
- •Implementing the Runnable Interface
- •The Start( ) and Run( ) Methods
- •Thread Name, Priority, and Group
- •Using the Thread.sleep() Method
- •Using Thread’s Join Method
- •Asynchronous Execution
- •The States of a Thread
- •Two States in “Runnable” State
- •Concurrent Access Problems
- •Data Races
- •Thread Synchronization
- •Synchronized Blocks
- •Synchronized Methods
- •Synchronized Blocks vs. Synchronized Methods
- •Deadlocks
- •Other Threading Problems
- •Livelocks
- •Lock Starvation
- •The Wait/Notify Mechanism
- •Let’s Solve a Problem
- •More Thread States
- •timed_waiting and blocked States
- •waiting State
- •Using Thread.State enum
- •Understanding IllegalThreadStateException
- •Summary
- •Using java.util.concurrent Collections
- •Semaphore
- •CountDownLatch
- •Exchanger
- •CyclicBarrier
- •Phaser
- •Concurrent Collections
- •Apply Atomic Variables and Locks
- •Atomic Variables
- •Locks
- •Conditions
- •Multiple Conditions on a Lock
- •Use Executors and ThreadPools
- •Executor
- •Callable, Executors, ExecutorService, ThreadPool, and Future
- •ThreadFactory
- •The ThreadLocalRandom Class
- •TimeUnit Enumeration
- •Use the Parallel Fork/Join Framework
- •Useful Classes of the Fork/Join Framework
- •Using the Fork/Join Framework
- •Points to Remember
- •Summary
- •Using java.util.concurrent Collections
- •Applying Atomic Variables and Locks
- •Using Executors and ThreadPools
- •Using the Parallel Fork/Join Framework
- •Chapter 3: Java Class Design
- •Chapter 4: Advanced Class Design
- •Chapter 5: Object-Oriented Design Principles
- •Chapter 6: Generics and Collections
- •Chapter 7: String Processing
- •Chapter 8: Java I/O Fundamentals
- •Chapter 9: Java File I/O (NIO.2)
- •Chapter 10: Building Database Applications with JDBC
- •Chapter 11: Exceptions and Assertions
- •Chapter 12: Localization
- •Chapter 13: Threads
- •Chapter 14: Concurrency
- •OCPJP7 Exam (1Z0-804 a.k.a. Java SE 7 Programmer II) Topics
- •OCPJP 7 Exam (1Z0-805, a.k.a. Upgrade to Java SE 7 Programmer) Topics
- •Answers and Explanations
- •Answer Sheet
- •Answers and Explanations
- •Index

Chapter 8
Java I/O Fundamentals
Read and write data from the console
Exam Topics
Use streams to read and write files
In this chapter, we’ll introduce you to the fundamentals of Java I/O programming. We’ll cover two topics: how to read and write data from console, and then how to use (file) streams to read and write data.
Programming with I/O involves writing some exception-handling code as well. If you’re not familiar with the basics of exception handling, such as how to use try-catch-finally blocks or try-with-resources statements, we
recommend that you to read the first three sections in the chapter on exception handling and assertions (Chapter 11) and then return to this chapter.
The support for file manipulation is provided in the java.io and java.nio packages. In the initial part of this chapter, we’ll focus only on the java.io package; later, we’ll focus on reading and writing data using streams (but none of the other features provided in the java.io package. The java.nio package provides comprehensive support for file I/O, and we cover it in Chapter 9). You can use printf-style formatting with the Console class, and this formatting API is covered in detail in Chapter 7.
Reading and Writing from Console
In this section, we’ll discuss reading and writing from the console.
Understanding the Console Class
Using the Console class (which was introduced in Java 1.6) will considerably simplify reading the data from the console and writing the data on the console. Note that the word “console” here refers to the character input device (typically
a keyboard), and the character display device (typically the screen display). You can obtain a reference to the console using the System.console() method; if the JVM is not associated with any console, this method will return null.
225
Chapter 8 ■ Java I/O Fundamentals
Your first exercise is to implement a simple Echo command that prints back the line of text typed as input when you run this program (Listing 8-1).
Listing 8-1. Echo.java
import java.io.Console;
// simple implementation of Echo command class Echo {
public static void main(String []args) { // get the System console object Console console = System.console(); if(console == null) {
System.err.println("Cannot retrive console object - are you running your application from an IDE? Exiting the application ... ");
System.exit(−1); // terminate the application
}
// read a line and print it through printf console.printf(console.readLine());
}
}
Here is how the program behaves for different output:
D:\>java Echo hello world hello world
D:\>java Echo ^Z
Exception in thread "main" java.lang.NullPointerException
at java.util.regex.Matcher.getTextLength(Matcher.java:1234)
... [this part of the stack trace elided to save space] at Echo.main(Echo.java:14)
For normal text input, this program works fine. If you type no input and try terminating the program with ^z or ^d (Ctrl+Z or Ctrl+D key combinations), then the program receives no input, so the readLine() method returns null; when printf takes a null argument, it throws a NullReferenceException.
Note that you ran this program from the command line. The method System.console() will succeed if the JVM is invoked from a command line without redirecting input or output streams since the JVM will be associated with a console (typically a keyboard and display screen). If the JVM is invoked indirectly by IDE, or if the JVM is invoked from a background process, then the method call System.console() will fail and return null. For example, Figure 8-1 shows what happened when we ran this program from the Eclipse IDE.
226

Chapter 8 ■ Java I/O Fundamentals
Figure 8-1. System.console() returns null when invoked from Eclipse IDE
In this case, the JVM is not associated with a console (like a command line) since it is invoked from an IDE, so the program failed.
If the JVM is invoked indirectly by IDE, or if the JVM is invoked from a background process, then the method call System.console() will fail and return null.
Some of the important methods available in the Console class are listed in Table 8-1.
Table 8-1. Important Methods in the Console Class |
|
|
|
Method |
Short description |
Reader reader() |
Returns the Reader object associated with this Console object; |
|
can perform read operations through this returned reference. |
PrintWriter writer() |
Returns the PrintReader object associated with this Console |
|
object; can perform write operations through this returned |
|
reference. |
String readLine() |
Reads a line of text String (and this returned string object does |
|
not include any line termination characters); returns null if it |
|
fails (e.g., the user pressed Ctrl+Z or Ctrl+D in the console) |
String readLine(String fmt, Object... args) |
Same as the readLine() method, but it first prints the string fmt. |
char[] readPassword() |
Reads a password text and returns as a char array; echoing is |
|
disabled with this method, so nothing will be displayed in the |
|
console when the password is typed by the user. |
char[] readPassword(String fmt, |
Same as the readPassword() method, but it first prints the |
Object... args) |
string given as the format string argument before reading the |
|
password string. |
Console format(String fmt, Object... args) |
Writes the formatted string (created based on values of fmt |
|
string and the args passed) to the console. |
Console printf(String fmt, Object... args) |
Writes the formatted string (created based on values of fmt |
|
string and the args passed) to the console. This printf method |
|
is the same as the format method: This is a “convenience |
|
method”—the method printf and the format specifiers |
|
are familiar to most C/C++ programmers, so this method is |
|
provided in addition to the format method. |
void flush() |
Flushes any of the data still remaining to be printed in the |
|
console object’s buffer. |
|
|
227
Chapter 8 ■ Java I/O Fundamentals
Formatted I/O with the Console Class
The Console class supports formatted I/O in the methods printf() and format() plus the overloaded methods of readPassword() and readLine(). We will not cover the printf() and format() methods in this chapter; they are covered in detail in the “String Formatting” section of Chapter 7.
In the methods readPassword() and readLine(), the first argument is the format specifier string, and the following arguments are the values that will be passed to the format specifier string. These two methods return the character data read from the console. What’s the difference between the readLine() and readPassword() methods? The main difference is that the readPassword() does not display the typed string in the console (for the obvious reason of not displaying the secret password), whereas readLine() displays the input you type in the console. Another minor difference is that the readLine() method returns a String whereas readPassword() returns a char array. See Listing 8-2.
Listing 8-2. Login.java
import java.io.Console; import java.util.Arrays;
// code to illustrate the use of readPassword method class Login {
public static void main(String []args) { Console console = System.console(); if(console != null) {
String userName = null; char[] password = null;
userName = console.readLine("Enter your username: ");
//typed characters for password will not be displayed in the screen password = console.readPassword("Enter password: ");
//password is a char[]: convert it to a String first before comparing contents if(userName.equals("scrat") && new String(password).equals("nuts")) {
//we're hardcoding username and password here for
//illustration, don't do such hardcoding in pratice! console.printf("login successful!");
}
else {
console.printf("restart application and try again");
}
// "empty" the password since its use is over Arrays.fill(password, ' ');
}
}
}
Here is an instance of running this program typing the correct username and password:
D:\>java Login
Enter your username: scrat Enter password:
login successful!
228