cs2110 sw development methods
Download
Skip this Video
Download Presentation
CS2110: SW Development Methods

Loading in 2 Seconds...

play fullscreen
1 / 24

CS2110: SW Development Methods - PowerPoint PPT Presentation


  • 106 Views
  • Uploaded on

CS2110: SW Development Methods. Textbook readings: MSD, Chapter 8 (Sect. 8.1 and 8.2) But we won ’ t implement our own, so study the section on Java ’ s Map classes… MSD, Chapter 9 (Sect. 9.3.2 and 9.3.4). Sets and Maps in Java. Set and HashSet in Java Collections.

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 ' CS2110: SW Development Methods' - kamuzu


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
cs2110 sw development methods
CS2110: SW Development Methods
  • Textbook readings:
    • MSD, Chapter 8 (Sect. 8.1 and 8.2)
      • But we won’t implement our own, sostudy the section on Java’s Map classes…
    • MSD, Chapter 9 (Sect. 9.3.2 and 9.3.4)

Sets and Maps in Java

set and hashset in java collections
Set and HashSet in Java Collections
  • We’ve focused on List and ArrayList, but now…
  • A Set is a collection of items that
    • are unordered
    • are unique (no duplicates)
  • What kind of operations do we think of?
    • element membership (add, remove, isMember, etc.)
    • manipulation (union, intersection,…)
  • Java has:
    • Set – an interface
    • Several implementation classes, including HashSet
java s set interface see msd p 625
Java’s Set Interface (see MSD, p. 625)
  • The Set interface looks just like the Collection interface, but with more specific behaviors
    • boolean add(elem) – returns false if already there
    • boolean remove(elem) – returns false if not there
  • What’s sweet here:
    • Try to add something that’s already there?Remove something that’s not there? No problem!
    • It basically ignores that attempt!
  • This allows some powerful methods to be very short
    • See examples on pages 625 and 626
examples using set
Examples using Set
  • How many unique items in any Collection object?

int numUniq = new HashSet(aCollection).size();

    • Creates a new set “on the fly” using the constructor that adds all items from an existing collection
  • Remove duplicates from any Collection object?

Set noDups = new HashSet( aCollection );aCollection.clear();aCollection.addAll( noDups );

    • Note we don’t have to iterate
    • We rely on useful constructors and bulk operations
  • Procedural Abstraction opportunity: Put these lines of code into a method with a good names
using sets in java treeset class
Using Sets in Java: TreeSet class
  • TreeSet is a concrete class that implements Set
  • How’s it work inside? How is it implemented?
    • We won’t focus on that in CS2110 (not now anyway)
    • Because it’s a well-implemented abstraction, you don’t need to understand what’s in the black-box
  • The “tree” refers to type of data structure used
  • But you do need one thing:
    • All items must be Comparable
    • All items must correctly implement compareTo()
    • Bonus! Iterating over a TreeSet uses compareTo()’s ordering. So prints in “correct” order
using sets in java hashset class
Using Sets in Java: HashSet class
  • HashSet is a concrete class that implements Set
  • How’s it work inside? How is it implemented?
    • Right now, we’ll show you the one thing you need to know but not explain the details
  • The “hash” refers to this idea in computing
    • Data objects have state values that identify them uniquely, and…
    • Often we want to get a “hash value” or “ID-like” value for an object:
      • Equal items must have the same hash value
      • Un-equal items may have the same value
    • Hash-value used to link objects to “buckets”
hash values for java classes
Hash Values for Java Classes
  • Hashing to get a hash-value is very useful, so…
  • Java’s superclass Object defines a method hashCode() for every class
    • If you want to use HashSet or any other class that uses hashing, override this method
    • Important: when you override equals(), you should override hashCode() too!
      • Otherwise things break when you don’t expect it.
      • Make sure that things that are equals() as you define that will also hash to the same value
    • Overriding hashCode() is often very very easy
over riding hashcode in java
Over-riding hashCode() in Java
  • Goal: make sure that two items that areequals() return the same value when hashCode() is called
  • Focus on what fields determine identity of objects
    • Example #1: Class Person
      • Say two objects are equals() if their SSN fields are equal
    • Example #2: Class Song
      • Say two objects are equals() if their title and artist fields are both equal
  • Caveat: later we’ll see that the “simple” rules you’ll see next may not always have the best performance (but they will work)
over riding hashcode in java 2
Over-riding hashCode() in Java (2)
  • If your object’s “key” is a String
    • Guess what? Most Java library classes already implement hashCode(). So use this fact!
    • If just one String value, your hashCode() method should just return the result of calling hashCode() on that String object
  • If multiple fields, here’s a simple solution:
    • get the hash-value for each individual field and just add them
  • See example in MSD text for Class Dog (p. 578)
  • Example #2: for class Song where title and artist must be equals(), the method just does:

return artist.hashCode() + title.hashCode();

over riding hashcode in java 21
Over-riding hashCode() in Java (2)
  • If your “key” field is numeric?
  • If integers, then:
    • Just return that field
    • Example #2: Class InventoryItem
      • Just return the int value itemID for that object
  • If not an integer but a double etc.
    • Use the wrapper class to create an object

Double dval = new Double(doubleKeyField);

    • Each wrapper class has hashCode() defined, so…

