JavaData Structures in Java: Part 2, What Is a Collection?

Data Structures in Java: Part 2, What Is a Collection? content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

Java Programming, Lecture Notes #1352


This is the second lesson in a miniseries on Java data structures and the
Java Collections Framework.  The first lesson in the miniseries was
entitled Data
Structures in Java: Part 1, Getting Started

The purpose of this miniseries is to help you learn the essential features
of Object-Oriented data structures in Java using the Collections Framework.

Supplementary material

I recommend that you also study the other lessons in my extensive collection
of online Java tutorials.  You will find those lessons published at
However, as of the date of this writing, Gamelan doesn’t maintain a consolidated
index of my Java tutorial lessons, and sometimes they are difficult to
locate there.  You will find a consolidated index at
Java Programming Tutorials

The index on my site provides links to the lessons


Collection is not only the name of a Java interface,
it is also the term given to an object that groups multiple elements into
a single unit.

In this lesson, I will discuss how elements are
stored in a collection, and why it is often necessary to use a downcast
when retrieving and processing those elements.

I will discuss the advantages of passing collections
between methods as type Collection.

I will summarize the core interfaces in the Collections
Framework and show you how they are related.

I will very briefly discuss the concrete implementations
of the interfaces that are provided by the framework. (I will discuss
those implementations in much more detail in subsequent lessons.)

And finally, I will introduce you to the three
kinds of things that are part of a collections framework.


The previous lesson, entitled Data
Structures in Java: Part 1, Getting Started
introduced you to the use of the Java Collections Framework for building
and using data structures.  This lesson will continue down that path.


What is a collection?

Just to see if you are awake today, let’s start with a little quiz.

What is a collection insofar as Java programming is concerned?

  • A.  Something they gather in plates at church.
  • B.  An object that groups multiple elements into a single unit.
  • C.  The name of a Java interface.
  • D.  None of the above.

If you answered A, you are probably reading an article on the wrong website
by mistake.  If you answered Both B and C, then you are off
to a very good start on today’s lesson.

Collection is the name of a Java interface.  This interface
is an integral part of the Java Collections Framework.  In fact, as
of JDK 1.3, it is one of two top-level interfaces in the framework. 
The other top-level interface in the framework is named Map.

According to The Java Tutorial from Sun, a collection (sometimes
called a container)
is also an object that groups multiple elements
into a single unit.

Typical collection objects might contain information about employees
in the company telephone book, all the purchase orders issued during the
past year, or the transactions occurring in a person’s checking account.

Slightly different terminology

Note that this terminology may be somewhat different from what you are
accustomed to.  For example, if you speak of your coin collection,
you are probably speaking about the actual coins rather than the container
that holds the coins.

This is an important distinction.  The usage of the term collection
in the Collection Framework usually refers to the container and not to
the contents of the container.  In the framework, the contents are
usually referred to as elements.

Store references rather than objects

The collections in the framework always store references to objects,
rather than storing the objects themselves.  One consequence of this
is that primitive values cannot be stored in a collection without first
encapsulating them in an object. (Standard wrapper classes are provided
for encapsulating all primitive types.)

Stored as type Object

Furthermore, the references are always stored as type Object
Thus, when you retrieve an element from a collection, you frequently need
to downcast it before you can gain access to the members of the object
to which the reference refers.

Moving data among methods

In addition to their use for storing, retrieving, and manipulating data,
collections are also used to move data among methods.

One of the primary advantages of the Collections Framework is the ability
to pass a collection to a method as the generic interface type Collection
The receiving method doesn’t need to know the actual type of the object
referred to by the incoming reference in order to invoke its methods.

Polymorphic behavior

