1. Chapter 101 Dynamic Data Structures and Generics Chapter 10

2. 2 Objectives become familiar with vectors learn about linked data structures in Java learn how to manipulate linked lists learn to use inner classes in defining linked data structures learn about iterators learn about generics (parameters for types)

3. Chapter 103 Outline Vectors Linked Data Structures Introduction to Generics (optional) Graphics Supplement

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

5. Chapter 105 Introduction, cont. Vectors are similar to arrays, but offer more flexibility. 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.

6. Chapter 106 Introduction, cont. Java 5.0 allows definitions with parameters for types. These definitions are known as generics. int[] scores = new int[100]; … scores = new int[200]; Does NOT add 100 new locations to scores! It creates a new array of 200 locations and the old array becomes garbage 

7. Chapter 107 Vectors: Outline Introduction to Vectors Using Vectors Parameterized Classes and Generics

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

9. Chapter 109 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 than it used to be.)

10. Chapter 1010 Using Vectors The definition of class Vector must be imported. import java.util.*; to create and name a vector Vector v = new Vector (20); –The vector v stores objects of class String and has an initial capacity of 20.

11. Chapter 1011 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.

12. Chapter 1012 Creating and Naming a Vector syntax Vector v1 = new Vector ();// capacity=10, doubles Vector v2 = new Vector (n);// capacity=n, doubles Vector v3 = new Vector (n,p); //capacity=n, increases by p

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

14. Chapter 1014 Size and Indices to learn the size of the vector int howMany = v.size(); The indices range from 0 to v.size()-1.

15. Chapter 1015 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(position);

16. Chapter 1016 Inserting and Removing Values, cont. to remove the first occurrence of an element v.removeElement(“Hello!”); to remove element at index i v.removeElementAt(i); to remove all elements v.removeAllElements();

17. Chapter 1017 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 location = v.indexOf(“Hi, Mom!”); to learn the location of the first occurrence of an element at or after a position int location = v.indexOf(“Hello”, position);

18. Chapter 1018 Searching a Vector, cont. to learn the location of the last occurrence of an element int location = 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 last = v.lastElement();

19. Chapter 1019 Size and Capacity to learn if the vector is empty boolean none = v.isEmpty(); 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();

20. Chapter 1020 Size and Capacity, cont. to set the size v.setSize(howMany);

21. Chapter 1021 Copying and Determining Equality to make a copy Vector w = v.clone(); to test for equality boolean same = v.equals(w);

22. Chapter 1022 Vector Demonstration class VectorDemo

23. Chapter 1023 Vector Demonstration, cont.

24. Chapter 1024 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 )v.clone(); using a correct type cast. On the other hand Vector otherV = v.clone(); //ILLEGAL will produce an error message.

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

26. Chapter 1026 Using Method clone, cont. However, the return type of method clone is Object. Hence, the appropriate form is public Vector getVector() { return (Vector )v.clone(); } Any objects stored in the vector also must have appropriate accessor methods.

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

28. Chapter 1028 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.

29. Chapter 1029 Linked Data Structures: Outline Linked Lists Inner Classes Node Inner Classes Iterators Exception Handling with Linked Lists Variations on a Linked List Other Linked Data Structures

30. Chapter 1030 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.

31. Chapter 1031 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.

32. Chapter 1032 Linked Lists, cont.

33. Chapter 1033 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.

34. Chapter 1034 Linked Lists, cont. Each node is an object of a class that has (at least) two instance variables: –the data –the link.

35. Chapter 1035 Linked Lists, cont. class ListNode

36. Chapter 1036 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 ==.

37. Chapter 1037 A Linked List of Strings class StringLinkedList

38. Chapter 1038 Moving Down a Linked List

39. Chapter 1039 Adding a Node at the Start

40. Chapter 1040 A Linked List Demonstration class LinkedListDemo

41. Chapter 1041 A Linked List Demonstration, cont.

42. Chapter 1042 Null Pointer Exception The message NullPointerException indicates that access has been attempted using a class variable that names no object. A reference value of null means that no object is named by the reference. A NullPointerException does not need to be caught or declared in a throws clause. Instead, it indicates that the code needs to be fixed.

43. Chapter 1043 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.

44. Chapter 1044 Privacy Leaks, cont. class ListNode

45. Chapter 1045 Privacy Leaks, cont. This problem can be remedied by making class ListNode a private inner class of class StringLinkedList.

