View
219
Download
0
Tags:
Embed Size (px)
Citation preview
Dynamic Data Structures and GenericsRecitation – 11/(14,15)/2008
CS 180
Department of Computer Science,
Purdue University
Announcements Project 7: Final Due Wed, Nov. 19 at 10 pm Start early, prefix/jumble search are non-
trivial Mid Term 2 papers ready!! Project 5 grades ready!!
Array List
ArrayList is a class in the standard Java libraries
A dynamically re-sizeable array, so that the total number of elements does not need to be known when created
stores a collection of any type of object
must be all the same type
Array List Why not always use an ArrayList
instead of an array?
1. An ArrayList is less efficient than an array
2. It does not have the convenient square bracket notation.
3. The base type of an ArrayList must be a class type (or other reference type): it cannot be a primitive type.
ArrayList<BaseType> aList = new ArrayList<BaseType>();
Array Lists The following code creates an ArrayList that stores
objects of the base type String with an initial capacity of 20 items:
ArrayList<String> myList = new ArrayList<String>(20);
Specifying an initial capacity does not limit the size to which an ArrayList can eventually grow
Add an Element in ArrayList Add at a specified index
myList.add(2, “Doc”); Add at the end
myList.add(“Dopey”);
Array List Methods The size method is used to find out how
many indices already have elements in the ArrayList
int howMany = myList.size();
The set method is used to replace any existing element, and the get method is used to access the value of any existing element
myList.set(index, "something else");String thing = myList.get(index);
Iterators Iterators provide a general way to traverse
all elements in a collection
ArrayList<String> list = new ArrayList<String>();
list.add("1-FiRsT"); list.add("2-SeCoND"); list.add("3-ThIrD"); Iterator<String> itr = list.iterator(); while (itr.hasNext()) { System.out.println(itr.next().toLowerCase()); }
Linked Data Structures The ArrayList: add and remove methods
operate in linear time because they require a loop to shift elements in the underlying array This is due to contiguous storage in memory.
Linked list overcomes this: Each node in a linked list stores information
and a link to the next node ( and optionally previous node)
This provides the ability to add or remove items anywhere in the list in constant time
Linked List A linked list consists of:
A sequence of nodes
Header
a b c d
Each node contains a value and a link (pointer or reference) to some other node
The last node contains a null link
The list may have a header
Linked List Terminology A node’s successor is the next node in the
sequence The last node has no successor
A node’s predecessor is the previous node in the sequence The first node has no predecessor
A list’s length is the number of elements in it A list may be empty (contain no elements)
Single Linked List in Java
44 97 23 17
myList:
class Node { int value; Node next; Node (int v, Node n) { // constructor
value = v; next = n;}
}
Node n1 = new Node(17, null); Node n2 = new Node(23, n1); Node n3 = new Node(97, n2); Node myList = new Node(44, n3);
Inserting a node in Linked List
321
numerals
2.5node
Find the node you want to insert afterFirst, copy the link from the node that's already in the list
Then, change the link in the node that's already in the list
Delete a Node in Linked List
• To delete the first element, change the link in the header
321
numerals
• To delete some other element, change the link in its predecessor
321
numerals
• Deleted nodes will eventually be garbage collected
Doubly-linked lists
Here is a doubly-linked list (DLL):
Header
null a c nulldb
Each node contains a value, a link to its successor (if any), and a link to its predecessor (if any)
The header points to the first node in the list
Double LL compared to Single LL
Advantages: Can be traversed in
either direction (may be essential for some programs)
Some operations, such as deletion and inserting before a node, become easier
Disadvantages: Requires more
space List manipulations
are slower (because more links must be changed)
Greater chance of having bugs (because more links must be manipulated)
Deleting a node from a DLL Node deletion from a DLL involves changing two links
Deletion of the first node or the last node is a special case
Garbage collection will take care of deleted nodes
Header
null nulla b c
Inner Classes All the classes so far have been “top level”
classes It is possible (and useful) to define a class
inside another class Sometimes you want a class C2 that will
only be used only by class C1. It might be handy to be able to include the
definition of C2 in the file defining C1. Inner classes can be very useful, especially
with AWT (GUI) event handling.
Inner Classes Exampleclass Outer {
int n;class Inner {
int ten = 10;void setNToTen ( ) { n = ten; }
}void setN ( ) {
new Inner( ).setNToTen ( );}
}
Generics Motivation In Java, array elements must all be of the
same type: int[] counts = new int[10];
Hence, arrays are type safe: The compiler will not let you put the wrong kind of thing into an array
A collection, such as a Vector or the non-parameterized ArrayList, cannot hold primitives, but will accept any type of Object: ArrayList someStuff = new ArrayList();
someStuff.add("A String is an Object");someStuff.add(10);
Is not type safe; Making a collection type safe is a tedious process
Generics J2SE 5.0 provides compile-time type safety with
the Java Collections framework through generics
Generics allows you to specify, at compile-time, the types of objects you want to store in a Collection. Then when you add and get items from the list, the list already knows what types of objects are supposed to be acted on
So you don't need to cast anything. The "<>" characters are used to designate what type is to be stored. If the wrong type of data is provided, a compile-time exception is thrown.
Generics Example Example (compile-time exception):
import java.util.*; public class First {
public static void main(String args[]) { ArrayList<Integer> myList = new ArrayList<Integer>(10); myList.add(10); // Autoboxing converted the int type to an
Integer myList.add("Hello, World");
} }
First.java:7: cannot find symbol symbol : method add(java.lang.String) location: interface java.util.List<java.lang.Integer> myList.add("Hello, World"); ^ 1 error
Question 2public class Exam{
private int x;public Exam() {x = 0;}public Exam(int x) {setX(x);}public Exam(Exam e) {x = e.getX();}public int getX() {return x + 10;}public void setX(int x) {this.x = x;}public void modifyX(Exam e) {this.x = e.getX() + 10;}
public static void main(String[] args) {Exam e1 = new Exam();Exam e2 = new Exam(e1);e2.modifyX(e1);System.out.println(e1.getX() + "::" + e2.getX());}
}
Q2. If X is static(a) No change(b) 10::10(c) 40::40(d) 30::30
Question 4
Q4. Which of the following statements about Java’s wrapper classes is FALSE?
(a) They provide utility methods for their primitive counterparts.
(b) They facilitate information hiding by adding a layer of indirection.
(c) They have no default constructor.(d) They do not provide modifier methods.
Question 10public class Parent{
private void f() {System.out.print("parent f()"); }
public static void main(String[] args) {Parent p = new Derived();p.f();}}
class Derived extends Parent{public void f() {System.out.print("derived f()");}}
(a) parent f() derived f()(b) parent f()(c) derived f()(d) derived f() parent f()
Question 12public class Question12{public void method(Object o) {System.out.print("Object Verion");}
public void method(String s) {System.out.print("String Version");}
public static void main(String args[]) {Question12 q = new Question12();q.method(null);}}
(a) String Version(b) There is no output due to null pointer Exception(c) There is no output due to compile time error(d) Object Version
Question 19public class Call{private int var;public Call (int var) { this.var = var; }public void Exchange (Call arr1, Call arr2) {Call temp = arr1;arr1 = arr2;arr2 = temp;}
public static void main (String[] args) {Call[] arr = new Call[3];for (int i = 0; i < arr.length; ++i)arr[i] = new Call(i + 1);arr[0].Exchange(arr[1], arr[2]);for (int i = 1; i < arr.length; i++)System.out.print(arr[i].var); } }
(a) 32(b) 64(c) 23(d) 46
Question 20public class Base {public void Print () {System.out.print("Red");} }
public class FirstDerived extends Base {
public void Print () {System.out.print("Blue");} }
public class SecondDerived extends Base
{public void Print (String str) {System.out.print("Green"); }}
public class Dynamic{public static void main (String[] args) {
Base[] b = new Base[2];b[0] = new FirstDerived();b[1] = new SecondDerived();b[0].Print();b[1].Print();}}
OUTPUT: BlueRed
Quiz Show the Linked List formed at the end of this
program class Node { int value;
Node next; Node (int v, Node n) { // constructor
value = v; next = n;}
public static void main(String args[]) {
Node n1 = new Node(13, null); Node n2 = new Node(17, n1); Node n3 = new Node(29, n2); n1.next = n3; }