The receiving method can invoke (on the reference to the Collection
any of the methods declared in the Collection interface,
with confidence that the behavior of the method will be appropriate for
the actual type of Collection object involved.  (That is
polymorphic behavior.)

Core collection interfaces

If you have been working with the framework, you might be inclined to
think that all of the interfaces in the following list are members of the
core collection interfaces.

  • Collection
  • Set
  • List
  • SortedSet
  • Map
  • SortedMap
  • Iterator

However, that is not the case.

While the Iterator interface is heavily
used in conjunction with collections, according to The Java Tutorial
from Sun, it is not one of the core collection interfaces.

The core collection interfaces identified by the
Sun book are shown below, with indentation showing the superinterface-subinterface
relationships among the interfaces.

  • Collection
    • Set
      • SortedSet
    • List
  • Map
    • SortedMap

As you can see, as mentioned earlier, Collection and Map
are the two top-level interfaces.

You should probably commit the above list of interfaces and their relationships
to memory.  You might find that helpful when navigating the Sun documentation.

Concrete implementations

In addition to interfaces, the framework provides several concrete implementations
of the interfaces defined in the framework.  (A concrete implementation
is a class that implements one or more of the interfaces.)

Are you still awake?  If so, see if you can answer the following

True or False?  Each of the following classes provides an implementation
of one of the interfaces that make up the Java Collections Framework. 
If False, which items don’t belong in the list.

  • AbstractSet
  • AbstractList
  • AbstractMap
  • HashSet
  • TreeSet
  • LinkedList
  • Vector
  • ArrayList
  • HashMap
  • Hashtable
  • WeakHashMap
  • TreeMap
  • Iterator
  • Attributes
  • RenderingHints

Hopefully your answer was False, but even so, that isn’t the complete answer.

Iterator is not a class

To begin with, Iterator is not a
class.  I told you that a couple of paragraphs back.  It is an
interface.  Therefore, it has no place on the above list of classes.

What about Attributes and RenderingHints?

You may also have wondered if the classes named
and RenderingHints belong on the list.  Note that I didn’t
restrict the above list to only those classes that might be considered
part of the framework, so this was sort of a trick question.  (Of
course you could have looked them up in the Sun documentation just like
I did.)

While these two classes are not really a part of the core Java Collections
Framework, they do implement interfaces that are part of the framework.

The RenderingHints class implements the Map interface
and is used in conjunction with the Graphics2D class.  The
Attributes class also implements the Map interface

What is a Collections Framework?

According to The Java Tutorial from Sun, “A collections framework
is a unified architecture for representing and manipulating collections.
All collections frameworks contain three things.”

Those three things are:

  • Interfaces
  • Implementations
  • Algorithms

This is probably a good place to close off the discussion for this lesson. 
The next lesson will take up at this point, providing a more in-depth discussion
of the interfaces, implementations, and algorithms that make up the framework.


I started out by telling you that a collection is not only the name of
a Java interface (Collection) but is also an object that groups
multiple elements into a single unit.

Java Collection objects don’t store objects or primitive values
directly.  Rather, they store references to objects.  Further,
all such references are stored as the type Object.  This often
leads to the later need to downcast the reference in order to gain access
to the members of the object to which it refers.

If you need to store primitive values in a collection, you will first
need to wrap those values in appropriate objects.  Standard wrapper
classes are provided for all the primitive types.

Collections are not only useful for storing and retrieving data, they
are also useful for moving data among methods.

Because a collection can be passed to a method as type Collection,
all of the methods declared in the Collection interface can be invoked
on the incoming reference in a polymorphic manner.

In addition to the interfaces defined in the Collections Framework,
the framework also provides various concrete implementations of the interfaces
for most of the commonly-used data structures.  This makes it possible
for you to conveniently use the framework without the requirement to define
new Collection classes.

As of JDK 1.3, there are six core interfaces in the framework. 
Although the Iterator interface is often used with collections,
it is not one of the core interfaces.

I ended the lesson by telling you that there are basically three things
in a collections framework:  interfaces, implementations, and algorithms.

What’s Next?

In the next lesson, I will

  • Discuss the purpose of interfaces, implementations, and algorithms in a
    collections framework
  • Provide some additional discussion about polymorphic behavior in the Java
    Collections Framework
  • Discuss some of the advantages of using the framework to satisfy your need
    for data structures.

About the author

Richard Baldwin
is a college professor and private consultant whose primary focus is a
combination of Java and XML. In addition to the many platform-independent
benefits of Java applications, he believes that a combination of Java and
XML will become the primary driving force in the delivery of structured
information on the Web.

Richard has participated in numerous consulting projects involving
Java, XML, or a combination of the two.  He frequently provides onsite
Java and/or XML training at the high-tech companies located in and around
Austin, Texas.  He is the author of Baldwin’s Java Programming Tutorials,
which has gained a worldwide following among experienced and aspiring Java
programmers. He has also published articles on Java Programming in Java
Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and
has many years of experience in the application of computer technology
to real-world problems.

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories