java programming: guided learning with early objects chapter 12 generics, dynamic representations,...

Java Programming: Guided Learning with Early Objects

Chapter 12Generics, Dynamic Representations,

and Collections

Java Programming: Guided Learning with Early Objects 2

Objectives

• Learn about generic methods and classes• Learn about the interface Comparable

and how to implement it• Learn about the Java class LinkedList

and how to use various operations of this class


Objectives (continued)

• Explore iterators and how they work• Learn about the interface Collection

and its framework• Learn about various collection algorithms


Generic Methods

• Generic methods: write one method definition rather than multiple definitions

• Defined using type parameters• Type parameter section precedes return type

of the method• Type parameters separated by commas

– Enclosed in angle brackets

– Also called type variables


Generic Methods (continued)

• Type parameters used for:– Declaring return type of the method– Declaring formal parameters– Declaring local variables

• Type parameters represent only reference parameters– Not primitivesmodifiers <T> returnType methodName

(formal parameter list) {

// Method body}


Generic Classes

• Type parameters are enclosed in angle brackets– Placed after the name of the class

• Type parameter declares variables and generic methods within the class

modifiers className<T> modifiers {

//class members

}

• Also known as parametric classes


Generic Classes (continued)

• Reference variables declared using type parameter T within definition of the class

• Cannot instantiate objects using type parameter


The interface Comparable

• One method: compareTo• Used to require a class to provide definition for

the method compareTo– Allows values of two objects to be compared

• Make the class implement interface Comparable


Generic Methods and Bounded Type Parameters

• Recall generic method print• Type parameter T refers to any built-in Java class

– No restriction on type parameter T

• Type parameters restricted, for example, to classes that define compareTo

• Example:

public static <T extends Comparable<T>> T

larger( T x, T y )


Generic Methods and Bounded Type Parameters (continued)

• Consider:<T extends Comparable<T>>

• T refers to any class that implements Comparable

• Comparable is the upper bound of the type parameter T

• By default, Object always an upper bound• Keyword extends used when type parameter

declaration bounds a parameter


Generic Search and Sort Algorithms (Optional)

• Sort algorithms from earlier chapters work only on int arrays

• Designing generic search and sort algorithms• Generic selection sort

– Place definition of selection algorithm in a class


Collections

• Vector known as a collection class • class Vector implements array-based lists• class LinkedList implements a linked list


Linked Lists and the class LinkedList

• Array also called a sequential list• Operations on sequential lists:

– Insertion– Deletion– Searching

• Searching unsorted data is time-consuming• Insertion and deletion is time-consuming on

sorted lists• Array size is fixed


Linked Lists

• Linked list: collection of components called nodes

• Each node contains address of next node– Two parts:

• One stores relevant information• One stores address

• Address of first node is called head or first • class Node defines the node of a linked list

– Two instance variables: info and link


Figure 12-2 Linked list

Figure 12-3 Linked list and values of the links


Linked Lists: Some Properties

• Keep a reference variable current to point to address of the current node in the list– Useful for traversing the list


Figure 12-4 Linked list with four nodes


Table 12-1 Values of head and Some of the Nodes of the Linked List in Figure 12-4


Figure 12-5 Linked list after the statement current = current.link; executes


Table 12-2 Values of current and Some of the Nodes of the Linked List in Figure 12-5


Insertion

• Create a new node• Store data in instance variable info• Set instance variable link to point to following

node • Set previous node variable link to point to

new node


Figure 12-6 Linked list before item insertion


Figure 12-7 Create newNode and store 50 in it


Figure 12-8 List after the statement newNode.link = p.link; executes


Figure 12-9 List after the statement p.link = newNode; executes


Deletion

• Set link variable of previous node to link to next node in list– Bypass the node to be deleted

• Garbage collector runs if no reference variable points to the deleted node– Memory reclaimed by system


Figure 12-10 Node to be deleted is with info 34


Figure 12-11 List after the statement p.link = p.link.link; executes


Doubly Linked Lists

• Every node has a next pointer and a previous pointer

• Can be traversed efficiently in either direction– Can traverse from first or last node

• Inserting a node requires setting pointers in both directions

• Deleting a node requires bypassing a node in both directions


Figure 12-12 Doubly linked list


The class LinkedList

• class LinkedList implemented as a doubly linked list

• Every element points to immediate predecessor and successor

• Two constructors:

Collection<? extends E>– Type parameter ? represents unknown type– ? called wildcard

– Type E an upper bound of the wildcard


Iterators

• Process elements of a collection one by one– Could use foreach loop

• Use an iterator– Processes elements in collection one after the

other

• interface ListIterator implements interface Iterator

• interface Iterator has only three methods


Table 12-4 Methods of the interface Iterator


Table 12-5 The interface ListIterator and its Methods


Table 12-5 The interface ListIterator and its Methods (continued)


Iterators (continued)

• Typically, iterator moves in only one direction– Starts at first element, moves to last

• class LinkedList implemented as doubly linked lists– Iterator should move in both directions

• interface ListInterface extends interface Iterator – Has methods to move in both directions

– Can also be used for insertion and deletion


Collections and Collection Algorithms

• Collection: data structure that holds references to other objects– Examples: vector, array

• Collection class: a class whose objects are collections– Example: class Vector

• Several interfaces and classes implement collections systematically– Hierarchical structure


Figure 12-13 Some Java Collection classes and the inheritance hierarchy


Table 12-6 Methods of the Collections class


The Method addAll

• Method addAll adds the elements of a collection into another collection

• List to be added is a variable length parameter– Elements specified individually or as an array

• Throws: UnsupportedOperationException, NullPointerException, IllegalArgumentException


The Methods binarySearch, sort, and reverseOrder

• binarySearch: search the list, specified as parameter for object– Efficiently searches a list for a given element

– Requires a list to be sorted

• List can be sorted in ascending or descending order using reverseOrder

• sort: type parameter T bounded by interface Comparable


Table 12-7 Methods of the interface Comparator


The Method copy

• Copies elements of one collection into another collection object

• After copy operation, index of each copied element is identical in source and destination

• Copies only references of the objects– Objects in destination list point to same objects

as source– Objects in source list are mutable– Changing value of object by using source

changes value in destination


The Methods max and min

• Methods max and min determine maximum and minimum elements

• All elements in collection must be mutually comparable by the comparator

• Throws exceptions:– ClassCastException– NoSuchElementException


The Methods fill and frequency

• Method fill replaces all elements of a given list with given element– Type parameter T specifies type of list elements

as well as type of replacement element

• Method frequency finds the number of times a specific object appears in a collection– If collection is null, throws NullPointerException


The Method replaceAll

• Replaces all occurrences of a given element with another

• Type parameter T specifies type of list elements

• Returns true if list contains one or more elements equal to replacement object

• If list or list iterator does not support set method, throws exception


The Methods shuffle and swap

• Method shuffle randomly shuffles elements of a list

• Two forms: with and without random seed• All permutations occur with approximately equal

likelihood• Method swap swaps elements of list


Summary

• Generic methods are defined using type parameters

• Every generic method has a type parameter section preceding the return type of the method– Type parameters separated by commas

– Enclosed in angle brackets

• Type parameters specify generic type names• Within generic method, declare reference

variables using type parameter T


Summary (continued)

• Type parameter may be bounded or unbounded

• Cannot instantiate objects using type parameter• class LinkedList implemented as a doubly

linked list– Contained in package java.util

• The foreach loop iterates over LinkedList• Iterator iterates over elements of a collection


Summary (continued)

• Collection is a data structure that holds references to objects

• Collection class is a class whose objects are collections

• interface Collection is the superclass of all Java collection classes

• Generic algorithms designed as static methods of class Collections

java programming: guided learning with early objects chapter 12 generics, dynamic representations,...

Documents

java programming

guided learning

class slide

type parameter slide

linked list slide

class type parameter

java class linkedlist

builtin java class