46. Chapter 1046 Privacy Leaks, cont. A method such as getData in class ListNode (page 754) does not create a privacy leak because, unlike almost any other class, class String has no methods that change the value of the string without changing the reference. Method Find (page ???) does not create a privacy leak because it is a private method.

47. Chapter 1047 Privacy Leaks, cont. class ListNode

48. Chapter 1048 Inner Classes An inner class is a class defined within another class.

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

50. Chapter 1050 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.

51. Chapter 1051 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.

52. Chapter 1052 Node Inner Classes, cont. class StringLinkedListSelfContained

53. Chapter 1053 Node Inner Classes, cont. class StringLinkedListSelfContained, cont.

54. Chapter 1054 Iterators With a collection of objects, such as the nodes of a linked list, we often need to “step through” all the objects to perform some action on each object. An iterator allows us to “step through” a collection of objects.

55. Chapter 1055 Iterators, cont. The loop control variable of a for loop functions as an iterator for an array. for (int i = 0; i < a.length, i++) process a[i];

56. Chapter 1056 Iterators, cont. method arrayCopy()

57. Chapter 1057 Iterators, cont. Similarly, an instance variable capable of referencing a node, can serve the same purpose as the loop control variable in a for loop. Another instance variable capable of referencing a node can “follow behind” to provide access to the previous node.

58. Chapter 1058 Iterators, cont. class StringLinkedListWithIterator

59. Chapter 1059 Iterators, cont. class StringLinkedListWithIterator, cont.

60. Chapter 1060 Iterators, cont. class StringLinkedListWithIterator, cont.

61. Chapter 1061 Advancing to the Next Node

62. Chapter 1062 Adding a Node

63. Chapter 1063 Deleting a Node

64. Chapter 1064 A Linked List Can Be Its Own Iterator Often we want the iterator of a linked list to be an object of some sort. The same linked-list object can be used as the linked list and as the iterator.

65. Chapter 1065 Internal and External Iterators An iterator defined within a linked-list class is an internal iterator. When the elements of a linked list are copied into an array and iterated using the loop control variable of the array, the loop control variable is an external iterator because the iterator is outside the linked list.

66. Chapter 1066 Exception Handling with Linked Lists Occasionally, we do not want to end a program that uses a linked list when something unusual happens. In these rare cases, an exception can be thrown and handled appropriately.

67. Chapter 1067 Exception Handling with Linked Lists, cont. method goToNext

68. Chapter 1068 Exception Handling with Linked Lists, cont. Class LinkedListException

69. Chapter 1069 Variations on a Linked List A reference to the last node in a linked list can be useful. … public ListNode head; public ListNode tail; … A linked list can contain (or reference) any kind of data.

70. Chapter 1070 Variations on a Linked List, cont. A linked list can contain different kinds of objects private class ListNode { private Object data; private ListNode link;... }

71. Chapter 1071 Variations on a Linked List, cont. An additional reference can be added to reference the previous node, producing a doubly-linked list. private class ListNode { private Object data; private ListNode next; private ListNode previous;... }

72. Chapter 1072 Variations on a Linked List, cont.

73. Chapter 1073 Variations on a Linked List, cont. The last node in a singly-linked list can reference the first node, producing a circularly-linked list. The last node in a doubly-linked list can reference the first node with its next reference, and the first node can reference the last node with its previous reference, producing a doubly-circularly-linked list.

74. Chapter 1074 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.

75. Chapter 1075 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.

76. Chapter 1076 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.

77. Chapter 1077 class Sample Generic Basics, cont.

78. Chapter 1078 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.

79. Chapter 1079 Generic Basics, cont. example Sample o1 = new Sample (); o1.setData(“Hello”); Sample o2 = new Sample (); Species s = new Species(); o2.setData(s);

80. Chapter 1080 Generic Basics, cont. You cannot substitute a primitive type for a type parameter. You must instead use a class type.

81. Chapter 1081 Programming Example: A Generic Linked List class LinkedList

82. Chapter 1082 Programming Example: A Generic Linked List, cont. class LinkedList, cont.

83. Chapter 1083 Programming Example: A Generic Linked List, cont. class GenericDemo

84. Chapter 1084 Programming Example: A Generic Linked List, cont.

85. Chapter 1085 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 () // ILLEGAL

86. Chapter 1086 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.

87. Chapter 1087 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.

88. Chapter 1088 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 to use inner classes in defining linked data structures

89. Chapter 1089 Summary, cont. You have learned about iterators. You have learned about generics (parameters for types).