Some of java s collection framework
Download
1 / 14

- PowerPoint PPT Presentation


  • 235 Views
  • Uploaded on

Some of Java's Collection Framework. Rick Mercer. Java's Collection Framework. Collection framework Unified architecture for representing and manipulating collections Java's collection framework contains Interfaces (ADTs): specification not implementation

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about '' - jacob


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Some of java s collection framework

Some of Java's Collection Framework

Rick Mercer


Java s collection framework
Java's Collection Framework

  • Collection framework

    • Unified architecture for representing and manipulating collections

  • Java's collection framework contains

    • Interfaces (ADTs): specification not implementation

    • Concrete implementations as classes

    • Polymorphic Algorithms to search, sort, find, shuffle, ...

  • The algorithms are polymorphic:

    • the same method can be used on many different implementations of the appropriate collection interface. In essence, algorithms are reusable functionality.


Collection interfaces in java util
Collection interfaces in java.util

Image from the Java Tutorial


Abstract data type
Abstract Data Type

  • Abstract data type (ADT) is a specification of the behaviour (methods) of a type

    • Specifies method names to add, remove, find

    • Specifies if elements are unique, indexed, accessible from only one location, mapped,...

    • An ADT shows no implementation

      • no structure to store elements, no implemented algorithms

  • What Java construct nicely specifies ADTs?


Collection classes
Collection Classes

  • A collection class the can be instantiated

    • implements an interface as a Java class

    • implements all methods of the interface

    • selects appropriate instance variables

  • Java has concrete collection classes

    • ArrayList<E>, LinkedList<E>, Vector<E>

    • Stack<E>

    • LinkedBlockingQueue<E>, ArrayBlockingQueue<E>

    • HashSet<E>, TreeSet<E>

    • TreeMap<K,V>, HashMap<K,V>


Common functionality
Common Functionality

  • Collection classes often have methods for

    • Adding objects

    • Removing an object

    • Finding a reference to a particular object find

      • can then send messages to the object still in the collection


List e an adt written as a java interface
List<E>, an ADT written as a Java interface

  • List<E>: a collection with a first element, a last element, distinct predecessors and successors

    • The user of this interface has precise control over where in the list each element is inserted

    • duplicates that "equals" each other are allowed

  • The List interface is implemented by these three collection classes

    • ArrayList<E>

    • LinkedList<E>

    • Vector<E>


  • import java.util.*; // For List, ArrayList, Linked ...

  • importstatic org.junit.Assert.*;

  • import org.junit.Test;

  • publicclass ThreeClassesImplementList {

  • @Test

  • publicvoid showThreeImplementationsOfList() {

  • // Interface name: List

  • // Three classes that implement the List interface:

  • List<String> bigList = new ArrayList<String>();

  • List<String> littleList = new LinkedList<String>();

  • List<String> sharedList = new Vector<String>();

  • // All three have an add method

  • bigList.add("in array list");

  • littleList.add("in linked list");

  • sharedList.add("in vector");

  • // All three have a get method

  • assertEquals("in array list", bigList.get(0));

  • assertEquals("in linked list", littleList.get(0));

  • assertEquals("in vector", sharedList.get(0));

  • }

  • }


Can t add the wrong type
Can't add the wrong type

  • Java generics checks the type at compile time

    • See errors early--a good thing

    • "type safe" because you can't add different types

  • ArrayList<GregorianCalendar> dates =

  • new ArrayList<GregorianCalendar>();

  • dates.add(new GregorianCalendar()); // Okay

  • dates.add("String not a GregorianCalendar"); // Error

  • ArrayList<Integer> ints = new ArrayList<Integer>();

  • ints.add(1); // Okay. Same as add(new Integer(1))

  • ints.add("Pat not an int")); // Error


  • Algorithms
    Algorithms

    • Java has polymorphic algorithms to provide functionality for different types of collections

      • Sorting (e.g. sort)

      • Shuffling (e.g. shuffle)

      • Routine Data Manipulation (e.g. reverse, addAll)

      • Searching (e.g. binarySearch)

      • Composition (e.g. frequency)

      • Finding Extreme Values (e.g. max)

    • Demo a few with ArrayList

      • Override toString and equals for DayCounter


    The map interface adt
    The Map Interface (ADT)

    • Map describes a type that stores a collection of elements that consists of a key and a value

    • A Map associates (maps) a key the it's value

    • The keys must be unique

      • the values need not be unique

      • putdestroys one with same key


    Map operations
    Map Operations

    • Java's TreeMap<K, V>

      • public V put(K key, V value)

        • associates key to value and stores mapping

      • public V get(Object key)

        • associates the value to which key is mapped or null

      • public boolean containsKey(Object key)

        • returns true if the Map already uses the key

      • public V remove(Object key)

        • Returns previous value associated with specified key, or null if there was no mapping for key.

      • Collection<V> values()

        • get a collection you can iterate over


    Using a map
    Using a Map

    • @Test publicvoid testContainsKey() {

    • Map<String, BankAccount> m =

    • new TreeMap<String, BankAccount>();

    • BankAccount acct1 = new BankAccount("Jessica", 500.00);

    • BankAccount acct2 = new BankAccount("Alex", 400.00);

    • BankAccount acct3 = new BankAccount("Anthony", 300.00);

    • BankAccount acct4 = new BankAccount("Danny", 200.00);

    • BankAccount acct5 = new BankAccount("Patrick", 100.00);

    • m.put(acct1.getID(), acct1);

    • m.put(acct2.getID(), acct2);

    • m.put(acct3.getID(), acct3);

    • m.put(acct4.getID(), acct4);

    • m.put(acct5.getID(), acct5);

    • BankAccount current = m.get("Jessica");

    • assertEquals("Jessica", current.getID());

    • }



    ad