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

Reset author name to chosen name ✨

Browse Source
This commit is contained in:
Chloe Fontenot 🏳️‍⚧️
2025-10-19 21:55:26 -05:00
parent a3e71f9673
commit 03c2474f78
1825 changed files with 8916 additions and 8921 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
Semester 3/Assignments/MP6_ChloeFontenot/Printed HTMLs/CircularList.html Normal file
View File

@@ -0,0 +1,238 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>CircularList.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}
pre {color: #a9b7c6; background-color: #2b2b2b; font-family: monospace}
table {color: #888888; background-color: #313335; font-family: monospace}
.ST1 {color: #9876aa}
.ST2 {color: #ffc66d}
.number {color: #6897bb}
.string {color: #6a8759}
.whitespace {color: #505050}
.comment {color: #808080}
.ST4 {color: #9876aa; font-family: monospace; font-style: italic}
.ST5 {color: #ffc66d; font-family: monospace; font-style: italic}
.ST0 {color: #808080; font-family: monospace; font-weight: bold}
.ST3 {color: #8a653b}
.literal {color: #cc7832}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/chloe/mp6_chloefontenot/CircularList.java</td></tr></table>
<pre>
<span class="literal">package</span> edu.slcc.asdv.chloe.mp6_chloefontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@author</span> <span class="comment">Markou</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> CircularList&lt;T <span class="literal">extends</span> Comparable&lt;T&gt;&gt; {
Node&lt;T&gt; <span class="ST1">head</span>;
<span class="literal">public</span> <span class="literal">class</span> Node&lt; T <span class="literal">extends</span> Comparable&lt;T&gt;&gt;
<span class="literal">implements</span> Comparable&lt;Node&lt;T&gt;&gt; {
<span class="literal">private</span> T <span class="ST1">t</span>;
<span class="literal">public</span> <span class="literal">void</span> <span class="ST2">set</span>(T t)
{
<span class="literal">this</span>.<span class="ST1">t</span> = t;
}
<span class="literal">public</span> T <span class="ST2">get</span>()
{
<span class="literal">return</span> <span class="ST1">t</span>;
}
Node&lt;T&gt; <span class="ST1">next</span>;
@Override
<span class="literal">public</span> <span class="literal">int</span> <span class="ST2">compareTo</span>(Node&lt;T&gt; o)
{
<span class="literal">return</span> <span class="literal">this</span>.<span class="ST1">t</span>.compareTo(o.get());
}
}
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@param</span> <span class="ST3">t</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">void</span> <span class="ST2">add</span>(Object t)
{
Node&lt;T&gt; temp = <span class="literal">new</span> Node();
temp.set((T) t);
<span class="literal">if</span> (<span class="ST1">head</span> == <span class="literal">null</span>) {
<span class="ST1">head</span> = temp;
<span class="ST1">head</span>.<span class="ST1">next</span> = <span class="ST1">head</span>;
} <span class="literal">else</span> {
Node&lt;T&gt; temp2 = <span class="ST1">head</span>;
<span class="literal">do</span> {
temp2 = temp2.<span class="ST1">next</span>;
} <span class="literal">while</span> (temp2.<span class="ST1">next</span> != <span class="ST1">head</span>);
temp.<span class="ST1">next</span> = <span class="ST1">head</span>;
temp2.<span class="ST1">next</span> = temp;
}
}
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@return</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">int</span> <span class="ST2">getSize</span>()
{
<span class="literal">if</span> (<span class="ST1">head</span> == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="number">0</span>;
}
Node&lt;T&gt; temp = <span class="ST1">head</span>;
<span class="literal">int</span> count = <span class="number">0</span>;
<span class="literal">do</span> {
temp = temp.<span class="ST1">next</span>;
count++;
} <span class="literal">while</span> (temp != <span class="ST1">head</span>);
<span class="literal">return</span> count;
}
<span class="comment">////////////////////////////////////////////////////////</span>
<span class="literal">public</span> <span class="literal">void</span> <span class="ST2">addAt</span>(Object t, <span class="literal">int</span> pos)
{
<span class="literal">if</span> (pos &lt; <span class="number">0</span> || pos &gt; getSize()) {
<span class="literal">return</span>;
}
Node&lt;T&gt; temp = <span class="literal">new</span> Node();
temp.set((T) t);
<span class="literal">if</span> (<span class="ST1">head</span> == <span class="literal">null</span>) {
add(t);
} <span class="literal">else</span> <span class="literal">if</span> (pos == <span class="number">0</span>) {
<span class="literal">int</span> oldSize = getSize();
Node&lt;T&gt; <span class="comment">currentHead</span> = <span class="ST1">head</span>;
temp.<span class="ST1">next</span> = <span class="ST1">head</span>;
<span class="ST1">head</span> = temp;
<span class="comment">// Set the node at the end of the list to point back to the new head.</span>
Node&lt;T&gt; pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; oldSize; ++i) {
pointer = pointer.<span class="ST1">next</span>;
}
pointer.<span class="ST1">next</span> = temp;
} <span class="literal">else</span> {
<span class="comment">// Iterate to the desired position</span>
Node&lt;T&gt; pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; pos -<span class="number">1</span>; ++i) {
pointer = pointer.<span class="ST1">next</span>;
}
temp.<span class="ST1">next</span> = pointer.<span class="ST1">next</span>;
pointer.<span class="ST1">next</span> = temp;
}
}
<span class="comment">//////////////////////////////////////////////////////////////</span>
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">removes</span> <span class="comment">the</span> <span class="comment">last</span> <span class="comment">node</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">void</span> <span class="ST2">remove</span>()
{
Node&lt;T&gt; pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="literal">this</span>.getSize() - <span class="number">2</span>; ++i) {
pointer = pointer.<span class="ST1">next</span>;
}
pointer.<span class="ST1">next</span> = <span class="ST1">head</span>;
}
<span class="comment">//////////////////////////////////////////////////////////////</span>
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">removes</span> <span class="comment">a</span> <span class="comment">specific</span> <span class="comment">object</span> <span class="comment">from</span> <span class="comment">the</span> <span class="comment">list</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST2">remove</span>(Object t)
{
Node&lt;T&gt; pointer = <span class="ST1">head</span>;
<span class="literal">boolean</span> isObjectRemoved = <span class="literal">false</span>;
<span class="literal">do</span> {
<span class="literal">boolean</span> eval = pointer.<span class="ST1">next</span>.<span class="ST1">t</span>.equals(t);
<span class="literal">if</span> (eval) {
isObjectRemoved = <span class="literal">true</span>;
pointer.<span class="ST1">next</span> = pointer.<span class="ST1">next</span>.<span class="ST1">next</span>;
<span class="literal">break</span>;
} <span class="literal">else</span> {
pointer = pointer.<span class="ST1">next</span>;
}
} <span class="literal">while</span> (pointer != <span class="ST1">head</span>);
<span class="literal">return</span> isObjectRemoved;
}
<span class="comment">//////////////////////////////////////////////////////////////</span>
<span class="literal">public</span> <span class="literal">void</span> <span class="ST2">removeAt</span>(<span class="literal">int</span> pos)
{
Node&lt;T&gt; pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; pos; ++i) {
<span class="literal">boolean</span> eval = i == pos - <span class="number">1</span>;
<span class="literal">if</span> (eval) {
pointer.<span class="ST1">next</span> = pointer.<span class="ST1">next</span>.<span class="ST1">next</span>;
<span class="literal">break</span>;
} <span class="literal">else</span> {
pointer = pointer.<span class="ST1">next</span>;
}
}
}
<span class="literal">public</span> <span class="literal">void</span> <span class="ST2">print</span>()
{
<span class="literal">if</span> (<span class="ST1">head</span> == <span class="literal">null</span>) {
<span class="literal">return</span>;
}
Node&lt;T&gt; temp = <span class="ST1">head</span>;
<span class="literal">int</span> elementNum = <span class="number">0</span>;
<span class="literal">do</span> {
System.<span class="ST4">out</span>.print(++elementNum + <span class="string">&quot;</span><span class="string">: </span><span class="string">&quot;</span>);
System.<span class="ST4">out</span>.println(temp.get().toString());
temp = temp.<span class="ST1">next</span>;
} <span class="literal">while</span> (temp != <span class="ST1">head</span>);
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST5">main</span>(String... ar)
{
CircularList&lt;String&gt; list = <span class="literal">new</span> CircularList();
list.add(<span class="string">&quot;</span><span class="string">Hello</span><span class="string">&quot;</span>);
list.add(<span class="string">&quot;</span><span class="string">World</span><span class="string">&quot;</span>);
list.add(<span class="string">&quot;</span><span class="string">one</span><span class="string">&quot;</span>);
String removeMe = <span class="string">&quot;</span><span class="string">two</span><span class="string">&quot;</span>;
list.add(removeMe);
list.add(<span class="string">&quot;</span><span class="string">three</span><span class="string">&quot;</span>);
list.add(<span class="string">&quot;</span><span class="string">four</span><span class="string">&quot;</span>);
list.add(<span class="string">&quot;</span><span class="string">five</span><span class="string">&quot;</span>);
list.add(<span class="string">&quot;</span><span class="string">six</span><span class="string">&quot;</span>);
list.add(<span class="string">&quot;</span><span class="string">seven</span><span class="string">&quot;</span>);
list.print();
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">-------------</span><span class="string">&quot;</span>);
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Remove the last object:</span><span class="string">&quot;</span>);
list.remove();
list.print();
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">-------------</span><span class="string">&quot;</span>);
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Remove </span><span class="literal">\&quot;</span><span class="string">two</span><span class="literal">\&quot;</span><span class="string">&quot;</span>);
list.remove(removeMe);
list.print();
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">-------------</span><span class="string">&quot;</span>);
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Remove the 3rd element:</span><span class="string">&quot;</span>);
list.removeAt(<span class="number">2</span>);
list.print();
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">-------------</span><span class="string">&quot;</span>);
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Add an element to the beginning</span><span class="string">&quot;</span>);
list.addAt(<span class="string">&quot;</span><span class="string">Earth</span><span class="string">&quot;</span>, <span class="number">0</span>);
list.print();
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">-------------</span><span class="string">&quot;</span>);
System.<span class="ST4">out</span>.println(<span class="string">&quot;</span><span class="string">Add an element named </span><span class="literal">\&quot;</span><span class="string">potato</span><span class="literal">\&quot;</span><span class="string"> in the 4th position:</span><span class="string">&quot;</span>);
list.addAt(<span class="string">&quot;</span><span class="string">potato</span><span class="string">&quot;</span>, <span class="number">3</span>);
list.print();
}
}
</pre></body>
</html>

944
Semester 3/Assignments/MP6_ChloeFontenot/Printed HTMLs/PriorityQueueASDV.html Normal file
View File

@@ -0,0 +1,944 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>PriorityQueueASDV.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}
.comment {color: #808080}
.whitespace {color: #505050}
.ST2 {color: #9999ff; font-family: monospace; font-style: italic}
.ST5 {font-family: monospace; font-weight: bold; font-style: italic}
.string {color: #6a8759}
.number {color: #6897bb}
.ST1 {color: #9876aa}
.ST4 {color: #ffc66d}
.ST3 {color: #8a653b}
.ST6 {color: #9876aa; font-family: monospace; font-weight: bold; font-style: italic}
.ST7 {color: #ffc66d; font-family: monospace; font-weight: bold; font-style: italic}
.ST0 {color: #287bde}
.literal {color: #cc7832}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/chloe/mp6_chloefontenot/PriorityQueueASDV.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> edu.slcc.asdv.chloe.mp6_chloefontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">import</span> java.util.ArrayList;
<span class="literal">import</span> java.util.Arrays;
<span class="literal">import</span> java.util.Collection;
<span class="literal">import</span> java.util.Iterator;
<span class="literal">import</span> java.util.List;
<span class="literal">import</span> java.util.NoSuchElementException;
<span class="literal">import</span> java.util.PriorityQueue;
<span class="literal">import</span> java.util.Queue;
<span class="literal">import</span> java.util.function.Consumer;
<span class="literal">public</span> <span class="literal">class</span> PriorityQueueASDV&lt;E <span class="literal">extends</span> Comparable&lt;E&gt;&gt;
<span class="literal">implements</span> Queue&lt;E&gt;, Cloneable {
<span class="literal">private</span> Node&lt;E&gt; <span class="ST1">head</span>;<span class="comment">//head</span>
<span class="literal">private</span> Node&lt;E&gt; <span class="ST1">tail</span>;<span class="comment">//tail</span>
<span class="literal">class</span> Node&lt;E&gt; {
E <span class="ST1">e</span>;
Node&lt;E&gt; <span class="ST1">l</span>;
Node&lt;E&gt; <span class="ST1">r</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Inserts</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">into</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">possible</span> <span class="comment">to</span> <span class="comment">do</span> <span class="comment">so</span> <span class="comment">immediately</span> <span class="comment">without</span> <span class="comment">violating</span> <span class="comment">capacity</span> <span class="comment">restrictions</span><span class="comment">, </span><span class="comment">returning</span> <span class="comment">true</span> <span class="comment">upon</span> <span class="comment">success</span> <span class="comment">and</span> <span class="comment">throwing</span> <span class="comment">an</span> <span class="comment">IllegalStateException</span> <span class="comment">if</span> <span class="comment">no</span> <span class="comment">space</span> <span class="comment">is</span> <span class="comment">currently</span> <span class="comment">available</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">Specified</span> <span class="comment">by</span><span class="comment">: </span><span class="comment">add</span> <span class="comment">in</span> <span class="comment">interface</span> <span class="comment">Collection</span><span class="ST2">&lt;E&gt;</span>
<span class="comment"> * </span><span class="comment">Parameters</span><span class="comment">: </span><span class="comment">e</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">to</span> <span class="comment">add</span> <span class="comment">Returns</span><span class="comment">: </span><span class="comment">true</span><span class="comment"> (</span><span class="comment">as</span> <span class="comment">specified</span> <span class="comment">by</span> <span class="comment">Collection</span><span class="comment">.</span><span class="comment">add</span><span class="comment">(</span><span class="comment">E</span><span class="comment">)) </span><span class="comment">Throws</span><span class="comment">: </span><span class="comment">IllegalStateException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">at</span> <span class="comment">this</span> <span class="comment">time</span> <span class="comment">due</span> <span class="comment">to</span> <span class="comment">capacity</span> <span class="comment">restrictions</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</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">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">e</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">to</span> <span class="comment">add</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">collection</span> <span class="comment">changed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">call</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IllegalStateException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">at</span> <span class="comment">this</span> <span class="comment">time</span> <span class="comment">due</span> <span class="comment">to</span> <span class="comment">capacity</span> <span class="comment">restrictions</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</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">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">add</span>(E e) {
<span class="literal">if</span> (e == <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 elements not allowed!</span><span class="string">&quot;</span>);
}
Node&lt;E&gt; newNode = <span class="literal">new</span> Node&lt;E&gt;();
newNode.<span class="ST1">e</span> = e;
<span class="comment">//1. empty queue</span>
<span class="literal">if</span> (<span class="literal">this</span>.<span class="ST1">head</span> == <span class="literal">null</span> &amp;&amp; <span class="literal">this</span>.<span class="ST1">tail</span> == <span class="literal">null</span>) {
<span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">tail</span> = newNode;
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">int</span> index = findCorrectPositionToInsertElement(e);
<span class="comment">//int index = findCorrectPositionToInsertElementHashCode(e);</span>
<span class="comment">//2. we add at size ( last node)</span>
<span class="literal">if</span> (index == size()) {
<span class="ST1">tail</span>.<span class="ST1">r</span> = newNode;<span class="comment">//1</span>
newNode.<span class="ST1">l</span> = <span class="ST1">tail</span>;<span class="comment">//2</span>
<span class="ST1">tail</span> = newNode;<span class="comment">//3</span>
} <span class="comment">//3. we add at 0 in the front</span>
<span class="literal">else</span> <span class="literal">if</span> (index == <span class="number">0</span>) {
newNode.<span class="ST1">r</span> = <span class="ST1">head</span>;
<span class="literal">this</span>.<span class="ST1">head</span>.<span class="ST1">l</span> = newNode;
<span class="literal">this</span>.<span class="ST1">head</span> = newNode;
<span class="literal">if</span> (size() == <span class="number">1</span>) {
<span class="ST1">tail</span> = <span class="ST1">head</span>;
}
} <span class="comment">//4. we add in the middle</span>
<span class="literal">else</span> {
Node&lt;E&gt; p = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; index - <span class="number">1</span>; ++i) {
p = p.<span class="ST1">r</span>;
}
<span class="comment">//after for loop p point one position before insertion</span>
newNode.<span class="ST1">l</span> = p;<span class="comment">//we connect the left of the new node </span>
<span class="comment">//to the node that is BEFORE </span>
<span class="comment">//the node to be inserted</span>
newNode.<span class="ST1">r</span> = p.<span class="ST1">r</span>;<span class="comment">//we connect the right of the new node</span>
<span class="comment">// to the node thta is AFTER </span>
<span class="comment">//the node to be inserted</span>
p.<span class="ST1">r</span> = newNode; <span class="comment">//we connect the right the node BEFORE the node</span>
<span class="comment">//to be inserted to the new node</span>
p.<span class="ST1">r</span>.<span class="ST1">r</span>.<span class="ST1">l</span> = newNode;<span class="comment">//we connect the left of the node AFTER the node </span>
<span class="comment">//to be iserted to the new node</span>
}
<span class="literal">return</span> <span class="literal">true</span>;
}
@Override
<span class="literal">public</span> <span class="literal">int</span> <span class="ST4">size</span>() {
Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
<span class="literal">int</span> count = <span class="number">0</span>;
<span class="literal">while</span> (p != <span class="literal">null</span>) {
p = p.<span class="ST1">r</span>;
count++;
}
<span class="literal">return</span> count;
}
<span class="literal">private</span> <span class="literal">int</span> <span class="ST4">findCorrectPositionToInsertElement</span>(E e) {
Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
<span class="literal">int</span> pos = <span class="number">0</span>;
<span class="literal">while</span> (p != <span class="literal">null</span>) {
<span class="literal">if</span> (e.compareTo(p.<span class="ST1">e</span>) &gt; <span class="number">0</span>) {
p = p.<span class="ST1">r</span>;
++pos;
} <span class="literal">else</span> {
<span class="literal">break</span>;
}
}
<span class="literal">return</span> pos;
}
<span class="literal">private</span> <span class="literal">int</span> <span class="comment">findCorrectPositionToInsertElementHashCode</span>(E e) {
Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
<span class="literal">int</span> pos = <span class="number">0</span>;
<span class="literal">while</span> (p != <span class="literal">null</span>) {
<span class="literal">if</span> (e.hashCode() &gt; p.<span class="ST1">e</span>.hashCode()) {
p = p.<span class="ST1">r</span>;
++pos;
} <span class="literal">else</span> {
<span class="literal">break</span>;
}
}
<span class="literal">return</span> pos;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Inserts</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">into</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">possible</span> <span class="comment">to</span> <span class="comment">do</span> <span class="comment">so</span> <span class="comment">immediately</span> <span class="comment">without</span> <span class="comment">violating</span> <span class="comment">capacity</span> <span class="comment">restrictions</span><span class="comment">.</span> <span class="comment">When</span> <span class="comment">using</span> <span class="comment">a</span> <span class="comment">capacity</span><span class="comment">-</span><span class="comment">restricted</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">this</span> <span class="comment">method</span> <span class="comment">is</span> <span class="comment">generally</span> <span class="comment">preferable</span> <span class="comment">to</span> <span class="comment">add</span><span class="comment">(</span><span class="comment">E</span><span class="comment">), </span><span class="comment">which</span> <span class="comment">can</span> <span class="comment">fail</span> <span class="comment">to</span> <span class="comment">insert</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">only</span> <span class="comment">by</span> <span class="comment">throwing</span> <span class="comment">an</span> <span class="comment">exception</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">e</span><span class="comment"> - </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">to</span> <span class="comment">add</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IllegalStateException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">element</span> <span class="comment">cannot</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">at</span> <span class="comment">this</span> <span class="comment">time</span> <span class="comment">due</span> <span class="comment">to</span> <span class="comment">capacity</span> <span class="comment">restrictions</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</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">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">element</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">queue</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">element</span> <span class="comment">was</span> <span class="comment">added</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">offer</span>(E e) {
<span class="literal">return</span> add(e);
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Retrieves</span> <span class="comment">and</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">differs</span> <span class="comment">from</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">poll</span> <span class="comment">poll</span><span class="comment">} </span><span class="comment">only</span> <span class="comment">in</span> <span class="comment">that</span> <span class="comment">it</span> <span class="comment">throws</span> <span class="comment">an</span> <span class="comment">exception</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">This</span> <span class="comment">implementation</span> <span class="comment">returns</span> <span class="comment">the</span> <span class="comment">result</span> <span class="comment">of</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">poll</span><span class="comment">}</span> <span class="comment">unless</span> <span class="comment">the</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NoSuchElementException</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> E <span class="ST4">remove</span>() {
Node&lt;E&gt; <span class="comment">pointer</span> = <span class="ST1">head</span>.<span class="ST1">r</span>;
E removedElement = <span class="ST1">head</span>.<span class="ST1">e</span>;
<span class="ST1">head</span> = <span class="ST1">head</span>.<span class="ST1">r</span>;
<span class="ST1">head</span>.<span class="ST1">l</span> = <span class="literal">null</span>;
<span class="literal">return</span> removedElement;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Retrieves</span> <span class="comment">and</span> <span class="comment">removes</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">returns</span> <span class="comment">null</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">Returns</span><span class="comment">: </span><span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</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">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> E <span class="ST4">poll</span>() {
<span class="literal">if</span> (size() == <span class="number">0</span>) {
<span class="literal">return</span> <span class="literal">null</span>;
}
<span class="literal">if</span> (size() &gt; <span class="number">1</span>) {
<span class="ST1">head</span> = <span class="ST1">head</span>.<span class="ST1">r</span>;
E e = <span class="ST1">head</span>.<span class="ST1">l</span>.<span class="ST1">e</span>;
<span class="ST1">head</span>.<span class="ST1">l</span> = <span class="literal">null</span>;
<span class="literal">return</span> e;
} <span class="literal">else</span> <span class="comment">//size 1</span>
{
E e = <span class="ST1">head</span>.<span class="ST1">e</span>;
<span class="ST1">head</span> = <span class="ST1">tail</span> = <span class="literal">null</span>;
<span class="literal">return</span> e;
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Retrieves</span><span class="comment">, </span><span class="comment">but</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">remove</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">.</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">differs</span> <span class="comment">from</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">peek</span> <span class="comment">peek</span><span class="comment">} </span><span class="comment">only</span> <span class="comment">in</span> <span class="comment">that</span> <span class="comment">it</span> <span class="comment">throws</span> <span class="comment">an</span> <span class="comment">exception</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">NoSuchElementException</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> E <span class="ST4">element</span>() {
<span class="literal">if</span> (<span class="ST1">head</span> != <span class="literal">null</span>) {
<span class="literal">return</span> (E) <span class="ST1">head</span>;
} <span class="literal">else</span> {
<span class="literal">throw</span> <span class="literal">new</span> NoSuchElementException(<span class="string">&quot;</span><span class="string">Element does not exist.</span><span class="string">&quot;</span>);
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Retrieves</span><span class="comment">, </span><span class="comment">but</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">remove</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">the</span> <span class="comment">head</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">queue</span><span class="comment">, </span><span class="comment">or</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">queue</span> <span class="comment">is</span> <span class="comment">empty</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> E <span class="ST4">peek</span>() {
<span class="literal">return</span> (E) <span class="ST1">head</span>;
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">isEmpty</span>() {
<span class="literal">return</span> <span class="ST1">head</span> == <span class="literal">null</span> &amp;&amp; <span class="ST1">tail</span> == <span class="literal">null</span> ? <span class="literal">true</span> : <span class="literal">false</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</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"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</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">collection</span> <span class="comment">contains</span> <span class="comment">at</span> <span class="comment">least</span> <span class="comment">one</span> <span class="comment">element</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">e</span><span class="comment">}</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">Objects</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">o</span><span class="comment">, </span><span class="comment">e</span><span class="comment">)</span><span class="comment">}</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">o</span> <span class="comment">element</span> <span class="comment">whose</span> <span class="comment">presence</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</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"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">incompatible</span> <span class="comment">with</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">})</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">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">})</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">contains</span>(Object o) {
Node&lt;E&gt; pointer = <span class="ST1">head</span>;
<span class="literal">do</span> {
<span class="literal">if</span> (pointer.equals(o)) {
<span class="literal">return</span> <span class="literal">true</span>;
} <span class="literal">else</span> {
pointer = pointer.<span class="ST1">r</span>;
}
} <span class="literal">while</span> (pointer != <span class="literal">null</span>);
<span class="literal">return</span> <span class="literal">false</span>;
}
@Override
<span class="literal">public</span> Iterator&lt;E&gt; <span class="ST4">iterator</span>() {
Iterator&lt;E&gt; it = <span class="literal">new</span> Iterator&lt;E&gt;() {
Node&lt;E&gt; <span class="ST1">p</span> = <span class="ST1">head</span>;
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">hasNext</span>() {
<span class="literal">return</span> <span class="ST1">p</span> == <span class="literal">null</span> ? <span class="literal">false</span> : <span class="literal">true</span>;
}
@Override
<span class="literal">public</span> E <span class="ST4">next</span>() {
<span class="literal">if</span> (hasNext() == <span class="literal">false</span>) {
<span class="literal">throw</span> <span class="literal">new</span> NoSuchElementException(<span class="string">&quot;</span><span class="string">the is no next element</span><span class="string">&quot;</span>);
}
E e = <span class="ST1">p</span>.<span class="ST1">e</span>;
<span class="ST1">p</span> = <span class="ST1">p</span>.<span class="ST1">r</span>;
<span class="literal">return</span> e;
}
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">forEachRemaining</span>(Consumer&lt;? <span class="literal">super</span> E&gt; action) {
<span class="literal">while</span> (hasNext()) {
action.accept(<span class="ST1">p</span>.<span class="ST1">e</span>);
<span class="ST1">p</span> = <span class="ST1">p</span>.<span class="ST1">r</span>;
}
}
};
<span class="literal">return</span> it;
}
@Override
<span class="literal">public</span> Object[] <span class="ST4">toArray</span>() {
Node&lt;E&gt; pointer = <span class="ST1">head</span>;
Object[] returnArray = <span class="literal">new</span> Object[<span class="literal">this</span>.size()];
<span class="literal">int</span> i = <span class="number">0</span>;
<span class="literal">while</span> (pointer.<span class="ST1">r</span> != <span class="literal">null</span>) {
returnArray[i++] = pointer.<span class="ST1">e</span>;
pointer = pointer.<span class="ST1">r</span>;
}
returnArray[i++] = pointer.<span class="ST1">e</span>;
<span class="literal">return</span> returnArray;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">an</span> <span class="comment">array</span> <span class="comment">containing</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">; </span><span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">returned</span> <span class="comment">array</span> <span class="comment">is</span> <span class="comment">that</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">fits</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span><span class="comment">, </span><span class="comment">it</span> <span class="comment">is</span> <span class="comment">returned</span> <span class="comment">therein</span><span class="comment">.</span> <span class="comment">Otherwise</span><span class="comment">, </span><span class="comment">a</span> <span class="comment">new</span> <span class="comment">array</span> <span class="comment">is</span> <span class="comment">allocated</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span> <span class="comment">and</span> <span class="comment">the</span> <span class="comment">size</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">If</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">fits</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</span> <span class="comment">with</span> <span class="comment">room</span> <span class="comment">to</span> <span class="comment">spare</span><span class="comment"> (</span><span class="comment">i</span><span class="comment">.</span><span class="comment">e</span><span class="comment">.</span><span class="comment">, </span><span class="comment">the</span> <span class="comment">array</span> <span class="comment">has</span> <span class="comment">more</span> <span class="comment">elements</span> <span class="comment">than</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">), </span><span class="comment">the</span> <span class="comment">element</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">array</span> <span class="comment">immediately</span> <span class="comment">following</span> <span class="comment">the</span> <span class="comment">end</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">set</span> <span class="comment">to</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span><span class="comment">.</span><span class="comment"> (</span><span class="comment">This</span> <span class="comment">is</span> <span class="comment">useful</span> <span class="comment">in</span> <span class="comment">determining</span> <span class="comment">the</span> <span class="comment">length</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="ST2">&lt;i&gt;</span><span class="comment">only</span><span class="ST2">&lt;/i&gt;</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">caller</span> <span class="comment">knows</span> <span class="comment">that</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">contain</span> <span class="comment">any</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">null</span><span class="comment">}</span> <span class="comment">elements</span><span class="comment">.</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">If</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">makes</span> <span class="comment">any</span> <span class="comment">guarantees</span> <span class="comment">as</span> <span class="comment">to</span> <span class="comment">what</span> <span class="comment">order</span> <span class="comment">its</span> <span class="comment">elements</span> <span class="comment">are</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">its</span> <span class="comment">iterator</span><span class="comment">, </span><span class="comment">this</span> <span class="comment">method</span> <span class="comment">must</span> <span class="comment">return</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">same</span> <span class="comment">order</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@apiNote</span> <span class="comment">This</span> <span class="comment">method</span> <span class="comment">acts</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">bridge</span> <span class="comment">between</span> <span class="comment">array</span><span class="comment">-</span><span class="comment">based</span> <span class="comment">and</span> <span class="comment">collection</span><span class="comment">-</span><span class="comment">based</span> <span class="comment">APIs</span><span class="comment">.</span> <span class="comment">It</span> <span class="comment">allows</span> <span class="comment">an</span> <span class="comment">existing</span> <span class="comment">array</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">reused</span> <span class="comment">under</span> <span class="comment">certain</span> <span class="comment">circumstances</span><span class="comment">.</span> <span class="comment">Use</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">toArray</span><span class="comment">()} </span><span class="comment">to</span> <span class="comment">create</span> <span class="comment">an</span> <span class="comment">array</span> <span class="comment">whose</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">is</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">Object</span><span class="comment">[]</span><span class="comment">}, </span><span class="comment">or</span> <span class="comment">use</span><span class="comment"> {</span><span class="comment">@link</span> <span class="comment">#</span><span class="comment">toArray</span><span class="comment">(</span><span class="comment">IntFunction</span><span class="comment">)} </span><span class="comment">to</span> <span class="comment">control</span> <span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">array</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">Suppose</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">x</span><span class="comment">}</span> <span class="comment">is</span> <span class="comment">a</span> <span class="comment">collection</span> <span class="comment">known</span> <span class="comment">to</span> <span class="comment">contain</span> <span class="comment">only</span> <span class="comment">strings</span><span class="comment">.</span> <span class="comment">The</span> <span class="comment">following</span> <span class="comment">code</span> <span class="comment">can</span> <span class="comment">be</span> <span class="comment">used</span> <span class="comment">to</span> <span class="comment">dump</span> <span class="comment">the</span> <span class="comment">collection</span> <span class="comment">into</span> <span class="comment">a</span> <span class="comment">previously</span> <span class="comment">allocated</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">String</span><span class="comment">}</span> <span class="comment">array</span><span class="comment">:</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;pre&gt;</span>
<span class="comment"> * </span><span class="comment">String</span><span class="comment">[] </span><span class="comment">y</span><span class="comment"> = </span><span class="comment">new</span> <span class="comment">String</span><span class="comment">[</span><span class="comment">SIZE</span><span class="comment">];</span>
<span class="comment"> * </span><span class="comment">.</span><span class="comment">.</span><span class="comment">.</span>
<span class="comment"> * </span><span class="comment">y</span><span class="comment"> = </span><span class="comment">x</span><span class="comment">.</span><span class="comment">toArray</span><span class="comment">(</span><span class="comment">y</span><span class="comment">);</span><span class="ST2">&lt;/pre&gt;</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">The</span> <span class="comment">return</span> <span class="comment">value</span> <span class="comment">is</span> <span class="comment">reassigned</span> <span class="comment">to</span> <span class="comment">the</span> <span class="comment">variable</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">y</span><span class="comment">}</span><span class="comment">, </span><span class="comment">because</span> <span class="comment">a</span> <span class="comment">new</span> <span class="comment">array</span> <span class="comment">will</span> <span class="comment">be</span> <span class="comment">allocated</span> <span class="comment">and</span> <span class="comment">returned</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">collection</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">x</span><span class="comment">}</span> <span class="comment">has</span> <span class="comment">too</span> <span class="comment">many</span> <span class="comment">elements</span> <span class="comment">to</span> <span class="comment">fit</span> <span class="comment">into</span> <span class="comment">the</span> <span class="comment">existing</span> <span class="comment">array</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">y</span><span class="comment">}</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">Note</span> <span class="comment">that</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">toArray</span><span class="comment">(</span><span class="comment">new</span> <span class="comment">Object</span><span class="comment">[0])</span><span class="comment">} </span><span class="comment">is</span> <span class="comment">identical</span> <span class="comment">in</span> <span class="comment">function</span> <span class="comment">to</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">toArray</span><span class="comment">()</span><span class="comment">}</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">&lt;T&gt;</span> <span class="comment">the</span> <span class="comment">component</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">array</span> <span class="comment">to</span> <span class="comment">contain</span> <span class="comment">the</span> <span class="comment">collection</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">a</span> <span class="comment">the</span> <span class="comment">array</span> <span class="comment">into</span> <span class="comment">which</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">are</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">stored</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">it</span> <span class="comment">is</span> <span class="comment">big</span> <span class="comment">enough</span><span class="comment">; </span><span class="comment">otherwise</span><span class="comment">, </span><span class="comment">a</span> <span class="comment">new</span> <span class="comment">array</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">same</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">is</span> <span class="comment">allocated</span> <span class="comment">for</span> <span class="comment">this</span> <span class="comment">purpose</span><span class="comment">.</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">an</span> <span class="comment">array</span> <span class="comment">containing</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ArrayStoreException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">runtime</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">any</span> <span class="comment">element</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">not</span> <span class="comment">assignable</span> <span class="comment">to</span> <span class="comment">the</span><span class="comment"> {</span><span class="comment">@linkplain</span> <span class="comment">Class</span><span class="comment">#</span><span class="comment">getComponentType</span>
<span class="comment"> * </span><span class="comment">runtime</span> <span class="comment">component</span> <span class="comment">type</span><span class="comment">} </span><span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">array</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">specified</span> <span class="comment">array</span> <span class="comment">is</span> <span class="comment">null</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> &lt;T&gt; T[] <span class="ST4">toArray</span>(T[] a) {
a = Arrays.<span class="ST5">copyOf</span>(a, <span class="literal">t</span><span class="literal">his</span>.size());
Node&lt;E&gt; pointer = <span class="ST1">head</span>;
System.<span class="ST6">out</span>.println(a.getClass());
System.<span class="ST6">out</span>.println(pointer.getClass());
System.<span class="ST6">out</span>.println(pointer.<span class="ST1">e</span>.getClass());
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="literal">this</span>.size(); ++i) {
a[i] = (T) pointer.<span class="ST1">e</span>;
pointer = pointer.<span class="ST1">r</span>;
}
<span class="literal">return</span> a;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">a</span> <span class="comment">single</span> <span class="comment">instance</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </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">removes</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">e</span> <span class="comment">such</span> <span class="comment">that</span><span class="comment"> (</span><span class="comment">o</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> ? </span><span class="comment">e</span><span class="comment">==</span><span class="comment">null</span><span class="comment"> : </span><span class="comment">o</span><span class="comment">.</span><span class="comment">equals</span><span class="comment">(</span><span class="comment">e</span><span class="comment">)), </span><span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">such</span> <span class="comment">elements</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">collection</span> <span class="comment">contained</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span><span class="comment"> (</span><span class="comment">or</span> <span class="comment">equivalently</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">changed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">call</span><span class="comment">)</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">o</span><span class="comment"> - </span><span class="comment">element</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">if</span> <span class="comment">present</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">type</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">element</span> <span class="comment">is</span> <span class="comment">incompatible</span> <span class="comment">with</span> <span class="comment">this</span> <span class="comment">collection</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">element</span> <span class="comment">is</span> <span class="comment">null</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span>
<span class="comment"> * </span><span class="comment">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">was</span> <span class="comment">removed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">call</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">remove</span>(Object o) {
<span class="literal">if</span> (o == <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 vales not allowed</span><span class="string">&quot;</span>);
}
<span class="literal">if</span> (size() == <span class="number">0</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
Node&lt;E&gt; p = <span class="literal">this</span>.<span class="ST1">head</span>;
<span class="literal">int</span> pos = <span class="number">0</span>;
<span class="literal">while</span> (p != <span class="literal">this</span>.<span class="ST1">tail</span>) {
<span class="literal">if</span> (p.<span class="ST1">e</span>.equals(o)) {
<span class="literal">if</span> (size() == <span class="number">1</span>) {
<span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">tail</span> = <span class="literal">null</span>;
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">this</span>.removeAt(pos, (E) o);
<span class="literal">break</span>;
}
++pos;
p = p.<span class="ST1">r</span>;
}
<span class="literal">if</span> (p == <span class="ST1">tail</span> &amp;&amp; p.<span class="ST1">e</span>.equals(o)) {
<span class="literal">this</span>.removeAt(size() - <span class="number">1</span>, (E) o);
}
<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="ST3">pos</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">e</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IndexOutOfBoundsException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">pos</span> <span class="comment">less</span><span class="comment"> 0 </span><span class="comment">OR</span> <span class="comment">pos</span> <span class="comment">greater</span><span class="comment">-</span><span class="comment">equal</span> <span class="comment">size</span><span class="comment">()</span>
<span class="comment"> * </span><span class="comment">@return</span>
<span class="comment">*/</span>
<span class="literal">private</span> <span class="literal">boolean</span> <span class="ST4">removeAt</span>(<span class="literal">int</span> pos, E <span class="comment">e</span>) {
<span class="literal">if</span> (pos &lt; <span class="number">0</span> || pos &gt;= size()) {
<span class="literal">throw</span> <span class="literal">new</span> IndexOutOfBoundsException(pos + <span class="string">&quot;</span><span class="string"> is out of bounds</span><span class="string">&quot;</span>);
}
<span class="comment">//1.list is empty</span>
<span class="literal">if</span> (isEmpty()) {
<span class="literal">return</span> <span class="literal">false</span>;
} <span class="comment">//2. one node exists</span>
<span class="literal">else</span> <span class="literal">if</span> (size() == <span class="number">1</span>) {
<span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">tail</span> = <span class="literal">null</span>;
} <span class="comment">//3. remove in the front( head)</span>
<span class="literal">else</span> <span class="literal">if</span> (pos == <span class="number">0</span>) {
<span class="literal">this</span>.<span class="ST1">head</span> = <span class="literal">this</span>.<span class="ST1">head</span>.<span class="ST1">r</span>;
<span class="ST1">head</span>.<span class="ST1">l</span> = <span class="literal">null</span>;
} <span class="comment">//4. remove in the end ( tail)</span>
<span class="literal">else</span> <span class="literal">if</span> (pos == size() - <span class="number">1</span>) {
<span class="literal">this</span>.<span class="ST1">tail</span> = <span class="literal">this</span>.<span class="ST1">tail</span>.<span class="ST1">l</span>;
<span class="literal">this</span>.<span class="ST1">tail</span>.<span class="ST1">r</span> = <span class="literal">null</span>;
} <span class="comment">//5. remove in the middle ( at least 3 nodes are in the queue)</span>
<span class="literal">else</span> {
Node&lt;E&gt; p = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; pos - <span class="number">1</span>; ++i) {
p = p.<span class="ST1">r</span>;
}
p.<span class="ST1">r</span> = p.<span class="ST1">r</span>.<span class="ST1">r</span>;
p.<span class="ST1">r</span>.<span class="ST1">l</span> = p;
}
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">c</span> <span class="comment">collection</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">checked</span> <span class="comment">for</span> <span class="comment">containment</span> <span class="comment">in</span> <span class="comment">this</span> <span class="comment">collection</span>
<span class="comment"> * </span><span class="comment">@return</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">true</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">types</span> <span class="comment">of</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">are</span> <span class="comment">incompatible</span> <span class="comment">with</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">})</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">specified</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">null</span> <span class="comment">elements</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span><span class="comment"> ({</span><span class="comment">@linkplain</span> <span class="comment">Collection</span><span class="comment">#</span><span class="comment">#</span><span class="comment">optional</span><span class="comment">-</span><span class="comment">restrictions</span> <span class="comment">optional</span><span class="comment">}) </span><span class="comment">or</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">.</span>
<span class="comment"> * </span><span class="comment">@see</span> <span class="comment">#</span><span class="comment">contains</span><span class="comment">(</span><span class="comment">Object</span><span class="comment">)</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">containsAll</span>(Collection&lt;?&gt; c) {
<span class="comment">// Java already throws a CastCastException if you give it the wrong type, so we don&#39;t have to throw that ourselves</span>
<span class="literal">if</span> (c.contains(<span class="literal">n</span><span class="literal">ull</span>) || c == <span class="literal">null</span>) {
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">The collection you passed to containsAll() contains a null element. Cannot continue.</span><span class="string">&quot;</span>);
}
<span class="comment">// Unpack the collection so we can compare them</span>
Object[] compareArray = c.toArray();
Node&lt;E&gt; pointer = <span class="literal">null</span>;
<span class="literal">int</span> matchCount = <span class="number">0</span>;
<span class="literal">for</span> (Object compare : compareArray) {
pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; size() - <span class="number">1</span>; ++i) {
<span class="literal">if</span> (pointer.<span class="ST1">e</span>.equals(compare)) {
matchCount++;
}
pointer = pointer.<span class="ST1">r</span>;
}
}
<span class="literal">if</span> (matchCount == compareArray.<span class="ST1">length</span> - <span class="number">1</span>) {
<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">Adds</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</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">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">collection</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">This</span> <span class="comment">implies</span> <span class="comment">that</span> <span class="comment">the</span> <span class="comment">behavior</span> <span class="comment">of</span> <span class="comment">this</span> <span class="comment">call</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">collection</span> <span class="comment">is</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">nonempty</span><span class="comment">.</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@param</span> <span class="ST3">c</span><span class="comment"> - </span><span class="comment">collection</span> <span class="comment">containing</span> <span class="comment">elements</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">the</span> <span class="comment">class</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</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">collection</span> <span class="comment">contains</span> <span class="comment">a</span> <span class="comment">null</span> <span class="comment">element</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">permit</span> <span class="comment">null</span> <span class="comment">elements</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">is</span> <span class="comment">null</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">IllegalArgumentException</span><span class="comment"> - </span><span class="comment">if</span> <span class="comment">some</span> <span class="comment">property</span> <span class="comment">of</span> <span class="comment">an</span> <span class="comment">element</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span> <span class="comment">prevents</span> <span class="comment">it</span> <span class="comment">from</span> <span class="comment">being</span> <span class="comment">added</span> <span class="comment">to</span> <span class="comment">this</span> <span class="comment">collection</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">collection</span> <span class="comment">changed</span> <span class="comment">as</span> <span class="comment">a</span> <span class="comment">result</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">call</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">addAll</span>(Collection&lt;? <span class="literal">extends</span> E&gt; c) {
<span class="literal">int</span> sizeBefore = size();
<span class="literal">for</span> (E e : c) {
add(e);
}
<span class="literal">int</span> sizeAfter = size();
<span class="literal">return</span> sizeAfter &gt; sizeBefore;
}
<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">this</span> <span class="comment">collection</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">elements</span> <span class="comment">that</span> <span class="comment">are</span> <span class="comment">also</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</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">After</span> <span class="comment">this</span> <span class="comment">call</span> <span class="comment">returns</span><span class="comment">, </span><span class="comment">this</span> <span class="comment">collection</span> <span class="comment">will</span> <span class="comment">contain</span> <span class="comment">no</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">common</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@implSpec</span> <span class="comment">This</span> <span class="comment">implementation</span> <span class="comment">iterates</span> <span class="comment">over</span> <span class="comment">this</span> <span class="comment">collection</span><span class="comment">, </span><span class="comment">checking</span> <span class="comment">each</span> <span class="comment">element</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">iterator</span> <span class="comment">in</span> <span class="comment">turn</span> <span class="comment">to</span> <span class="comment">see</span> <span class="comment">if</span> <span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span> <span class="comment">If</span> <span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">so</span> <span class="comment">contained</span><span class="comment">, </span><span class="comment">it</span><span class="comment">&#39;</span><span class="comment">s</span> <span class="comment">removed</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">iterator</span><span class="comment">&#39;</span><span class="comment">s</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">remove</span><span class="comment">}</span> <span class="comment">method</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST2">&lt;p&gt;</span>
<span class="comment"> * </span><span class="comment">Note</span> <span class="comment">that</span> <span class="comment">this</span> <span class="comment">implementation</span> <span class="comment">will</span> <span class="comment">throw</span> <span class="comment">an</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">UnsupportedOperationException</span><span class="comment">}</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">iterator</span> <span class="comment">returned</span> <span class="comment">by</span> <span class="comment">the</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">iterator</span><span class="comment">}</span> <span class="comment">method</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">implement</span> <span class="comment">the</span><span class="comment"> {</span><span class="comment">@code</span> <span class="comment">remove</span><span class="comment">}</span> <span class="comment">method</span> <span class="comment">and</span> <span class="comment">this</span> <span class="comment">collection</span> <span class="comment">contains</span> <span class="comment">one</span> <span class="comment">or</span> <span class="comment">more</span> <span class="comment">elements</span> <span class="comment">in</span> <span class="comment">common</span> <span class="comment">with</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">collection</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">UnsupportedOperationException</span><span class="comment"> {</span><span class="comment">@inheritDoc</span><span class="comment">}</span>
<span class="comment"> * </span><span class="comment">@throws</span> <span class="comment">ClassCastException</span><span class="comment"> {</span><span class="comment">@inheritDoc</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">@inheritDoc</span><span class="comment">}</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="comment">@see</span> <span class="comment">#</span><span class="comment">remove</span><span class="comment">(</span><span class="comment">Object</span><span class="comment">)</span>
<span class="comment"> * </span><span class="comment">@see</span> <span class="comment">#</span><span class="comment">contains</span><span class="comment">(</span><span class="comment">Object</span><span class="comment">)</span>
<span class="comment">*/</span>
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">removeAll</span>(Collection&lt;?&gt; c) {
<span class="literal">if</span> (c.contains(<span class="literal">n</span><span class="literal">ull</span>) || c == <span class="literal">null</span>) {
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">The collection you passed to removeAll() contains a null element. Cannot continue.</span><span class="string">&quot;</span>);
}
<span class="comment">// Unpack the collection so we can remove them</span>
Object[] compareArray = c.toArray();
Node&lt;E&gt; pointer = <span class="literal">null</span>;
<span class="literal">boolean</span> removeSuccessful = <span class="literal">false</span>;
<span class="literal">for</span> (Object compare : compareArray) {
pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; size() - <span class="number">1</span>; ++i) {
<span class="literal">if</span> (pointer.<span class="ST1">e</span>.equals(compare)) {
remove(pointer.<span class="ST1">e</span>);
removeSuccessful = <span class="literal">true</span>;
}
pointer = pointer.<span class="ST1">r</span>;
}
}
<span class="literal">return</span> removeSuccessful;
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">retainAll</span>(Collection&lt;?&gt; c) {
<span class="literal">if</span> (c.contains(<span class="literal">n</span><span class="literal">ull</span>) || c == <span class="literal">null</span>) {
<span class="literal">throw</span> <span class="literal">new</span> NullPointerException(<span class="string">&quot;</span><span class="string">The collection you passed to retainAll() contains a null element. Cannot continue.</span><span class="string">&quot;</span>);
}
Node&lt;E&gt; pointer = <span class="literal">null</span>;
<span class="literal">boolean</span> removeSuccessful = <span class="literal">false</span>;
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; c.size() - <span class="number">1</span>; ++j) {
pointer = <span class="ST1">head</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; size(); ++i) {
<span class="literal">if</span> (!c.contains(pointer.<span class="ST1">e</span>)) {
remove(pointer.<span class="ST1">e</span>);
removeSuccessful = <span class="literal">true</span>;
}
pointer = pointer.<span class="ST1">r</span>;
}
}
<span class="literal">return</span> removeSuccessful;
}
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">clear</span>() {
<span class="comment">// head = tail = null;</span>
<span class="comment">//extra, no necessary to set the link of every node</span>
Node&lt;E&gt; p = <span class="ST1">head</span>;
<span class="literal">while</span> (p != <span class="ST1">tail</span>) {
p = p.<span class="ST1">r</span>;
p.<span class="ST1">l</span> = <span class="literal">null</span>;
}
<span class="ST1">head</span> = <span class="ST1">tail</span> = <span class="literal">null</span>;
}
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">forEach</span>(Consumer&lt;? <span class="literal">super</span> E&gt; action) {
<span class="comment">//1. use a pointer that points to the head</span>
<span class="comment">//2. while the pointer has not reached the end of the queue </span>
<span class="comment">//consume it</span>
Node&lt;E&gt; p = <span class="ST1">head</span>;
<span class="literal">while</span> (p != <span class="literal">null</span>) {
action.accept(p.<span class="ST1">e</span>);
p = p.<span class="ST1">r</span>;
}
}
@Override
<span class="literal">public</span> String <span class="ST4">toString</span>() {
String s = <span class="string">&quot;</span><span class="string">PriorityQueueASDV {</span><span class="string">&quot;</span>;
Node&lt;E&gt; p = <span class="ST1">head</span>;
<span class="literal">while</span> (p != <span class="literal">null</span>) {
s += p.<span class="ST1">e</span>.toString();
<span class="literal">if</span> (p != <span class="ST1">tail</span>) {
s += <span class="string">&quot;</span><span class="string">, </span><span class="string">&quot;</span>;
}
p = p.<span class="ST1">r</span>;
}
s += <span class="string">&quot;</span><span class="string">}</span><span class="string">&quot;</span>;
<span class="literal">return</span> s;
}
@Override
<span class="literal">protected</span> Object <span class="ST4">clone</span>()
<span class="literal">throws</span> CloneNotSupportedException {
PriorityQueueASDV&lt;E&gt; c = (PriorityQueueASDV&lt;E&gt;) <span class="literal">super</span>.clone();
<span class="literal">return</span> c;
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST7">main</span>(String[] args) {
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV testing add</span><span class="string">&quot;</span>);
PriorityQueueASDV&lt;String&gt; pq1 = <span class="literal">new</span> PriorityQueueASDV();
pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; Colllections PriorityQueue testing add</span><span class="string">&quot;</span>);
PriorityQueue&lt;String&gt; pq2 = <span class="literal">new</span> PriorityQueue();
pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq2);
<span class="comment">//TEST IT FULLY HERE. FOR ALL METHODS AND ALL CASES.</span>
<span class="comment">//Have the Jzva PriorityQueue below</span>
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV testing remove(object o)</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from front Athens</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from end Paris</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the middle Lafayette</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">add at the end Stocholm</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the middle London</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the front Berlin</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from the front/end Stocholm</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string">remove from empty queue</span><span class="string">&quot;</span>);
pq1.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
pq2.remove(<span class="string">&quot;</span><span class="string">Stocholm</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV recreate priority queues from empty</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\n</span><span class="string">+++HERE YOU TEST ALL YOUR METHODS FULLY, and the methods of Colleciion PriorityQueue</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> offer New York</span><span class="string">&quot;</span>);
pq1.offer(<span class="string">&quot;</span><span class="string">New York</span><span class="string">&quot;</span>);
pq2.offer(<span class="string">&quot;</span><span class="string">New York</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> offer Miami</span><span class="string">&quot;</span>);
pq1.offer(<span class="string">&quot;</span><span class="string">Miami</span><span class="string">&quot;</span>);
pq2.offer(<span class="string">&quot;</span><span class="string">Miami</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> offer null</span><span class="string">&quot;</span>);
<span class="literal">try</span> {
pq1.offer(<span class="literal">n</span><span class="literal">ull</span>);
} <span class="literal">catch</span> (Exception e) {
System.<span class="ST6">err</span>.println(e);
}
<span class="literal">try</span> {
pq2.offer(<span class="literal">n</span><span class="literal">ull</span>);
} <span class="literal">catch</span> (Exception e) {
System.<span class="ST6">err</span>.println(e);
}
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> offer ClassCastException with Object</span><span class="string">&quot;</span>);
<span class="literal">try</span> {
pq1.offer((String) <span class="literal">new</span> Object());
} <span class="literal">catch</span> (Exception e) {
System.<span class="ST6">err</span>.println(e);
}
<span class="literal">try</span> {
pq2.offer((String) <span class="literal">new</span> Object());
} <span class="literal">catch</span> (Exception e) {
System.<span class="ST6">err</span>.println(e);
}
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> poll suposed to be Athens</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1.poll());
System.<span class="ST6">out</span>.println(pq2.poll());
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> Iterator</span><span class="string">&quot;</span>);
Iterator&lt;String&gt; it1 = pq1.iterator();
Iterator&lt;String&gt; it2 = pq2.iterator();
<span class="literal">while</span> (it1.hasNext()) {
System.<span class="ST6">out</span>.print(it1.next() + <span class="string">&quot;</span> <span class="string">&quot;</span>);
}
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
<span class="literal">while</span> (it2.hasNext()) {
System.<span class="ST6">out</span>.print(it2.next() + <span class="string">&quot;</span> <span class="string">&quot;</span>);
}
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> Iterator NoSuchElementException </span><span class="string">&quot;</span>);
<span class="literal">try</span> {
System.<span class="ST6">out</span>.println(it1.next());
} <span class="literal">catch</span> (NoSuchElementException e) {
System.<span class="ST6">err</span>.println(e);
}
<span class="literal">try</span> {
System.<span class="ST6">out</span>.println(it2.next());
} <span class="literal">catch</span> (NoSuchElementException e) {
System.<span class="ST6">err</span>.println(e);
}
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> Iterator foreach </span><span class="string">&quot;</span>);
it1 = pq1.iterator();
it2 = pq2.iterator();
it1.forEachRemaining(<span class="literal">new</span> Consumer() {
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">*** </span><span class="string">&quot;</span>);
}
});
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
it2.forEachRemaining(<span class="literal">new</span> Consumer() {
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">+++ </span><span class="string">&quot;</span>);
}
});
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> addAll Houston Chicago</span><span class="string">&quot;</span>);
List&lt;String&gt; ar1 = Arrays.<span class="ST5">asList</span>(<span class="string">&quot;</span><span class="string">Houston</span><span class="string">&quot;</span>, <span class="string">&quot;</span><span class="string">Chicago</span><span class="string">&quot;</span>);
pq1.addAll(ar1);
pq2.addAll(ar1);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> clear</span><span class="string">&quot;</span>);
pq1.clear();
pq2.clear();
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="string">--&gt; PriorityQueueASDV recreate priority queues from empty</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> forEach</span><span class="string">&quot;</span>);
pq1.forEach(<span class="literal">new</span> Consumer() {
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">*** </span><span class="string">&quot;</span>);
}
});
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
pq2.forEach(<span class="literal">new</span> Consumer() {
@Override
<span class="literal">public</span> <span class="literal">void</span> <span class="ST4">accept</span>(Object t) {
System.<span class="ST6">out</span>.print(t + <span class="string">&quot;</span><span class="string">+++ </span><span class="string">&quot;</span>);
}
});
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="literal">\n</span><span class="literal">\t</span><span class="string"> clone</span><span class="string">&quot;</span>);
<span class="literal">try</span> {
PriorityQueueASDV&lt;String&gt; pq1Cloned
= (PriorityQueueASDV&lt;String&gt;) pq1.clone();
System.<span class="ST6">out</span>.println(pq1Cloned);
pq1Cloned.add(<span class="string">&quot;</span><span class="string">Las Vegas</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1Cloned);
System.<span class="ST6">out</span>.println(pq1);
} <span class="literal">catch</span> (CloneNotSupportedException e) {
System.<span class="ST6">err</span>.println(e);
}
pq1.clear();
pq2.clear();
pq1.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq1.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Athens</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
pq2.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Attempt to remove an element.</span><span class="string">&quot;</span>);
pq1.remove();
pq2.remove();
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Get array of the priority queues.</span><span class="string">&quot;</span>);
Object pqArray1[] = pq1.toArray();
Object pqArray2[] = pq2.toArray();
<span class="ST5">printArrays</span>(pqArray1);
<span class="ST5">printArrays</span>(pqArray2);
System.<span class="ST6">out</span>.println();
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Test .toArray(T[])</span><span class="string">&quot;</span>);
String[] pqArray3 = pq1.toArray(<span class="literal">new</span> String[<span class="number">0</span>]);
<span class="ST5">printArrays</span>(pqArray3);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Test containsAll()</span><span class="string">&quot;</span>);
ArrayList&lt;String&gt; testArray = <span class="literal">new</span> ArrayList&lt;&gt;();
testArray.add(<span class="string">&quot;</span><span class="string">Lafayette</span><span class="string">&quot;</span>);
testArray.add(<span class="string">&quot;</span><span class="string">Berlin</span><span class="string">&quot;</span>);
testArray.add(<span class="string">&quot;</span><span class="string">Zurich</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain Lafayette, Berlin, and Zurich? </span><span class="string">&quot;</span> + (pq1.containsAll(testArray) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>));
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain the contents of pq2? </span><span class="string">&quot;</span> + (pq1.containsAll(pq2) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>));
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq2 contain the contents of pq1? </span><span class="string">&quot;</span> + (pq2.containsAll(pq1) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>));
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Adding funkytown to testArray...</span><span class="string">&quot;</span>);
testArray.add(<span class="string">&quot;</span><span class="string">Funkytown</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain Lafayette, Berlin, Zurich, and Funkytown? </span><span class="string">&quot;</span> + (pq1.containsAll(testArray) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>));
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Test if containsAll() correctly throws a NullPointerException...</span><span class="string">&quot;</span>);
<span class="literal">try</span> {
testArray.add(<span class="literal">n</span><span class="literal">ull</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Does pq1 contain Lafayette, Berlin, Zurich, Funkytown, and null? </span><span class="string">&quot;</span> + (pq1.containsAll(testArray) ? <span class="string">&quot;</span><span class="string">yes</span><span class="string">&quot;</span> : <span class="string">&quot;</span><span class="string">no</span><span class="string">&quot;</span>));
} <span class="literal">catch</span> (NullPointerException ex) {
System.<span class="ST6">out</span>.println(ex);
}
testArray.remove(<span class="literal">n</span><span class="literal">ull</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">That worked! Continuing with tests...</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Testing removeAll(Collection&lt;?&gt;)...</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Removing the elements in the test array...</span><span class="string">&quot;</span>);
pq1.removeAll(testArray);
pq2.removeAll(testArray);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">----------------</span><span class="string">&quot;</span>);
System.<span class="ST6">out</span>.println(<span class="string">&quot;</span><span class="string">Testing retainAll()...</span><span class="string">&quot;</span>);
ArrayList&lt;String&gt; testArray2 = <span class="literal">new</span> ArrayList&lt;&gt;();
testArray2.add(<span class="string">&quot;</span><span class="string">London</span><span class="string">&quot;</span>);
testArray2.add(<span class="string">&quot;</span><span class="string">Paris</span><span class="string">&quot;</span>);
pq1.retainAll(testArray2);
pq2.retainAll(testArray2);
System.<span class="ST6">out</span>.println(pq1);
System.<span class="ST6">out</span>.println(pq2);
}
<span class="literal">static</span> <span class="literal">void</span> <span class="ST7">printArrays</span>(Object[] arr) {
<span class="literal">for</span> (Object element : arr) {
System.<span class="ST6">out</span>.print(element + <span class="string">&quot;</span><span class="string">, </span><span class="string">&quot;</span>);
}
}
}
</pre></body>
</html>

