Glad that's over with

master
Chloe Fontenot 🏳️‍⚧️ 2024-02-13 20:17:38 +07:00
parent bcb6aa480a
commit f08b26a4a2
6 changed files with 1198 additions and 398 deletions

@ -0,0 +1,813 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>MapASDV.java</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<style type="text/css">
<!--
body {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
pre {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace; font-weight: bold}
table {color: #888888; background-color: #313335; font-family: monospace; font-weight: bold}
.number {color: #6897bb}
.string {color: #6a8759}
.ST1 {color: #9876aa}
.ST3 {color: #ffc66d}
.ST4 {color: #8a653b}
.comment {color: #808080}
.whitespace {color: #505050}
.ST5 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
.ST6 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
.ST0 {color: #287bde}
.literal {color: #cc7832}
.ST2 {font-family: monospace; font-weight: bold; font-style: italic}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/caleb/ASDV-Java/Semester 4/Assignments/MapASDV_CalebFontenot/src/mapasdv_calebfontenot/MapASDV.java</td></tr></table>
<pre>
<span class="comment">/*</span>
<span class="comment"> * Click </span><span class="ST0">nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt</span><span class="comment"> to change this license</span>
<span class="comment"> * Click </span><span class="ST0">nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java</span><span class="comment"> to edit this template</span>
<span class="comment"> */</span>
<span class="literal">package</span> mapasdv_calebfontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@author</span> <span class="comment">caleb</span>
<span class="comment">*/</span>
<span class="comment">//import ListASDV;</span>
<span class="literal">import</span> java.util.ArrayList;
<span class="literal">import</span> java.util.Collection;
<span class="literal">import</span> java.util.HashMap;
<span class="literal">import</span> java.util.HashSet;
<span class="literal">import</span> java.util.Iterator;
<span class="literal">import</span> java.util.Map;
<span class="literal">import</span> java.util.Objects;
<span class="literal">import</span> java.util.Set;
<span class="literal">import</span> java.util.function.BiConsumer;<span class="comment">//needed in putAll</span>
<span class="literal">public</span> <span class="literal">class</span> MapASDV&lt;K, V&gt; <span class="literal">implements</span> Map&lt;K, V&gt;, Cloneable {
<span class="literal">private</span> <span class="literal">int</span> <span class="ST1">capacity</span> = <span class="number">4</span>;
<span class="literal">private</span> <span class="literal">double</span> <span class="comment">loadFactor</span> = <span class="number">0.75</span>;
<span class="literal">private</span> ArrayList&lt;ListASDV&lt;EntryASDV&lt;K, V&gt;&gt;&gt; <span class="ST1">map</span> = <span class="literal">new</span> ArrayList&lt;&gt;();
<span class="literal">private</span> Set&lt;K&gt; <span class="ST1">sharedKeySet</span> = <span class="literal">new</span> SharedSet&lt;&gt;();
<span class="literal">private</span> Set&lt;<span class="ST2">Entry</span>&lt;K, V&gt;&gt; <span class="ST1">sharedEntrySet</span> = <span class="literal">new</span> SharedSet&lt;&gt;();
<span class="literal">private</span> Collection&lt;V&gt; <span class="ST1">sharedValuesCollection</span> = <span class="literal">new</span> SharedCollection&lt;&gt;();
<span class="literal">private</span> <span class="literal">class</span> SharedCollection&lt;V&gt; <span class="literal">extends</span> ArrayList&lt;V&gt; {
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">addValue</span>(V v) {
<span class="literal">return</span> <span class="literal">this</span>.add(v);
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">remove</span>(Object o) {
<span class="comment">//&gt; The parameter is key not entry if we are here</span>
<span class="comment">//&gt;&gt;remove value) and key) from the map</span>
<span class="literal">return</span> MapASDV.<span class="literal">this</span>.removeFirstValue(o);
<span class="comment">//&gt;&gt;remove key from shared values set</span>
<span class="comment">//return super.remove(o);</span>
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">one</span> <span class="comment">value</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">collection</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">is</span> <span class="comment">meant</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">called</span> <span class="comment">from</span> <span class="comment">out</span> <span class="comment">class</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">overridden</span> <span class="comment">remove</span><span class="comment">(</span><span class="comment">Object</span> <span class="comment">o</span><span class="comment">) </span><span class="comment">of</span> <span class="comment">this</span> <span class="comment">inner</span> <span class="comment">class</span><span class="comment">, </span><span class="comment">calls</span> <span class="comment">the</span> <span class="comment">remove</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">outer</span> <span class="comment">class</span><span class="comment">(</span><span class="comment">MapASDV</span><span class="comment">), </span><span class="comment">and</span> <span class="comment">the</span> <span class="comment">remove</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">outer</span> <span class="comment">class</span><span class="comment">, </span><span class="comment">calls</span> <span class="comment">remove</span><span class="comment">(</span><span class="comment">V</span> <span class="comment">v</span><span class="comment">, </span><span class="comment">boolean</span> <span class="comment">callFromOuterClass</span><span class="comment">) </span><span class="comment">instead</span> <span class="comment">of</span> <span class="comment">remove</span><span class="comment">(</span><span class="comment">Object</span> <span class="comment">o</span><span class="comment">) </span><span class="comment">to</span> <span class="comment">avoid</span> <span class="comment">Stack</span> <span class="comment">Overflow</span> <span class="comment">when</span> <span class="comment">remover</span> <span class="comment">of</span> <span class="comment">inner</span> <span class="comment">calls</span> <span class="comment">remove</span> <span class="comment">of</span> <span class="comment">outer</span> <span class="comment">and</span> <span class="comment">vice</span> <span class="comment">versa</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">o</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">key</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">callFromOuterClass</span><span class="comment"> - </span><span class="comment">dummy</span> <span class="comment">variable</span><span class="comment">.</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">was</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">Set</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">remove</span>(V v, <span class="literal">boolean</span> callFromOuterClass) {
<span class="comment">//remove key from shared keys set</span>
<span class="literal">boolean</span> b = <span class="literal">super</span>.remove(v);
<span class="literal">return</span> b;
}
@Override
<span class="literal">public</span> Object <span class="ST3">clone</span>() {
<span class="literal">return</span> <span class="literal">super</span>.clone();
}
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST3">clear</span>() {
<span class="literal">super</span>.clear();
}
}
<span class="literal">private</span> <span class="literal">class</span> SharedSet&lt;E&gt; <span class="literal">extends</span> HashSet&lt;E&gt; {
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">add</span>(E e) {
<span class="literal">return</span> <span class="literal">super</span>.add(e);
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">removeAll</span>(Collection&lt;?&gt; c) {
<span class="literal">return</span> <span class="literal">super</span>.removeAll(c);
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Adds</span> <span class="comment">an</span> <span class="comment">EntryASDV</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">set</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">is</span> <span class="comment">private</span> <span class="comment">and</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">used</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">user</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">Set</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">is</span> <span class="comment">used</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">MapASDV</span> <span class="comment">to</span> <span class="comment">add</span> <span class="comment">EntriesASDV</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">SharedSet</span><span class="comment">.</span> <span class="comment">Without</span> <span class="comment">this</span> <span class="comment">method</span> <span class="comment">we</span> <span class="comment">wouldn</span><span class="comment">&#39;</span><span class="comment">t</span> <span class="comment">be</span> <span class="comment">able</span> <span class="comment">to</span> <span class="comment">create</span> <span class="comment">a</span> <span class="comment">Set</span> <span class="comment">of</span> <span class="comment">keys</span> <span class="comment">or</span> <span class="comment">a</span> <span class="comment">Set</span> <span class="comment">of</span> <span class="comment">entries</span> <span class="comment">to</span> <span class="comment">give</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">user</span> <span class="comment">via</span> <span class="comment">methods</span> <span class="comment">keySet</span><span class="comment">() </span><span class="comment">and</span> <span class="comment">entrySet</span><span class="comment">() </span><span class="comment">of</span> <span class="comment">this</span> <span class="comment">Map</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">e</span> <span class="comment">EntryASDV</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">entry</span> <span class="comment">was</span> <span class="comment">added</span> <span class="comment">false</span> <span class="comment">otherwise</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">boolean</span> <span class="ST3">addEntry</span>(E e) {
<span class="literal">return</span> <span class="literal">super</span>.add(e);
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">remove</span>(Object o) {
<span class="comment">//&gt;if parameter oo is EntryASDV call auxiliary method removeEntry</span>
<span class="literal">if</span> (o <span class="literal">instanceof</span> EntryASDV) {
<span class="literal">return</span> removeEntry((EntryASDV) o);
}
<span class="comment">//&gt; The parameter is key not entry if we are here</span>
<span class="comment">//&gt;&gt;remove key from the map</span>
MapASDV.<span class="literal">this</span>.remove(o);
<span class="comment">//&gt;&gt;remove key from shared keys set</span>
<span class="literal">return</span> <span class="literal">super</span>.remove(o);
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">the</span> <span class="comment">entry</span> <span class="comment">for</span> <span class="comment">the</span> <span class="comment">shared</span> <span class="comment">set</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">entry</span> <span class="comment">the</span> <span class="comment">entry</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">entry</span> <span class="comment">was</span> <span class="comment">removed</span><span class="comment">, </span><span class="comment">false</span> <span class="comment">otherwise</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">boolean</span> <span class="ST3">removeEntry</span>(EntryASDV&lt;K, V&gt; entry) {
MapASDV.<span class="literal">this</span>.remove(entry.getKey());
<span class="literal">return</span> <span class="literal">super</span>.remove(entry);
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">set</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">is</span> <span class="comment">meant</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">called</span> <span class="comment">from</span> <span class="comment">out</span> <span class="comment">class</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">overridden</span> <span class="comment">remove</span><span class="comment">(</span><span class="comment">Object</span> <span class="comment">o</span><span class="comment">) </span><span class="comment">of</span> <span class="comment">this</span> <span class="comment">inner</span> <span class="comment">class</span> <span class="comment">calls</span> <span class="comment">the</span> <span class="comment">remove</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">out</span> <span class="comment">class</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">the</span> <span class="comment">remove</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">outer</span> <span class="comment">class</span> <span class="comment">calls</span> <span class="comment">remove</span><span class="comment">(</span><span class="comment">K</span> <span class="comment">o</span><span class="comment">, </span><span class="comment">boolean</span> <span class="comment">callFromOuterClass</span><span class="comment">) </span><span class="comment">instead</span> <span class="comment">of</span> <span class="comment">remove</span><span class="comment">(</span><span class="comment">Object</span> <span class="comment">o</span><span class="comment">) </span><span class="comment">to</span> <span class="comment">avoid</span> <span class="comment">Stack</span> <span class="comment">Overflow</span> <span class="comment">when</span> <span class="comment">remover</span> <span class="comment">of</span> <span class="comment">inner</span> <span class="comment">calls</span> <span class="comment">remove</span> <span class="comment">of</span> <span class="comment">outer</span> <span class="comment">and</span> <span class="comment">vice</span> <span class="comment">versa</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">o</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">key</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">callFromOuterClass</span><span class="comment"> - </span><span class="comment">dummy</span> <span class="comment">variable</span><span class="comment">.</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">was</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">Set</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">remove</span>(E o, <span class="literal">boolean</span> callFromOuterClass) {
<span class="comment">//remove key from shared keys set</span>
<span class="literal">return</span> <span class="literal">super</span>.remove(o);
}
@Override
<span class="literal">public</span> Object <span class="ST3">clone</span>() {
<span class="literal">return</span> <span class="literal">super</span>.clone();
}
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST3">clear</span>() {
<span class="literal">super</span>.clear();
}
}
<span class="literal">public</span> MapASDV() {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">capacity</span>; ++i) {
<span class="ST1">map</span>.add(<span class="literal">new</span> ListASDV&lt;EntryASDV&lt;K, V&gt;&gt;());
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Double</span> <span class="comment">the</span> <span class="comment">size</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">Map</span> <span class="comment">and</span> <span class="comment">rehashes</span> <span class="comment">the</span> <span class="comment">entries</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">Map</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">void</span> <span class="ST3">doubleTheSizeOfTheMapAndRehash</span>() {
<span class="ST1">capacity</span> *= <span class="number">2</span>;
<span class="comment">//&gt;create a new arrayList of ListsASDV</span>
ArrayList&lt;ListASDV&lt;EntryASDV&lt;K, V&gt;&gt;&gt; newMap = <span class="literal">new</span> ArrayList&lt;ListASDV&lt;EntryASDV&lt;K, V&gt;&gt;&gt;();
<span class="comment">//&gt;Add at every enetry of the arrayList a new ASDVList</span>
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">capacity</span>; ++i) {
newMap.add(<span class="literal">new</span> ListASDV&lt;EntryASDV&lt;K, V&gt;&gt;());
}
<span class="comment">//&gt;for the size of the OLD arrayList</span>
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i)<span class="comment">//array list</span>
{
<span class="comment">//&gt;&gt; get The ASDVlist at i</span>
ListASDV&lt;EntryASDV&lt;K, V&gt;&gt; list = <span class="ST1">map</span>.get(i);
<span class="comment">//&gt;&gt;for the size() of the ASDVlist</span>
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; list.size(); ++j) {
<span class="comment">///&gt;&gt;&gt;hash and put in the the new array </span>
<span class="literal">int</span> index = hash(list.get(j).getKey().hashCode());
newMap.get(index).add(list.get(j));
}
}
<span class="ST1">map</span> = newMap;
}
<span class="literal">class</span> EntryASDV&lt;K, V&gt; <span class="literal">implements</span> <span class="ST2">Entry</span>&lt;K, V&gt;, Comparable&lt;K&gt; {
K <span class="ST1">key</span>;
V <span class="ST1">value</span>;
<span class="literal">public</span> EntryASDV(K key, V value) {
<span class="literal">this</span>.<span class="ST1">key</span> = key;
<span class="literal">this</span>.<span class="ST1">value</span> = value;
}
@Override
<span class="literal">public</span> K <span class="ST3">getKey</span>() {
<span class="literal">return</span> <span class="ST1">key</span>;
}
@Override
<span class="literal">public</span> V <span class="ST3">getValue</span>() {
<span class="literal">return</span> <span class="ST1">value</span>;
}
@Override
<span class="literal">public</span> V <span class="ST3">setValue</span>(V value) {
V oldValue = <span class="literal">this</span>.<span class="ST1">value</span>;
<span class="literal">this</span>.<span class="ST1">value</span> = value;
<span class="literal">return</span> oldValue;
}
@Override
<span class="literal">public</span> String <span class="ST3">toString</span>() {
<span class="literal">return</span> <span class="string">&quot;</span><span class="string">EntryASDV{</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">key=</span><span class="string">&quot;</span> + <span class="ST1">key</span> + <span class="string">&quot;</span><span class="string">, value=</span><span class="string">&quot;</span> + <span class="ST1">value</span> + <span class="string">&#39;</span><span class="string">}</span><span class="string">&#39;</span>;
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">equals</span>(Object obj) {
<span class="literal">if</span> (<span class="literal">this</span> == obj) {
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">if</span> (obj == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (getClass() != obj.getClass()) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">final</span> EntryASDV&lt;?, ?&gt; other = (EntryASDV&lt;?, ?&gt;) obj;
<span class="literal">if</span> (!Objects.<span class="ST2">equals</span>(<span class="literal">t</span><span class="literal">his</span>.<span class="ST1">key</span>, other.<span class="ST1">key</span>)) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">o</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">throws</span> <span class="comment">IllegalArgumentException</span> <span class="comment">if</span> <span class="comment">parameter</span> <span class="comment">class</span> <span class="comment">is</span> <span class="comment">not</span> <span class="comment">K</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">int</span> <span class="ST3">compareTo</span>(K o) {
<span class="literal">if</span> (getClass() != o.getClass()) {
<span class="literal">throw</span> <span class="literal">new</span> IllegalArgumentException(<span class="string">&quot;</span><span class="string">ellegal parameter </span><span class="string">&quot;</span> + o);
}
<span class="literal">return</span> ((Comparable) <span class="ST1">key</span>).compareTo(o);
}
}
@Override
<span class="literal">public</span> <span class="literal">int</span> <span class="ST3">size</span>() {
<span class="literal">return</span> <span class="literal">this</span>.keySet().size();
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">isEmpty</span>() {
<span class="literal">if</span> (<span class="ST1">map</span>.size() == <span class="number">0</span>) {
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="comment">// done</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">containsKey</span>(Object key) {
String dashes = <span class="string">&quot;</span><span class="string">---------</span><span class="string">&quot;</span>;
System.<span class="ST5">out</span>.println(dashes + <span class="string">&quot;</span><span class="string"> containsKey(</span><span class="string">&quot;</span> + key.toString() + <span class="string">&quot;</span><span class="string">) </span><span class="string">&quot;</span> + dashes);
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; <span class="ST1">map</span>.get(i).size(); ++j) {
<span class="literal">if</span> (<span class="ST1">map</span>.get(i).get(j).<span class="ST1">key</span>.equals(key)) {
<span class="literal">return</span> <span class="literal">true</span>;
}
}
}
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Return</span> <span class="comment">an</span> <span class="comment">entry</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">map</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">key</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">entry</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">returned</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">entry</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">is</span> <span class="comment">not</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">map</span>
<span class="comment">*/</span>
<span class="literal">private</span> EntryASDV&lt;K, V&gt; <span class="ST3">getEntryForKey</span>(Object key) {
<span class="literal">for</span> (ListASDV&lt;EntryASDV&lt;K, V&gt;&gt; list : <span class="ST1">map</span>) {
Iterator&lt;EntryASDV&lt;K, V&gt;&gt; it = list.iterator();
<span class="literal">while</span> (it.hasNext()) {
EntryASDV&lt;K, V&gt; entry = it.next();
<span class="literal">if</span> (key.equals(entry.getKey())) {
<span class="literal">return</span> entry;
}
}
}
<span class="literal">return</span> <span class="literal">null</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">the</span> <span class="comment">index</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">given</span> <span class="comment">key</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">key</span> <span class="comment">a</span> <span class="comment">key</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">map</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">index</span> <span class="comment">of</span> <span class="comment">a</span> <span class="comment">key</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">or</span><span class="comment"> -1, </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">is</span> <span class="comment">not</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">map</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">int</span> <span class="ST3">getIndexForKey</span>(Object key) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i) {
Iterator&lt;EntryASDV&lt;K, V&gt;&gt; it = <span class="ST1">map</span>.get(i).iterator();
<span class="literal">while</span> (it.hasNext()) {
EntryASDV&lt;K, V&gt; entry = it.next();
<span class="literal">if</span> (key.equals(entry.getKey())) {
<span class="literal">return</span> i;
}
}
}
<span class="literal">return</span> -<span class="number">1</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">maps</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">keys</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span><span class="comment">.</span> <span class="comment">More</span> <span class="comment">formally</span><span class="comment">, </span><span class="comment">returns</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">and</span> <span class="comment">only</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">at</span> <span class="comment">least</span> <span class="comment">one</span> <span class="comment">mapping</span> <span class="comment">to</span> <span class="comment">a</span> <span class="comment">value</span> <span class="comment">v</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> (</span><span class="comment">value</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> ? </span><span class="comment">v</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> : </span><span class="comment">value</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">v</span><span class="comment">))</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">operation</span> <span class="comment">will</span> <span class="comment">probably</span> <span class="comment">require</span> <span class="comment">time</span> <span class="comment">linear</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">size</span> <span class="comment">for</span> <span class="comment">most</span> <span class="comment">implementations</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">Map</span> <span class="comment">interface</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">Parameters</span><span class="comment">: </span><span class="comment">value</span><span class="comment"> - </span><span class="comment">value</span> <span class="comment">whose</span> <span class="comment">presence</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">tested</span> <span class="comment">Returns</span><span class="comment">: </span><span class="comment">true</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">maps</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">keys</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span> <span class="comment">Throws</span><span class="comment">: </span><span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">inappropriate</span> <span class="comment">type</span> <span class="comment">for</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment"> (</span><span class="comment">optional</span><span class="comment">) </span><span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">values</span><span class="comment"> (</span><span class="comment">optional</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">value</span><span class="comment"> - </span><span class="comment">value</span> <span class="comment">whose</span> <span class="comment">presence</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">tested</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">maps</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">keys</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">values</span><span class="comment"> (</span><span class="comment">optional</span><span class="comment">)</span>
<span class="comment">*/</span>
<span class="comment">//done</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST3">containsValue</span>(Object value) {
String dashes = <span class="string">&quot;</span><span class="string">---------</span><span class="string">&quot;</span>;
System.<span class="ST5">out</span>.println(dashes + <span class="string">&quot;</span><span class="string"> containsValue(</span><span class="string">&quot;</span> + value.toString() + <span class="string">&quot;</span><span class="string">) </span><span class="string">&quot;</span> + dashes);
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; <span class="ST1">map</span>.get(i).size(); ++j) {
<span class="literal">if</span> (<span class="ST1">map</span>.get(i).get(j).<span class="ST1">value</span>.equals(value)) {
<span class="literal">return</span> <span class="literal">true</span>;
}
}
}
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">the</span> <span class="comment">value</span> <span class="comment">to</span> <span class="comment">which</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">key</span> <span class="comment">is</span> <span class="comment">mapped</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">no</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">the</span> <span class="comment">key</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">More</span> <span class="comment">formally</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">a</span> <span class="comment">mapping</span> <span class="comment">from</span> <span class="comment">a</span> <span class="comment">key</span> <span class="comment">k</span> <span class="comment">to</span> <span class="comment">a</span> <span class="comment">value</span> <span class="comment">v</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> (</span><span class="comment">key</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> ? </span><span class="comment">k</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> : </span><span class="comment">key</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">k</span><span class="comment">)), </span><span class="comment">then</span> <span class="comment">this</span> <span class="comment">method</span> <span class="comment">returns</span> <span class="comment">v</span><span class="comment">; </span><span class="comment">otherwise</span> <span class="comment">it</span> <span class="comment">returns</span> <span class="comment">null</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">There</span> <span class="comment">can</span> <span class="comment">be</span> <span class="comment">at</span> <span class="comment">most</span> <span class="comment">one</span> <span class="comment">such</span> <span class="comment">mapping</span><span class="comment">.</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">If</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">permits</span> <span class="comment">null</span> <span class="comment">values</span><span class="comment">, </span><span class="comment">then</span> <span class="comment">a</span> <span class="comment">return</span> <span class="comment">value</span> <span class="comment">of</span> <span class="comment">null</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">necessarily</span> <span class="comment">indicate</span> <span class="comment">that</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">no</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">the</span> <span class="comment">key</span><span class="comment">; </span><span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">also</span> <span class="comment">possible</span> <span class="comment">that</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">explicitly</span> <span class="comment">maps</span> <span class="comment">the</span> <span class="comment">key</span> <span class="comment">to</span> <span class="comment">null</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">containsKey</span> <span class="comment">operation</span> <span class="comment">may</span> <span class="comment">be</span> <span class="comment">used</span> <span class="comment">to</span> <span class="comment">distinguish</span> <span class="comment">these</span> <span class="comment">two</span> <span class="comment">cases</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">key</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">key</span> <span class="comment">whose</span> <span class="comment">associated</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">returned</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">value</span> <span class="comment">to</span> <span class="comment">which</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">key</span> <span class="comment">is</span> <span class="comment">mapped</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">no</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">the</span> <span class="comment">key</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">key</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">keys</span><span class="comment"> (</span><span class="comment">optional</span><span class="comment">)</span>
<span class="comment">*/</span>
<span class="comment">//done</span>
@Override
<span class="literal">public</span> V <span class="ST3">get</span>(Object key) {
String dashes = <span class="string">&quot;</span><span class="string">---------</span><span class="string">&quot;</span>;
<span class="literal">try</span> {
System.<span class="ST5">out</span>.println(dashes + <span class="string">&quot;</span><span class="string"> get(</span><span class="string">&quot;</span> + key.toString() + <span class="string">&quot;</span><span class="string">) </span><span class="string">&quot;</span> + dashes);
} <span class="literal">catch</span> (NullPointerException ex) {
<span class="comment">//System.out.println(ex);</span>
System.<span class="ST5">out</span>.println(dashes + <span class="string">&quot;</span><span class="string"> get(</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">null</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">) </span><span class="string">&quot;</span> + dashes);
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">null parameter</span><span class="string">&quot;</span>);
}
Object currentKey = <span class="literal">null</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; <span class="ST1">map</span>.get(i).size(); ++j) {
currentKey = <span class="ST1">map</span>.get(i).get(j).<span class="ST1">key</span>;
<span class="literal">if</span> (currentKey.equals(key)) {
<span class="literal">return</span> <span class="ST1">map</span>.get(i).get(j).<span class="ST1">value</span>;
}
}
}
<span class="literal">return</span> <span class="literal">null</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Associates</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">key</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">previously</span> <span class="comment">contained</span> <span class="comment">a</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">the</span> <span class="comment">key</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">old</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">replaced</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">A</span> <span class="comment">map</span> <span class="comment">m</span> <span class="comment">is</span> <span class="comment">said</span> <span class="comment">to</span> <span class="comment">contain</span> <span class="comment">a</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">a</span> <span class="comment">key</span> <span class="comment">k</span> <span class="comment">if</span> <span class="comment">and</span> <span class="comment">only</span> <span class="comment">if</span> <span class="comment">m</span><span class="comment">.</span><span class="comment">containsKey</span><span class="comment">(</span><span class="comment">k</span><span class="comment">) </span><span class="comment">would</span> <span class="comment">return</span> <span class="comment">true</span><span class="comment">.</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">key</span><span class="comment"> - </span><span class="comment">key</span> <span class="comment">with</span> <span class="comment">which</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">associated</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">value</span><span class="comment"> - </span><span class="comment">value</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">associated</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">key</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">previous</span> <span class="comment">value</span> <span class="comment">associated</span> <span class="comment">with</span> <span class="comment">key</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">there</span> <span class="comment">was</span> <span class="comment">no</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">key</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">A</span> <span class="comment">null</span> <span class="comment">return</span> <span class="comment">can</span> <span class="comment">also</span> <span class="comment">indicate</span> <span class="comment">that</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">previously</span> <span class="comment">associated</span> <span class="comment">null</span> <span class="comment">with</span> <span class="comment">key</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">implementation</span> <span class="comment">supports</span> <span class="comment">null</span> <span class="comment">values</span><span class="comment">.</span><span class="comment">)</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">specified</span> <span class="comment">key</span> <span class="comment">or</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">keys</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> V <span class="ST3">put</span>(K key, V value) {
<span class="literal">if</span> (key == <span class="literal">null</span> || value == <span class="literal">null</span>) {
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">parm(s) null</span><span class="string">&quot;</span>);
}
<span class="comment">//&gt;if contains the key, replace the key&#39;s value </span>
EntryASDV&lt;K, V&gt; entry = getEntryForKey(key);
<span class="literal">if</span> (entry != <span class="literal">null</span>) {
V oldValue = entry.<span class="ST1">value</span>;
entry.<span class="ST1">value</span> = value;
<span class="literal">return</span> oldValue;
}
<span class="comment">///&gt;&gt;hash and put in the array </span>
<span class="literal">int</span> code = <span class="literal">this</span>.hash(key.hashCode());
<span class="literal">int</span> index = hash(code);
ListASDV&lt;EntryASDV&lt;K, V&gt;&gt; list = <span class="ST1">map</span>.get(index);
EntryASDV e = <span class="literal">new</span> EntryASDV(key, value);
list.add(e);
<span class="comment">//&gt;&gt;add the key to the shared keys-set</span>
((SharedSet&lt;K&gt;) <span class="literal">this</span>.<span class="ST1">sharedKeySet</span>).addEntry(key);
((SharedSet&lt;<span class="ST2">Entry</span>&lt;K, V&gt;&gt;) <span class="literal">this</span>.<span class="ST1">sharedEntrySet</span>).addEntry(e);
<span class="comment">//&gt;&gt;get the value of this entry</span>
V v = list.get(list.size() - <span class="number">1</span>).getValue();
<span class="comment">//&gt;&gt; add value to the value collection</span>
((SharedCollection&lt;V&gt;) <span class="literal">this</span>.<span class="ST1">sharedValuesCollection</span>).addValue(v);
<span class="comment">//&gt;&gt; if reach 75% capacity double the size</span>
<span class="literal">if</span> ((<span class="literal">double</span>) <span class="literal">this</span>.size() / <span class="ST1">capacity</span> &gt;= <span class="number">0.75</span>) {
<span class="literal">this</span>.doubleTheSizeOfTheMapAndRehash();
}
<span class="comment">//&gt;&gt;return the value of Entry just added</span>
<span class="literal">return</span> v;
}
<span class="literal">int</span> <span class="ST3">hash</span>(<span class="literal">int</span> keyHashCode) {
<span class="literal">int</span> h = <span class="ST2">hashHash</span>(keyHashCode);
<span class="literal">return</span> Math.<span class="ST2">abs</span>(h % <span class="ST1">capacity</span> - <span class="number">1</span>);
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">the</span> <span class="comment">first</span> <span class="comment">entry</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">given</span> <span class="comment">values</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">value</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">value</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">removed</span><span class="comment">, </span><span class="comment">false</span> <span class="comment">otherwise</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">null</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">boolean</span> <span class="ST3">removeFirstValue</span>(Object value) {
Iterator&lt;V&gt; iterator = <span class="ST1">sharedValuesCollection</span>.iterator();
<span class="literal">while</span> (iterator.hasNext()) {
Object o = iterator.next();
<span class="literal">if</span> (o.equals(value)) {
iterator.remove();
<span class="literal">return</span> <span class="literal">true</span>;
}
}
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Ensure</span> <span class="comment">hash</span> <span class="comment">code</span> <span class="comment">is</span> <span class="comment">evenly</span> <span class="comment">distributed</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">h</span><span class="comment"> - </span><span class="comment">hash</span> <span class="comment">code</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">evenly</span> <span class="comment">distributed</span> <span class="comment">hash</span> <span class="comment">code</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">static</span> <span class="literal">int</span> <span class="ST6">hashHash</span>(<span class="literal">int</span> h) {
h ^= (h &gt;&gt;&gt; <span class="number">20</span>) ^ (h &gt;&gt;&gt; <span class="number">12</span>);
<span class="literal">return</span> h ^ (h &gt;&gt;&gt; <span class="number">7</span>) ^ (h &gt;&gt;&gt; <span class="number">4</span>);
}
<span class="comment">// class cast helper method</span>
<span class="literal">public</span> <span class="literal">static</span> &lt;T&gt; T <span class="ST6">cast</span>(Object o, Class&lt;T&gt; clazz) {
<span class="literal">return</span> clazz.isInstance(o) ? clazz.cast(o) : <span class="literal">null</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">the</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">a</span> <span class="comment">key</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">present</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">More</span> <span class="comment">formally</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">a</span> <span class="comment">mapping</span> <span class="comment">from</span> <span class="comment">key</span> <span class="comment">k</span> <span class="comment">to</span> <span class="comment">value</span> <span class="comment">v</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> (</span><span class="comment">key</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> ? </span><span class="comment">k</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> : </span><span class="comment">key</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">k</span><span class="comment">)), </span><span class="comment">that</span> <span class="comment">mapping</span> <span class="comment">is</span> <span class="comment">removed</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">The</span> <span class="comment">map</span> <span class="comment">can</span> <span class="comment">contain</span> <span class="comment">at</span> <span class="comment">most</span> <span class="comment">one</span> <span class="comment">such</span> <span class="comment">mapping</span><span class="comment">.</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">key</span><span class="comment"> - </span><span class="comment">key</span> <span class="comment">whose</span> <span class="comment">mapping</span> <span class="comment">is</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">map</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">previous</span> <span class="comment">value</span> <span class="comment">associated</span> <span class="comment">with</span> <span class="comment">key</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">there</span> <span class="comment">was</span> <span class="comment">no</span> <span class="comment">mapping</span> <span class="comment">for</span> <span class="comment">key</span><span class="comment">.</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">key</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">keys</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> V <span class="ST3">remove</span>(Object key) {
String dashes = <span class="string">&quot;</span><span class="string">---------</span><span class="string">&quot;</span>;
<span class="literal">try</span> {
System.<span class="ST5">out</span>.println(dashes + <span class="string">&quot;</span><span class="string"> remove(</span><span class="string">&quot;</span> + key.toString() + <span class="string">&quot;</span><span class="string">) </span><span class="string">&quot;</span> + dashes);
} <span class="literal">catch</span> (NullPointerException ex) {
System.<span class="ST5">out</span>.println(ex);
System.<span class="ST5">out</span>.println(dashes + <span class="string">&quot;</span><span class="string"> remove(</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">null</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">) </span><span class="string">&quot;</span> + dashes);
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">null parameter</span><span class="string">&quot;</span>);
}
K currentKey = <span class="literal">null</span>;
V currentValue = <span class="literal">null</span>;
EntryASDV&lt;K, V&gt; currentEntry = <span class="literal">null</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; <span class="ST1">map</span>.get(i).size(); ++j) {
currentEntry = <span class="ST1">map</span>.get(i).get(j);
currentKey = currentEntry.<span class="ST1">key</span>;
currentValue = currentEntry.<span class="ST1">value</span>;
<span class="literal">if</span> (currentKey.equals(key) || currentValue.equals(key)) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">key: </span><span class="string">&quot;</span> + currentKey + <span class="string">&quot;</span><span class="string">; value: </span><span class="string">&quot;</span> + currentValue);
<span class="comment">// remove the entry from the map</span>
<span class="ST1">map</span>.remove(i);
<span class="comment">// remove the key from the shared key set</span>
<span class="comment">// duplicate the set so we can iterate through it and not throw a ConcurrentModificationException...</span>
Object[] iterateArray = <span class="ST1">sharedKeySet</span>.toArray();
<span class="literal">for</span> (Object o : iterateArray) {
<span class="literal">if</span> (o.equals(currentKey)) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">removing </span><span class="string">&quot;</span> + o);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">remove successful? </span><span class="string">&quot;</span> + <span class="ST1">sharedKeySet</span>.remove(currentKey));
<span class="literal">break</span>; <span class="comment">// we only want to delete the first one</span>
}
}
<span class="comment">// remove the value from the shared key map</span>
<span class="comment">// duplicate again...</span>
iterateArray = <span class="ST1">sharedEntrySet</span>.toArray();
<span class="literal">for</span> (Object o : iterateArray) {
<span class="literal">if</span> (o.equals(currentEntry)) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">removing </span><span class="string">&quot;</span> + o);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">remove successful? </span><span class="string">&quot;</span> + <span class="ST1">sharedEntrySet</span>.remove(currentEntry));
<span class="literal">break</span>; <span class="comment">// we only want to delete the first one</span>
}
}
<span class="comment">// Finally, remove the value from sharedValuesCollection</span>
<span class="comment">// duplicate again...</span>
iterateArray = <span class="ST1">sharedValuesCollection</span>.toArray();
<span class="literal">for</span> (Object o : iterateArray) {
<span class="comment">//System.out.println(o);</span>
<span class="literal">if</span> (o.equals(currentValue)) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">removing </span><span class="string">&quot;</span> + o);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">remove successful? </span><span class="string">&quot;</span> + <span class="ST1">sharedValuesCollection</span>.remove(o));
<span class="literal">break</span>; <span class="comment">// we only want to delete the first one</span>
}
}
<span class="comment">//for(Object o: sharedValuesCollection.toArray()) System.out.println(o); </span>
<span class="literal">return</span> currentValue;
}
}
}
<span class="literal">return</span> <span class="literal">null</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Copies</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">mappings</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">map</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">effect</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">call</span> <span class="comment">is</span> <span class="comment">equivalent</span> <span class="comment">to</span> <span class="comment">that</span> <span class="comment">of</span> <span class="comment">calling</span> <span class="comment">put</span><span class="comment">(</span><span class="comment">k</span><span class="comment">, </span><span class="comment">v</span><span class="comment">) </span><span class="comment">on</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">once</span> <span class="comment">for</span> <span class="comment">each</span> <span class="comment">mapping</span> <span class="comment">from</span> <span class="comment">key</span> <span class="comment">k</span> <span class="comment">to</span> <span class="comment">value</span> <span class="comment">v</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">map</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">behavior</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">operation</span> <span class="comment">is</span> <span class="comment">undefined</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">modified</span> <span class="comment">while</span> <span class="comment">the</span> <span class="comment">operation</span> <span class="comment">is</span> <span class="comment">in</span> <span class="comment">progress</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST4">m</span><span class="comment"> - </span><span class="comment">mappings</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">stored</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NullPointerException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">map</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">keys</span> <span class="comment">or</span> <span class="comment">values</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">map</span> <span class="comment">contains</span> <span class="comment">null</span> <span class="comment">keys</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST3">putAll</span>(Map&lt;? <span class="literal">extends</span> K, ? <span class="literal">extends</span> V&gt; m) {
<span class="literal">if</span> (m == <span class="literal">null</span>) {
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">null parameter</span><span class="string">&quot;</span>);
}
BiConsumer consumeEachEntry = <span class="literal">new</span> BiConsumer&lt;K, V&gt;() {
MapASDV&lt;K, V&gt; <span class="ST1">mapForConsumer</span> = MapASDV.<span class="literal">this</span>;
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST3">accept</span>(K k, V v) {
<span class="ST1">mapForConsumer</span>.put(k, v);
}
};
m.forEach(consumeEachEntry);
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">mappings</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment"> (</span><span class="comment">optional</span> <span class="comment">operation</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">map</span> <span class="comment">will</span> <span class="comment">be</span> <span class="comment">empty</span> <span class="comment">after</span> <span class="comment">this</span> <span class="comment">call</span> <span class="comment">returns</span><span class="comment">.</span> <span class="comment">Any</span> <span class="comment">shared</span> <span class="comment">sets</span> <span class="comment">are</span> <span class="comment">also</span> <span class="comment">cleared</span><span class="comment">.</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST3">clear</span>() {
<span class="comment">// Clear everything out by redefining all internal values, and let Java&#39;s GC take care of the rest</span>
<span class="ST1">map</span> = <span class="literal">new</span> ArrayList&lt;&gt;();
<span class="ST1">sharedKeySet</span> = <span class="literal">new</span> SharedSet&lt;K&gt;();
<span class="ST1">sharedEntrySet</span> = <span class="literal">new</span> SharedSet&lt;<span class="ST2">Entry</span>&lt;K, V&gt;&gt;();
<span class="ST1">sharedValuesCollection</span> = <span class="literal">new</span> SharedCollection&lt;V&gt;();
<span class="comment">//capacity = 4;</span>
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">capacity</span>; ++i) {
<span class="ST1">map</span>.add(<span class="literal">new</span> ListASDV&lt;EntryASDV&lt;K, V&gt;&gt;());
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">a</span> <span class="comment">Set</span> <span class="comment">view</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">keys</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">set</span> <span class="comment">is</span> <span class="comment">backed</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">map</span><span class="comment">, </span><span class="comment">so</span> <span class="comment">changes</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">are</span> <span class="comment">reflected</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">set</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">vice</span><span class="comment">-</span><span class="comment">versa</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">modified</span> <span class="comment">while</span> <span class="comment">an</span> <span class="comment">iteration</span> <span class="comment">over</span> <span class="comment">the</span> <span class="comment">set</span> <span class="comment">is</span> <span class="comment">in</span> <span class="comment">progress</span><span class="comment"> (</span><span class="comment">except</span> <span class="comment">through</span> <span class="comment">the</span> <span class="comment">iterator</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">own</span> <span class="comment">remove</span> <span class="comment">operation</span><span class="comment">), </span><span class="comment">the</span> <span class="comment">results</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">iteration</span> <span class="comment">are</span> <span class="comment">undefined</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">set</span> <span class="comment">supports</span> <span class="comment">element</span> <span class="comment">removal</span><span class="comment">, </span><span class="comment">which</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">corresponding</span> <span class="comment">mapping</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">map</span><span class="comment">, </span><span class="comment">via</span> <span class="comment">the</span> <span class="comment">Iterator</span><span class="comment">.</span><span class="comment">remove</span><span class="comment">, </span><span class="comment">Set</span><span class="comment">.</span><span class="comment">remove</span><span class="comment">, </span><span class="comment">removeAll</span><span class="comment">, </span><span class="comment">retainAll</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">clear</span> <span class="comment">operations</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">support</span> <span class="comment">the</span> <span class="comment">add</span> <span class="comment">or</span> <span class="comment">addAll</span> <span class="comment">operations</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">a</span> <span class="comment">set</span> <span class="comment">view</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">keys</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> Set&lt;K&gt; <span class="ST3">keySet</span>() {
<span class="literal">return</span> <span class="literal">this</span>.<span class="ST1">sharedKeySet</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">a</span> <span class="comment">Collection</span> <span class="comment">view</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">values</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">backed</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">map</span><span class="comment">, </span><span class="comment">so</span> <span class="comment">changes</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">are</span> <span class="comment">reflected</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">vice</span><span class="comment">-</span><span class="comment">versa</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">modified</span> <span class="comment">while</span> <span class="comment">an</span> <span class="comment">iteration</span> <span class="comment">over</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">in</span> <span class="comment">progress</span><span class="comment"> (</span><span class="comment">except</span> <span class="comment">through</span> <span class="comment">the</span> <span class="comment">iterator</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">own</span> <span class="comment">remove</span> <span class="comment">operation</span><span class="comment">), </span><span class="comment">the</span> <span class="comment">results</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">iteration</span> <span class="comment">are</span> <span class="comment">undefined</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">collection</span> <span class="comment">supports</span> <span class="comment">element</span> <span class="comment">removal</span><span class="comment">, </span><span class="comment">which</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">corresponding</span> <span class="comment">mapping</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">map</span><span class="comment">, </span><span class="comment">via</span> <span class="comment">the</span> <span class="comment">Iterator</span><span class="comment">.</span><span class="comment">remove</span><span class="comment">, </span><span class="comment">Collection</span><span class="comment">.</span><span class="comment">remove</span><span class="comment">, </span><span class="comment">removeAll</span><span class="comment">, </span><span class="comment">retainAll</span> <span class="comment">and</span> <span class="comment">clear</span> <span class="comment">operations</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">support</span> <span class="comment">the</span> <span class="comment">add</span> <span class="comment">or</span> <span class="comment">addAll</span> <span class="comment">operations</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> Collection&lt;V&gt; <span class="ST3">values</span>() {
<span class="literal">return</span> <span class="ST1">sharedValuesCollection</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">a</span> <span class="comment">Set</span> <span class="comment">view</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">mappings</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">set</span> <span class="comment">is</span> <span class="comment">backed</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">map</span><span class="comment">, </span><span class="comment">so</span> <span class="comment">changes</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">are</span> <span class="comment">reflected</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">set</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">vice</span><span class="comment">-</span><span class="comment">versa</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">the</span> <span class="comment">map</span> <span class="comment">is</span> <span class="comment">modified</span> <span class="comment">while</span> <span class="comment">an</span> <span class="comment">iteration</span> <span class="comment">over</span> <span class="comment">the</span> <span class="comment">set</span> <span class="comment">is</span> <span class="comment">in</span> <span class="comment">progress</span><span class="comment"> (</span><span class="comment">except</span> <span class="comment">through</span> <span class="comment">the</span> <span class="comment">iterator</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">own</span> <span class="comment">remove</span> <span class="comment">operation</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">through</span> <span class="comment">the</span> <span class="comment">setValue</span> <span class="comment">operation</span> <span class="comment">on</span> <span class="comment">a</span> <span class="comment">map</span> <span class="comment">entry</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">iterator</span><span class="comment">) </span><span class="comment">the</span> <span class="comment">results</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">iteration</span> <span class="comment">are</span> <span class="comment">undefined</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">set</span> <span class="comment">supports</span> <span class="comment">element</span> <span class="comment">removal</span><span class="comment">, </span><span class="comment">which</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">corresponding</span> <span class="comment">mapping</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">map</span><span class="comment">, </span><span class="comment">via</span> <span class="comment">the</span> <span class="comment">Iterator</span><span class="comment">.</span><span class="comment">remove</span><span class="comment">, </span><span class="comment">Set</span><span class="comment">.</span><span class="comment">remove</span><span class="comment">, </span><span class="comment">removeAll</span><span class="comment">, </span><span class="comment">retainAll</span> <span class="comment">and</span> <span class="comment">clear</span> <span class="comment">operations</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">support</span> <span class="comment">the</span> <span class="comment">add</span> <span class="comment">or</span> <span class="comment">addAll</span> <span class="comment">operations</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">a</span> <span class="comment">set</span> <span class="comment">view</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">mappings</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">map</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> Set&lt;<span class="ST2">Entry</span>&lt;K, V&gt;&gt; <span class="ST3">entrySet</span>() {
<span class="literal">return</span> <span class="literal">this</span>.<span class="ST1">sharedEntrySet</span>;
}
@Override
<span class="literal">public</span> String <span class="ST3">toString</span>() {
String s = <span class="string">&quot;</span><span class="string">[ </span><span class="string">&quot;</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST1">map</span>.size(); ++i) {
s += <span class="ST1">map</span>.get(i).toString() + <span class="string">&quot;</span><span class="literal">\n</span><span class="string">&quot;</span>;
}
s += <span class="string">&quot;</span><span class="string"> ]</span><span class="string">&quot;</span>;
<span class="literal">return</span> s;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Created</span> <span class="comment">a</span> <span class="comment">deep</span> <span class="comment">copy</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">MapASDV</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">deep</span> <span class="comment">copy</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">map</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> Object <span class="ST3">clone</span>() {
<span class="comment">/*</span>
<span class="comment"> MapASDV&lt;K, V&gt; clonedMap = new MapASDV&lt;K, V&gt;();</span>
<span class="comment"> //clonedMap.putAll(this);</span>
<span class="comment"> for (ListASDV&lt; EntryASDV&lt;K, V&gt;&gt; list : this.map)</span>
<span class="comment"> {</span>
<span class="comment"> ListASDV&lt; EntryASDV&lt;K, V&gt;&gt; l = (ListASDV&lt; EntryASDV&lt;K, V&gt;&gt;) list.clone();</span>
<span class="comment"> clonedMap.map.add(l); </span>
<span class="comment"> }</span>
<span class="comment"> return clonedMap;</span>
<span class="comment"> */</span>
MapASDV&lt;K, V&gt; clonedMap = <span class="literal">new</span> MapASDV&lt;K, V&gt;();
clonedMap.putAll(<span class="literal">t</span><span class="literal">his</span>);
<span class="literal">return</span> clonedMap;
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">main</span>(String[] args) {
MapASDV&lt;String, Integer&gt; map = <span class="literal">new</span> MapASDV&lt;&gt;();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------------------------testing put(K, V)</span><span class="string">&quot;</span>);
map.put(<span class="string">&quot;</span><span class="string">ann</span><span class="string">&quot;</span>, <span class="number">2</span><span class="number">0</span>);
map.put(<span class="string">&quot;</span><span class="string">coco</span><span class="string">&quot;</span>, <span class="number">2</span><span class="number">5</span>);
System.<span class="ST5">out</span>.println(map);
MapASDV&lt;String, Integer&gt; clonedMap = (MapASDV&lt;String, Integer&gt;) map.clone();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing double-the-size-and-rehash by reaching 0.75 load factor with another put(K, V)</span><span class="string">&quot;</span>);
map.put(<span class="string">&quot;</span><span class="string">Jonathan</span><span class="string">&quot;</span>, <span class="number">3</span><span class="number">0</span>);
System.<span class="ST5">out</span>.println(map);
map.put(<span class="string">&quot;</span><span class="string">Jonhathan</span><span class="string">&quot;</span>, <span class="number">4</span><span class="number">5</span>);
System.<span class="ST5">out</span>.println(map);
map.put(<span class="string">&quot;</span><span class="string">Alexander</span><span class="string">&quot;</span>, <span class="number">3</span><span class="number">3</span>);
System.<span class="ST5">out</span>.println(map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing putAll(Map&lt;K,V&gt;)</span><span class="string">&quot;</span>);
Map&lt;String, Integer&gt; anotherJavaMap = <span class="literal">new</span> HashMap();
anotherJavaMap.put(<span class="string">&quot;</span><span class="string">lion king</span><span class="string">&quot;</span>, <span class="number">4</span><span class="number">5</span>);
anotherJavaMap.put(<span class="string">&quot;</span><span class="string">HYENA</span><span class="string">&quot;</span>, <span class="number">6</span>);
map.putAll(anotherJavaMap);
System.<span class="ST5">out</span>.println(map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing containsKey</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.containsKey(<span class="string">&quot;</span><span class="string">Alexander</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(map.containsKey(<span class="string">&quot;</span><span class="string">alexander</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing containsValue</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.containsValue(<span class="number">3</span><span class="number">3</span>));
System.<span class="ST5">out</span>.println(map.containsValue(<span class="number">3</span><span class="number">4</span>));
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing getEntryForKey</span><span class="string">&quot;</span>);
<span class="ST2">Entry</span>&lt;String, Integer&gt; e = map.getEntryForKey(<span class="string">&quot;</span><span class="string">Alexander</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.getEntryForKey(<span class="string">&quot;</span><span class="string">Alexander</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(map.getEntryForKey(<span class="string">&quot;</span><span class="string">Alex</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing get</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.get(<span class="string">&quot;</span><span class="string">Alexander</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(map.get(<span class="string">&quot;</span><span class="string">Alex</span><span class="string">&quot;</span>));
<span class="literal">try</span> {
map.get(<span class="literal">n</span><span class="literal">ull</span>);
} <span class="literal">catch</span> (NullPointerException ex) {
System.<span class="ST5">out</span>.println(ex.getMessage());
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing getIndexForKey</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.getIndexForKey(<span class="string">&quot;</span><span class="string">Alexander</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(map.getIndexForKey(<span class="string">&quot;</span><span class="string">Alex</span><span class="string">&quot;</span>));
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing isEmpty</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.isEmpty());
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing size</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(map.size());
System.<span class="ST5">out</span>.println(map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing entrySet()</span><span class="string">&quot;</span>);
Set&lt;<span class="ST2">Entry</span>&lt;String, Integer&gt;&gt; entries = map.entrySet();
System.<span class="ST5">out</span>.println(entries);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing keySet()</span><span class="string">&quot;</span>);
Set&lt;String&gt; keys = map.keySet();
System.<span class="ST5">out</span>.println(keys);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing values()</span><span class="string">&quot;</span>);
Collection&lt;Integer&gt; values = map.values();
System.<span class="ST5">out</span>.println(values);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing remove( K) coco 25</span><span class="string">&quot;</span>);
map.remove(<span class="string">&quot;</span><span class="string">coco</span><span class="string">&quot;</span>);
values = map.values();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">map: </span><span class="string">&quot;</span> + map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">entries: </span><span class="string">&quot;</span> + entries);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">keys: </span><span class="string">&quot;</span> + keys);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">values: </span><span class="string">&quot;</span> + values);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing Entry-Collection remove </span><span class="string">&quot;</span>);
entries.remove(e);
values = map.values();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">map: </span><span class="string">&quot;</span> + map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">entries: </span><span class="string">&quot;</span> + entries);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">keys: </span><span class="string">&quot;</span> + keys);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">values: </span><span class="string">&quot;</span> + values);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing Set Keys remove </span><span class="string">&quot;</span>);
keys.remove(<span class="string">&quot;</span><span class="string">ann</span><span class="string">&quot;</span>);
values = map.values();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">map: </span><span class="string">&quot;</span> + map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">entries: </span><span class="string">&quot;</span> + entries);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">keys: </span><span class="string">&quot;</span> + keys);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">values: </span><span class="string">&quot;</span> + values);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing Set Values remove </span><span class="string">&quot;</span>);
values.remove(<span class="number">4</span><span class="number">5</span>);
values = map.values();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">map: </span><span class="string">&quot;</span> + map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">entries: </span><span class="string">&quot;</span> + entries);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">keys: </span><span class="string">&quot;</span> + keys);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">values: </span><span class="string">&quot;</span> + values);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing clear </span><span class="string">&quot;</span>);
map.clear();
values = map.values();
entries = map.entrySet();
keys = map.keySet();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">map: </span><span class="string">&quot;</span> + map);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">entries: </span><span class="string">&quot;</span> + entries);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">keys: </span><span class="string">&quot;</span> + keys);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">values: </span><span class="string">&quot;</span> + values);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing add of sets and collections </span><span class="string">&quot;</span>);
<span class="literal">try</span> {
keys.add(<span class="string">&quot;</span><span class="string">a</span><span class="string">&quot;</span>);
} <span class="literal">catch</span> (Exception ex) {
System.<span class="ST5">out</span>.println(ex.getMessage());
}
<span class="literal">try</span> {
values.add(<span class="number">3</span><span class="number">3</span>);
} <span class="literal">catch</span> (Exception ex) {
System.<span class="ST5">out</span>.println(ex.getMessage());
}
<span class="literal">try</span> {
entries.add(e);
} <span class="literal">catch</span> (Exception ex) {
System.<span class="ST5">out</span>.println(ex.getMessage());
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">---------------------------testing clone</span><span class="string">&quot;</span>);
System.<span class="ST5">out</span>.println(clonedMap);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------------------------testing put(K, V) AGAIN</span><span class="string">&quot;</span>);
map.put(<span class="string">&quot;</span><span class="string">Nicholas</span><span class="string">&quot;</span>, <span class="number">1</span><span class="number">00</span>);
map.put(<span class="string">&quot;</span><span class="string">a</span><span class="string">&quot;</span>, <span class="number">2</span><span class="number">00</span>);
map.put(<span class="string">&quot;</span><span class="string">b</span><span class="string">&quot;</span>, -<span class="number">20</span>);
System.<span class="ST5">out</span>.println(map);
}
}
</pre></body>
</html>

