Dynamic Data Structures and Generics

Transcription

1 Dynamic Data Structures and Generics Chapter 10 Chapter 10 1

2 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. Chapter 10 4

3 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. Chapter 10 5

4 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 Chapter 10 6

5 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. Chapter 10 8

6 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.) Chapter 10 9

7 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. Chapter 10 10

8 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. Chapter 10 11

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

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

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

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

13 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(); Chapter 10 16

14 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); Chapter 10 17

15 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(); Chapter 10 18

16 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(); Chapter 10 19

17 Size and Capacity, cont. to set the size v.setsize(howmany); Chapter 10 20

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

19 Vector Demonstration class VectorDemo Chapter 10 22

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

21 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. Chapter 10 28

22 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. Chapter 10 30

23 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. Chapter 10 31

24 Linked Lists, cont. Chapter 10 32

25 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. Chapter 10 33

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

27 class ListNode Linked Lists, cont. Chapter 10 35

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

29 A Linked List of Strings class StringLinkedList Chapter 10 37

30 Moving Down a Linked List Chapter 10 38

31 Adding a Node at the Start Chapter 10 39

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

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

34 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. Chapter 10 50

35 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. Chapter 10 51

36 Node Inner Classes, cont. class StringLinkedListSelfContained Chapter 10 52

37 Node Inner Classes, cont. class StringLinkedListSelfContained, cont. Chapter 10 53

38 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. Chapter 10 54

39 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]; Chapter 10 55

40 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. Chapter 10 57

41 Advancing to the Next Node Chapter 10 61

42 Adding a Node Chapter 10 62

43 Deleting a Node Chapter 10 63

44 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. Chapter 10 69

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

46 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;... Chapter 10 71

47 Variations on a Linked List, cont. Chapter 10 72

48 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. Chapter 10 73

49 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. Chapter 10 75

50 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. Chapter 10 76

51 Generic Basics, cont. class Sample<T> Chapter 10 77

52 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. Chapter 10 78

53 Generic Basics, cont. example Sample<String> o1 = new Sample<String>(); o1.setdata( Hello ); Sample<Species> o2 = new Sample<Species>(); Species s = new Species(); <code to set the data for object s> o2.setdata(s); Chapter 10 79

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

55 Programming Example: A Generic Linked List class LinkedList<E> Chapter 10 81

56 Programming Example: A Generic Linked List, cont. class LinkedList<E>, cont. Chapter 10 82

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

58 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 Chapter 10 85