14
Semester 3/Assignments/MP6_ChloeFontenot/pom.xml Normal file
View File

@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>edu.slcc.asdv.chloe</groupId>
<artifactId>MP6_ChloeFontenot</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>20</maven.compiler.source>
<maven.compiler.target>20</maven.compiler.target>
<exec.mainClass>edu.slcc.asdv.chloe.mp6_chloefontenot.MP6_ChloeFontenot</exec.mainClass>
</properties>
</project>

208
Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/CircularList.java Normal file
View File

@@ -0,0 +1,208 @@
package edu.slcc.asdv.chloe.mp6_chloefontenot;
/**
*
* @author Markou
*/
public class CircularList<T extends Comparable<T>> {
Node<T> head;
public class Node< T extends Comparable<T>>
implements Comparable<Node<T>> {
private T t;
public void set(T t)
{
this.t = t;
}
public T get()
{
return t;
}
Node<T> next;
@Override
public int compareTo(Node<T> o)
{
return this.t.compareTo(o.get());
}
}
/**
*
* @param t
*/
public void add(Object t)
{
Node<T> temp = new Node();
temp.set((T) t);
if (head == null) {
head = temp;
head.next = head;
} else {
Node<T> temp2 = head;
do {
temp2 = temp2.next;
} while (temp2.next != head);
temp.next = head;
temp2.next = temp;
}
}
/**
*
* @return
*/
private int getSize()
{
if (head == null) {
return 0;
}
Node<T> temp = head;
int count = 0;
do {
temp = temp.next;
count++;
} while (temp != head);
return count;
}
////////////////////////////////////////////////////////
public void addAt(Object t, int pos)
{
if (pos < 0 || pos > getSize()) {
return;
}
Node<T> temp = new Node();
temp.set((T) t);
if (head == null) {
add(t);
} else if (pos == 0) {
int oldSize = getSize();
Node<T> currentHead = head;
temp.next = head;
head = temp;
// Set the node at the end of the list to point back to the new head.
Node<T> pointer = head;
for (int i = 0; i < oldSize; ++i) {
pointer = pointer.next;
}
pointer.next = temp;
} else {
// Iterate to the desired position
Node<T> pointer = head;
for (int i = 0; i < pos -1; ++i) {
pointer = pointer.next;
}
temp.next = pointer.next;
pointer.next = temp;
}
}
//////////////////////////////////////////////////////////////
/**
* removes the last node
*/
public void remove()
{
Node<T> pointer = head;
for (int i = 0; i < this.getSize() - 2; ++i) {
pointer = pointer.next;
}
pointer.next = head;
}
//////////////////////////////////////////////////////////////
/**
* removes a specific object from the list
*/
public boolean remove(Object t)
{
Node<T> pointer = head;
boolean isObjectRemoved = false;
do {
boolean eval = pointer.next.t.equals(t);
if (eval) {
isObjectRemoved = true;
pointer.next = pointer.next.next;
break;
} else {
pointer = pointer.next;
}
} while (pointer != head);
return isObjectRemoved;
}
//////////////////////////////////////////////////////////////
public void removeAt(int pos)
{
Node<T> pointer = head;
for (int i = 0; i < pos; ++i) {
boolean eval = i == pos - 1;
if (eval) {
pointer.next = pointer.next.next;
break;
} else {
pointer = pointer.next;
}
}
}
public void print()
{
if (head == null) {
return;
}
Node<T> temp = head;
int elementNum = 0;
do {
System.out.print(++elementNum + ": ");
System.out.println(temp.get().toString());
temp = temp.next;
} while (temp != head);
}
public static void main(String... ar)
{
CircularList<String> list = new CircularList();
list.add("Hello");
list.add("World");
list.add("one");
String removeMe = "two";
list.add(removeMe);
list.add("three");
list.add("four");
list.add("five");
list.add("six");
list.add("seven");
list.print();
System.out.println("-------------");
System.out.println("Remove the last object:");
list.remove();
list.print();
System.out.println("-------------");
System.out.println("Remove \"two\"");
list.remove(removeMe);
list.print();
System.out.println("-------------");
System.out.println("Remove the 3rd element:");
list.removeAt(2);
list.print();
System.out.println("-------------");
System.out.println("Add an element to the beginning");
list.addAt("Earth", 0);
list.print();
System.out.println("-------------");
System.out.println("Add an element named \"potato\" in the 4th position:");
list.addAt("potato", 3);
list.print();
}
}

