Hash Maps/AbstractHashMap - Revision history

Admin: Replacing charlesreid1.com:3000 with git.charlesreid1.com

2019-10-09T03:27:39Z

Replacing charlesreid1.com:3000 with git.charlesreid1.com

← Older revision		Revision as of 03:27, 9 October 2019
Line 33:		Line 33:
	==Code==		==Code==

	Link to code on git.charlesreid1.com: https://charlesreid1.com~~:3000~~/cs/java/src/master/hash/AbstractHashMap.java		Link to code on git.charlesreid1.com: https://git.charlesreid1.com/cs/java/src/master/hash/AbstractHashMap.java

	We start with the class declaration, where we take two generic types (K for key and V for value), and require key types to be comparable.		We start with the class declaration, where we take two generic types (K for key and V for value), and require key types to be comparable.

Admin: /* Code */

2017-06-27T05:11:49Z

Code

← Older revision		Revision as of 05:11, 27 June 2017
Line 111:		Line 111:
	/** Public (abstract) method to put the item with this key and value into the map. */		/** Public (abstract) method to put the item with this key and value into the map. */
	public abstract void put(K key, V value);		public abstract void put(K key, V value);
			</pre>

			Now, the protected methods:

	// ~~Semi-private~~ methods:		<pre>
			// Protected methods:
	/** Compute the hash code for a key object. */		/** Compute the hash code for a key object. */
	protected int hashValue(K k) {		protected int hashValue(K k) {
Line 136:		Line 139:
	}		}
	</pre>		</pre>


	==Flags==		==Flags==

Admin: /* Flags */

2017-06-27T05:10:33Z

Flags

@@ Line 30: / Line 30: @@
 * MapItem class was actually protected and lived in AbstractMap class
 * Therefore, we had to hold off declaring an abstract MapItem iterator until the AbstractMap class, not the Map interface
 ==Flags==

Admin: /* Notes */

2017-06-27T05:04:53Z

Notes

← Older revision		Revision as of 05:04, 27 June 2017
Line 1:		Line 1:
	==Notes==		==Notes==

	~~Start by defining~~ an interface ~~for~~ the Map ~~ADT~~ (~~Map.java~~).		To recap, here is how these classes are organized:
			* Map is an interface class that defines the public interfaces that any Map data container must implement
			* AbstractMap is an abstract class that does the following:
			** Define a map item (utility) class
			** This is designed to take a K,V key value pair
			** Also defines four more classes:
			** Two Iterators and two Iterables - the key and value Iterator and Iterable classes.

	~~Next, define an abstract class to lay out some useful methods, fields, and utility classes~~ (~~AbstractMap.java~~).		itemSet() method:
			* The itemSet() method returns an iterator over the set of all MapItems
	~~The process of defining the abstract map~~:		* itemSet() returns an iterator over MapItem types, so keySet() and valueSet() both utilize this and unwrap only the key or value from the MapItem object.
	* ~~Needed to define a map item wrapper class~~		* We aren't defining itemSet anywhere in this class - just using it. Then we implement it as an abstract method, requiring concrete classes to implement it.
	* This is designed to take a K,V key value pair
	* Also need to define four more classes:
	* Two Iterators and two Iterables

	~~Iterators vs Iterables - ?~~
	* Map key Iterator object
	* Map value Iterator object
	* Map key Iterable object (?) ~~- thought I understood this, but maybe not?~~
	* ~~Map value Iterable object~~ (?)
	* The Iterator objects are like mini-scanners.
	* The Iterable objects just have an iterator() ~~method~~ and ~~are what are actually returned.~~

	~~itemSet:~~
	* Note that the key ~~and~~ value ~~sets use~~ the ~~itemSet method~~
	* We aren't defining itemSet, just using it
	* itemSet must be defined in our concrete class		* itemSet must be defined in our concrete class
	* This means we have three total Iterators and three total Iterables		* This means that eventually our concrete class will have three total Iterators and three total Iterables - two Iterators and two Iterables defined in the abstract class, for the keys and values, and one Iterator and one Iterable defined in the concrete class, when we know more about how the actual hash map is being implemented under the hood.

	More iterators vs iterables:		More iterators vs iterables:
	* Iterable just says, I return an ~~Iterator~~. it is part of the core language.		* Iterable just says, this thing can be used with for-each syntax (it has a specific way to return an iterator). It is part of the core language.
	* Iterator has to be defined for each container.		* Iterator has to be defined for each container.

Line 39:		Line 30:
	* MapItem class was actually protected and lived in AbstractMap class		* MapItem class was actually protected and lived in AbstractMap class
	* Therefore, we had to hold off declaring an abstract MapItem iterator until the AbstractMap class, not the Map interface		* Therefore, we had to hold off declaring an abstract MapItem iterator until the AbstractMap class, not the Map interface






	==Flags==		==Flags==

Admin at 05:03, 27 June 2017

2017-06-27T05:03:35Z

← Older revision	Revision as of 05:03, 27 June 2017
Line 1:	Line 1:
		==Notes==

		Start by defining an interface for the Map ADT (Map.java).

		Next, define an abstract class to lay out some useful methods, fields, and utility classes (AbstractMap.java).

		The process of defining the abstract map:
		* Needed to define a map item wrapper class
		* This is designed to take a K,V key value pair
		* Also need to define four more classes:
		* Two Iterators and two Iterables

		Iterators vs Iterables - ?
		* Map key Iterator object
		* Map value Iterator object
		* Map key Iterable object (?) - thought I understood this, but maybe not?
		* Map value Iterable object (?)
		* The Iterator objects are like mini-scanners.
		* The Iterable objects just have an iterator() method and are what are actually returned.

		itemSet:
		* Note that the key and value sets use the itemSet method
		* We aren't defining itemSet, just using it
		* itemSet must be defined in our concrete class
		* This means we have three total Iterators and three total Iterables

		More iterators vs iterables:
		* Iterable just says, I return an Iterator. it is part of the core language.
		* Iterator has to be defined for each container.

		Exceptions:
		* NoSuchElementException
		* UnsupportedOperationException
		* Don't forget to check for size!
		* Especially if you are not wraapping someone else's iterator

		Ordering of class declaration and undeclared class declarations
		* I could not use MapItem class undefined in the Map interface (most generic of all)
		* MapItem class was actually protected and lived in AbstractMap class
		* Therefore, we had to hold off declaring an abstract MapItem iterator until the AbstractMap class, not the Map interface

Admin: Created page with " ==Flags== {{MapsFlag}} Category:Maps Category:Hash Map"

2017-06-27T04:24:31Z

Created page with " ==Flags== {{MapsFlag}} Category:Maps Category:Hash Map"

New page

==Flags==

{{MapsFlag}}
[[Category:Maps]]
[[Category:Hash Map]]