CCF_100/ASDV-Java
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

broken code :)

Browse Source
This commit is contained in:
Chloe Fontenot 🏳️‍⚧️ 2024-02-08 14:01:43 -06:00
parent a48615c8f8
commit eb94a026a7
11 changed files with 4582 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -205,3 +205,5 @@
/Semester 4/Assignments/HashMapASDV_Ant/dist/
/Semester 4/Assignments/MP1_ManyToMany_CalebFontenot/target/
/Semester 4/Assignments/Multithreading_CalebFontenot/target/
/Semester 4/Assignments/MapASDV_CalebFontenot/nbproject/private/
/Semester 4/Assignments/MapASDV_CalebFontenot/build/

135
Semester 4/Assignments/MP1_ManyToMany_CalebFontenot/src/main/java/edu/slcc/asdv/caleb/mp1_manytomany_calebfontenot/ManyToManyFactory.java
View File

@ -14,6 +14,7 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
@ -24,24 +25,20 @@ public class ManyToManyFactory {
public static <Many1, Many2> //generic types to be used in the method
ManyToMany< Many1, Many2>//return type
createManyToMany()
{
createManyToMany() {
return new ManyToMany<Many1, Many2>() {
//private HashSet parents = new HashSet();
private HashSet<Many1> parents = new HashSet<>();
private Map<Object, Object> left = new HashMap();
private Map<Object, Object> right = new HashMap();
private Map<Object, Object> left = new HashMap<>();
private Map<Object, Object> right = new HashMap<>();
@Override
public String toString()
{
public String toString() {
return "{" + "left=" + left + ", right=" + right + '}';
}
/**
* Creates a Many to Many relationship between the parentLeft and the childrenRight.
* Example for ( Many1 a, Many2 1, 2, 3) it creates --> (a 1) ( a 2 ) ( a 3 ) and ( 1, a ), ( 2, a ), ( 3, a).
* No duplicate values of Many2 are allowed.
* Creates a Many to Many relationship between the parentLeft and the childrenRight. Example for ( Many1 a, Many2 1, 2, 3) it creates --> (a 1) ( a 2 ) ( a 3 ) and ( 1, a ), ( 2, a ), ( 3, a). No duplicate values of Many2 are allowed.
*
* @param parentLeft - exactly one Many1 object.
* @param childrenRight - one or more Many2 objects.
@ -52,70 +49,126 @@ public class ManyToManyFactory {
* @return the previous value associated with parentLeft, or null if there was no childrenRight for parentLeft.
*/
@Override
public List<Many2> add(Many1 parentLeft, Many2... childrenRight)
{
List<Many2> returnList = new ArrayList<Many2>();
public List<Many2> add(Many1 parentLeft, Many2... childrenRight) {
HashSet<Many2> verifyUnique = new HashSet<>();
List<Many2> returnList = new ArrayList<>();
// Check for exceptions
if (!childrenRight.equals(parentLeft.getClass())) {
throw new ClassCastException();
//throw new ClassCastException();
}
if (parentLeft == null || childrenRight == null) {
throw new NullPointerException();
}
// Try to add all elements from childrenRight into HashSet. If we're unable to, through an IllegalArgumentException, assuming HashSet doesn't throw one already.
verifyUnique.addAll(Arrays.asList(childrenRight));
if (left.size() > 0 && childrenRight.length > 0) {
for (Object e : left.values()) {
returnList.add((Many2) e);
}
//returnList.addAll((<? extends Many2>) left.values());
}
// Keep track of the parents so we can manipulate the RHS
parents.add(parentLeft);
// Handle LHS
//for (Many2 e : childrenRight) {
left.put(parentLeft, new ArrayList<Many2>(Arrays.asList(childrenRight)));
//}
//Handle RHS
/*
for (Many1 e: parents) {
right.put(, e );
}
*/
if (returnList.size() == 0) {
return null;
}
left.put(parentLeft, new ArrayList<Many2>(Arrays.asList(childrenRight)));
return returnList;
}
/**
* Returns the List of all left children of the parentRight.
*
* @param parentRight a parent at the RHS of the many to many relationship.
* @return the List of all left children of the parentRight.
* @throw IllegalArgumentException if the value of parameter parentRight does not exist in the RHS of the many to many relationship.
*/
@Override
public List<Many1> getChildrenLeft(Many2 parentRight)
{
public List<Many1> getChildrenLeft(Many2 parentRight) {
List<Many1> returnList = new ArrayList<Many1>();
for (Entry<Object, Object> ee : left.entrySet()) {
System.out.println(ee.getKey() + ", " + parentRight);
if (ee.getKey().equals(parentRight)) {
returnList.add((Many1) ee.getValue());
}
}
if (returnList.size() > 0) {
return null;
}
return returnList;
}
/**
* Returns the List of all right children of the parentLeft.
*
* @param parentLeft a parent at the LHS of the many to many relationship.
* @return the List of all right children of the parentLeft.
* @throws IllegalArgumentException if the value of parameter parentLeft does not exist on the LHS of the many to many relationship.
*/
@Override
public List<Many2> getChildrenRight(Many1 parentLeft) {
List<Many2> returnList = new ArrayList<>();
for (Entry<Object, Object> ee : right.entrySet()) {
if (ee.getKey() == parentLeft) {
returnList.add((Many2) ee.getValue());
}
}
if (returnList.size() > 0) {
return null;
}
return returnList;
}
/**
* Returns a set of the Many1 elements that exist on the LHS of the many to many relationship.
*
* @return Set of Many1
*/
@Override
public Set<Many1> getParentsLeft() {
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
@Override
public List<Many2> getChildrenRight(Many1 parentLeft)
{
public Set<Many2> getParentsRight() {
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
@Override
public Set<Many1> getParentsLeft()
{
public boolean removeLeft(Many1 many1) {
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
@Override
public Set<Many2> getParentsRight()
{
public boolean removeRight(Many2 many2) {
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
@Override
public boolean removeLeft(Many1 many1)
{
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
@Override
public boolean removeRight(Many2 many2)
{
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
@Override
public void clear()
{
public void clear() {
throw new UnsupportedOperationException("Not supported yet."); // Generated from nbfs://nbhost/SystemFileSystem/Templates/Classes/Code/GeneratedMethodBody
}
};
}
public static void main(String[] args) throws InterruptedException
{
public static void main(String[] args) throws InterruptedException {
ManyToMany<String, String> mm = ManyToManyFactory.createManyToMany();
//mm.add(1, 1);///will not compile, we have Many1, Many2 as String
System.out.println("add(e1, p1, p2)returns: " + mm.add("e1", "p1", "p2"));
System.out.println("add(e2, p2, p3)returns: " + mm.add("e2", "p2", "p3"));
System.out.println("getParentsLeft returns: " + mm.getParentsLeft());
System.out.println("getParentsRight returns: " + mm.getParentsRight());
//System.out.println("getParentsLeft returns: " + mm.getParentsLeft());
//System.out.println("getParentsRight returns: " + mm.getParentsRight());
System.out.println("getChildrenLeft(p1) returns: " + mm.getChildrenLeft("p2"));
System.out.println("getChildrenLeft(p2) returns: " + mm.getChildrenLeft("p3"));
System.out.println("getChildrenRight(e1) returns: " + mm.getChildrenRight("e1"));

73
Semester 4/Assignments/MapASDV_CalebFontenot/build.xml Normal file
View File

@ -0,0 +1,73 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- You may freely edit this file. See commented blocks below for -->
<!-- some examples of how to customize the build. -->
<!-- (If you delete it and reopen the project it will be recreated.) -->
<!-- By default, only the Clean and Build commands use this build script. -->
<!-- Commands such as Run, Debug, and Test only use this build script if -->
<!-- the Compile on Save feature is turned off for the project. -->
<!-- You can turn off the Compile on Save (or Deploy on Save) setting -->
<!-- in the project's Project Properties dialog box.-->
<project name="MapASDV_CalebFontenot" default="default" basedir=".">
<description>Builds, tests, and runs the project MapASDV_CalebFontenot.</description>
<import file="nbproject/build-impl.xml"/>
<!--
There exist several targets which are by default empty and which can be
used for execution of your tasks. These targets are usually executed
before and after some main targets. They are:
-pre-init: called before initialization of project properties
-post-init: called after initialization of project properties
-pre-compile: called before javac compilation
-post-compile: called after javac compilation
-pre-compile-single: called before javac compilation of single file
-post-compile-single: called after javac compilation of single file
-pre-compile-test: called before javac compilation of JUnit tests
-post-compile-test: called after javac compilation of JUnit tests
-pre-compile-test-single: called before javac compilation of single JUnit test
-post-compile-test-single: called after javac compilation of single JUunit test
-pre-jar: called before JAR building
-post-jar: called after JAR building
-post-clean: called after cleaning build products
(Targets beginning with '-' are not intended to be called on their own.)
Example of inserting an obfuscator after compilation could look like this:
<target name="-post-compile">
<obfuscate>
<fileset dir="${build.classes.dir}"/>
</obfuscate>
</target>
For list of available properties check the imported
nbproject/build-impl.xml file.
Another way to customize the build is by overriding existing main targets.
The targets of interest are:
-init-macrodef-javac: defines macro for javac compilation
-init-macrodef-junit: defines macro for junit execution
-init-macrodef-debug: defines macro for class debugging
-init-macrodef-java: defines macro for class execution
-do-jar: JAR building
run: execution of project
-javadoc-build: Javadoc generation
test-report: JUnit report generation
An example of overriding the target for project execution could look like this:
<target name="run" depends="MapASDV_CalebFontenot-impl.jar">
<exec dir="bin" executable="launcher.exe">
<arg file="${dist.jar}"/>
</exec>
</target>
Notice that the overridden target depends on the jar target and not only on
the compile target as the regular run target does. Again, for a list of available
properties which you can use, check the target you are overriding in the
nbproject/build-impl.xml file.
-->
</project>

3
Semester 4/Assignments/MapASDV_CalebFontenot/manifest.mf Normal file
View File

@ -0,0 +1,3 @@
Manifest-Version: 1.0
X-COMMENT: Main-Class will be added automatically by build

1799
Semester 4/Assignments/MapASDV_CalebFontenot/nbproject/build-impl.xml Normal file
View File

File diff suppressed because it is too large Load Diff

8
Semester 4/Assignments/MapASDV_CalebFontenot/nbproject/genfiles.properties Normal file
View File

@ -0,0 +1,8 @@
build.xml.data.CRC32=25d86ec5
build.xml.script.CRC32=638d3506
build.xml.stylesheet.CRC32=f85dc8f2@1.108.0.48
# This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml.
# Do not edit this file. You may delete it but then the IDE will never regenerate such files for you.
nbproject/build-impl.xml.data.CRC32=25d86ec5
nbproject/build-impl.xml.script.CRC32=57519cf4
nbproject/build-impl.xml.stylesheet.CRC32=12e0a6c2@1.108.0.48

95
Semester 4/Assignments/MapASDV_CalebFontenot/nbproject/project.properties Normal file
View File

@ -0,0 +1,95 @@
annotation.processing.enabled=true
annotation.processing.enabled.in.editor=false
annotation.processing.processor.options=
annotation.processing.processors.list=
annotation.processing.run.all.processors=true
annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output
build.classes.dir=${build.dir}/classes
build.classes.excludes=**/*.java,**/*.form
# This directory is removed when the project is cleaned:
build.dir=build
build.generated.dir=${build.dir}/generated
build.generated.sources.dir=${build.dir}/generated-sources
# Only compile against the classpath explicitly listed here:
build.sysclasspath=ignore
build.test.classes.dir=${build.dir}/test/classes
build.test.results.dir=${build.dir}/test/results
# Uncomment to specify the preferred debugger connection transport:
#debug.transport=dt_socket
debug.classpath=\
${run.classpath}
debug.modulepath=\
${run.modulepath}
debug.test.classpath=\
${run.test.classpath}
debug.test.modulepath=\
${run.test.modulepath}
# Files in build.classes.dir which should be excluded from distribution jar
dist.archive.excludes=
# This directory is removed when the project is cleaned:
dist.dir=dist
dist.jar=${dist.dir}/MapASDV_CalebFontenot.jar
dist.javadoc.dir=${dist.dir}/javadoc
dist.jlink.dir=${dist.dir}/jlink
dist.jlink.output=${dist.jlink.dir}/MapASDV_CalebFontenot
excludes=
includes=**
jar.compress=false
javac.classpath=
# Space-separated list of extra javac options
javac.compilerargs=
javac.deprecation=false
javac.external.vm=true
javac.modulepath=
javac.processormodulepath=
javac.processorpath=\
${javac.classpath}
javac.source=20
javac.target=20
javac.test.classpath=\
${javac.classpath}:\
${build.classes.dir}
javac.test.modulepath=\
${javac.modulepath}
javac.test.processorpath=\
${javac.test.classpath}
javadoc.additionalparam=
javadoc.author=false
javadoc.encoding=${source.encoding}
javadoc.html5=false
javadoc.noindex=false
javadoc.nonavbar=false
javadoc.notree=false
javadoc.private=false
javadoc.splitindex=true
javadoc.use=true
javadoc.version=false
javadoc.windowtitle=
# The jlink additional root modules to resolve
jlink.additionalmodules=
# The jlink additional command line parameters
jlink.additionalparam=
jlink.launcher=true
jlink.launcher.name=MapASDV_CalebFontenot
main.class=mapasdv_calebfontenot.MapASDV_CalebFontenot
manifest.file=manifest.mf
meta.inf.dir=${src.dir}/META-INF
mkdist.disabled=false
platform.active=Graal_JDK_20
run.classpath=\
${javac.classpath}:\
${build.classes.dir}
# Space-separated list of JVM arguments used when running the project.
# You may also define separate properties like run-sys-prop.name=value instead of -Dname=value.
# To set system properties for unit tests define test-sys-prop.name=value:
run.jvmargs=
run.modulepath=\
${javac.modulepath}
run.test.classpath=\
${javac.test.classpath}:\
${build.test.classes.dir}
run.test.modulepath=\
${javac.test.modulepath}
source.encoding=UTF-8
src.dir=src
test.src.dir=test

16
Semester 4/Assignments/MapASDV_CalebFontenot/nbproject/project.xml Normal file
View File

@ -0,0 +1,16 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.netbeans.org/ns/project/1">
<type>org.netbeans.modules.java.j2seproject</type>
<configuration>
<data xmlns="http://www.netbeans.org/ns/j2se-project/3">
<name>MapASDV_CalebFontenot</name>
<explicit-platform explicit-source-supported="true"/>
<source-roots>
<root id="src.dir"/>
</source-roots>
<test-roots>
<root id="test.src.dir"/>
</test-roots>
</data>
</configuration>
</project>

1694
Semester 4/Assignments/MapASDV_CalebFontenot/src/mapasdv_calebfontenot/ListASDV.java Normal file
View File

File diff suppressed because it is too large Load Diff

796
Semester 4/Assignments/MapASDV_CalebFontenot/src/mapasdv_calebfontenot/MapASDV.java Normal file
View File

@ -0,0 +1,796 @@
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
*/
package mapasdv_calebfontenot;
/**
*
* @author caleb
*/
//import ListASDV;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiConsumer;//needed in putAll
public class MapASDV<K, V> implements Map<K, V>, Cloneable
{
private int capacity = 4;
private double loadFactor = 0.75;
private ArrayList<ListASDV<EntryASDV<K, V>>> map = new ArrayList<>();
private Set<K> sharedKeySet = new SharedSet<K>();
private Set<Entry<K, V>> sharedEntrySet = new SharedSet<Entry<K, V>>();
private Collection<V> sharedValuesCollection = new SharedCollection<V>();
private class SharedCollection<V> extends ArrayList<V>
{
public boolean addValue(V v)
{
return this.add(v);
}
@Override
public boolean remove(Object o)
{
//> The parameter is key not entry if we are here
//>>remove value) and key) from the map
return MapASDV.this.removeFirstValue(o);
//>>remove key from shared values set
//return super.remove(o);
}
/**
* 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.
*
* @param o - the key
* @param callFromOuterClass - dummy variable.
* @return true if the key was removed from the Set
*/
public boolean remove(V v, boolean callFromOuterClass)
{
//remove key from shared keys set
boolean b = super.remove(v);
return b;
}
@Override
public Object clone()
{
return super.clone();
}
@Override
public void clear()
{
super.clear();
}
}
private class SharedSet<E> extends HashSet<E>
{
@Override
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);
}
@Override
public boolean remove(Object o)
{
//>if parameter oo is EntryASDV call auxiliary method removeEntry
if (o instanceof EntryASDV)
{
return removeEntry((EntryASDV) o);
}
//> The parameter is key not entry if we are here
//>>remove key from the map
MapASDV.this.remove(o);
//>>remove key from shared keys set
return super.remove(o);
}
/**
* Removes the entry for the shared set
*
* @param entry the entry to be removed
* @return true if the entry was removed, false otherwise
*/
private boolean removeEntry(EntryASDV<K, V> entry)
{
MapASDV.this.remove(entry.getKey());
return super.remove(entry);
}
/**
* 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.
*
* @param o - the key
* @param callFromOuterClass - dummy variable.
* @return true if the key was removed from the Set
*/
public boolean remove(E o, boolean callFromOuterClass)
{
//remove key from shared keys set
return super.remove(o);
}
@Override
public Object clone()
{
return super.clone();
}
@Override
public void clear()
{
super.clear();
}
}
public MapASDV()
{
for (int i = 0; i < capacity; ++i)
{
map.add(new ListASDV<EntryASDV<K, V>>());
}
}
/**
* Double the size of the Map and rehashes the entries of the Map
*/
private void doubleTheSizeOfTheMapAndRehash()
{
capacity *= 2;
//>create a new arrayList of ListsASDV
ArrayList<ListASDV<EntryASDV<K, V>>> newMap = new ArrayList<ListASDV<EntryASDV<K, V>>>();
//>Add at every enetry of the arrayList a new ASDVList
for (int i = 0; i < capacity; ++i)
{
newMap.add(new ListASDV<EntryASDV<K, V>>());
}
//>for the size of the OLD arrayList
for (int i = 0; i < map.size(); ++i)//array list
{
//>> get The ASDVlist at i
ListASDV<EntryASDV<K, V>> list = map.get(i);
//>>for the size() of the ASDVlist
for (int j = 0; j < list.size(); ++j)
{
///>>>hash and put in the the new array
int index = hash( list.get(j).getKey().hashCode() );
newMap.get(index).add(list.get(j));
}
}
map = newMap;
}
class EntryASDV<K, V> implements Entry<K, V>, Comparable<K>
{
K key;
V value;
public EntryASDV(K key, V value)
{
this.key = key;
this.value = value;
}
@Override
public K getKey()
{
return key;
}
@Override
public V getValue()
{
return value;
}
@Override
public V setValue(V value)
{
V oldValue = this.value;
this.value = value;
return oldValue;
}
@Override
public String toString()
{
return "EntryASDV{" + "key=" + key + ", value=" + value + '}';
}
@Override
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if (obj == null)
{
return false;
}
if (getClass() != obj.getClass())
{
return false;
}
final EntryASDV<?, ?> other = (EntryASDV<?, ?>) obj;
if (!Objects.equals(this.key, other.key))
{
return false;
}
return true;
}
/**
*
* @param o
* @return throws IllegalArgumentException if parameter class is not K
*/
@Override
public int compareTo(K o)
{
if (getClass() != o.getClass())
{
throw new IllegalArgumentException("ellegal parameter " + o);
}
return ((Comparable) key).compareTo(o);
}
}
@Override
public int size()
{
return this.keySet().size();
}
@Override
public boolean isEmpty()
{
throw new UnsupportedOperationException("Not supported....");
}
@Override
public boolean containsKey(Object key)
{
for (int i = 0; i < map.size(); ++i) {
System.out.println(map.get(i));
}
throw new UnsupportedOperationException("Not supported yet....");
}
/**
* Return an entry of the map
*
* @param key the key of the entry to be returned
* @return the entry, or null if the key is not in the map
*/
private EntryASDV<K, V> getEntryForKey(Object key)
{
for (ListASDV<EntryASDV<K, V>> list : map)
{
Iterator<EntryASDV<K, V>> it = list.iterator();
while (it.hasNext())
{
EntryASDV<K, V> entry = it.next();
if (key.equals(entry.getKey()))
{
return entry;
}
}
}
return null;
}
/**
* Returns the index of the given key
*
* @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
*/
private int getIndexForKey(Object key)
{
for (int i = 0; i < map.size(); ++i)
{
Iterator<EntryASDV<K, V>> it = map.get(i).iterator();
while (it.hasNext())
{
EntryASDV<K, V> entry = it.next();
if (key.equals(entry.getKey()))
{
return i;
}
}
}
return -1;
}
/**
* 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.
*
* 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)
*
* @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
* @throws NullPointerException - if the specified value is null and this
* map does not permit null values (optional)
*/
@Override
public boolean containsValue(Object value)
{
throw new UnsupportedOperationException("Not supported yet....");
}
/**
* Returns the value to which the specified key is mapped, or null if this
* map contains no mapping for the key.
*
* 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.)
*
* 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.
*
* @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
* map contains no mapping for the key
* @throws NullPointerException - if the specified key is null and this map
* does not permit null keys (optional)
*/
@Override
public V get(Object key)
{
throw new UnsupportedOperationException("Not supported yet....");
}
/**
* 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.)
*
* @param key - key with which the specified value is to be associated
* @param value - value to be associated with the specified key
* @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.)
* @throws NullPointerException - if specified key or value is null and this
* map does not permit null keys
*/
@Override
public V put(K key, V value)
{
if (key == null || value == null)
{
throw new NullPointerException("parm(s) null");
}
//>if contains the key, replace the key's value
EntryASDV<K, V> entry = getEntryForKey(key);
if (entry != null)
{
V oldValue = entry.value;
entry.value = value;
return oldValue;
}
///>>hash and put in the array
int code = this.hash(key.hashCode());
int index = hash(code);
ListASDV<EntryASDV<K, V>> list = map.get(index);
EntryASDV e = new EntryASDV(key, value);
list.add(e);
//>>add the key to the shared keys-set
((SharedSet<K>) this.sharedKeySet).addEntry(key);
((SharedSet<Entry<K, V>>) this.sharedEntrySet).addEntry(e);
//>>get the value of this entry
V v = list.get(list.size() - 1).getValue();
//>> add value to the value collection
((SharedCollection<V>) this.sharedValuesCollection).addValue(v);
//>> if reach 75% capacity double the size
if ((double) this.size() / capacity >= 0.75)
{
this.doubleTheSizeOfTheMapAndRehash();
}
//>>return the value of Entry just added
return v;
}
int hash(int keyHashCode)
{
int h = hashHash(keyHashCode);
return Math.abs(h % capacity - 1);
}
/**
* Removes the first entry with the given values.
*
* @param value - the value to be removed
* @return true if removed, false otherwise
* @throws NullPointerException if the value is null
*/
private boolean removeFirstValue(Object value)
{
throw new UnsupportedOperationException("Not supported yet....");
}
/**
* Ensure hash code is evenly distributed
*
* @param h - hash code
* @return evenly distributed hash code
*/
private static int hashHash(int h)
{
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
/**
* 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.)
*
* @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
* mapping for key.
* @throws NullPointerException - if the specified key is null and this map
* does not permit null keys
*/
@Override
public V remove(Object key)
{
throw new UnsupportedOperationException("Not supported yet....");
}
/**
* 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.
*
* @param m - mappings to be stored in this map
* @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
*/
@Override
public void putAll(Map<? extends K, ? extends V> m)
{
if (m == null)
{
throw new NullPointerException("null parameter");
}
BiConsumer consumeEachEntry = new BiConsumer<K, V>()
{
MapASDV<K, V> mapForConsumer = MapASDV.this;
@Override
public void accept(K k, V v)
{
mapForConsumer.put(k, v);
}
};
m.forEach(consumeEachEntry);
}
/**
* 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.
*/
@Override
public void clear()
{
throw new UnsupportedOperationException("Not supported yet....");
}
/**
* 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.
*
* @return a set view of the keys contained in this map
*/
@Override
public Set<K> keySet()
{
return this.sharedKeySet;
}
/**
* 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.
*
* @return
*/
@Override
public Collection<V> values()
{
return sharedValuesCollection;
}
/**
* 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.
*
*
* @return a set view of the mappings contained in this map
*/
@Override
public Set<Entry<K, V>> entrySet()
{
return this.sharedEntrySet;
}
@Override
public String toString()
{
String s = "[ ";
for (int i = 0; i < capacity; ++i)
{
s += map.get(i).toString() + "\n";
}
s += " ]";
return s;
}
/**
* Created a deep copy of the MapASDV
*
* @return the deep copy of the map
*/
@Override
public Object clone()
{
/*
MapASDV<K, V> clonedMap = new MapASDV<K, V>();
//clonedMap.putAll(this);
for (ListASDV< EntryASDV<K, V>> list : this.map)
{
ListASDV< EntryASDV<K, V>> l = (ListASDV< EntryASDV<K, V>>) list.clone();
clonedMap.map.add(l);
}
return clonedMap;
*/
MapASDV<K, V> clonedMap = new MapASDV<K, V>();
clonedMap.putAll(this);
return clonedMap;
}
public static void main(String[] args)
{
MapASDV<String, Integer> map = new MapASDV();
System.out.println("---------------------------testing put(K, V)");
map.put("ann", 20);
map.put("coco", 25);
System.out.println(map);
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)");
map.put("Jonathan", 30);
System.out.println(map);
map.put("Jonhathan", 45);
System.out.println(map);
map.put("Alexander", 33);
System.out.println(map);
System.out.println("\n\n---------------------------testing putAll(Map<K,V>)");
Map<String, Integer> anotherJavaMap = new HashMap();
anotherJavaMap.put("lion king", 45);
anotherJavaMap.put("HYENA", 6);
map.putAll(anotherJavaMap);
System.out.println(map);
System.out.println("\n\n---------------------------testing containsKey");
System.out.println(map.containsKey("Alexander"));
System.out.println(map.containsKey("alexander"));
System.out.println("\n\n---------------------------testing containsValue");
System.out.println(map.containsValue(33));
System.out.println(map.containsValue(34));
System.out.println("\n\n---------------------------testing getEntryForKey");
Entry<String, Integer> e = map.getEntryForKey("Alexander");
System.out.println( map.getEntryForKey("Alexander"));
System.out.println( map.getEntryForKey("Alex"));
System.out.println("\n\n---------------------------testing get");
System.out.println(map.get( "Alexander") );
System.out.println(map.get( "Alex") );
try{ map.get( null);}catch (NullPointerException ex ){System.out.println(ex.getMessage());}
System.out.println("\n\n---------------------------testing getIndexForKey");
System.out.println(map.getIndexForKey("Alexander"));
System.out.println(map.getIndexForKey("Alex"));
System.out.println("\n\n---------------------------testing isEmpty");
System.out.println( map.isEmpty());
System.out.println("\n\n---------------------------testing size");
System.out.println( map.size());
System.out.println( map);
System.out.println("\n\n---------------------------testing entrySet()");
Set<Entry<String, Integer>> entries = map.entrySet();
System.out.println( entries);
System.out.println("\n\n---------------------------testing keySet()");
Set<String> keys = map.keySet();
System.out.println( keys );
System.out.println("\n\n---------------------------testing values()");
Collection<Integer> values = map.values();
System.out.println( values);
System.out.println("\n\n---------------------------testing remove( K) coco 25");
map.remove("coco");
System.out.println(map);
System.out.println(entries);
System.out.println(keys);
System.out.println(values);
System.out.println("\n\n---------------------------testing Entry-Collection remove ");
entries.remove( e);
System.out.println(map);
System.out.println(entries);
System.out.println(keys);
System.out.println(values);
System.out.println("\n\n---------------------------testing Set Keys remove ");
keys.remove( "ann");
System.out.println(map);
System.out.println(entries);
System.out.println(keys);
System.out.println(values);
System.out.println("\n\n---------------------------testing Set Values remove ");
values.remove( 45);
System.out.println(map);
System.out.println(entries);
System.out.println(keys);
System.out.println(values);
System.out.println("\n\n---------------------------testing clear ");
map.clear();
System.out.println(map);
System.out.println(entries);
System.out.println(keys);
System.out.println("\n\n---------------------------testing add of sets and collections ");
try{ keys.add( "a");}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( clonedMap);
System.out.println("---------------------------testing put(K, V) AGAIN");
map.put("Nicholas", 100);
map.put("a", 200);
map.put("b", -20);
System.out.println( map);
}
}

BIN
Semester 4/ZIPs/MP1_ManyToMany_CalebFontenot.zip Normal file
View File

Binary file not shown.