129
Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/DoubleLinkedList.java Normal file
View File

@@ -0,0 +1,129 @@
/*
* 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 edu.slcc.asdv.chloe.mp6_chloefontenot;
/**
*
* @author chloe
*/
public class DoubleLinkedList<T> {
Node<T> head;
Node<T> tail;
class Node<T> {
T t;
Node<T> left;
Node<T> right;
}
public T removeAt(int pos)
{
if (pos < 0 || pos > size()-1)
{
throw new IndexOutOfBoundsException();
}
//list is empty
if ( size() == 0 )
throw new EmptyListException( "The list empty.");
//remove at 0
if ( pos == 0)
{
if ( size() == 1)
head = tail = null;
else
head = head.right;
}
else if (pos== size() - 1) { //remove at end
tail = tail.left;
tail.right = null;
}
else { //remove in the middle
Node<T> p = head;
for (int i = 0; i < pos; ++i) {
p = p.right;
p.left.right = p.right;
p.right.left = p.right;
p.right.left = p.left;
}
}
return null;
}
public void addAt(T t, int pos) {
if (pos < 0 || pos > size()) {
throw new IndexOutOfBoundsException();
}
Node<T> newNode = new Node<T>();
newNode.t = t;
if (head == null) { // list is empty
head = tail = newNode;
} else if (pos == 0) { // add at the front
newNode.right = head;
head.left = newNode;
head = newNode;
} else if (pos == size()) {// add at the end
newNode.left = tail;
tail.right = newNode;
tail = newNode;
} else { //We're in the middle
Node<T> p = head;
for (int i = 0; i < pos - 1; ++i) {
p = p.right;
}
newNode.left = p;
newNode.right = p.right;
p.right.left = newNode;
}
}
public int size() {
Node<T> p = head;
int count = 0;
while (p != null) {
count++;
p = p.right;
}
return count;
}
@Override
public String toString()
{
String outputString = "DoubleLinkedList{" + "head=" + head + ", tail=" + tail +", size=" + this.size() + "}\n Contents= [";
Node<T> p = head;
int count = 0;
int size = size();
System.out.println(size);
while (p != null) {
outputString += p.t.toString();
count++;
if (count < size) {
outputString += ", ";
} else {
outputString += "]";
}
p = p.right;
}
return outputString;
}
public static void main(String[] args)
{
DoubleLinkedList<Integer> list = new DoubleLinkedList<>();
list.addAt(10, 0);
list.addAt(20, 0);
list.addAt(30, 0);
list.addAt(40, 0);
list.addAt(40, 3);
list.addAt(25, 3);
list.removeAt(3);
list.removeAt(1);
System.out.println(list);
}
}