@ -71,7 +71,7 @@ jlink.additionalmodules=
jlink.additionalparam= jlink.additionalparam=
jlink.launcher=true jlink.launcher=true
jlink.launcher.name=MapASDV_CalebFontenot jlink.launcher.name=MapASDV_CalebFontenot
main.class=mapasdv_calebfontenot.MapASDV_CalebFontenot main.class=mapasdv_calebfontenot.MapASDV
manifest.file=manifest.mf manifest.file=manifest.mf
meta.inf.dir=${src.dir}/META-INF meta.inf.dir=${src.dir}/META-INF
mkdist.disabled=false mkdist.disabled=false

@ -1330,7 +1330,7 @@ public class ListASDV<E>
s += '}'; s += '}';
return s; return s;
} }
/**
public static void main(String[] args) public static void main(String[] args)
{ {
class ASDV_ENTRY<T1, T2> implements Map.Entry<T1, T1> class ASDV_ENTRY<T1, T2> implements Map.Entry<T1, T1>
@ -1685,6 +1685,7 @@ public class ListASDV<E>
} }
} }
**/
} }

@ -8,7 +8,6 @@ package mapasdv_calebfontenot;
* *
* @author caleb * @author caleb
*/ */
//import ListASDV; //import ListASDV;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -20,28 +19,24 @@ import java.util.Objects;
import java.util.Set; import java.util.Set;
import java.util.function.BiConsumer;//needed in putAll import java.util.function.BiConsumer;//needed in putAll
public class MapASDV<K, V> implements Map<K, V>, Cloneable public class MapASDV<K, V> implements Map<K, V>, Cloneable {
{
private int capacity = 4; private int capacity = 4;
private double loadFactor = 0.75; private double loadFactor = 0.75;
private ArrayList<ListASDV<EntryASDV<K, V>>> map = new ArrayList<>(); private ArrayList<ListASDV<EntryASDV<K, V>>> map = new ArrayList<>();
private Set<K> sharedKeySet = new SharedSet<K>(); private Set<K> sharedKeySet = new SharedSet<>();
private Set<Entry<K, V>> sharedEntrySet = new SharedSet<Entry<K, V>>(); private Set<Entry<K, V>> sharedEntrySet = new SharedSet<>();
private Collection<V> sharedValuesCollection = new SharedCollection<V>(); private Collection<V> sharedValuesCollection = new SharedCollection<>();
private class SharedCollection<V> extends ArrayList<V> private class SharedCollection<V> extends ArrayList<V> {
{
public boolean addValue(V v) public boolean addValue(V v) {
{
return this.add(v); return this.add(v);
} }
@Override @Override
public boolean remove(Object o) public boolean remove(Object o) {
{
//> The parameter is key not entry if we are here //> The parameter is key not entry if we are here
//>>remove value) and key) from the map //>>remove value) and key) from the map
@ -52,19 +47,13 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
} }
/** /**
* Removes one value from the collection. This method is meant to be * Removes one value from the collection. This method is meant to be called from out class. The overridden remove(Object o) of this inner class, calls the remove of the outer class(MapASDV), and the remove of the outer class, calls remove(V v, boolean callFromOuterClass) instead of remove(Object o) to avoid Stack Overflow when remover of inner calls remove of outer and vice versa.
* called from out class. The overridden remove(Object o) of this inner
* class, calls the remove of the outer class(MapASDV), and the remove
* of the outer class, calls remove(V v, boolean callFromOuterClass)
* instead of remove(Object o) to avoid Stack Overflow when remover of
* inner calls remove of outer and vice versa.
* *
* @param o - the key * @param o - the key
* @param callFromOuterClass - dummy variable. * @param callFromOuterClass - dummy variable.
* @return true if the key was removed from the Set * @return true if the key was removed from the Set
*/ */
public boolean remove(V v, boolean callFromOuterClass) public boolean remove(V v, boolean callFromOuterClass) {
{
//remove key from shared keys set //remove key from shared keys set
boolean b = super.remove(v); boolean b = super.remove(v);
return b; return b;
@ -72,55 +61,43 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
} }
@Override @Override
public Object clone() public Object clone() {
{
return super.clone(); return super.clone();
} }
@Override @Override
public void clear() public void clear() {
{
super.clear(); super.clear();
} }
} }
private class SharedSet<E> extends HashSet<E> private class SharedSet<E> extends HashSet<E> {
{
@Override @Override
public boolean add(E e) public boolean add(E e) {
{
throw new UnsupportedOperationException("Not supported....");
}
@Override
public boolean removeAll(Collection<?> c)
{
throw new UnsupportedOperationException("Not supported....");
}
/**
* Adds an EntryASDV to the set. It is private and cannot be used by the
* user of the Set. It is used from the MapASDV to add EntriesASDV to
* the SharedSet. Without this method we wouldn't be able to create a
* Set of keys or a Set of entries to give to the user via methods
* keySet() and entrySet() of this Map
*
* @param e EntryASDV
* @return true if the entry was added false otherwise
*/
private boolean addEntry(E e)
{
return super.add(e); return super.add(e);
} }
@Override @Override
public boolean remove(Object o) public boolean removeAll(Collection<?> c) {
{ return super.removeAll(c);
}
/**
* Adds an EntryASDV to the set. It is private and cannot be used by the user of the Set. It is used from the MapASDV to add EntriesASDV to the SharedSet. Without this method we wouldn't be able to create a Set of keys or a Set of entries to give to the user via methods keySet() and entrySet() of this Map
*
* @param e EntryASDV
* @return true if the entry was added false otherwise
*/
private boolean addEntry(E e) {
return super.add(e);
}
@Override
public boolean remove(Object o) {
//>if parameter oo is EntryASDV call auxiliary method removeEntry //>if parameter oo is EntryASDV call auxiliary method removeEntry
if (o instanceof EntryASDV) if (o instanceof EntryASDV) {
{
return removeEntry((EntryASDV) o); return removeEntry((EntryASDV) o);
} }
@ -137,50 +114,39 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @param entry the entry to be removed * @param entry the entry to be removed
* @return true if the entry was removed, false otherwise * @return true if the entry was removed, false otherwise
*/ */
private boolean removeEntry(EntryASDV<K, V> entry) private boolean removeEntry(EntryASDV<K, V> entry) {
{
MapASDV.this.remove(entry.getKey()); MapASDV.this.remove(entry.getKey());
return super.remove(entry); return super.remove(entry);
} }
/** /**
* Removes the key from the set. This method is meant to be called from * Removes the key from the set. This method is meant to be called from out class. The overridden remove(Object o) of this inner class calls the remove of the out class, and the remove of the outer class calls remove(K o, boolean callFromOuterClass) instead of remove(Object o) to avoid Stack Overflow when remover of inner calls remove of outer and vice versa.
* out class. The overridden remove(Object o) of this inner class calls
* the remove of the out class, and the remove of the outer class calls
* remove(K o, boolean callFromOuterClass) instead of remove(Object o)
* to avoid Stack Overflow when remover of inner calls remove of outer
* and vice versa.
* *
* @param o - the key * @param o - the key
* @param callFromOuterClass - dummy variable. * @param callFromOuterClass - dummy variable.
* @return true if the key was removed from the Set * @return true if the key was removed from the Set
*/ */
public boolean remove(E o, boolean callFromOuterClass) public boolean remove(E o, boolean callFromOuterClass) {
{
//remove key from shared keys set //remove key from shared keys set
return super.remove(o); return super.remove(o);
} }
@Override @Override
public Object clone() public Object clone() {
{
return super.clone(); return super.clone();
} }
@Override @Override
public void clear() public void clear() {
{
super.clear(); super.clear();
} }
} }
public MapASDV() public MapASDV() {
{ for (int i = 0; i < capacity; ++i) {
for (int i = 0; i < capacity; ++i)
{
map.add(new ListASDV<EntryASDV<K, V>>()); map.add(new ListASDV<EntryASDV<K, V>>());
} }
} }
@ -188,15 +154,13 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
/** /**
* Double the size of the Map and rehashes the entries of the Map * Double the size of the Map and rehashes the entries of the Map
*/ */
private void doubleTheSizeOfTheMapAndRehash() private void doubleTheSizeOfTheMapAndRehash() {
{
capacity *= 2; capacity *= 2;
//>create a new arrayList of ListsASDV //>create a new arrayList of ListsASDV
ArrayList<ListASDV<EntryASDV<K, V>>> newMap = new ArrayList<ListASDV<EntryASDV<K, V>>>(); ArrayList<ListASDV<EntryASDV<K, V>>> newMap = new ArrayList<ListASDV<EntryASDV<K, V>>>();
//>Add at every enetry of the arrayList a new ASDVList //>Add at every enetry of the arrayList a new ASDVList
for (int i = 0; i < capacity; ++i) for (int i = 0; i < capacity; ++i) {
{
newMap.add(new ListASDV<EntryASDV<K, V>>()); newMap.add(new ListASDV<EntryASDV<K, V>>());
} }
@ -207,10 +171,9 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
ListASDV<EntryASDV<K, V>> list = map.get(i); ListASDV<EntryASDV<K, V>> list = map.get(i);
//>>for the size() of the ASDVlist //>>for the size() of the ASDVlist
for (int j = 0; j < list.size(); ++j) for (int j = 0; j < list.size(); ++j) {
{
///>>>hash and put in the the new array ///>>>hash and put in the the new array
int index = hash( list.get(j).getKey().hashCode() ); int index = hash(list.get(j).getKey().hashCode());
newMap.get(index).add(list.get(j)); newMap.get(index).add(list.get(j));
} }
@ -218,62 +181,51 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
map = newMap; map = newMap;
} }
class EntryASDV<K, V> implements Entry<K, V>, Comparable<K> class EntryASDV<K, V> implements Entry<K, V>, Comparable<K> {
{
K key; K key;
V value; V value;
public EntryASDV(K key, V value) public EntryASDV(K key, V value) {
{
this.key = key; this.key = key;
this.value = value; this.value = value;
} }
@Override @Override
public K getKey() public K getKey() {
{
return key; return key;
} }
@Override @Override
public V getValue() public V getValue() {
{
return value; return value;
} }
@Override @Override
public V setValue(V value) public V setValue(V value) {
{
V oldValue = this.value; V oldValue = this.value;
this.value = value; this.value = value;
return oldValue; return oldValue;
} }
@Override @Override
public String toString() public String toString() {
{
return "EntryASDV{" + "key=" + key + ", value=" + value + '}'; return "EntryASDV{" + "key=" + key + ", value=" + value + '}';
} }
@Override @Override
public boolean equals(Object obj) public boolean equals(Object obj) {
{ if (this == obj) {
if (this == obj)
{
return true; return true;
} }
if (obj == null) if (obj == null) {
{
return false; return false;
} }
if (getClass() != obj.getClass()) if (getClass() != obj.getClass()) {
{
return false; return false;
} }
final EntryASDV<?, ?> other = (EntryASDV<?, ?>) obj; final EntryASDV<?, ?> other = (EntryASDV<?, ?>) obj;
if (!Objects.equals(this.key, other.key)) if (!Objects.equals(this.key, other.key)) {
{
return false; return false;
} }
return true; return true;
@ -285,10 +237,8 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @return throws IllegalArgumentException if parameter class is not K * @return throws IllegalArgumentException if parameter class is not K
*/ */
@Override @Override
public int compareTo(K o) public int compareTo(K o) {
{ if (getClass() != o.getClass()) {
if (getClass() != o.getClass())
{
throw new IllegalArgumentException("ellegal parameter " + o); throw new IllegalArgumentException("ellegal parameter " + o);
} }
return ((Comparable) key).compareTo(o); return ((Comparable) key).compareTo(o);
@ -297,27 +247,33 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
} }
@Override @Override
public int size() public int size() {
{
return this.keySet().size(); return this.keySet().size();
} }
@Override @Override
public boolean isEmpty() public boolean isEmpty() {
{ if (map.size() == 0) {
throw new UnsupportedOperationException("Not supported...."); return true;
}
return false;
} }
// done
@Override @Override
public boolean containsKey(Object key) public boolean containsKey(Object key) {
{ String dashes = "---------";
System.out.println(dashes + " containsKey(" + key.toString() + ") " + dashes);
for (int i = 0; i < map.size(); ++i) { for (int i = 0; i < map.size(); ++i) {
System.out.println(map.get(i)); for (int j = 0; j < map.get(i).size(); ++j) {
if (map.get(i).get(j).key.equals(key)) {
return true;
}
} }
throw new UnsupportedOperationException("Not supported yet....");
} }
return false;
}
/** /**
* Return an entry of the map * Return an entry of the map
@ -325,16 +281,12 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @param key the key of the entry to be returned * @param key the key of the entry to be returned
* @return the entry, or null if the key is not in the map * @return the entry, or null if the key is not in the map
*/ */
private EntryASDV<K, V> getEntryForKey(Object key) private EntryASDV<K, V> getEntryForKey(Object key) {
{ for (ListASDV<EntryASDV<K, V>> list : map) {
for (ListASDV<EntryASDV<K, V>> list : map)
{
Iterator<EntryASDV<K, V>> it = list.iterator(); Iterator<EntryASDV<K, V>> it = list.iterator();
while (it.hasNext()) while (it.hasNext()) {
{
EntryASDV<K, V> entry = it.next(); EntryASDV<K, V> entry = it.next();
if (key.equals(entry.getKey())) if (key.equals(entry.getKey())) {
{
return entry; return entry;
} }
} }
@ -348,16 +300,12 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @param key a key of the map * @param key a key of the map
* @return the index of a key in the map or -1, if the key is not in the map * @return the index of a key in the map or -1, if the key is not in the map
*/ */
private int getIndexForKey(Object key) private int getIndexForKey(Object key) {
{ for (int i = 0; i < map.size(); ++i) {
for (int i = 0; i < map.size(); ++i)
{
Iterator<EntryASDV<K, V>> it = map.get(i).iterator(); Iterator<EntryASDV<K, V>> it = map.get(i).iterator();
while (it.hasNext()) while (it.hasNext()) {
{
EntryASDV<K, V> entry = it.next(); EntryASDV<K, V> entry = it.next();
if (key.equals(entry.getKey())) if (key.equals(entry.getKey())) {
{
return i; return i;
} }
} }
@ -366,84 +314,83 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
} }
/** /**
* Returns true if this map maps one or more keys to the specified value. * Returns true if this map maps one or more keys to the specified value. More formally, returns true if and only if this map contains at least one mapping to a value v such that (value==null ? v==null : value.equals(v)). This operation will probably require time linear in the map size for most implementations of the Map interface.
* More formally, returns true if and only if this map contains at least one
* mapping to a value v such that (value==null ? v==null : value.equals(v)).
* This operation will probably require time linear in the map size for most
* implementations of the Map interface.
* *
* Parameters: value - value whose presence in this map is to be tested * Parameters: value - value whose presence in this map is to be tested Returns: true if this map maps one or more keys to the specified value Throws: ClassCastException - if the value is of an inappropriate type for this map (optional) NullPointerException - if the specified value is null and this map does not permit null values (optional)
* Returns: true if this map maps one or more keys to the specified value
* Throws: ClassCastException - if the value is of an inappropriate type for
* this map (optional) NullPointerException - if the specified value is null
* and this map does not permit null values (optional)
* *
* @param value - value whose presence in this map is to be tested * @param value - value whose presence in this map is to be tested
* @return true if this map maps one or more keys to the specified value * @return true if this map maps one or more keys to the specified value
* @throws NullPointerException - if the specified value is null and this * @throws NullPointerException - if the specified value is null and this map does not permit null values (optional)
* map does not permit null values (optional)
*/ */
//done
@Override @Override
public boolean containsValue(Object value) public boolean containsValue(Object value) {
{ String dashes = "---------";
throw new UnsupportedOperationException("Not supported yet...."); System.out.println(dashes + " containsValue(" + value.toString() + ") " + dashes);
for (int i = 0; i < map.size(); ++i) {
for (int j = 0; j < map.get(i).size(); ++j) {
if (map.get(i).get(j).value.equals(value)) {
return true;
}
}
}
return false;
} }
/** /**
* Returns the value to which the specified key is mapped, or null if this * Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
* map contains no mapping for the key.
* *
* More formally, if this map contains a mapping from a key k to a value v * More formally, if this map contains a mapping from a key k to a value v such that (key==null ? k==null : key.equals(k)), then this method returns v; otherwise it returns null. (There can be at most one such mapping.)
* such that (key==null ? k==null : key.equals(k)), then this method returns
* v; otherwise it returns null. (There can be at most one such mapping.)
* *
* If this map permits null values, then a return value of null does not * If this map permits null values, then a return value of null does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to null. The containsKey operation may be used to distinguish these two cases.
* necessarily indicate that the map contains no mapping for the key; it's
* also possible that the map explicitly maps the key to null. The
* containsKey operation may be used to distinguish these two cases.
* *
* @param key - the key whose associated value is to be returned * @param key - the key whose associated value is to be returned
* @return the value to which the specified key is mapped, or null if this * @return the value to which the specified key is mapped, or null if this map contains no mapping for the key
* map contains no mapping for the key * @throws NullPointerException - if the specified key is null and this map does not permit null keys (optional)
* @throws NullPointerException - if the specified key is null and this map
* does not permit null keys (optional)
*/ */
//done
@Override @Override
public V get(Object key) public V get(Object key) {
{ String dashes = "---------";
throw new UnsupportedOperationException("Not supported yet...."); try {
System.out.println(dashes + " get(" + key.toString() + ") " + dashes);
} catch (NullPointerException ex) {
//System.out.println(ex);
System.out.println(dashes + " get(" + "null" + ") " + dashes);
throw new NullPointerException("null parameter");
}
Object currentKey = null;
for (int i = 0; i < map.size(); ++i) {
for (int j = 0; j < map.get(i).size(); ++j) {
currentKey = map.get(i).get(j).key;
if (currentKey.equals(key)) {
return map.get(i).get(j).value;
}
}
}
return null;
} }
/** /**
* Associates the specified value with the specified key in this map * Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map m is said to contain a mapping for a key k if and only if m.containsKey(k) would return true.)
* (optional operation). If the map previously contained a mapping for the
* key, the old value is replaced by the specified value. (A map m is said
* to contain a mapping for a key k if and only if m.containsKey(k) would
* return true.)
* *
* @param key - key with which the specified value is to be associated * @param key - key with which the specified value is to be associated
* @param value - value to be associated with the specified key * @param value - value to be associated with the specified key
* @return the previous value associated with key, or null if there was no * @return the previous value associated with key, or null if there was no mapping for key. (A null return can also indicate that the map previously associated null with key, if the implementation supports null values.)
* mapping for key. (A null return can also indicate that the map previously * @throws NullPointerException - if specified key or value is null and this map does not permit null keys
* associated null with key, if the implementation supports null values.)
* @throws NullPointerException - if specified key or value is null and this
* map does not permit null keys
*/ */
@Override @Override
public V put(K key, V value) public V put(K key, V value) {
{
if (key == null || value == null) if (key == null || value == null) {
{
throw new NullPointerException("parm(s) null"); throw new NullPointerException("parm(s) null");
} }
//>if contains the key, replace the key's value //>if contains the key, replace the key's value
EntryASDV<K, V> entry = getEntryForKey(key); EntryASDV<K, V> entry = getEntryForKey(key);
if (entry != null) if (entry != null) {
{
V oldValue = entry.value; V oldValue = entry.value;
entry.value = value; entry.value = value;
@ -468,8 +415,7 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
((SharedCollection<V>) this.sharedValuesCollection).addValue(v); ((SharedCollection<V>) this.sharedValuesCollection).addValue(v);
//>> if reach 75% capacity double the size //>> if reach 75% capacity double the size
if ((double) this.size() / capacity >= 0.75) if ((double) this.size() / capacity >= 0.75) {
{
this.doubleTheSizeOfTheMapAndRehash(); this.doubleTheSizeOfTheMapAndRehash();
} }
@ -477,8 +423,7 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
return v; return v;
} }
int hash(int keyHashCode) int hash(int keyHashCode) {
{
int h = hashHash(keyHashCode); int h = hashHash(keyHashCode);
return Math.abs(h % capacity - 1); return Math.abs(h % capacity - 1);
} }
@ -490,10 +435,16 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @return true if removed, false otherwise * @return true if removed, false otherwise
* @throws NullPointerException if the value is null * @throws NullPointerException if the value is null
*/ */
private boolean removeFirstValue(Object value) private boolean removeFirstValue(Object value) {
{ Iterator<V> iterator = sharedValuesCollection.iterator();
throw new UnsupportedOperationException("Not supported yet...."); while (iterator.hasNext()) {
Object o = iterator.next();
if (o.equals(value)) {
iterator.remove();
return true;
}
}
return false;
} }
/** /**
@ -502,58 +453,102 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @param h - hash code * @param h - hash code
* @return evenly distributed hash code * @return evenly distributed hash code
*/ */
private static int hashHash(int h) private static int hashHash(int h) {
{
h ^= (h >>> 20) ^ (h >>> 12); h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4); return h ^ (h >>> 7) ^ (h >>> 4);
} }
// class cast helper method
public static <T> T cast(Object o, Class<T> clazz) {
return clazz.isInstance(o) ? clazz.cast(o) : null;
}
/** /**
* Removes the mapping for a key from this map if it is present (optional * Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key k to value v such that (key==null ? k==null : key.equals(k)), that mapping is removed. (The map can contain at most one such mapping.)
* operation). More formally, if this map contains a mapping from key k to
* value v such that (key==null ? k==null : key.equals(k)), that mapping is
* removed. (The map can contain at most one such mapping.)
* *
* @param key - key whose mapping is to be removed from the map * @param key - key whose mapping is to be removed from the map
* @return the previous value associated with key, or null if there was no * @return the previous value associated with key, or null if there was no mapping for key.
* mapping for key. * @throws NullPointerException - if the specified key is null and this map does not permit null keys
* @throws NullPointerException - if the specified key is null and this map
* does not permit null keys
*/ */
@Override @Override
public V remove(Object key) public V remove(Object key) {
{ String dashes = "---------";
throw new UnsupportedOperationException("Not supported yet...."); try {
System.out.println(dashes + " remove(" + key.toString() + ") " + dashes);
} catch (NullPointerException ex) {
System.out.println(ex);
System.out.println(dashes + " remove(" + "null" + ") " + dashes);
throw new NullPointerException("null parameter");
}
K currentKey = null;
V currentValue = null;
EntryASDV<K, V> currentEntry = null;
for (int i = 0; i < map.size(); ++i) {
for (int j = 0; j < map.get(i).size(); ++j) {
currentEntry = map.get(i).get(j);
currentKey = currentEntry.key;
currentValue = currentEntry.value;
if (currentKey.equals(key) || currentValue.equals(key)) {
System.out.println("key: " + currentKey + "; value: " + currentValue);
// remove the entry from the map
map.remove(i);
// remove the key from the shared key set
// duplicate the set so we can iterate through it and not throw a ConcurrentModificationException...
Object[] iterateArray = sharedKeySet.toArray();
for (Object o : iterateArray) {
if (o.equals(currentKey)) {
System.out.println("removing " + o);
System.out.println("remove successful? " + sharedKeySet.remove(currentKey));
break; // we only want to delete the first one
}
}
// remove the value from the shared key map
// duplicate again...
iterateArray = sharedEntrySet.toArray();
for (Object o : iterateArray) {
if (o.equals(currentEntry)) {
System.out.println("removing " + o);
System.out.println("remove successful? " + sharedEntrySet.remove(currentEntry));
break; // we only want to delete the first one
}
}
// Finally, remove the value from sharedValuesCollection
// duplicate again...
iterateArray = sharedValuesCollection.toArray();
for (Object o : iterateArray) {
//System.out.println(o);
if (o.equals(currentValue)) {
System.out.println("removing " + o);
System.out.println("remove successful? " + sharedValuesCollection.remove(o));
break; // we only want to delete the first one
}
}
//for(Object o: sharedValuesCollection.toArray()) System.out.println(o);
return currentValue;
}
}
}
return null;
} }
/** /**
* Copies all of the mappings from the specified map to this map (optional * Copies all of the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling put(k, v) on this map once for each mapping from key k to value v in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.
* operation). The effect of this call is equivalent to that of calling
* put(k, v) on this map once for each mapping from key k to value v in the
* specified map. The behavior of this operation is undefined if the
* specified map is modified while the operation is in progress.
* *
* @param m - mappings to be stored in this map * @param m - mappings to be stored in this map
* @throws NullPointerException - if the specified map is null, or if this * @throws NullPointerException - if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys
* map does not permit null keys or values, and the specified map contains
* null keys
*/ */
@Override @Override
public void putAll(Map<? extends K, ? extends V> m) public void putAll(Map<? extends K, ? extends V> m) {
{ if (m == null) {
if (m == null)
{
throw new NullPointerException("null parameter"); throw new NullPointerException("null parameter");
} }
BiConsumer consumeEachEntry = new BiConsumer<K, V>() BiConsumer consumeEachEntry = new BiConsumer<K, V>() {
{
MapASDV<K, V> mapForConsumer = MapASDV.this; MapASDV<K, V> mapForConsumer = MapASDV.this;
@Override @Override
public void accept(K k, V v) public void accept(K k, V v) {
{
mapForConsumer.put(k, v); mapForConsumer.put(k, v);
} }
}; };
@ -561,82 +556,59 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
m.forEach(consumeEachEntry); m.forEach(consumeEachEntry);
} }
/** /**
* Removes all of the mappings from this map (optional operation). The map * Removes all of the mappings from this map (optional operation). The map will be empty after this call returns. Any shared sets are also cleared.
* will be empty after this call returns. Any shared sets are also cleared.
*/ */
@Override @Override
public void clear() public void clear() {
{
throw new UnsupportedOperationException("Not supported yet....");
// Clear everything out by redefining all internal values, and let Java's GC take care of the rest
map = new ArrayList<>();
sharedKeySet = new SharedSet<K>();
sharedEntrySet = new SharedSet<Entry<K, V>>();
sharedValuesCollection = new SharedCollection<V>();
//capacity = 4;
for (int i = 0; i < capacity; ++i) {
map.add(new ListASDV<EntryASDV<K, V>>());
}
} }
/** /**
* Returns a Set view of the keys contained in this map. The set is backed * Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
* by the map, so changes to the map are reflected in the set, and
* vice-versa. If the map is modified while an iteration over the set is in
* progress (except through the iterator's own remove operation), the
* results of the iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* Iterator.remove, Set.remove, removeAll, retainAll, and clear operations.
* It does not support the add or addAll operations.
* *
* @return a set view of the keys contained in this map * @return a set view of the keys contained in this map
*/ */
@Override @Override
public Set<K> keySet() public Set<K> keySet() {
{
return this.sharedKeySet; return this.sharedKeySet;
} }
/** /**
* Returns a Collection view of the values contained in this map. The * Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.
* collection is backed by the map, so changes to the map are reflected in
* the collection, and vice-versa. If the map is modified while an iteration
* over the collection is in progress (except through the iterator's own
* remove operation), the results of the iteration are undefined. The
* collection supports element removal, which removes the corresponding
* mapping from the map, via the Iterator.remove, Collection.remove,
* removeAll, retainAll and clear operations. It does not support the add or
* addAll operations.
* *
* @return * @return
*/ */
@Override @Override
public Collection<V> values() public Collection<V> values() {
{
return sharedValuesCollection; return sharedValuesCollection;
} }
/** /**
* Returns a Set view of the mappings contained in this map. The set is * Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.
* backed by the map, so changes to the map are reflected in the set, and
* vice-versa. If the map is modified while an iteration over the set is in
* progress (except through the iterator's own remove operation, or through
* the setValue operation on a map entry returned by the iterator) the
* results of the iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* Iterator.remove, Set.remove, removeAll, retainAll and clear operations.
* It does not support the add or addAll operations.
* *
* *
* @return a set view of the mappings contained in this map * @return a set view of the mappings contained in this map
*/ */
@Override @Override
public Set<Entry<K, V>> entrySet() public Set<Entry<K, V>> entrySet() {
{
return this.sharedEntrySet; return this.sharedEntrySet;
} }
@Override @Override
public String toString() public String toString() {
{
String s = "[ "; String s = "[ ";
for (int i = 0; i < capacity; ++i) for (int i = 0; i < map.size(); ++i) {
{
s += map.get(i).toString() + "\n"; s += map.get(i).toString() + "\n";
} }
s += " ]"; s += " ]";
@ -650,8 +622,7 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
* @return the deep copy of the map * @return the deep copy of the map
*/ */
@Override @Override
public Object clone() public Object clone() {
{
/* /*
MapASDV<K, V> clonedMap = new MapASDV<K, V>(); MapASDV<K, V> clonedMap = new MapASDV<K, V>();
@ -670,16 +641,14 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
return clonedMap; return clonedMap;
} }
public static void main(String[] args) public static void main(String[] args) {
{
MapASDV<String, Integer> map = new MapASDV(); MapASDV<String, Integer> map = new MapASDV<>();
System.out.println("---------------------------testing put(K, V)"); System.out.println("---------------------------testing put(K, V)");
map.put("ann", 20); map.put("ann", 20);
map.put("coco", 25); map.put("coco", 25);
System.out.println(map); System.out.println(map);
MapASDV<String, Integer> clonedMap = ( MapASDV<String, Integer>) map.clone(); MapASDV<String, Integer> clonedMap = (MapASDV<String, Integer>) map.clone();
System.out.println("\n\n---------------------------testing double-the-size-and-rehash by reaching 0.75 load factor with another put(K, V)"); System.out.println("\n\n---------------------------testing double-the-size-and-rehash by reaching 0.75 load factor with another put(K, V)");
map.put("Jonathan", 30); map.put("Jonathan", 30);
@ -696,7 +665,6 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
map.putAll(anotherJavaMap); map.putAll(anotherJavaMap);
System.out.println(map); System.out.println(map);
System.out.println("\n\n---------------------------testing containsKey"); System.out.println("\n\n---------------------------testing containsKey");
System.out.println(map.containsKey("Alexander")); System.out.println(map.containsKey("Alexander"));
System.out.println(map.containsKey("alexander")); System.out.println(map.containsKey("alexander"));
@ -707,90 +675,108 @@ public class MapASDV<K, V> implements Map<K, V>, Cloneable
System.out.println("\n\n---------------------------testing getEntryForKey"); System.out.println("\n\n---------------------------testing getEntryForKey");
Entry<String, Integer> e = map.getEntryForKey("Alexander"); Entry<String, Integer> e = map.getEntryForKey("Alexander");
System.out.println( map.getEntryForKey("Alexander")); System.out.println(map.getEntryForKey("Alexander"));
System.out.println( map.getEntryForKey("Alex")); System.out.println(map.getEntryForKey("Alex"));
System.out.println("\n\n---------------------------testing get"); System.out.println("\n\n---------------------------testing get");
System.out.println(map.get( "Alexander") ); System.out.println(map.get("Alexander"));
System.out.println(map.get( "Alex") ); System.out.println(map.get("Alex"));
try{ map.get( null);}catch (NullPointerException ex ){System.out.println(ex.getMessage());} try {
map.get(null);
} catch (NullPointerException ex) {
System.out.println(ex.getMessage());
}
System.out.println("\n\n---------------------------testing getIndexForKey"); System.out.println("\n\n---------------------------testing getIndexForKey");
System.out.println(map.getIndexForKey("Alexander")); System.out.println(map.getIndexForKey("Alexander"));
System.out.println(map.getIndexForKey("Alex")); System.out.println(map.getIndexForKey("Alex"));
System.out.println("\n\n---------------------------testing isEmpty"); System.out.println("\n\n---------------------------testing isEmpty");
System.out.println( map.isEmpty()); System.out.println(map.isEmpty());
System.out.println("\n\n---------------------------testing size"); System.out.println("\n\n---------------------------testing size");
System.out.println( map.size()); System.out.println(map.size());
System.out.println( map); System.out.println(map);
System.out.println("\n\n---------------------------testing entrySet()"); System.out.println("\n\n---------------------------testing entrySet()");
Set<Entry<String, Integer>> entries = map.entrySet(); Set<Entry<String, Integer>> entries = map.entrySet();
System.out.println( entries); System.out.println(entries);
System.out.println("\n\n---------------------------testing keySet()"); System.out.println("\n\n---------------------------testing keySet()");
Set<String> keys = map.keySet(); Set<String> keys = map.keySet();
System.out.println( keys ); System.out.println(keys);
System.out.println("\n\n---------------------------testing values()"); System.out.println("\n\n---------------------------testing values()");
Collection<Integer> values = map.values(); Collection<Integer> values = map.values();
System.out.println( values); System.out.println(values);
System.out.println("\n\n---------------------------testing remove( K) coco 25"); System.out.println("\n\n---------------------------testing remove( K) coco 25");
map.remove("coco"); map.remove("coco");
System.out.println(map); values = map.values();
System.out.println(entries); System.out.println("map: " + map);
System.out.println(keys); System.out.println("entries: " + entries);
System.out.println(values); System.out.println("keys: " + keys);
System.out.println("values: " + values);
System.out.println("\n\n---------------------------testing Entry-Collection remove "); System.out.println("\n\n---------------------------testing Entry-Collection remove ");
entries.remove( e); entries.remove(e);
System.out.println(map); values = map.values();
System.out.println(entries); System.out.println("map: " + map);
System.out.println(keys); System.out.println("entries: " + entries);
System.out.println(values); System.out.println("keys: " + keys);
System.out.println("values: " + values);
System.out.println("\n\n---------------------------testing Set Keys remove "); System.out.println("\n\n---------------------------testing Set Keys remove ");
keys.remove( "ann"); keys.remove("ann");
System.out.println(map); values = map.values();
System.out.println(entries); System.out.println("map: " + map);
System.out.println(keys); System.out.println("entries: " + entries);
System.out.println(values); System.out.println("keys: " + keys);
System.out.println("values: " + values);
System.out.println("\n\n---------------------------testing Set Values remove "); System.out.println("\n\n---------------------------testing Set Values remove ");
values.remove( 45); values.remove(45);
System.out.println(map); values = map.values();
System.out.println(entries); System.out.println("map: " + map);
System.out.println(keys); System.out.println("entries: " + entries);
System.out.println(values); System.out.println("keys: " + keys);
System.out.println("values: " + values);
System.out.println("\n\n---------------------------testing clear "); System.out.println("\n\n---------------------------testing clear ");
map.clear(); map.clear();
System.out.println(map); values = map.values();
System.out.println(entries); entries = map.entrySet();
System.out.println(keys); keys = map.keySet();
System.out.println("map: " + map);
System.out.println("entries: " + entries);
System.out.println("keys: " + keys);
System.out.println("values: " + values);
System.out.println("\n\n---------------------------testing add of sets and collections "); System.out.println("\n\n---------------------------testing add of sets and collections ");
try{ keys.add( "a");}catch (Exception ex ){System.out.println(ex.getMessage());} try {
try{ values.add( 33);}catch (Exception ex ){System.out.println(ex.getMessage());} keys.add("a");
try{ entries.add( e);}catch (Exception ex ){System.out.println(ex.getMessage());} } catch (Exception ex) {
System.out.println(ex.getMessage());
}
try {
values.add(33);
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
try {
entries.add(e);
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
System.out.println("\n\n---------------------------testing clone"); System.out.println("\n\n---------------------------testing clone");
System.out.println( clonedMap); System.out.println(clonedMap);
System.out.println("---------------------------testing put(K, V) AGAIN"); System.out.println("---------------------------testing put(K, V) AGAIN");
map.put("Nicholas", 100); map.put("Nicholas", 100);
map.put("a", 200); map.put("a", 200);
map.put("b", -20); map.put("b", -20);
System.out.println( map); System.out.println(map);
} }
} }