return dval.hashCode();

  • Multiple fields affect equals()? Again, sum up the hash-values for each field.
summary on set hashset
Summary on Set, HashSet
  • HashSet is an implementation of Set you can use
    • Don’t forget to implement hashCode() for items you want to store!
    • You MUST over-ride hashCode() and equals() together! If you do one, always do the other!
  • Items in Sets are not ordered
    • But you can construct a List from a Set and sort it (in two lines of code)
  • add() handles duplicates, and remove() ignores missing items
adt table
ADT Table
  • What’s a table? What’s “lookup”?
adt table1
ADT Table
  • Lookup: find data given some key value
  • ADT Table’s model of information
    • Some set of values associated with a key
  • Operations
    • Lookup: given a key, retrieve the values
    • Is this key stored in the table?
    • Insert, remove, updates, etc.
  • How could we implement this?
    • You’ve been using lists (arrays, ArrayLists) and the contains() and indexOf() methods
    • Disadvantages?
java type maps
Java Type: Maps
  • Maps
    • Like sets, but have <key, value> instead of <value>
    • Dictionary example
    • Other examples
      • Student’s email to Facebook Profile
      • Host Names to IP addresses
  • How to declare: Map<KeyType,ValueType>…Examples:

Map<String,Integer> // maps string to a number

Map<Student,String> // maps Student to a StringMap<String,List<Course>> // e.g. a schedule

important map methods
Important Map Methods
  • Keys and values
    • put (key, value), get(key), remove(key)
    • containsKey(key), containsValue(value)
  • Can think of a Map as a set of keys and a set of values
    • keySet() // returns a Set of key values
    • values() // returns a Collection of values
    • (Note: Map itself does not extend Collection, but it uses Sets and is part of the Java Collection Framework)
  • Others too! See doc or a Java reference.
concrete classes
Concrete Classes
  • HashMap
    • Most commonly used. Allows nulls as values.
    • Need a hashCode() method
  • TreeMap
    • Uses a search tree data structure
    • Values stored in a sorted order
    • Keys must have a compareTo() method
      • Or can create with a Comparator object
  • HashTable
    • Old class -- deprecated! Don’t use!
why are maps useful and important
Why Are Maps Useful and Important?
  • “Lookup values for a key” -- an important task
    • We often want to do this!
    • Need flexibility for what values are stored for a given key
    • Need to use objects other than Strings or ints as key values
  • Efficiency matters for large sets of data
    • HashMap has O(1) lookup cost
    • TreeMap is O(lg n) which is still very good
summary
Summary
  • Set and Table are important ADTs
    • Java supports these directly
  • Set interface
    • Concrete classes: HashSet, TreeSet
    • Note:
      • How add() and remove() fail “nicely” (I.e. return false)
      • How used to achieve solve more complex tasks with Collections
    • HashSet relies on proper implementation ofhashCode()
      • hashCode() and equals() must be “consistent”
    • TreeSet relies on compareTo()
summary 2
Summary (2)
  • Map Interface
    • Concrete classes: HashMap and TreeMap
    • Declared using both key-type and value-type, e.g. Map<Student,List<Course>>
    • Important because “lookup” is a frequent problem
    • Lookup for maps is very efficient for large amounts of data
    • Code often needs to take different actions for:
      • The first time a key/value pair is inserted into a map
      • We want to update information for an existing key
note map not is a collection
Note: Map not IS-A Collection
  • It’s wrong to say a Map is a Collection
    • It does not implement the Collection interface
    • Why not? For example, add(E) doesn’t make sense for a map
    • We need to add a (key,value) pair
  • But Map and its concrete classes are part of the JCF
    • They use Sets as part of their definition and API
big picture on java collections unit
Big Picture on Java Collections Unit
  • Java Collections Framework
    • A large collections of interfaces and classes
    • Includes things we can use “as is” (concrete classes) and building blocks for new things (abstract classes)
    • Classes that exist to contain static methods, e.g. Collections class (see also Arrays class)
  • Power of inheritance, interfaces, polymorphism
    • See how “type” Collection and List are used in parameter lists and in Collections class’ methods (e.g. sort)
  • Be aware of and start to use Java 5.0 generics with your collections
big picture on java collections unit 2
Big Picture on Java Collections Unit (2)
  • Iterators: both concepts and the practice
    • Example of procedural abstraction (use, methods) anddata abstraction (what’s really in a iterator object?)
    • Using these in Java for Collections, Lists (methods, cursor, etc.)
  • Procedural abstraction: the concepts, examples
  • Function-objects and procedural abstraction
    • Encapsulating “functionality” or “control” in an object
    • Comparator objects (contrast to implementing Comparable interface)
    • Java trick: anonymous classes
big picture on java collections unit 3
Big Picture on Java Collections Unit (3)
  • Java skills: Concrete collection classes and methods for you to use
    • ArrayList and ListIterator
    • HashSet
      • Must over-ride hashCode()
  • Collections static methods
    • See JavaDoc or p 587 in MSD textbook
      • E.g. sort, reverse, binarySearch, fill, shuffle, min, max,…
    • Implement Comparable for your collection items
    • Define Comparator classes for more powerful, flexible use
ad