Download Chapter 10 Dynamic Data Structures and Generics

Dynamic Data Structures and
Generics
Chapter 10
Outline
• Vectors
• Linked Data Structures
• Introduction to Generics
Introduction
• A data structure is a construct used to
organize data in a specific way.
• An array is a static data structure.
• Dynamic data structures can grow and shrink
while a program is running.
• Vectors and linked data structures are
dynamic.
• Vectors are similar to arrays, but offer more
flexibility.
Introduction, cont.
• The linked list is a simple but useful linked
data structure that makes use of inner
classes.
• An inner class is a class definition within
another class definition.
• Java 5.0 allows definitions with parameters
for types.
• These definitions are known as generics.
Vectors: Outline
• Introduction to Vectors
• Using Vectors
• Parameterized Classes and Generics
Introduction to Vectors
• We can think of vectors as arrays that grow
and shrink while a program is running.
• At the time an array is created, its length is
fixed.
– Sometimes an array turns out to be too
small for its intended use.
– Sometimes an array turns out to be too
large for its intended use, but the unused
portion of the array is not available for
other purposes.
Introduction to Vectors, cont.
• Vectors serve the same purposes as arrays,
but can change in length while a program is
running.
• This added flexibility comes at a price:
– Vectors are less efficient than arrays.
– The base type of a vector must be a class
type rather than a primitive type.
(Automatic boxing and unboxing make this
requirement less significant.)
Using Vectors
• The definition of class Vector must be
imported.
import java.util.*;
• to create and name a vector
vector<String> v = new Vector<String>(20);
– The vector v stores objects of class String
and has an initial capacity of 20.
Using Vectors, cont.
– When more capacity is needed, the system
allocates more memory automatically.
– If the initial capacity was sufficient, the
code is more efficient.
• In this example, the base type is type String.
– Any class can be used as the base type.
– But, wrapper classes must be used for
primitive types.
Creating and Naming a Vector
• syntax
Vector<Base_Type> v1 = new
Vector<Base_Type>();
Vector<Base_Type> v2 = new
Vector<Base_Type>(Initial_Capacity);
Vector<Base_Type> v2 = new
Vector<Base_Type>(Initial_Capacity,
Capacity_Increment);
Adding, Getting, and Setting
Values
• to add an element
v.addElement(“Hello!);
• to get the value of an element
String temp = v.elementAt(index);
• to change the value of an existing element
v.setElementAt(“Hi, Mom!”, index);
Inserting and Removing
Values
• to insert an element
v.insertElementAt(“Good-bye”, position);
– elements at index position or higher move
to index positions greater by one.
• to remove an element from a position
v.removeElementAt(postion);
• to remove the first occurrence of an element
boolean done = v.removeElement(“Hello!”);
• to remove all elements
v.removeAllElements();
Searching a Vector
• to learn if an element is in the vector
boolean found = v.contains(“Good-bye”);
• to learn the location of the first occurrence of
an element
int position = v.indexOf(“Hi, Mom!”);
• to learn the location of the first occurrence of
an element at or after a position
int position = v.indexOf(“Hello”,
startFrom);
Searching a Vector, cont.
• to learn the location of the last occurrence of
an element
int position =
v.lastIndexOf(“Hi, Mom!”);
• to learn the value of the first element
String first = v.firstElement();
• to learn the value of the last element
String first = v.lastElement();
Size and Capacity
• to learn if the vector is empty
boolean none = v.isEmpty();
• to learn the size of the vector
int howMany = v.size();
• to learn the current capacity
int howBig = v.capacity();
• to make room for more elements
v.ensureCapacity(moreElements);
• to trim to the current size
v.trimToSize();
• to set the size
v.setSize(howMany);
Vector Demonstration
Using Method clone
• When used with a vector, the assignment
statement creates another reference to the
same vector.
• To make a copy of a vector, use
otherV = (Vector<String>)v.clone();
using a correct type cast.
• On the other hand
Vector otherV = v.clone(); //ILLEGAL
will produce an error message.
Using Method clone, cont.
• Accessor methods should not return a private
instance variable of type Vector.
• Accessor methods should return a copy of the
vector, not the private instance vector itself.
• Method clone can be used to produce a copy
of the private instance vector.
Using Method clone, cont.
• However, the return type of method clone is
Object.
• Hence, the appropriate form is
public Vector<String> getVector()
{
return (Vector<String>)v.clone();
}
• Any objects stored in the vector also must
have appropriate accessor methods.
Parameterized Classes and
Generics
• The class Vector is a parameterized class.
• Its parameter, denoted Base_Type, can be
replaced by any class type.
• Java 5.0 allows definitions, called generic
definitions or simply generics, with
parameters for types.
(optional) Newer Collection
Classes
• A new group of classes implement the
Collection interface.
– These classes are known as collection
classes.
• The Vector definition has been retrofitted to be
a collection class.
AbstractList class
• Roughly equivalent to Vector except
that it is unsynchronized.
– More efficient in environments that
synchronization are not required
Linked Data Structures:
Outline
•
•
•
•
Linked Lists
Inner Classes
Node Inner Classes
Other Linked Data Structures
Introduction to Linked Data
Structures
• A linked data structure is a collection of
objects (called nodes), each containing data
and a (potential) reference to (at least) one
other node.
Linked Lists
• The predefined LinkedList class is part of the
java.util package.
• Nevertheless, to learn how linked data
structures work, we’ll construct a simplified
example of a linked list.
Linked Lists, cont.
Linked Lists, cont.
• Links, shown as arrows in the previous
diagram, are implemented as references and
are instance variables of the node type.
• The reference marked head is a variable of the
node type which provides access to the first
node in the linked list, but is not itself one of
the nodes.
• Each node is an object of a class that has (at
least) two instance variables:
– the data
– the link.
Linked Lists, cont.
Detecting the Last Node
• There must be means for detecting the last
node.
• A link instance variable with the value null
indicates the last node.
• A reference to the linked list with the value
null indicates an empty linked list.
• The value of the link instance variable is
tested using ==.
A Linked List of Strings
Moving Down a Linked List
Adding a Node at the Start
A Linked List Demonstration
Advancing to the Next Node
Adding a Node
Deleting a Node
Privacy Leaks
• A method such as getLink in class ListNode
returns an instance variable which is a
reference to a node, potentially defeating the
private restriction of the instance variable.
• This problem can be remedied by making
class ListNode a private inner class of class
StringLinkedList.
Inner Classes
• An inner class is a class defined within
another class.
• An inner class provides a solution to the
privacy leak problem.
Defining an Inner Class
public class OuterClass
{
OuterClass_Instance_Variables
OuterClass_Methods
private class InnerClass
{
InnerClass_Instance_Variables
InnerClass_Methods
}
}
Access to Members
• The inner and outer classes’ methods have
access to each other’s methods and instance
variables, even when they are declared
private.
Node Inner Classes
• By making the node class an inner class, data
structure classes become self-contained.
• Further, the accessor and mutator methods of
the inner class can be eliminated since
instance variables of an inner class are
accessible directly.
Node Inner Classes, cont.
Node Inner Classes, cont.
• class StringLinkedListSelfContained, cont.
Other Linked Data Structures
• Many colleges and universities offer a course
devoted entirely to the study of data
structures.
• Typically, a data structure can be
implemented by “linking” its elements
together.
• Example data structures include stacks,
queues, deques, trees, binary trees, graphs,
and directed graphs.
– Refer java.util package
Introduction to Generics
• Java 5.0 allows definitions, called generics,
that include parameters for types.
• Generics can be subtle and full of pitfalls.
• We provide an introduction to generics.
• Serious programming with generics is
presented in more advanced texts.
Generic Basics
• Classes and methods can have a type
parameter.
• Any class type can be substituted for the type
parameter, producing a specific class type or
method.
Generic Basics, cont.
• class Sample<T>
Generic Basics, cont.
• A class definition with a type parameter is
stored in a file and compiled just like any
other class.
• When used in code a class type must be
specified so that it can be substituted for the
type parameter.
Generic Basics, cont.
• example
Sample<String> 01 = new Sample<String>();
o1. setData(“Hello”);
Sample<Species> ow = new Sample<Species>();
Species x = new Species();
<code to set the data for object s>
o2.setData(s);
Generic Basics, cont.
• You cannot substitute a primitive type for a
type parameter.
• You must instead use a class type.
Programming Example: A
Generic Linked List
Programming Example: A
Generic Linked List, cont.
Programming Example: A
Generic Linked List, cont.
Programming Example: A
Generic Linked List, cont.
Generic Constructor
• The class name in a parameterized class
definition has a type parameter attached.
• But, a generic constructor name has no type
parameter and the type parameter is not used
in the heading of the constructor definition.
public LinkedList()
not
public LinkedList<e>() // ILLEGAL
Limited Use of the Type
Parameter
• Within the definition of a parameterized class
definition, there are places where a type
name is allowed, but a type parameter is not
allowed.
• Type parameters cannot be used in simple
expressions that use new to create a new
object.
Limited Use of the Type
Parameter
• examples
T object = new T(); // ILLEGAL
T[] a = new T[10]; // ILLEGAL
– In both cases, the first T is legal, but the
second T is illegal.
Summary
• You have become familiar with vectors.
• You have learned about linked data
structures in Java.
• You have learned how to manipulate linked
lists.
• You have learned about generics
(parameters for types).