Dynamic Data Structures and Generics

1. Dynamic Data Structures and Generics Chapter 10

2. Outline • Vectors • Linked Data Structures • Introduction to Generics

3. 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.

4. 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.

5. Vectors: Outline • Introduction to Vectors • Using Vectors • Parameterized Classes and Generics

6. 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.

7. 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.)

8. 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.

9. 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.

10. 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);

11. 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);

12. 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();

13. 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);

14. 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();

15. 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);

16. Vector Demonstration

17. 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.

18. 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.

19. 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.

20. 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.

21. (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.

22. AbstractList class • Roughly equivalent to Vector except that it is unsynchronized. • More efficient in environments that synchronization are not required

23. Linked Data Structures: Outline • Linked Lists • Inner Classes • Node Inner Classes • Other Linked Data Structures

24. 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.

25. 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.

26. Linked Lists, cont.

27. 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.

28. Linked Lists, cont.

29. 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 ==.

30. A Linked List of Strings

31. Moving Down a Linked List

32. Adding a Node at the Start

33. A Linked List Demonstration

34. Advancing to the Next Node

35. Adding a Node

36. Deleting a Node

37. 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.

38. Inner Classes • An inner class is a class defined within another class. • An inner class provides a solution to the privacy leak problem.

39. Defining an Inner Class public class OuterClass { OuterClass_Instance_Variables OuterClass_Methods private class InnerClass { InnerClass_Instance_Variables InnerClass_Methods } }

40. 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.

41. 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.

42. Node Inner Classes, cont.

43. Node Inner Classes, cont. • class StringLinkedListSelfContained, cont.

44. 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

45. 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.

46. 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.

47. Generic Basics, cont. • class Sample<T>

48. 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.

49. 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);

50. Generic Basics, cont. • You cannot substitute a primitive type for a type parameter. • You must instead use a class type.