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; }