16
Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/EmptyListException.java Normal file
View File

@@ -0,0 +1,16 @@
/*
* 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 edu.slcc.asdv.chloe.mp6_chloefontenot;
/**
*
* @author chloe
*/
public class EmptyListException extends RuntimeException{
public EmptyListException() {}
public EmptyListException(String msg) {
super(msg);
}
}

16
Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/MP6_CalebFontenot.java Normal file
View File

@@ -0,0 +1,16 @@
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
*/
package edu.slcc.asdv.chloe.mp6_chloefontenot;
/**
*
* @author chloe
*/
public class MP6_ChloeFontenot {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

912
Semester 3/Assignments/MP6_ChloeFontenot/src/main/java/edu/slcc/asdv/caleb/mp6_calebfontenot/PriorityQueueASDV.java Normal file
View File

@@ -0,0 +1,912 @@
/*
* 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 edu.slcc.asdv.chloe.mp6_chloefontenot;
/**
*
* @author chloe
*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.function.Consumer;
public class PriorityQueueASDV<E extends Comparable<E>>
implements Queue<E>, Cloneable {
private Node<E> head;//head
private Node<E> tail;//tail
class Node<E> {
E e;
Node<E> l;
Node<E> r;
}
/**
* Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
*
* Specified by: add in interface Collection<E>
* Parameters: e - the element to add Returns: true (as specified by Collection.add(E)) Throws: IllegalStateException - if the element cannot be added at this time due to capacity restrictions ClassCastException - if the class of the specified element prevents it from being added to this queue NullPointerException - if the specified element is null and this queue does not permit null elements IllegalArgumentException - if some property of this element prevents it from being added to this queue
*
* @param e - the element to add
* @return true if this collection changed as a result of the call
* @throws IllegalStateException - if the element cannot be added at this time due to capacity restrictions
* @throws ClassCastException - if the class of the specified element
* @throws NullPointerException - if the specified element is null and this queue does not permit null elements
* @throws IllegalArgumentException - if some property of this element prevents it from being added to this queue
*/
@Override
public boolean add(E e) {
if (e == null) {
throw new NullPointerException("NULL elements not allowed!");
}
Node<E> newNode = new Node<E>();
newNode.e = e;
//1. empty queue
if (this.head == null && this.tail == null) {
this.head = this.tail = newNode;
return true;
}
int index = findCorrectPositionToInsertElement(e);
//int index = findCorrectPositionToInsertElementHashCode(e);
//2. we add at size ( last node)
if (index == size()) {
tail.r = newNode;//1
newNode.l = tail;//2
tail = newNode;//3
} //3. we add at 0 in the front
else if (index == 0) {
newNode.r = head;
this.head.l = newNode;
this.head = newNode;
if (size() == 1) {
tail = head;
}
} //4. we add in the middle
else {
Node<E> p = head;
for (int i = 0; i < index - 1; ++i) {
p = p.r;
}
//after for loop p point one position before insertion
newNode.l = p;//we connect the left of the new node
//to the node that is BEFORE
//the node to be inserted
newNode.r = p.r;//we connect the right of the new node
// to the node thta is AFTER
//the node to be inserted
p.r = newNode; //we connect the right the node BEFORE the node
//to be inserted to the new node
p.r.r.l = newNode;//we connect the left of the node AFTER the node
//to be iserted to the new node
}
return true;
}
@Override
public int size() {
Node<E> p = this.head;
int count = 0;
while (p != null) {
p = p.r;
count++;
}
return count;
}
private int findCorrectPositionToInsertElement(E e) {
Node<E> p = this.head;
int pos = 0;
while (p != null) {
if (e.compareTo(p.e) > 0) {
p = p.r;
++pos;
} else {
break;
}
}
return pos;
}
private int findCorrectPositionToInsertElementHashCode(E e) {
Node<E> p = this.head;
int pos = 0;
while (p != null) {
if (e.hashCode() > p.e.hashCode()) {
p = p.r;
++pos;
} else {
break;
}
}
return pos;
}
/**
* Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions. When using a capacity-restricted queue, this method is generally preferable to add(E), which can fail to insert an element only by throwing an exception.
*
* @param e - the element to add
* @throws IllegalStateException - if the element cannot be added at this time due to capacity restrictions
* @throws ClassCastException - if the class of the specified element
* @throws NullPointerException - if the specified element is null and this queue does not permit null elements
* @throws IllegalArgumentException - if some property of this element prevents it from being added to this queue
* @return true if the element was added
*/
@Override
public boolean offer(E e) {
return add(e);
}
/**
* Retrieves and removes the head of this queue. This method differs from {@link #poll poll} only in that it throws an exception if this queue is empty.
*
* <p>
* This implementation returns the result of {@code poll} unless the queue is empty.
*
* @return the head of this queue
* @throws NoSuchElementException if this queue is empty
*/
@Override
public E remove() {
Node<E> pointer = head.r;
E removedElement = head.e;
head = head.r;
head.l = null;
return removedElement;
}
/**
* Retrieves and removes the head of this queue, or returns null if this queue is empty.
*
* Returns: the head of this queue, or null if this queue is empty
*
* @return
*/
@Override
public E poll() {
if (size() == 0) {
return null;
}
if (size() > 1) {
head = head.r;
E e = head.l.e;
head.l = null;
return e;
} else //size 1
{
E e = head.e;
head = tail = null;
return e;
}
}
/**
* Retrieves, but does not remove, the head of this queue. This method differs from {@link #peek peek} only in that it throws an exception if this queue is empty.
*
* @return the head of this queue
* @throws NoSuchElementException if this queue is empty
*/
@Override
public E element() {
if (head != null) {
return (E) head;
} else {
throw new NoSuchElementException("Element does not exist.");
}
}
/**
* Retrieves, but does not remove, the head of this queue, or returns {@code null} if this queue is empty.
*
* @return the head of this queue, or {@code null} if this queue is empty
*/
@Override
public E peek() {
return (E) head;
}
@Override
public boolean isEmpty() {
return head == null && tail == null ? true : false;
}
/**
* Returns {@code true} if this collection contains the specified element. More formally, returns {@code true} if and only if this collection contains at least one element {@code e} such that {@code Objects.equals(o, e)}.
*
* @param o element whose presence in this collection is to be tested
* @return {@code true} if this collection contains the specified element
* @throws ClassCastException if the type of the specified element is incompatible with this collection ({@linkplain Collection##optional-restrictions optional})
* @throws NullPointerException if the specified element is null and this collection does not permit null elements ({@linkplain Collection##optional-restrictions optional})
*/
@Override
public boolean contains(Object o) {
Node<E> pointer = head;
do {
if (pointer.equals(o)) {
return true;
} else {
pointer = pointer.r;
}
} while (pointer != null);
return false;
}
@Override
public Iterator<E> iterator() {
Iterator<E> it = new Iterator<E>() {
Node<E> p = head;
@Override
public boolean hasNext() {
return p == null ? false : true;
}
@Override
public E next() {
if (hasNext() == false) {
throw new NoSuchElementException("the is no next element");
}
E e = p.e;
p = p.r;
return e;
}
@Override
public void forEachRemaining(Consumer<? super E> action) {
while (hasNext()) {
action.accept(p.e);
p = p.r;
}
}
};
return it;
}
@Override
public Object[] toArray() {
Node<E> pointer = head;
Object[] returnArray = new Object[this.size()];
int i = 0;
while (pointer.r != null) {
returnArray[i++] = pointer.e;
pointer = pointer.r;
}
returnArray[i++] = pointer.e;
return returnArray;
}
/**
* Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. If the collection fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this collection.
*
* <p>
* If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to {@code null}. (This is useful in determining the length of this collection <i>only</i> if the caller knows that this collection does not contain any {@code null} elements.)
*
* <p>
* If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
*
* @apiNote This method acts as a bridge between array-based and collection-based APIs. It allows an existing array to be reused under certain circumstances. Use {@link #toArray()} to create an array whose runtime type is {@code Object[]}, or use {@link #toArray(IntFunction)} to control the runtime type of the array.
*
* <p>
* Suppose {@code x} is a collection known to contain only strings. The following code can be used to dump the collection into a previously allocated {@code String} array:
*
* <pre>
* String[] y = new String[SIZE];
* ...
* y = x.toArray(y);</pre>
*
* <p>
* The return value is reassigned to the variable {@code y}, because a new array will be allocated and returned if the collection {@code x} has too many elements to fit into the existing array {@code y}.
*
* <p>
* Note that {@code toArray(new Object[0])} is identical in function to {@code toArray()}.
*
* @param <T> the component type of the array to contain the collection
* @param a the array into which the elements of this collection are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.
* @return an array containing all of the elements in this collection
* @throws ArrayStoreException if the runtime type of any element in this collection is not assignable to the {@linkplain Class#getComponentType
* runtime component type} of the specified array
* @throws NullPointerException if the specified array is null
*/
@Override
public <T> T[] toArray(T[] a) {
a = Arrays.copyOf(a, this.size());
Node<E> pointer = head;
System.out.println(a.getClass());
System.out.println(pointer.getClass());
System.out.println(pointer.e.getClass());
for (int i = 0; i < this.size(); ++i) {
a[i] = (T) pointer.e;
pointer = pointer.r;
}
return a;
}
/**
* Removes a single instance of the specified element from this collection, if it is present (optional operation). More formally, removes an element e such that (o==null ? e==null : o.equals(e)), if this collection contains one or more such elements. Returns true if this collection contained the specified element (or equivalently, if this collection changed as a result of the call).
*
* @param o - element to be removed from this collection, if present
* @throws ClassCastException - if the type of the specified element is incompatible with this collection
* @throws NullPointerException - if the specified element is null and this collection does not permit null elements
* @return true if an element was removed as a result of this call
*/
@Override
public boolean remove(Object o) {
if (o == null) {
throw new NullPointerException("null vales not allowed");
}
if (size() == 0) {
return false;
}
Node<E> p = this.head;
int pos = 0;
while (p != this.tail) {
if (p.e.equals(o)) {
if (size() == 1) {
this.head = this.tail = null;
return true;
}
this.removeAt(pos, (E) o);
break;
}
++pos;
p = p.r;
}
if (p == tail && p.e.equals(o)) {
this.removeAt(size() - 1, (E) o);
}
return true;
}
/**
*
* @param pos
* @param e
* @throws IndexOutOfBoundsException - if pos less 0 OR pos greater-equal size()
* @return
*/
private boolean removeAt(int pos, E e) {
if (pos < 0 || pos >= size()) {
throw new IndexOutOfBoundsException(pos + " is out of bounds");
}
//1.list is empty
if (isEmpty()) {
return false;
} //2. one node exists
else if (size() == 1) {
this.head = this.tail = null;
} //3. remove in the front( head)
else if (pos == 0) {
this.head = this.head.r;
head.l = null;
} //4. remove in the end ( tail)
else if (pos == size() - 1) {
this.tail = this.tail.l;
this.tail.r = null;
} //5. remove in the middle ( at least 3 nodes are in the queue)
else {
Node<E> p = head;
for (int i = 0; i < pos - 1; ++i) {
p = p.r;
}
p.r = p.r.r;
p.r.l = p;
}
return true;
}
/**
* Returns {@code true} if this collection contains all of the elements in the specified collection.
*
* @param c collection to be checked for containment in this collection
* @return {@code true} if this collection contains all of the elements in the specified collection
* @throws ClassCastException if the types of one or more elements in the specified collection are incompatible with this collection ({@linkplain Collection##optional-restrictions optional})
* @throws NullPointerException if the specified collection contains one or more null elements and this collection does not permit null elements ({@linkplain Collection##optional-restrictions optional}) or if the specified collection is null.
* @see #contains(Object)
*/
@Override
public boolean containsAll(Collection<?> c) {
// Java already throws a CastCastException if you give it the wrong type, so we don't have to throw that ourselves
if (c.contains(null) || c == null) {
throw new NullPointerException("The collection you passed to containsAll() contains a null element. Cannot continue.");
}
// Unpack the collection so we can compare them
Object[] compareArray = c.toArray();
Node<E> pointer = null;
int matchCount = 0;
for (Object compare : compareArray) {
pointer = head;
for (int i = 0; i < size() - 1; ++i) {
if (pointer.e.equals(compare)) {
matchCount++;
}
pointer = pointer.r;
}
}
if (matchCount == compareArray.length - 1) {
return true;
}
return false;
}
/**
* Adds all of the elements in the specified collection to this collection (optional operation). The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this collection, and this collection is nonempty.)
*
* @param c - collection containing elements to be added to this collection
* @throws ClassCastException - if the class of an element of the specified collection prevents it from being added to this collection.
* @throws NullPointerException - if the specified collection contains a null element and this collection does not permit null elements, or if the specified collection is null
* @throws IllegalArgumentException - if some property of an element of the specified collection prevents it from being added to this collection
* @throws IllegalArgumentException - if some property of an element of the specified collection prevents it from being added to this collection
* @return true if this collection changed as a result of the call
*/
@Override
public boolean addAll(Collection<? extends E> c) {
int sizeBefore = size();
for (E e : c) {
add(e);
}
int sizeAfter = size();
return sizeAfter > sizeBefore;
}
/**
* Removes all of this collection's elements that are also contained in the specified collection (optional operation). After this call returns, this collection will contain no elements in common with the specified collection.
*
* @implSpec This implementation iterates over this collection, checking each element returned by the iterator in turn to see if it's contained in the specified collection. If it's so contained, it's removed from this collection with the iterator's {@code remove} method.
*
* <p>
* Note that this implementation will throw an {@code UnsupportedOperationException} if the iterator returned by the {@code iterator} method does not implement the {@code remove} method and this collection contains one or more elements in common with the specified collection.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*
* @see #remove(Object)
* @see #contains(Object)
*/
@Override
public boolean removeAll(Collection<?> c) {
if (c.contains(null) || c == null) {
throw new NullPointerException("The collection you passed to removeAll() contains a null element. Cannot continue.");
}
// Unpack the collection so we can remove them
Object[] compareArray = c.toArray();
Node<E> pointer = null;
boolean removeSuccessful = false;
for (Object compare : compareArray) {
pointer = head;
for (int i = 0; i < size() - 1; ++i) {
if (pointer.e.equals(compare)) {
remove(pointer.e);
removeSuccessful = true;
}
pointer = pointer.r;
}
}
return removeSuccessful;
}
@Override
public boolean retainAll(Collection<?> c) {
if (c.contains(null) || c == null) {
throw new NullPointerException("The collection you passed to retainAll() contains a null element. Cannot continue.");
}
Node<E> pointer = null;
boolean removeSuccessful = false;
for (int j = 0; j < c.size() - 1; ++j) {
pointer = head;
for (int i = 0; i < size(); ++i) {
if (!c.contains(pointer.e)) {
remove(pointer.e);
removeSuccessful = true;
}
pointer = pointer.r;
}
}
return removeSuccessful;
}
@Override
public void clear() {
// head = tail = null;
//extra, no necessary to set the link of every node
Node<E> p = head;
while (p != tail) {
p = p.r;
p.l = null;
}
head = tail = null;
}
@Override
public void forEach(Consumer<? super E> action) {
//1. use a pointer that points to the head
//2. while the pointer has not reached the end of the queue
//consume it
Node<E> p = head;
while (p != null) {
action.accept(p.e);
p = p.r;
}
}
@Override
public String toString() {
String s = "PriorityQueueASDV {";
Node<E> p = head;
while (p != null) {
s += p.e.toString();
if (p != tail) {
s += ", ";
}
p = p.r;
}
s += "}";
return s;
}
@Override
protected Object clone()
throws CloneNotSupportedException {
PriorityQueueASDV<E> c = (PriorityQueueASDV<E>) super.clone();
return c;
}
public static void main(String[] args) {
System.out.println("\n--> PriorityQueueASDV testing add");
PriorityQueueASDV<String> pq1 = new PriorityQueueASDV();
pq1.add("Paris");
pq1.add("Athens");
pq1.add("London");
pq1.add("Lafayette");
pq1.add("Berlin");
System.out.println(pq1);
System.out.println("\n--> Colllections PriorityQueue testing add");
PriorityQueue<String> pq2 = new PriorityQueue();
pq2.add("Paris");
pq2.add("Athens");
pq2.add("London");
pq2.add("Lafayette");
pq2.add("Berlin");
System.out.println(pq2);
//TEST IT FULLY HERE. FOR ALL METHODS AND ALL CASES.
//Have the Jzva PriorityQueue below
System.out.println("\n--> PriorityQueueASDV testing remove(object o)");
System.out.println("\n\tremove from front Athens");
pq1.remove("Athens");
pq2.remove("Athens");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\tremove from end Paris");
pq1.remove("Paris");
pq2.remove("Paris");
System.out.println(pq1);
System.out.println(pq1);
System.out.println("\n\tremove from the middle Lafayette");
pq1.remove("Lafayette");
pq2.remove("Lafayette");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\tadd at the end Stocholm");
pq1.add("Stocholm");
pq2.add("Stocholm");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\tremove from the middle London");
pq1.remove("London");
pq2.remove("London");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\tremove from the front Berlin");
pq1.remove("Berlin");
pq2.remove("Berlin");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\tremove from the front/end Stocholm");
pq1.remove("Stocholm");
pq2.remove("Stocholm");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\tremove from empty queue");
pq1.remove("Stocholm");
pq2.remove("Stocholm");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n--> PriorityQueueASDV recreate priority queues from empty");
pq1.add("Paris");
pq1.add("Athens");
pq1.add("London");
pq1.add("Lafayette");
pq1.add("Berlin");
pq1.add("Zurich");
pq2.add("Paris");
pq2.add("Athens");
pq2.add("London");
pq2.add("Lafayette");
pq2.add("Berlin");
pq2.add("Zurich");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\n+++HERE YOU TEST ALL YOUR METHODS FULLY, and the methods of Colleciion PriorityQueue");
System.out.println("\n\t offer New York");
pq1.offer("New York");
pq2.offer("New York");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t offer Miami");
pq1.offer("Miami");
pq2.offer("Miami");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t offer null");
try {
pq1.offer(null);
} catch (Exception e) {
System.err.println(e);
}
try {
pq2.offer(null);
} catch (Exception e) {
System.err.println(e);
}
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t offer ClassCastException with Object");
try {
pq1.offer((String) new Object());
} catch (Exception e) {
System.err.println(e);
}
try {
pq2.offer((String) new Object());
} catch (Exception e) {
System.err.println(e);
}
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t poll suposed to be Athens");
System.out.println(pq1.poll());
System.out.println(pq2.poll());
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t Iterator");
Iterator<String> it1 = pq1.iterator();
Iterator<String> it2 = pq2.iterator();
while (it1.hasNext()) {
System.out.print(it1.next() + " ");
}
System.out.println("");
while (it2.hasNext()) {
System.out.print(it2.next() + " ");
}
System.out.println("");
System.out.println("\n\t Iterator NoSuchElementException ");
try {
System.out.println(it1.next());
} catch (NoSuchElementException e) {
System.err.println(e);
}
try {
System.out.println(it2.next());
} catch (NoSuchElementException e) {
System.err.println(e);
}
System.out.println("\n\t Iterator foreach ");
it1 = pq1.iterator();
it2 = pq2.iterator();
it1.forEachRemaining(new Consumer() {
@Override
public void accept(Object t) {
System.out.print(t + "*** ");
}
});
System.out.println("");
it2.forEachRemaining(new Consumer() {
@Override
public void accept(Object t) {
System.out.print(t + "+++ ");
}
});
System.out.println("");
System.out.println("\n\t addAll Houston Chicago");
List<String> ar1 = Arrays.asList("Houston", "Chicago");
pq1.addAll(ar1);
pq2.addAll(ar1);
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t clear");
pq1.clear();
pq2.clear();
System.out.println(pq1);
System.out.println(pq2);
System.out.println("");
System.out.println("\n--> PriorityQueueASDV recreate priority queues from empty");
pq1.add("Paris");
pq1.add("Athens");
pq1.add("London");
pq1.add("Lafayette");
pq1.add("Berlin");
pq1.add("Zurich");
pq2.add("Paris");
pq2.add("Athens");
pq2.add("London");
pq2.add("Lafayette");
pq2.add("Berlin");
pq2.add("Zurich");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("\n\t forEach");
pq1.forEach(new Consumer() {
@Override
public void accept(Object t) {
System.out.print(t + "*** ");
}
});
System.out.println("");
pq2.forEach(new Consumer() {
@Override
public void accept(Object t) {
System.out.print(t + "+++ ");
}
});
System.out.println("");
System.out.println("\n\t clone");
try {
PriorityQueueASDV<String> pq1Cloned
= (PriorityQueueASDV<String>) pq1.clone();
System.out.println(pq1Cloned);
pq1Cloned.add("Las Vegas");
System.out.println(pq1Cloned);
System.out.println(pq1);
} catch (CloneNotSupportedException e) {
System.err.println(e);
}
pq1.clear();
pq2.clear();
pq1.add("Paris");
pq1.add("Athens");
pq1.add("London");
pq1.add("Lafayette");
pq1.add("Berlin");
pq1.add("Zurich");
pq2.add("Paris");
pq2.add("Athens");
pq2.add("London");
pq2.add("Lafayette");
pq2.add("Berlin");
pq2.add("Zurich");
System.out.println("----------------");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("Attempt to remove an element.");
pq1.remove();
pq2.remove();
System.out.println(pq1);
System.out.println(pq2);
System.out.println("Get array of the priority queues.");
Object pqArray1[] = pq1.toArray();
Object pqArray2[] = pq2.toArray();
printArrays(pqArray1);
printArrays(pqArray2);
System.out.println();
System.out.println("----------------");
System.out.println("Test .toArray(T[])");
String[] pqArray3 = pq1.toArray(new String[0]);
printArrays(pqArray3);
System.out.println("----------------");
System.out.println("Test containsAll()");
ArrayList<String> testArray = new ArrayList<>();
testArray.add("Lafayette");
testArray.add("Berlin");
testArray.add("Zurich");
System.out.println("Does pq1 contain Lafayette, Berlin, and Zurich? " + (pq1.containsAll(testArray) ? "yes" : "no"));
System.out.println("Does pq1 contain the contents of pq2? " + (pq1.containsAll(pq2) ? "yes" : "no"));
System.out.println("Does pq2 contain the contents of pq1? " + (pq2.containsAll(pq1) ? "yes" : "no"));
System.out.println("Adding funkytown to testArray...");
testArray.add("Funkytown");
System.out.println("Does pq1 contain Lafayette, Berlin, Zurich, and Funkytown? " + (pq1.containsAll(testArray) ? "yes" : "no"));
System.out.println("Test if containsAll() correctly throws a NullPointerException...");
try {
testArray.add(null);
System.out.println("Does pq1 contain Lafayette, Berlin, Zurich, Funkytown, and null? " + (pq1.containsAll(testArray) ? "yes" : "no"));
} catch (NullPointerException ex) {
System.out.println(ex);
}
testArray.remove(null);
System.out.println("That worked! Continuing with tests...");
System.out.println("----------------");
System.out.println(pq1);
System.out.println(pq2);
System.out.println("Testing removeAll(Collection<?>)...");
System.out.println("Removing the elements in the test array...");
pq1.removeAll(testArray);
pq2.removeAll(testArray);
System.out.println(pq1);
System.out.println(pq2);
System.out.println("----------------");
System.out.println("Testing retainAll()...");
ArrayList<String> testArray2 = new ArrayList<>();
testArray2.add("London");
testArray2.add("Paris");
pq1.retainAll(testArray2);
pq2.retainAll(testArray2);
System.out.println(pq1);
System.out.println(pq2);
}
static void printArrays(Object[] arr) {
for (Object element : arr) {
System.out.print(element + ", ");
}
}
}