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

298
Semester 2/Assignments/MP4_ChloeFontenot/Printed HTMLs/Bicycle.html Normal file
View File

@@ -0,0 +1,298 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>BikeStores.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}
.literal {color: #cc7832}
.ST0 {color: #287bde}
.ST2 {color: #9876aa}
.ST4 {color: #ffc66d}
.number {color: #6897bb}
.string {color: #6a8759}
.ST5 {color: #9876aa; font-family: monospace; font-style: italic}
.ST6 {color: #ffc66d; font-family: monospace; font-style: italic}
.ST3 {color: #8a653b}
.ST8 {font-family: monospace; font-style: italic}
.ST7 {color: #9999ff; font-family: monospace; font-style: italic}
.comment {color: #808080}
.whitespace {color: #505050}
.ST1 {color: #808080; font-family: monospace; font-weight: bold}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/chloefontenot/mp4_chloefontenot/BikeStores.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> com.chloefontenot.mp4_chloefontenot;
<span class="literal">import</span> java.util.ArrayList;
<span class="literal">import</span> java.util.Collection;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> BikeStores {
ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; <span class="ST2">storesOfBikes</span> = <span class="literal">new</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt;();
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Add</span> <span class="comment">a</span> <span class="comment">bike</span> <span class="comment">at</span> <span class="comment">storeNumber</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">the</span> <span class="comment">storeNumber</span> <span class="comment">indicates</span> <span class="comment">the</span> <span class="comment">store</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">storeNumber</span> <span class="comment">which</span> <span class="comment">store</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">b</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">to</span> <span class="comment">add</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">added</span><span class="comment">, </span><span class="comment">false</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">storeNumber</span> <span class="comment">is</span> <span class="comment">invalid</span> <span class="comment">or</span> <span class="comment">b</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> BikeStores() {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="number">3</span>; i++) {
<span class="ST2">storesOfBikes</span>.add(<span class="literal">new</span> ArrayList&lt;Bicycle&gt;());
}
}
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">addBike</span>(<span class="literal">int</span> storeNumber, Bicycle b) {
<span class="literal">if</span> (storeNumber &lt; <span class="number">0</span> || storeNumber &gt; <span class="literal">this</span>.<span class="ST2">storesOfBikes</span>.size() - <span class="number">1</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (b == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Attempting to add </span><span class="string">&quot;</span> + b + <span class="string">&quot;</span><span class="string"> to store at index </span><span class="string">&quot;</span> + storeNumber);
<span class="comment">//Unpack array</span>
ArrayList&lt;Bicycle&gt; bikesInInventory = <span class="ST2">storesOfBikes</span>.get(storeNumber);
bikesInInventory.add(b);
<span class="comment">// Repack array</span>
<span class="ST2">storesOfBikes</span>.set(storeNumber, bikesInInventory);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">success!</span><span class="string">&quot;</span>);
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">a</span> <span class="comment">bike</span> <span class="comment">at</span> <span class="comment">a</span> <span class="comment">specific</span> <span class="comment">store</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">storeNumber</span> <span class="comment">the</span> <span class="comment">store</span> <span class="comment">that</span> <span class="comment">has</span> <span class="comment">the</span> <span class="comment">bike</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">b</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">true</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">is</span> <span class="comment">removed</span><span class="comment">, </span><span class="comment">false</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">exist</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">bike</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">removeBike</span>(<span class="literal">int</span> storeNumber, Bicycle b) {
<span class="literal">if</span> (storeNumber &lt; <span class="number">0</span> || storeNumber &gt; <span class="literal">this</span>.<span class="ST2">storesOfBikes</span>.size() - <span class="number">1</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (b == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Attempting to remove </span><span class="string">&quot;</span> + b + <span class="string">&quot;</span><span class="string"> to store at index </span><span class="string">&quot;</span> + storeNumber);
<span class="comment">// Remove bike from array.</span>
ArrayList&lt;Bicycle&gt; bikesInInventory = <span class="ST2">storesOfBikes</span>.get(storeNumber);
bikesInInventory.remove(b); <span class="comment">//YEET</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">success!</span><span class="string">&quot;</span>);
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Prints</span> <span class="comment">the</span> <span class="comment">indexes</span> <span class="comment">before</span> <span class="comment">each</span> <span class="comment">bike</span><span class="comment"> , </span><span class="comment">one</span> <span class="comment">store</span> <span class="comment">per</span> <span class="comment">line</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">stores</span> <span class="comment">stores</span> <span class="comment">of</span> <span class="comment">bikes</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">print</span>(ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; stores) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; stores.size(); ++i) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------- </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printing row </span><span class="string">&quot;</span> + (i + <span class="number">1</span>) + <span class="string">&quot;</span><span class="string"> ----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.get(i).size(); ++j) {
System.<span class="ST5">out</span>.println(stores.get(i).get(j) + <span class="string">&quot;</span> <span class="string">&quot;</span>);
}
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">printSingle</span>(ArrayList&lt;Bicycle&gt; stores) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printSingle</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.size(); ++j) {
System.<span class="ST5">out</span>.println(stores.get(j) + <span class="string">&quot;</span> <span class="string">&quot;</span>);
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">printRank</span>(ArrayList&lt;Bicycle&gt; stores) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printRank</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.size(); ++j) {
System.<span class="ST5">out</span>.println(stores.get(j) + <span class="string">&quot;</span> <span class="string">&quot;</span> + stores.get(j).calculatedDetails().getRank());
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Groups</span> <span class="comment">bikes</span> <span class="comment">by</span> <span class="comment">type</span> <span class="comment">ans</span> <span class="comment">sorts</span> <span class="comment">them</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">ranking</span> <span class="comment">of</span> <span class="comment">Details</span><span class="comment">.</span> <span class="comment">There</span> <span class="comment">will</span> <span class="comment">be</span> <span class="comment">three</span> <span class="comment">groups</span> <span class="comment">and</span> <span class="comment">each</span> <span class="comment">group</span> <span class="comment">stored</span> <span class="comment">in</span> <span class="comment">descending</span> <span class="comment">order</span> <span class="comment">by</span> <span class="comment">rank</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">stores</span> <span class="comment">the</span> <span class="comment">stores</span> <span class="comment">of</span> <span class="comment">bikes</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">a</span> <span class="comment">newly</span> <span class="comment">created</span> <span class="comment">ArrayList</span><span class="ST7">&lt;ArrayList</span><span class="ST7">&lt;Bicycle&gt;</span><span class="comment">&gt; </span><span class="comment">with</span> <span class="comment">the</span> <span class="comment">bikes</span> <span class="comment">sorted</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">static</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; <span class="ST6">sortBikesByType</span>(<span class="literal">final</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; stores) {
ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; newStore = <span class="literal">new</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt;();
<span class="comment">// group arrayLists</span>
ArrayList&lt;Bicycle&gt; mountainBikes = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
ArrayList&lt;Bicycle&gt; speedBikes = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
ArrayList&lt;Bicycle&gt; childBikes = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------- </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">grouping by bike type... </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string"> ----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; stores.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.get(i).size(); ++j) {
<span class="comment">// System.out.println(stores.get(i).get(j).calculatedDetails().getRank() + &quot; &quot;);</span>
Bicycle bike = stores.get(i).get(j);
<span class="literal">if</span> (bike <span class="literal">instanceof</span> ChildBike) {
childBikes.add(bike);
} <span class="literal">else</span> <span class="literal">if</span> (bike <span class="literal">instanceof</span> MountainBike) {
mountainBikes.add(bike);
} <span class="literal">else</span> <span class="literal">if</span> (bike <span class="literal">instanceof</span> SpeedBike) {
speedBikes.add(bike);
}
}
}
<span class="comment">//printRank(childBikes);</span>
<span class="comment">//printRank(mountainBikes);</span>
<span class="comment">//printRank(speedBikes);</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">sorting...</span><span class="string">&quot;</span>);
<span class="ST8">sortType</span>(childBikes);
<span class="ST8">sortType</span>(mountainBikes);
<span class="ST8">sortType</span>(speedBikes);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">sorted</span><span class="string">&quot;</span>);
<span class="comment">//printRank(childBikes);</span>
<span class="comment">//printRank(mountainBikes);</span>
<span class="comment">//printRank(speedBikes);</span>
newStore.add(childBikes);
newStore.add(mountainBikes);
newStore.add(speedBikes);
<span class="literal">return</span> newStore;
}
<span class="literal">private</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">sortType</span>(ArrayList&lt;Bicycle&gt; arrList) {
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x &lt; arrList.size(); ++x) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; arrList.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = i + <span class="number">1</span>; j &lt; arrList.size(); ++j) {
<span class="literal">int</span> compare1 = arrList.get(i).calculatedDetails().getRank();
<span class="literal">int</span> compare2 = arrList.get(j).calculatedDetails().getRank();
<span class="literal">if</span> (compare1 &lt; compare2) {
Bicycle tmp = arrList.get(i);
arrList.set(i, arrList.get(j));
arrList.set(j, tmp);
}
}
}
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">print</span>(Object[] arr) {
<span class="literal">for</span> (Object o : arr) {
System.<span class="ST5">out</span>.println(o);
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">print</span>(Object[][] arr) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; arr.<span class="ST2">length</span>; i++) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------- </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printing row </span><span class="string">&quot;</span> + (i + <span class="number">1</span>) + <span class="string">&quot;</span><span class="string"> ----------</span><span class="string">&quot;</span>);
<span class="ST8">print</span>(arr[i]);
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">a</span><span class="comment"> 2</span><span class="comment">D</span> <span class="comment">array</span> <span class="comment">containing</span> <span class="comment">all</span> <span class="comment">the</span> <span class="comment">bikes</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">store</span> <span class="comment">in</span> <span class="comment">proper</span> <span class="comment">sequence</span><span class="comment"> (</span><span class="comment">from</span> <span class="comment">first</span> <span class="comment">to</span> <span class="comment">last</span> <span class="comment">element</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">Store</span><span class="comment"> 0 </span><span class="comment">with</span> <span class="comment">all</span> <span class="comment">its</span> <span class="comment">bikes</span><span class="comment">, </span><span class="comment">store</span><span class="comment"> 1 </span><span class="comment">with</span> <span class="comment">all</span> <span class="comment">its</span> <span class="comment">bikes</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">so</span> <span class="comment">on</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">a</span><span class="comment"> 2</span><span class="comment">D</span> <span class="comment">array</span> <span class="comment">of</span> <span class="comment">all</span> <span class="comment">stores</span> <span class="comment">with</span> <span class="comment">bikes</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> Object[][] <span class="ST4">toArray</span>() {
Object[][] arr = <span class="literal">new</span> Object[<span class="ST2">storesOfBikes</span>.size()][];
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST2">storesOfBikes</span>.size(); i++) {
arr[i] = <span class="ST2">storesOfBikes</span>.toArray();
}
<span class="literal">return</span> arr;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Retains</span> <span class="comment">only</span> <span class="comment">the</span> <span class="comment">Bicycles</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">stores</span> <span class="comment">that</span> <span class="comment">are</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">In</span> <span class="comment">other</span> <span class="comment">words</span><span class="comment">, </span><span class="comment">removes</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">list</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">bikes</span> <span class="comment">that</span> <span class="comment">are</span> <span class="comment">not</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">location</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">c</span> <span class="comment">the</span> <span class="comment">bikes</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">any</span> <span class="comment">store</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="literal">public</span> <span class="literal">boolean</span> <span class="ST4">retainAll</span>(Collection&lt;Bicycle&gt; c) {
<span class="literal">boolean</span> modified = <span class="literal">false</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="ST2">storesOfBikes</span>.size() - <span class="number">1</span>; i &gt;= <span class="number">0</span>; i--) {
ArrayList&lt;Bicycle&gt; bikes = <span class="ST2">storesOfBikes</span>.get(i);
<span class="literal">for</span> (<span class="literal">int</span> j = bikes.size() - <span class="number">1</span>; j &gt;= <span class="number">0</span>; j--) {
Bicycle bike = bikes.get(j);
<span class="literal">if</span> (!c.contains(bike)) {
bikes.remove(j);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Removing </span><span class="string">&quot;</span> + bike);
modified = <span class="literal">true</span>;
}
}
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Bikes to remove:</span><span class="string">&quot;</span>);
<span class="ST8">printSingle</span>((ArrayList&lt;Bicycle&gt;) c);
<span class="literal">return</span> modified;
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">main</span>(String[] args) {
BikeStores bikes = <span class="literal">new</span> BikeStores();
<span class="comment">//add 5 bikes to store 0 ( 2 speedBikes, 2 mountain 1 child)</span>
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> SpeedBike(<span class="number">4</span>, <span class="number">3</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">4</span><span class="number">0</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> SpeedBike(<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">3</span><span class="number">0</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> MountainBike(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span><span class="number">0</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> MountainBike(<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">2</span><span class="number">5</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> ChildBike(<span class="literal">f</span><span class="literal">alse</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">0</span>));
<span class="comment">//add 5 bikes to store 1 ( 3 speedbikes, 1 mountain 1 child)</span>
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> SpeedBike(<span class="number">1</span><span class="number">0</span>, <span class="number">4</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">2</span><span class="number">0</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> SpeedBike(<span class="number">0</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">5</span><span class="number">0</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> SpeedBike(<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">3</span><span class="number">8</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> MountainBike(<span class="number">1</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">4</span><span class="number">4</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> ChildBike(<span class="literal">t</span><span class="literal">rue</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">5</span>));
<span class="comment">//add 6 bikes to store 2 ( 2 speedBikes, 2 mountain 2 child )</span>
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> SpeedBike(<span class="number">7</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">2</span><span class="number">0</span>, <span class="number">2</span><span class="number">5</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> SpeedBike(<span class="number">0</span>, <span class="number">8</span>, <span class="number">4</span><span class="number">0</span>, <span class="number">5</span><span class="number">5</span>)); <span class="comment">// retainAll should match this one</span>
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> MountainBike(<span class="number">2</span>, <span class="number">3</span>, <span class="number">1</span><span class="number">5</span>, <span class="number">3</span><span class="number">3</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> MountainBike(<span class="number">1</span>, <span class="number">3</span>, <span class="number">1</span><span class="number">5</span>, <span class="number">2</span><span class="number">4</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> ChildBike(<span class="literal">t</span><span class="literal">rue</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span><span class="number">0</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> ChildBike(<span class="literal">f</span><span class="literal">alse</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">8</span>));<span class="comment">// retainAll should match this one</span>
<span class="comment">//remove one child bike from store 2</span>
bikes.removeBike(<span class="number">2</span>, <span class="literal">new</span> ChildBike(<span class="literal">t</span><span class="literal">rue</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span><span class="number">0</span>)); <span class="comment">// Java reuses the object created earlier since it has the same values.</span>
<span class="comment">//PRINT</span>
<span class="ST8">print</span>(bikes.<span class="ST2">storesOfBikes</span>);
<span class="comment">//SORT</span>
ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; sortedBikes = <span class="ST8">sortBikesByType</span>(bikes.<span class="ST2">storesOfBikes</span>);
<span class="comment">//PRINT what the method return</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">SORTED BIKES</span><span class="string">&quot;</span>);
<span class="ST8">print</span>(sortedBikes);
<span class="comment">//PRINT the original store</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">ORIGINAL STORE ARRAYLIST</span><span class="string">&quot;</span>);
<span class="ST8">print</span>(bikes.<span class="ST2">storesOfBikes</span>);
<span class="comment">// ---------- TEST retainAll ----------</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Testing retainAll();...</span><span class="string">&quot;</span>);
Collection&lt;Bicycle&gt; c1 = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
c1.add(<span class="literal">new</span> SpeedBike(<span class="number">0</span>, <span class="number">8</span>, <span class="number">4</span><span class="number">0</span>, <span class="number">5</span><span class="number">5</span>));
c1.add(<span class="literal">new</span> ChildBike(<span class="literal">f</span><span class="literal">alse</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">8</span>));
Bicycle b1 = bikes.<span class="ST2">storesOfBikes</span>.get(<span class="number">2</span>).get(<span class="number">1</span>);
Bicycle b2 = bikes.<span class="ST2">storesOfBikes</span>.get(<span class="number">2</span>).get(<span class="number">4</span>);
Bicycle b3 = ((ArrayList&lt;Bicycle&gt;) c1).get(<span class="number">0</span>);
Bicycle b4 = ((ArrayList&lt;Bicycle&gt;) c1).get(<span class="number">1</span>);
System.<span class="ST5">out</span>.println(b1.equals(b3) + <span class="string">&quot;</span> <span class="string">&quot;</span> + b2.equals(b4));
bikes.retainAll(c1);
<span class="ST8">print</span>(bikes.<span class="ST2">storesOfBikes</span>);
}
}
<span class="literal">class</span> <span class="comment">NotABike</span> {
}
</pre></body>
</html>

298
Semester 2/Assignments/MP4_ChloeFontenot/Printed HTMLs/BikeStores.html Normal file
View File

@@ -0,0 +1,298 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>BikeStores.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}
.literal {color: #cc7832}
.ST0 {color: #287bde}
.ST2 {color: #9876aa}
.ST4 {color: #ffc66d}
.number {color: #6897bb}
.string {color: #6a8759}
.ST5 {color: #9876aa; font-family: monospace; font-style: italic}
.ST6 {color: #ffc66d; font-family: monospace; font-style: italic}
.ST3 {color: #8a653b}
.ST8 {font-family: monospace; font-style: italic}
.ST7 {color: #9999ff; font-family: monospace; font-style: italic}
.comment {color: #808080}
.whitespace {color: #505050}
.ST1 {color: #808080; font-family: monospace; font-weight: bold}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/chloefontenot/mp4_chloefontenot/BikeStores.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> com.chloefontenot.mp4_chloefontenot;
<span class="literal">import</span> java.util.ArrayList;
<span class="literal">import</span> java.util.Collection;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> BikeStores {
ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; <span class="ST2">storesOfBikes</span> = <span class="literal">new</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt;();
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Add</span> <span class="comment">a</span> <span class="comment">bike</span> <span class="comment">at</span> <span class="comment">storeNumber</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">the</span> <span class="comment">storeNumber</span> <span class="comment">indicates</span> <span class="comment">the</span> <span class="comment">store</span><span class="comment">)</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">storeNumber</span> <span class="comment">which</span> <span class="comment">store</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">b</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">to</span> <span class="comment">add</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">added</span><span class="comment">, </span><span class="comment">false</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">storeNumber</span> <span class="comment">is</span> <span class="comment">invalid</span> <span class="comment">or</span> <span class="comment">b</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> BikeStores() {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="number">3</span>; i++) {
<span class="ST2">storesOfBikes</span>.add(<span class="literal">new</span> ArrayList&lt;Bicycle&gt;());
}
}
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">addBike</span>(<span class="literal">int</span> storeNumber, Bicycle b) {
<span class="literal">if</span> (storeNumber &lt; <span class="number">0</span> || storeNumber &gt; <span class="literal">this</span>.<span class="ST2">storesOfBikes</span>.size() - <span class="number">1</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (b == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Attempting to add </span><span class="string">&quot;</span> + b + <span class="string">&quot;</span><span class="string"> to store at index </span><span class="string">&quot;</span> + storeNumber);
<span class="comment">//Unpack array</span>
ArrayList&lt;Bicycle&gt; bikesInInventory = <span class="ST2">storesOfBikes</span>.get(storeNumber);
bikesInInventory.add(b);
<span class="comment">// Repack array</span>
<span class="ST2">storesOfBikes</span>.set(storeNumber, bikesInInventory);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">success!</span><span class="string">&quot;</span>);
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Removes</span> <span class="comment">a</span> <span class="comment">bike</span> <span class="comment">at</span> <span class="comment">a</span> <span class="comment">specific</span> <span class="comment">store</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">storeNumber</span> <span class="comment">the</span> <span class="comment">store</span> <span class="comment">that</span> <span class="comment">has</span> <span class="comment">the</span> <span class="comment">bike</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">b</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">true</span> <span class="comment">of</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">is</span> <span class="comment">removed</span><span class="comment">, </span><span class="comment">false</span> <span class="comment">if</span> <span class="comment">the</span> <span class="comment">bike</span> <span class="comment">does</span> <span class="comment">not</span> <span class="comment">exist</span><span class="comment">, </span><span class="comment">or</span> <span class="comment">bike</span> <span class="comment">is</span> <span class="comment">null</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">boolean</span> <span class="ST4">removeBike</span>(<span class="literal">int</span> storeNumber, Bicycle b) {
<span class="literal">if</span> (storeNumber &lt; <span class="number">0</span> || storeNumber &gt; <span class="literal">this</span>.<span class="ST2">storesOfBikes</span>.size() - <span class="number">1</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (b == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Attempting to remove </span><span class="string">&quot;</span> + b + <span class="string">&quot;</span><span class="string"> to store at index </span><span class="string">&quot;</span> + storeNumber);
<span class="comment">// Remove bike from array.</span>
ArrayList&lt;Bicycle&gt; bikesInInventory = <span class="ST2">storesOfBikes</span>.get(storeNumber);
bikesInInventory.remove(b); <span class="comment">//YEET</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">success!</span><span class="string">&quot;</span>);
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Prints</span> <span class="comment">the</span> <span class="comment">indexes</span> <span class="comment">before</span> <span class="comment">each</span> <span class="comment">bike</span><span class="comment"> , </span><span class="comment">one</span> <span class="comment">store</span> <span class="comment">per</span> <span class="comment">line</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">stores</span> <span class="comment">stores</span> <span class="comment">of</span> <span class="comment">bikes</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">print</span>(ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; stores) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; stores.size(); ++i) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------- </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printing row </span><span class="string">&quot;</span> + (i + <span class="number">1</span>) + <span class="string">&quot;</span><span class="string"> ----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.get(i).size(); ++j) {
System.<span class="ST5">out</span>.println(stores.get(i).get(j) + <span class="string">&quot;</span> <span class="string">&quot;</span>);
}
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">printSingle</span>(ArrayList&lt;Bicycle&gt; stores) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printSingle</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.size(); ++j) {
System.<span class="ST5">out</span>.println(stores.get(j) + <span class="string">&quot;</span> <span class="string">&quot;</span>);
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">printRank</span>(ArrayList&lt;Bicycle&gt; stores) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printRank</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.size(); ++j) {
System.<span class="ST5">out</span>.println(stores.get(j) + <span class="string">&quot;</span> <span class="string">&quot;</span> + stores.get(j).calculatedDetails().getRank());
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Groups</span> <span class="comment">bikes</span> <span class="comment">by</span> <span class="comment">type</span> <span class="comment">ans</span> <span class="comment">sorts</span> <span class="comment">them</span> <span class="comment">by</span> <span class="comment">the</span> <span class="comment">ranking</span> <span class="comment">of</span> <span class="comment">Details</span><span class="comment">.</span> <span class="comment">There</span> <span class="comment">will</span> <span class="comment">be</span> <span class="comment">three</span> <span class="comment">groups</span> <span class="comment">and</span> <span class="comment">each</span> <span class="comment">group</span> <span class="comment">stored</span> <span class="comment">in</span> <span class="comment">descending</span> <span class="comment">order</span> <span class="comment">by</span> <span class="comment">rank</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">stores</span> <span class="comment">the</span> <span class="comment">stores</span> <span class="comment">of</span> <span class="comment">bikes</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">a</span> <span class="comment">newly</span> <span class="comment">created</span> <span class="comment">ArrayList</span><span class="ST7">&lt;ArrayList</span><span class="ST7">&lt;Bicycle&gt;</span><span class="comment">&gt; </span><span class="comment">with</span> <span class="comment">the</span> <span class="comment">bikes</span> <span class="comment">sorted</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">static</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; <span class="ST6">sortBikesByType</span>(<span class="literal">final</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; stores) {
ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; newStore = <span class="literal">new</span> ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt;();
<span class="comment">// group arrayLists</span>
ArrayList&lt;Bicycle&gt; mountainBikes = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
ArrayList&lt;Bicycle&gt; speedBikes = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
ArrayList&lt;Bicycle&gt; childBikes = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------- </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">grouping by bike type... </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string"> ----------</span><span class="string">&quot;</span>);
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; stores.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = <span class="number">0</span>; j &lt; stores.get(i).size(); ++j) {
<span class="comment">// System.out.println(stores.get(i).get(j).calculatedDetails().getRank() + &quot; &quot;);</span>
Bicycle bike = stores.get(i).get(j);
<span class="literal">if</span> (bike <span class="literal">instanceof</span> ChildBike) {
childBikes.add(bike);
} <span class="literal">else</span> <span class="literal">if</span> (bike <span class="literal">instanceof</span> MountainBike) {
mountainBikes.add(bike);
} <span class="literal">else</span> <span class="literal">if</span> (bike <span class="literal">instanceof</span> SpeedBike) {
speedBikes.add(bike);
}
}
}
<span class="comment">//printRank(childBikes);</span>
<span class="comment">//printRank(mountainBikes);</span>
<span class="comment">//printRank(speedBikes);</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">sorting...</span><span class="string">&quot;</span>);
<span class="ST8">sortType</span>(childBikes);
<span class="ST8">sortType</span>(mountainBikes);
<span class="ST8">sortType</span>(speedBikes);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">sorted</span><span class="string">&quot;</span>);
<span class="comment">//printRank(childBikes);</span>
<span class="comment">//printRank(mountainBikes);</span>
<span class="comment">//printRank(speedBikes);</span>
newStore.add(childBikes);
newStore.add(mountainBikes);
newStore.add(speedBikes);
<span class="literal">return</span> newStore;
}
<span class="literal">private</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">sortType</span>(ArrayList&lt;Bicycle&gt; arrList) {
<span class="literal">for</span> (<span class="literal">int</span> x = <span class="number">0</span>; x &lt; arrList.size(); ++x) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; arrList.size(); ++i) {
<span class="literal">for</span> (<span class="literal">int</span> j = i + <span class="number">1</span>; j &lt; arrList.size(); ++j) {
<span class="literal">int</span> compare1 = arrList.get(i).calculatedDetails().getRank();
<span class="literal">int</span> compare2 = arrList.get(j).calculatedDetails().getRank();
<span class="literal">if</span> (compare1 &lt; compare2) {
Bicycle tmp = arrList.get(i);
arrList.set(i, arrList.get(j));
arrList.set(j, tmp);
}
}
}
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">print</span>(Object[] arr) {
<span class="literal">for</span> (Object o : arr) {
System.<span class="ST5">out</span>.println(o);
}
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">print</span>(Object[][] arr) {
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; arr.<span class="ST2">length</span>; i++) {
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">---------- </span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">printing row </span><span class="string">&quot;</span> + (i + <span class="number">1</span>) + <span class="string">&quot;</span><span class="string"> ----------</span><span class="string">&quot;</span>);
<span class="ST8">print</span>(arr[i]);
}
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Returns</span> <span class="comment">a</span><span class="comment"> 2</span><span class="comment">D</span> <span class="comment">array</span> <span class="comment">containing</span> <span class="comment">all</span> <span class="comment">the</span> <span class="comment">bikes</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">store</span> <span class="comment">in</span> <span class="comment">proper</span> <span class="comment">sequence</span><span class="comment"> (</span><span class="comment">from</span> <span class="comment">first</span> <span class="comment">to</span> <span class="comment">last</span> <span class="comment">element</span><span class="comment">)</span><span class="comment">.</span> <span class="comment">Store</span><span class="comment"> 0 </span><span class="comment">with</span> <span class="comment">all</span> <span class="comment">its</span> <span class="comment">bikes</span><span class="comment">, </span><span class="comment">store</span><span class="comment"> 1 </span><span class="comment">with</span> <span class="comment">all</span> <span class="comment">its</span> <span class="comment">bikes</span><span class="comment">, </span><span class="comment">and</span> <span class="comment">so</span> <span class="comment">on</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">a</span><span class="comment"> 2</span><span class="comment">D</span> <span class="comment">array</span> <span class="comment">of</span> <span class="comment">all</span> <span class="comment">stores</span> <span class="comment">with</span> <span class="comment">bikes</span><span class="comment">.</span>
<span class="comment">*/</span>
<span class="literal">public</span> Object[][] <span class="ST4">toArray</span>() {
Object[][] arr = <span class="literal">new</span> Object[<span class="ST2">storesOfBikes</span>.size()][];
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="number">0</span>; i &lt; <span class="ST2">storesOfBikes</span>.size(); i++) {
arr[i] = <span class="ST2">storesOfBikes</span>.toArray();
}
<span class="literal">return</span> arr;
}
<span class="comment">/**</span>
<span class="comment"> * </span><span class="comment">Retains</span> <span class="comment">only</span> <span class="comment">the</span> <span class="comment">Bicycles</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">stores</span> <span class="comment">that</span> <span class="comment">are</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">In</span> <span class="comment">other</span> <span class="comment">words</span><span class="comment">, </span><span class="comment">removes</span> <span class="comment">from</span> <span class="comment">this</span> <span class="comment">list</span> <span class="comment">all</span> <span class="comment">of</span> <span class="comment">bikes</span> <span class="comment">that</span> <span class="comment">are</span> <span class="comment">not</span> <span class="comment">contained</span> <span class="comment">in</span> <span class="comment">the</span> <span class="comment">specified</span> <span class="comment">location</span><span class="comment">.</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST1">@param</span> <span class="ST3">c</span> <span class="comment">the</span> <span class="comment">bikes</span> <span class="comment">to</span> <span class="comment">be</span> <span class="comment">removed</span>
<span class="comment"> * </span><span class="ST1">@return</span> <span class="comment">true</span> <span class="comment">if</span> <span class="comment">any</span> <span class="comment">store</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="literal">public</span> <span class="literal">boolean</span> <span class="ST4">retainAll</span>(Collection&lt;Bicycle&gt; c) {
<span class="literal">boolean</span> modified = <span class="literal">false</span>;
<span class="literal">for</span> (<span class="literal">int</span> i = <span class="ST2">storesOfBikes</span>.size() - <span class="number">1</span>; i &gt;= <span class="number">0</span>; i--) {
ArrayList&lt;Bicycle&gt; bikes = <span class="ST2">storesOfBikes</span>.get(i);
<span class="literal">for</span> (<span class="literal">int</span> j = bikes.size() - <span class="number">1</span>; j &gt;= <span class="number">0</span>; j--) {
Bicycle bike = bikes.get(j);
<span class="literal">if</span> (!c.contains(bike)) {
bikes.remove(j);
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Removing </span><span class="string">&quot;</span> + bike);
modified = <span class="literal">true</span>;
}
}
}
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Bikes to remove:</span><span class="string">&quot;</span>);
<span class="ST8">printSingle</span>((ArrayList&lt;Bicycle&gt;) c);
<span class="literal">return</span> modified;
}
<span class="literal">public</span> <span class="literal">static</span> <span class="literal">void</span> <span class="ST6">main</span>(String[] args) {
BikeStores bikes = <span class="literal">new</span> BikeStores();
<span class="comment">//add 5 bikes to store 0 ( 2 speedBikes, 2 mountain 1 child)</span>
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> SpeedBike(<span class="number">4</span>, <span class="number">3</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">4</span><span class="number">0</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> SpeedBike(<span class="number">1</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">3</span><span class="number">0</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> MountainBike(<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">2</span><span class="number">0</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> MountainBike(<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">2</span><span class="number">5</span>));
bikes.addBike(<span class="number">0</span>, <span class="literal">new</span> ChildBike(<span class="literal">f</span><span class="literal">alse</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">0</span>));
<span class="comment">//add 5 bikes to store 1 ( 3 speedbikes, 1 mountain 1 child)</span>
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> SpeedBike(<span class="number">1</span><span class="number">0</span>, <span class="number">4</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">2</span><span class="number">0</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> SpeedBike(<span class="number">0</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">5</span><span class="number">0</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> SpeedBike(<span class="number">3</span>, <span class="number">2</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">3</span><span class="number">8</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> MountainBike(<span class="number">1</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">4</span><span class="number">4</span>));
bikes.addBike(<span class="number">1</span>, <span class="literal">new</span> ChildBike(<span class="literal">t</span><span class="literal">rue</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">5</span>));
<span class="comment">//add 6 bikes to store 2 ( 2 speedBikes, 2 mountain 2 child )</span>
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> SpeedBike(<span class="number">7</span>, <span class="number">1</span><span class="number">0</span>, <span class="number">2</span><span class="number">0</span>, <span class="number">2</span><span class="number">5</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> SpeedBike(<span class="number">0</span>, <span class="number">8</span>, <span class="number">4</span><span class="number">0</span>, <span class="number">5</span><span class="number">5</span>)); <span class="comment">// retainAll should match this one</span>
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> MountainBike(<span class="number">2</span>, <span class="number">3</span>, <span class="number">1</span><span class="number">5</span>, <span class="number">3</span><span class="number">3</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> MountainBike(<span class="number">1</span>, <span class="number">3</span>, <span class="number">1</span><span class="number">5</span>, <span class="number">2</span><span class="number">4</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> ChildBike(<span class="literal">t</span><span class="literal">rue</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span><span class="number">0</span>));
bikes.addBike(<span class="number">2</span>, <span class="literal">new</span> ChildBike(<span class="literal">f</span><span class="literal">alse</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">8</span>));<span class="comment">// retainAll should match this one</span>
<span class="comment">//remove one child bike from store 2</span>
bikes.removeBike(<span class="number">2</span>, <span class="literal">new</span> ChildBike(<span class="literal">t</span><span class="literal">rue</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">2</span><span class="number">0</span>)); <span class="comment">// Java reuses the object created earlier since it has the same values.</span>
<span class="comment">//PRINT</span>
<span class="ST8">print</span>(bikes.<span class="ST2">storesOfBikes</span>);
<span class="comment">//SORT</span>
ArrayList&lt;ArrayList&lt;Bicycle&gt;&gt; sortedBikes = <span class="ST8">sortBikesByType</span>(bikes.<span class="ST2">storesOfBikes</span>);
<span class="comment">//PRINT what the method return</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">SORTED BIKES</span><span class="string">&quot;</span>);
<span class="ST8">print</span>(sortedBikes);
<span class="comment">//PRINT the original store</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">ORIGINAL STORE ARRAYLIST</span><span class="string">&quot;</span>);
<span class="ST8">print</span>(bikes.<span class="ST2">storesOfBikes</span>);
<span class="comment">// ---------- TEST retainAll ----------</span>
System.<span class="ST5">out</span>.println(<span class="string">&quot;</span><span class="string">Testing retainAll();...</span><span class="string">&quot;</span>);
Collection&lt;Bicycle&gt; c1 = <span class="literal">new</span> ArrayList&lt;Bicycle&gt;();
c1.add(<span class="literal">new</span> SpeedBike(<span class="number">0</span>, <span class="number">8</span>, <span class="number">4</span><span class="number">0</span>, <span class="number">5</span><span class="number">5</span>));
c1.add(<span class="literal">new</span> ChildBike(<span class="literal">f</span><span class="literal">alse</span>, <span class="number">1</span>, <span class="number">1</span>, <span class="number">1</span><span class="number">8</span>));
Bicycle b1 = bikes.<span class="ST2">storesOfBikes</span>.get(<span class="number">2</span>).get(<span class="number">1</span>);
Bicycle b2 = bikes.<span class="ST2">storesOfBikes</span>.get(<span class="number">2</span>).get(<span class="number">4</span>);
Bicycle b3 = ((ArrayList&lt;Bicycle&gt;) c1).get(<span class="number">0</span>);
Bicycle b4 = ((ArrayList&lt;Bicycle&gt;) c1).get(<span class="number">1</span>);
System.<span class="ST5">out</span>.println(b1.equals(b3) + <span class="string">&quot;</span> <span class="string">&quot;</span> + b2.equals(b4));
bikes.retainAll(c1);
<span class="ST8">print</span>(bikes.<span class="ST2">storesOfBikes</span>);
}
}
<span class="literal">class</span> <span class="comment">NotABike</span> {
}
</pre></body>
</html>

84
Semester 2/Assignments/MP4_ChloeFontenot/Printed HTMLs/ChildBike.html Normal file
View File

@@ -0,0 +1,84 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>ChildBike.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}
.literal {color: #cc7832}
.string {color: #6a8759}
.comment {color: #808080}
.whitespace {color: #505050}
.ST0 {color: #808080; font-family: monospace; font-weight: bold}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/chloefontenot/mp4_chloefontenot/ChildBike.java</td></tr></table>
<pre>
<span class="comment">/*</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template</span>
<span class="comment"> */</span>
<span class="literal">package</span> com.chloefontenot.mp4_chloefontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> ChildBike <span class="literal">extends</span> Bicycle <span class="comment">//remove comment in front of extends</span>
{
@Override
<span class="literal">public</span> <span class="literal">boolean</span> equals(Object obj)
{
<span class="literal">if</span> (<span class="literal">this</span> == obj) {
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">if</span> (obj == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (getClass() != obj.getClass()) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">final</span> ChildBike other = (ChildBike) obj;
System.out.println(<span class="string">&quot;</span><span class="string">Super returns: </span><span class="string">&quot;</span> + <span class="literal">super</span>.equals(obj));
<span class="literal">return</span> <span class="literal">this</span>.helpWheels == other.helpWheels &amp;&amp; <span class="literal">super</span>.equals(obj);
}
<span class="literal">private</span> <span class="literal">boolean</span> helpWheels;
<span class="literal">public</span> ChildBike(<span class="literal">boolean</span> helpWheels, <span class="literal">int</span> cadence, <span class="literal">int</span> gear, <span class="literal">int</span> speed)
{
<span class="literal">super</span>(cadence, gear, speed);
<span class="literal">this</span>.helpWheels = helpWheels;
}
<span class="literal">public</span> <span class="literal">boolean</span> isHelpWheels()
{
<span class="literal">return</span> helpWheels;
}
<span class="literal">public</span> <span class="literal">void</span> setHelpWheels(<span class="literal">boolean</span> helpWheels)
{
<span class="literal">this</span>.helpWheels = helpWheels;
}
@Override
Details calculatedDetails()
{
<span class="literal">return</span> Details.getDetails(<span class="literal">this</span>);
}
@Override
<span class="literal">public</span> String toString()
{
<span class="literal">return</span> <span class="literal">super</span>.toString() + <span class="string">&quot;</span><span class="string">ChildBike{</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">helpWheels=</span><span class="string">&quot;</span> + helpWheels + <span class="string">&#39;</span><span class="string">}</span><span class="string">&#39;</span>;
}
}
</pre></body>
</html>

81
Semester 2/Assignments/MP4_ChloeFontenot/Printed HTMLs/Details.html Normal file
View File

@@ -0,0 +1,81 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>Details.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}
.literal {color: #cc7832}
.number {color: #6897bb}
.comment {color: #808080}
.whitespace {color: #505050}
.ST0 {color: #808080; font-family: monospace; font-weight: bold}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/chloefontenot/mp4_chloefontenot/Details.java</td></tr></table>
<pre>
<span class="comment">/*</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template</span>
<span class="comment"> */</span>
<span class="literal">package</span> com.chloefontenot.mp4_chloefontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> Details {
<span class="literal">private</span> <span class="literal">int</span> rank;
<span class="literal">private</span> String info;
<span class="literal">public</span> <span class="literal">int</span> getRank()
{
<span class="literal">return</span> rank;
}
<span class="literal">public</span> String getInfo()
{
<span class="literal">return</span> info;
}
<span class="literal">public</span> <span class="literal">static</span> Details getDetails(Bicycle b)
{
Details d = <span class="literal">new</span> Details();
<span class="literal">if</span> (b <span class="literal">instanceof</span> SpeedBike) {
<span class="literal">if</span> (((SpeedBike) b).getWeight() &lt; <span class="number">1</span>) {
d.rank = <span class="number">10</span>;
} <span class="literal">else</span> <span class="literal">if</span> (((SpeedBike) b).getWeight() &gt; <span class="number">1</span> &amp;&amp; ((SpeedBike) b).getWeight() &lt; <span class="number">8</span>) {
d.rank = <span class="number">9</span>;
} <span class="literal">else</span> {
d.rank = <span class="number">0</span>;
}
} <span class="literal">else</span> <span class="literal">if</span> (b <span class="literal">instanceof</span> MountainBike) {
<span class="literal">if</span> (((MountainBike) b).getSeatHeight() &gt; <span class="number">2</span>) {
d.rank = <span class="number">10</span>;
} <span class="literal">else</span> {
d.rank = <span class="number">0</span>;
}
} <span class="literal">else</span> <span class="literal">if</span> (b <span class="literal">instanceof</span> ChildBike) {
<span class="literal">if</span> (((ChildBike) b).isHelpWheels()) {
d.rank = <span class="number">10</span>;
} <span class="literal">else</span> {
d.rank = <span class="number">0</span>;
}
} <span class="literal">else</span> {
<span class="literal">return</span> <span class="literal">null</span>;
}
d.info = b.toString();
<span class="literal">return</span> d;
}
}
</pre></body>
</html>

86
Semester 2/Assignments/MP4_ChloeFontenot/Printed HTMLs/MountainBike.html Normal file
View File

@@ -0,0 +1,86 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>MountainBike.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}
.literal {color: #cc7832}
.string {color: #6a8759}
.comment {color: #808080}
.whitespace {color: #505050}
.ST0 {color: #808080; font-family: monospace; font-weight: bold}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/chloefontenot/mp4_chloefontenot/MountainBike.java</td></tr></table>
<pre>
<span class="comment">/*</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template</span>
<span class="comment"> */</span>
<span class="literal">package</span> com.chloefontenot.mp4_chloefontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> MountainBike <span class="literal">extends</span> Bicycle
{
<span class="literal">private</span> <span class="literal">int</span> seatHeight;
@Override
<span class="literal">public</span> <span class="literal">boolean</span> equals(Object obj)
{
<span class="literal">if</span> (<span class="literal">this</span> == obj) {
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">if</span> (obj == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (getClass() != obj.getClass()) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">final</span> MountainBike other = (MountainBike) obj;
System.out.println(<span class="string">&quot;</span><span class="string">Super returns: </span><span class="string">&quot;</span> + <span class="literal">super</span>.equals(obj));
<span class="literal">return</span> <span class="literal">this</span>.seatHeight == other.seatHeight &amp;&amp; <span class="literal">super</span>.equals(obj);
}
<span class="literal">public</span> MountainBike(<span class="literal">int</span> seatHeight, <span class="literal">int</span> cadence, <span class="literal">int</span> gear, <span class="literal">int</span> speed)
{
<span class="literal">super</span>(cadence, gear, speed);
<span class="literal">this</span>.seatHeight = seatHeight;
}
<span class="literal">public</span> <span class="literal">int</span> getSeatHeight()
{
<span class="literal">return</span> seatHeight;
}
<span class="literal">public</span> <span class="literal">void</span> setSeatHeight(<span class="literal">int</span> seatHeight)
{
<span class="literal">this</span>.seatHeight = seatHeight;
}
@Override
<span class="literal">public</span> String toString()
{
<span class="literal">return</span> <span class="literal">super</span>.toString() + <span class="string">&quot;</span><span class="string"> MountainBike{</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">seatHeight=</span><span class="string">&quot;</span> + seatHeight + <span class="string">&#39;</span><span class="string">}</span><span class="string">&#39;</span>;
}
@Override
Details calculatedDetails()
{
<span class="literal">return</span> Details.getDetails(<span class="literal">this</span>);
}
}
</pre></body>
</html>

94
Semester 2/Assignments/MP4_ChloeFontenot/Printed HTMLs/SpeedBike.html Normal file
View File

@@ -0,0 +1,94 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<title>SpeedBike.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}
.literal {color: #cc7832}
.number {color: #6897bb}
.string {color: #6a8759}
.comment {color: #808080}
.whitespace {color: #505050}
.ST0 {color: #808080; font-family: monospace; font-weight: bold}
-->
</style>
</head>
<body>
<table width="100%"><tr><td align="center">/home/chloe/ASDV-Java/Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/chloefontenot/mp4_chloefontenot/SpeedBike.java</td></tr></table>
<pre>
<span class="comment">/*</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license</span>
<span class="comment"> * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template</span>
<span class="comment"> */</span>
<span class="literal">package</span> com.chloefontenot.mp4_chloefontenot;
<span class="comment">/**</span>
<span class="comment"> *</span>
<span class="comment"> * </span><span class="ST0">@author</span> <span class="comment">chloe</span>
<span class="comment">*/</span>
<span class="literal">public</span> <span class="literal">class</span> SpeedBike <span class="literal">extends</span> Bicycle
{
@Override
<span class="literal">public</span> <span class="literal">int</span> hashCode()
{
<span class="literal">int</span> hash = <span class="number">5</span>;
<span class="literal">return</span> hash;
}
@Override
<span class="literal">public</span> <span class="literal">boolean</span> equals(Object obj)
{
<span class="literal">if</span> (<span class="literal">this</span> == obj) {
<span class="literal">return</span> <span class="literal">true</span>;
}
<span class="literal">if</span> (obj == <span class="literal">null</span>) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">if</span> (getClass() != obj.getClass()) {
<span class="literal">return</span> <span class="literal">false</span>;
}
<span class="literal">final</span> SpeedBike other = (SpeedBike) obj;
System.out.println(<span class="string">&quot;</span><span class="string">Super returns: </span><span class="string">&quot;</span> + <span class="literal">super</span>.equals(obj));
<span class="literal">return</span> Double.doubleToLongBits(<span class="literal">this</span>.weight) == Double.doubleToLongBits(other.weight) &amp;&amp; <span class="literal">super</span>.equals(obj);
}
<span class="literal">private</span> <span class="literal">double</span> weight;
<span class="literal">public</span> SpeedBike(<span class="literal">double</span> weight, <span class="literal">int</span> cadence, <span class="literal">int</span> gear, <span class="literal">int</span> speed)
{
<span class="literal">super</span>(cadence, gear, speed);
<span class="literal">this</span>.weight = weight;
}
<span class="literal">public</span> <span class="literal">double</span> getWeight()
{
<span class="literal">return</span> weight;
}
<span class="literal">public</span> <span class="literal">void</span> setWeight(<span class="literal">double</span> weight)
{
<span class="literal">this</span>.weight = weight;
}
@Override
<span class="literal">public</span> String toString()
{
<span class="literal">return</span> <span class="literal">super</span>.toString() + <span class="string">&quot;</span><span class="string"> SpeedBike{</span><span class="string">&quot;</span> + <span class="string">&quot;</span><span class="string">weight=</span><span class="string">&quot;</span> + weight + <span class="string">&#39;</span><span class="string">}</span><span class="string">&#39;</span>;
}
@Override
Details calculatedDetails()
{
<span class="literal">return</span> Details.getDetails(<span class="literal">this</span>);
}
}
</pre></body>
</html>

18
Semester 2/Assignments/MP4_ChloeFontenot/nb-configuration.xml Normal file
View File

@@ -0,0 +1,18 @@
<?xml version="1.0" encoding="UTF-8"?>
<project-shared-configuration>
<!--
This file contains additional configuration written by modules in the NetBeans IDE.
The configuration is intended to be shared among all the users of project and
therefore it is assumed to be part of version control checkout.
Without this configuration present, some functionality in the IDE may be limited or fail altogether.
-->
<properties xmlns="http://www.netbeans.org/ns/maven-properties-data/1">
<!--
Properties that influence various parts of the IDE, especially code formatting and the like.
You can copy and paste the single properties, into the pom.xml file and the IDE will pick them up.
That way multiple projects can share the same settings (useful for formatting rules for example).
Any value defined here will override the pom.xml file value but is only applicable to the current project.
-->
<netbeans.hint.jdkPlatform>JDK_17</netbeans.hint.jdkPlatform>
</properties>
</project-shared-configuration>

14
Semester 2/Assignments/MP4_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>com.chloefontenot</groupId>
<artifactId>MP4_ChloeFontenot</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<exec.mainClass>com.chloefontenot.mp4_chloefontenot.MP4_ChloeFontenot</exec.mainClass>
</properties>
</project>

61
Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/calebfontenot/mp4_calebfontenot/Bicycle.java Normal file
View File

@@ -0,0 +1,61 @@
/*
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
*/
package com.chloefontenot.mp4_chloefontenot;
/**
*
* @author chloe
*/
abstract public class Bicycle
{
private int cadence;
private int gear;
private int speed;
@Override
public boolean equals(Object obj)
{
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Bicycle other = (Bicycle) obj;
if (this.cadence != other.cadence) {
return false;
}
if (this.gear != other.gear) {
return false;
}
return this.speed == other.speed;
}
public Bicycle(int cadence, int gear, int speed)
{
this.cadence = cadence;
this.gear = gear;
this.speed = speed;
}
public int getGear(){return gear;}
public void setGear(int gear){this.gear = gear;}
public int getCadence(){return cadence;}
public void setCadence(int cadence){this.cadence = cadence;}
public int getSpeed(){return speed;}
public void setSpeed(int speed){this.speed = speed;}
@Override
public String toString()
{
return "Bicycle{" + "cadence=" + cadence + ", gear=" + gear + ", speed=" + speed + '}';
}
abstract Details calculatedDetails();
}

265
Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/calebfontenot/mp4_calebfontenot/BikeStores.java Normal file
View File

@@ -0,0 +1,265 @@
/*
* 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 com.chloefontenot.mp4_chloefontenot;
import java.util.ArrayList;
import java.util.Collection;
/**
*
* @author chloe
*/
public class BikeStores {
ArrayList<ArrayList<Bicycle>> storesOfBikes = new ArrayList<ArrayList<Bicycle>>();
/**
* Add a bike at storeNumber ( i.e. the storeNumber indicates the store)
*
* @param storeNumber which store
* @param b the bike to add
* @return true if the bike added, false if the storeNumber is invalid or b is null.
*/
public BikeStores() {
for (int i = 0; i < 3; i++) {
storesOfBikes.add(new ArrayList<Bicycle>());
}
}
public boolean addBike(int storeNumber, Bicycle b) {
if (storeNumber < 0 || storeNumber > this.storesOfBikes.size() - 1) {
return false;
}
if (b == null) {
return false;
}
System.out.println("Attempting to add " + b + " to store at index " + storeNumber);
//Unpack array
ArrayList<Bicycle> bikesInInventory = storesOfBikes.get(storeNumber);
bikesInInventory.add(b);
// Repack array
storesOfBikes.set(storeNumber, bikesInInventory);
System.out.println("success!");
return true;
}
/**
* Removes a bike at a specific store.
*
* @param storeNumber the store that has the bike
* @param b the bike to be removed
* @return true of the bike is removed, false if the bike does not exist, or bike is null.
*/
public boolean removeBike(int storeNumber, Bicycle b) {
if (storeNumber < 0 || storeNumber > this.storesOfBikes.size() - 1) {
return false;
}
if (b == null) {
return false;
}
System.out.println("Attempting to remove " + b + " to store at index " + storeNumber);
// Remove bike from array.
ArrayList<Bicycle> bikesInInventory = storesOfBikes.get(storeNumber);
bikesInInventory.remove(b); //YEET
System.out.println("success!");
return true;
}
/**
* Prints the indexes before each bike , one store per line
*
* @param stores stores of bikes
*/
public static void print(ArrayList<ArrayList<Bicycle>> stores) {
for (int i = 0; i < stores.size(); ++i) {
System.out.println("---------- " + "printing row " + (i + 1) + " ----------");
for (int j = 0; j < stores.get(i).size(); ++j) {
System.out.println(stores.get(i).get(j) + " ");
}
}
}
public static void printSingle(ArrayList<Bicycle> stores) {
System.out.println("----------" + "printSingle" + "----------");
for (int j = 0; j < stores.size(); ++j) {
System.out.println(stores.get(j) + " ");
}
}
public static void printRank(ArrayList<Bicycle> stores) {
System.out.println("----------" + "printRank" + "----------");
for (int j = 0; j < stores.size(); ++j) {
System.out.println(stores.get(j) + " " + stores.get(j).calculatedDetails().getRank());
}
}
/**
* Groups bikes by type ans sorts them by the ranking of Details. There will be three groups and each group stored in descending order by rank.
*
* @param stores the stores of bikes
* @return a newly created ArrayList<ArrayList<Bicycle>> with the bikes sorted.
*/
public static ArrayList<ArrayList<Bicycle>> sortBikesByType(final ArrayList<ArrayList<Bicycle>> stores) {
ArrayList<ArrayList<Bicycle>> newStore = new ArrayList<ArrayList<Bicycle>>();
// group arrayLists
ArrayList<Bicycle> mountainBikes = new ArrayList<Bicycle>();
ArrayList<Bicycle> speedBikes = new ArrayList<Bicycle>();
ArrayList<Bicycle> childBikes = new ArrayList<Bicycle>();
System.out.println("---------- " + "grouping by bike type... " + " ----------");
for (int i = 0; i < stores.size(); ++i) {
for (int j = 0; j < stores.get(i).size(); ++j) {
// System.out.println(stores.get(i).get(j).calculatedDetails().getRank() + " ");
Bicycle bike = stores.get(i).get(j);
if (bike instanceof ChildBike) {
childBikes.add(bike);
} else if (bike instanceof MountainBike) {
mountainBikes.add(bike);
} else if (bike instanceof SpeedBike) {
speedBikes.add(bike);
}
}
}
//printRank(childBikes);
//printRank(mountainBikes);
//printRank(speedBikes);
System.out.println("sorting...");
sortType(childBikes);
sortType(mountainBikes);
sortType(speedBikes);
System.out.println("sorted");
//printRank(childBikes);
//printRank(mountainBikes);
//printRank(speedBikes);
newStore.add(childBikes);
newStore.add(mountainBikes);
newStore.add(speedBikes);
return newStore;
}
private static void sortType(ArrayList<Bicycle> arrList) {
for (int x = 0; x < arrList.size(); ++x) {
for (int i = 0; i < arrList.size(); ++i) {
for (int j = i + 1; j < arrList.size(); ++j) {
int compare1 = arrList.get(i).calculatedDetails().getRank();
int compare2 = arrList.get(j).calculatedDetails().getRank();
if (compare1 < compare2) {
Bicycle tmp = arrList.get(i);
arrList.set(i, arrList.get(j));
arrList.set(j, tmp);
}
}
}
}
}
public static void print(Object[] arr) {
for (Object o : arr) {
System.out.println(o);
}
}
public static void print(Object[][] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println("---------- " + "printing row " + (i + 1) + " ----------");
print(arr[i]);
}
}
/**
* Returns a 2D array containing all the bikes in the store in proper sequence (from first to last element). Store 0 with all its bikes, store 1 with all its bikes, and so on.
*
* @return a 2D array of all stores with bikes.
*/
public Object[][] toArray() {
Object[][] arr = new Object[storesOfBikes.size()][];
for (int i = 0; i < storesOfBikes.size(); i++) {
arr[i] = storesOfBikes.toArray();
}
return arr;
}
/**
* Retains only the Bicycles in the stores that are contained in the specified collection. In other words, removes from this list all of bikes that are not contained in the specified location.
*
* @param c the bikes to be removed
* @return true if any store changed as a result of the call.
*/
public boolean retainAll(Collection<Bicycle> c) {
boolean modified = false;
for (int i = storesOfBikes.size() - 1; i >= 0; i--) {
ArrayList<Bicycle> bikes = storesOfBikes.get(i);
for (int j = bikes.size() - 1; j >= 0; j--) {
Bicycle bike = bikes.get(j);
if (!c.contains(bike)) {
bikes.remove(j);
System.out.println("Removing " + bike);
modified = true;
}
}
}
System.out.println("Bikes to remove:");
printSingle((ArrayList<Bicycle>) c);
return modified;
}
public static void main(String[] args) {
BikeStores bikes = new BikeStores();
//add 5 bikes to store 0 ( 2 speedBikes, 2 mountain 1 child)
bikes.addBike(0, new SpeedBike(4, 3, 10, 40));
bikes.addBike(0, new SpeedBike(1, 2, 10, 30));
bikes.addBike(0, new MountainBike(1, 2, 3, 20));
bikes.addBike(0, new MountainBike(3, 2, 10, 25));
bikes.addBike(0, new ChildBike(false, 1, 1, 10));
//add 5 bikes to store 1 ( 3 speedbikes, 1 mountain 1 child)
bikes.addBike(1, new SpeedBike(10, 4, 10, 20));
bikes.addBike(1, new SpeedBike(0, 2, 10, 50));
bikes.addBike(1, new SpeedBike(3, 2, 10, 38));
bikes.addBike(1, new MountainBike(1, 3, 5, 44));
bikes.addBike(1, new ChildBike(true, 1, 1, 15));
//add 6 bikes to store 2 ( 2 speedBikes, 2 mountain 2 child )
bikes.addBike(2, new SpeedBike(7, 10, 20, 25));
bikes.addBike(2, new SpeedBike(0, 8, 40, 55)); // retainAll should match this one
bikes.addBike(2, new MountainBike(2, 3, 15, 33));
bikes.addBike(2, new MountainBike(1, 3, 15, 24));
bikes.addBike(2, new ChildBike(true, 1, 2, 20));
bikes.addBike(2, new ChildBike(false, 1, 1, 18));// retainAll should match this one
//remove one child bike from store 2
bikes.removeBike(2, new ChildBike(true, 1, 2, 20)); // Java reuses the object created earlier since it has the same values.
//PRINT
print(bikes.storesOfBikes);
//SORT
ArrayList<ArrayList<Bicycle>> sortedBikes = sortBikesByType(bikes.storesOfBikes);
//PRINT what the method return
System.out.println("SORTED BIKES");
print(sortedBikes);
//PRINT the original store
System.out.println("ORIGINAL STORE ARRAYLIST");
print(bikes.storesOfBikes);
// ---------- TEST retainAll ----------
System.out.println("Testing retainAll();...");
Collection<Bicycle> c1 = new ArrayList<Bicycle>();
c1.add(new SpeedBike(0, 8, 40, 55));
c1.add(new ChildBike(false, 1, 1, 18));
Bicycle b1 = bikes.storesOfBikes.get(2).get(1);
Bicycle b2 = bikes.storesOfBikes.get(2).get(4);
Bicycle b3 = ((ArrayList<Bicycle>) c1).get(0);
Bicycle b4 = ((ArrayList<Bicycle>) c1).get(1);
System.out.println(b1.equals(b3) + " " + b2.equals(b4));
bikes.retainAll(c1);
print(bikes.storesOfBikes);
}
}
class NotABike {
}

60
Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/calebfontenot/mp4_calebfontenot/ChildBike.java Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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 com.chloefontenot.mp4_chloefontenot;
/**
*
* @author chloe
*/
public class ChildBike extends Bicycle //remove comment in front of extends
{
@Override
public boolean equals(Object obj)
{
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final ChildBike other = (ChildBike) obj;
System.out.println("Super returns: " + super.equals(obj));
return this.helpWheels == other.helpWheels && super.equals(obj);
}
private boolean helpWheels;
public ChildBike(boolean helpWheels, int cadence, int gear, int speed)
{
super(cadence, gear, speed);
this.helpWheels = helpWheels;
}
public boolean isHelpWheels()
{
return helpWheels;
}
public void setHelpWheels(boolean helpWheels)
{
this.helpWheels = helpWheels;
}
@Override
Details calculatedDetails()
{
return Details.getDetails(this);
}
@Override
public String toString()
{
return super.toString() + "ChildBike{" + "helpWheels=" + helpWheels + '}';
}
}

57
Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/calebfontenot/mp4_calebfontenot/Details.java Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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 com.chloefontenot.mp4_chloefontenot;
/**
*
* @author chloe
*/
public class Details {
private int rank;
private String info;
public int getRank()
{
return rank;
}
public String getInfo()
{
return info;
}
public static Details getDetails(Bicycle b)
{
Details d = new Details();
if (b instanceof SpeedBike) {
if (((SpeedBike) b).getWeight() < 1) {
d.rank = 10;
} else if (((SpeedBike) b).getWeight() > 1 && ((SpeedBike) b).getWeight() < 8) {
d.rank = 9;
} else {
d.rank = 0;
}
} else if (b instanceof MountainBike) {
if (((MountainBike) b).getSeatHeight() > 2) {
d.rank = 10;
} else {
d.rank = 0;
}
} else if (b instanceof ChildBike) {
if (((ChildBike) b).isHelpWheels()) {
d.rank = 10;
} else {
d.rank = 0;
}
} else {
return null;
}
d.info = b.toString();
return d;
}
}

62
Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/calebfontenot/mp4_calebfontenot/MountainBike.java Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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 com.chloefontenot.mp4_chloefontenot;
/**
*
* @author chloe
*/
public class MountainBike extends Bicycle
{
private int seatHeight;
@Override
public boolean equals(Object obj)
{
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final MountainBike other = (MountainBike) obj;
System.out.println("Super returns: " + super.equals(obj));
return this.seatHeight == other.seatHeight && super.equals(obj);
}
public MountainBike(int seatHeight, int cadence, int gear, int speed)
{
super(cadence, gear, speed);
this.seatHeight = seatHeight;
}
public int getSeatHeight()
{
return seatHeight;
}
public void setSeatHeight(int seatHeight)
{
this.seatHeight = seatHeight;
}
@Override
public String toString()
{
return super.toString() + " MountainBike{" + "seatHeight=" + seatHeight + '}';
}
@Override
Details calculatedDetails()
{
return Details.getDetails(this);
}
}

69
Semester 2/Assignments/MP4_ChloeFontenot/src/main/java/com/calebfontenot/mp4_calebfontenot/SpeedBike.java Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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 com.chloefontenot.mp4_chloefontenot;
/**
*
* @author chloe
*/
public class SpeedBike extends Bicycle
{
@Override
public int hashCode()
{
int hash = 5;
return hash;
}
@Override
public boolean equals(Object obj)
{
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final SpeedBike other = (SpeedBike) obj;
System.out.println("Super returns: " + super.equals(obj));
return Double.doubleToLongBits(this.weight) == Double.doubleToLongBits(other.weight) && super.equals(obj);
}
private double weight;
public SpeedBike(double weight, int cadence, int gear, int speed)
{
super(cadence, gear, speed);
this.weight = weight;
}
public double getWeight()
{
return weight;
}
public void setWeight(double weight)
{
this.weight = weight;
}
@Override
public String toString()
{
return super.toString() + " SpeedBike{" + "weight=" + weight + '}';
}
@Override
Details calculatedDetails()
{
return Details.getDetails(this);
}
}