What is the most used pattern in java.io?

Question

I was asked this question recently during my job interview, and I couldn't answer it. So, what is the most used pattern in java.io and how is it used? What are other patterns used in common java libraries?

Answer 1

BufferedReader etc implements decorator pattern. Any Reader, e.g. FileReader or StringReader, can be decorated with the buffering feature, which is really source-oblivious.

---

Other patterns

• java.util.Comparator<T> is a strategy pattern

---

Anti-patterns

To add to what others have said, these are several anti-patterns in the Java libraries:

Antipattern: inheritance instead of composition

From Effective Java 2nd Edition, Item 16: Favor composition over inheritance:

There are a number of obvious violations of this principle in the Java platform libraries. For example, a stack is not a vector, so Stack should not extend Vector. Similarly, a property list is not a hash table, so Properties should not extend Hashtable. In both cases, composition would have been preferable.

Related questions

• Prefer composition over inheritance?
• java inheritance versus composition (implementing a stack)
• Difference between Inheritance and Composition
• Inheritance or composition: Rely on “is-a” and “has-a”?
• Object Oriented Best Practices - Inheritance v Composition v Interfaces
• Should I use inheritance or composition?
• Inheritance vs. Aggregation
• Aggregation verses Composition
• Decorator Pattern Using Composition Instead of Inheritance

---

Antipattern: constant interfaces

From Effective Java 2nd Edition, Item 19: Use interfaces only to define types:

There are several constant interfaces in the Java platform libraries, such as java.io.ObjectStreamConstants. These interfaces should be regarded as anomalies and should not be emulated.

Related questions

• Should a class implement a constants-only interface?
• What is the best way to implement constants in Java ?

---

Antipattern: telescoping constructor and JavaBeans patterns

From Effective Java 2nd Edition, Item 2: Consider a builder when faced with many constructor parameters (excerpt online):

Traditionally, programmers have used the telescoping constructor pattern, in which you provide a constructor with only the required parameters, another with a single optional parameters, a third with two optional parameters, and so on [...] The telescoping constructor pattern works, but it is hard to write client code when there are many parameters, and harder still to write it.

A second alternative when you are faced with many constructor parameters is the JavaBeans pattern, in which you call a parameterless constructor to create the object, and then call setter methods to set each required parameter, and each optional parameter of interest. [...] Unfortunately the JavaBeans pattern has serious disadvantages of its own [...] a JavaBean may be in an inconsistent state partway through its construction [and it] precludes the possibility of making a class immutable.

Bloch recommends using a builder pattern instead.

Related questions

• Is this a well known design pattern? What is its name?
• What is the difference between Builder Design pattern and Factory Design pattern?
• When would you use the Builder Pattern?

Answer 2

I guess they wanted to hear about the Decorator pattern which can be found in the various Streams, Readers and Writers.

Other patterns (small selection):

• Observer pattern in the swing libraries
• Factory pattern in the javax.xml.parsers packages
• Iterator pattern, used in collections

I'm pretty sure that one can find examples for almost all patterns listed on this wikipedia page in the Java SDK.

Answer 3

The decorator pattern is often used in java i/o.

Example

BufferedReader br = new BufferedReader(new FileReader("filename.txt")); 

Answer 4

Decorator pattern, I think. To create all flavors of Readers, Writers, input and output streams. See this, for example.

Answer 5

Patterns used in java.io package.

1. Decorator_pattern.

   Examples:

   The abstract class java.io.FilterInputStream and its concrete subclasses : BufferedInputStream, CheckedInputStream etc

2. Abstract_factory_pattern and Factory_method_pattern patterns:

   Examples:

   The abstract class InputStream and its concrete sub classes: ByteArrayInputStream, FileInputStream, FilterInputStream etc.

   InputStream input = new FileInputStream("some_file.txt");
   

   Below classes enable unification of input from a byte-array, a file, a network connection, a persistent storage, a pipe, a string, etc:

   class java.io.InputStream 
         class java.io.ByteArrayInputStream 
         class java.io.FileInputStream 
         class java.io.FilterInputStream 
         class java.io.ObjectInputStream
         class java.io.PipedInputStream 
         class java.io.SequenceInputStream 
         class java.io.StringBufferInputStream
   

3. Adapter_pattern:

   Examples:

   java.io.InputStreamReader translates a byte stream into a character stream, and a java.io.OutputStreamWriter translates a character stream into a byte stream.

   You can find some more details in this article

4. Template_method_pattern (source: journaldev article)

   All non-abstract methods of java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer.

For all other patterns in java, refer to this post:

Examples of GoF Design Patterns in Java's core libraries