From f0b5074ac76b9eba3814746479d0708846d6870c Mon Sep 17 00:00:00 2001 From: k0rrluna Date: Wed, 9 Apr 2025 02:32:02 +0300 Subject: [PATCH] assignments --- DataLabs/lab3/ArrayBag.class | Bin 0 -> 2555 bytes DataLabs/lab3/ArrayBag.java | 143 ++++++++++++ DataLabs/lab3/ArrayBagDemo.java | 241 ++++++++++++++++++++ DataLabs/lab3/BagInterface.class | Bin 0 -> 524 bytes DataLabs/lab3/BagInterface.java | 48 ++++ Example.java | 9 + assignments/AssigmentS3/StorageBox.class | Bin 0 -> 1658 bytes assignments/AssigmentS3/StorageBox.java | 44 ++++ assignments/AssigmentS3/demo.java | 36 +++ assignments/AssigmentS4/AList.class | Bin 0 -> 3316 bytes assignments/AssigmentS4/AList.java | 181 +++++++++++++++ assignments/AssigmentS4/ListClient.java | 26 +++ assignments/AssigmentS4/ListInterface.class | Bin 0 -> 632 bytes assignments/AssigmentS4/ListInterface.java | 70 ++++++ 14 files changed, 798 insertions(+) create mode 100644 DataLabs/lab3/ArrayBag.class create mode 100644 DataLabs/lab3/ArrayBag.java create mode 100644 DataLabs/lab3/ArrayBagDemo.java create mode 100644 DataLabs/lab3/BagInterface.class create mode 100644 DataLabs/lab3/BagInterface.java create mode 100644 Example.java create mode 100644 assignments/AssigmentS3/StorageBox.class create mode 100644 assignments/AssigmentS3/StorageBox.java create mode 100644 assignments/AssigmentS3/demo.java create mode 100644 assignments/AssigmentS4/AList.class create mode 100644 assignments/AssigmentS4/AList.java create mode 100644 assignments/AssigmentS4/ListClient.java create mode 100644 assignments/AssigmentS4/ListInterface.class create mode 100644 assignments/AssigmentS4/ListInterface.java diff --git a/DataLabs/lab3/ArrayBag.class b/DataLabs/lab3/ArrayBag.class new file mode 100644 index 0000000000000000000000000000000000000000..f0762473f3fbb8e52a43ee13c6eb6340776b845f GIT binary patch literal 2555 zcmZ`)+j10D6kTU-olH6*cL2qcq4MkfTFA;?ualO_x#Ghs3l43-ZT zRH>!UR)JNP#e;d_0jnffTKWNgfIr}iT6_V;#kIS8(u0wjnm(t`*=Mh{*WUZ|?=OD- z4Zu-kg7Cnr!KcHIfI{OnW7+7NH}Z3RQ#04hY)K(7l*{Kz!wTMTWV#kLsMQeEQ3qY2 zW~5j&Rz{6E1>aKcmZ_kUV$z^vleM2U7L9DKv?7a5I-1c!6FO}_65dGlm>Va6+{GHV_vya^vi7CGlfD7OcL{IgT6IXi;mRt#}e>^<2ZMkD7ec|MPE^DfIs>pv&Xt2XOU&5A^(eMdAz&9V zcT?mDF{4C{@fWY));hQo7H%cJ8w^_dZ6F$3L+{bhH;4;Z$VKc=yYp&v--9X@yNN7P z2e6-M?nfsMkjX*54RChY;y|UJ;XtL{B>cD63t);QBuOH3_dQg>S3|D8{8LK9PFyo9 z3M^ZVW!l0b?P0zoiBj0x=#00cqwOV*V%zII>K*Q4G}?W%OHf_?vF{PM<573KYW3w` zAvcG%o})aNV7ZR5V8?m8C+PTu1yTp^bNG~MeMP4o(hUjEPn3+-=@ zE0>LSfw5d<_g$jb3kbom(1P$jgGaTzsuVw!)Jr<-Ah9I%O+>JI^t;#esA;)lk8V0H zJ<4yYzQtjOUjw+w3X#2(KxRs>#lNZX*+cSuCkVLO!sy2 zpJ%GCV^&kHoDigb$UJLyRFwL>EL3u?|1P>b<@nU|T%q}6JzuKqQI z&sbdkAxSa2kJdOxa&))iZgbo0O1uJ>na7)K^JTX6EgZtfyb^D*jXts1wZQirEgEW= z*DcSWWN^|uMX64$bN!NB implements BagInterface { + + private T[] t; + private int size; + private int capacity; + private static final int DEFAULT_CAPACITY = 25; + + + public ArrayBag(int capacity) { + this.size = 0; + this.capacity = capacity; + this.t = (T[]) new Object[capacity]; + + } + public ArrayBag() { + this(DEFAULT_CAPACITY); + } + + public int getCurrentSize() { + return size; + } + + public boolean isEmpty() { + return size == 0; + } + + public boolean add(T newEntry) { + if (isFull()) { + // return false; + resize(); + } + t[size] = newEntry; + size++; + return true; + } + + public T remove() { + if (isEmpty()) { + return null; + } + T temp = t[size - 1]; + t[size - 1] = null; + size--; + return temp; + } + + public boolean remove(T anEntry) { + int index = getIndexOf(anEntry); + if (index >= 0) { + t[index] = t[size - 1]; + t[size - 1] = null; + size--; + return true; + } + return false; + } + + public void clear() { + while(!isEmpty()) { + t[size - 1] = null; + size--; + } + } + + public int getFrequencyOf(T anEntry) { + int temp = 0; + for(int i = 0; i < size; i++) { + if(t[i] == anEntry) { + temp++; + } + } + return temp; + } + + public boolean contains(T anEntry) { + if(getFrequencyOf(anEntry) > 0) { + return true; + } else { + return false; + } + } + + public T[] toArray() { + T[] newArray = (T[]) new Object[size]; + for(int i = 0; i < size; i++) { + newArray[i] = t[i]; + } + return newArray; + } + + private int getIndexOf(T anEntry) { + for(int i = 0; i < size; i++) { + if(t[i] == anEntry) { + return i; + } + } + return -1; + } + + public boolean isFull() { + return capacity == size; + } + public void resize() { + int newCapacity = 2 * capacity; + T[] newArray = (T[]) new Object[newCapacity]; + + for (int i = 0; i < size; i++) { + newArray[i] = t[i]; + } + + t = newArray; + capacity = newCapacity;{} + } + + public ArrayBag union(ArrayBag otherBag) { + ArrayBag result = new ArrayBag<>(this.size + otherBag.size); + + for(int i = 0; i < this.size; i++){ + result.add(this.t[i]); + } + + for(int i = 0; i < otherBag.size; i++){ + result.add(otherBag.t[i]); + } + return result; + } + + public ArrayBag intersection(ArrayBag otherBag) { + ArrayBag result = new ArrayBag<>(Math.min(this.size, otherBag.size)); + + for(int i = 0; i < this.size; i++) { + T temp = this.t[i]; + + + if(otherBag.contains(temp)) { + result.add(temp); + otherBag.remove(temp); + } + } + return result; + } + +} diff --git a/DataLabs/lab3/ArrayBagDemo.java b/DataLabs/lab3/ArrayBagDemo.java new file mode 100644 index 0000000..46252bf --- /dev/null +++ b/DataLabs/lab3/ArrayBagDemo.java @@ -0,0 +1,241 @@ +/** A demonstration of the class ArrayBag + @author Frank M. Carrano + @version 4.0 +*/ +public class ArrayBagDemo +{ + public static void main(String[] args) + { + String[] contentsOfBag = {"A", "A", "B", "A", "C", "A"}; + // Tests on an empty bag + BagInterface aBag = new ArrayBag<>(contentsOfBag.length); + System.out.println("Testing an initially empty bag:"); + testIsEmpty(aBag, true); + String[] testStrings1 = {"", "B"}; + testFrequency(aBag, testStrings1); + testContains(aBag, testStrings1); + testRemove(aBag, testStrings1); + // Adding strings + System.out.println("Adding " + contentsOfBag.length + + " strings to an initially empty bag with" + + " the capacity to hold more than " + + contentsOfBag.length + " strings:"); + testAdd(aBag, contentsOfBag); + + // Tests on a bag that is not empty + testIsEmpty(aBag, false); + String[] testStrings2 = {"A", "B", "C", "D", "Z"}; + testFrequency(aBag, testStrings2); + testContains(aBag, testStrings2); + + // Removing strings + String[] testStrings3 = {"", "B", "A", "C", "Z"}; + testRemove(aBag, testStrings3); + System.out.println("\nClearing the bag:"); + aBag.clear(); + testIsEmpty(aBag, true); + displayBag(aBag); + + // Filling an initially empty bag to capacity + System.out.println("\nTesting an initially empty bag that " + + " will be filled to capacity:"); + aBag = new ArrayBag(7); + String[] contentsOfBag2 = {"A", "B", "A", "C", "B", "C", "D"}; + testAdd(aBag, contentsOfBag2); + + System.out.println("Try to add another string to the full bag:"); + if (aBag.add("another string")) + System.out.println("Added a string beyond the bag's capacity: ERROR!"); + else + System.out.println("The method add cannot add another string: OK"); + } // end main + + // Tests the method add. + private static void testAdd(BagInterface aBag, String[] content) + { + System.out.print("Adding "); + for (int index = 0; index < content.length; index++) + { + aBag.add(content[index]); + System.out.print(content[index] + " "); + } // end for + System.out.println(); + + displayBag(aBag); + } // end testAdd + // Tests the two remove methods. + private static void testRemove(BagInterface aBag, String[] tests) + { + for (int index = 0; index < tests.length; index++) + { + String aString = tests[index]; + if (aString.equals("") || (aString == null)) + { + // test remove() + System.out.println("\nRemoving a string from the bag:"); + String removedString = aBag.remove(); + System.out.println("remove() returns " + removedString); + } + else + { + // test remove(aString) + System.out.println("\nRemoving \"" + aString + "\" from the bag:"); + boolean result = aBag.remove(aString); + System.out.println("remove(\"" + aString + "\") returns " + result); + } // end if + + displayBag(aBag); + } // end for + } // end testRemove + // Tests the method isEmpty. + // correctResult indicates what isEmpty should return. + private static void testIsEmpty(BagInterface aBag, boolean correctResult) + { + System.out.print("Testing isEmpty with "); + if (correctResult) + System.out.println("an empty bag:"); + else + System.out.println("a bag that is not empty:"); + + System.out.print("isEmpty finds the bag "); + if (correctResult && aBag.isEmpty()) + System.out.println("empty: OK."); + else if (correctResult) + System.out.println("not empty, but it is empty: ERROR."); + else if (!correctResult && aBag.isEmpty()) + System.out.println("empty, but it is not empty: ERROR."); + else + System.out.println("not empty: OK."); + System.out.println(); + } // end testIsEmpty + // Tests the method getFrequencyOf. + private static void testFrequency(BagInterface aBag, String[] tests) + { + System.out.println("\nTesting the method getFrequencyOf:"); + for (int index = 0; index < tests.length; index++) + { + String aString = tests[index]; + if (!aString.equals("") && (aString != null)) + { + System.out.println("In this bag, the count of " + tests[index] + + " is " + aBag.getFrequencyOf(tests[index])); + } // end if + } // end for + } // end testFrequency + + // Tests the method contains. + private static void testContains(BagInterface aBag, String[] tests) + { + System.out.println("\nTesting the method contains:"); + for (int index = 0; index < tests.length; index++) + { + String aString = tests[index]; + if (!aString.equals("") && (aString != null)) + { + System.out.println("Does this bag contain " + tests[index] + + "? " + aBag.contains(tests[index])); + } // end if + } // end for + } // end testContains + // Tests the method toArray while displaying the bag. + private static void displayBag(BagInterface aBag) + { + System.out.println("The bag contains " + aBag.getCurrentSize() + + " string(s), as follows:"); + Object[] bagArray = aBag.toArray(); + for (int index = 0; index < bagArray.length; index++) + { + System.out.print(bagArray[index] + " "); + } // end for + + System.out.println(); + } // end displayBag +} // end ArrayBagDemo +/* + Testing an initially empty bag: + Testing isEmpty with an empty bag: + isEmpty finds the bag empty: OK. + + + Testing the method getFrequencyOf: + In this bag, the count of B is 0 + + Testing the method contains: + Does this bag contain B? false + + Removing a string from the bag: + remove() returns null + The bag contains 0 string(s), as follows: + + + Removing "B" from the bag: + remove("B") returns false + The bag contains 0 string(s), as follows: + + Adding 6 strings to an initially empty bag with the capacity to hold more than 6 strings: + Adding A A B A C A + The bag contains 6 string(s), as follows: + A A B A C A + Testing isEmpty with a bag that is not empty: + isEmpty finds the bag not empty: OK. + + + Testing the method getFrequencyOf: + In this bag, the count of A is 4 + In this bag, the count of B is 1 + In this bag, the count of C is 1 + In this bag, the count of D is 0 + In this bag, the count of Z is 0 + + Testing the method contains: + Does this bag contain A? true + Does this bag contain B? true + Does this bag contain C? true + Does this bag contain D? false + Does this bag contain Z? false + + Removing a string from the bag: + remove() returns A + The bag contains 5 string(s), as follows: + A A B A C + + Removing "B" from the bag: + remove("B") returns true + The bag contains 4 string(s), as follows: + A A C A + + Removing "A" from the bag: + remove("A") returns true + The bag contains 3 string(s), as follows: + A A C + + Removing "C" from the bag: + remove("C") returns true + The bag contains 2 string(s), as follows: + A A + + Removing "Z" from the bag: + remove("Z") returns false + The bag contains 2 string(s), as follows: + A A + + Clearing the bag: + Testing isEmpty with an empty bag: + isEmpty finds the bag empty: OK. + + The bag contains 0 string(s), as follows: + + + Testing an initially empty bag that will be filled to capacity: + Adding A B A C B C D + The bag contains 7 string(s), as follows: + A B A C B C D + Try to add another string to the full bag: + The method add cannot add another string: OK + */ + /* + Exception in thread "main" java.lang.SecurityException: Attempt to create a bag whose capacity exceeds 3 + at ArrayBag.(ArrayBag.java:38) + at ArrayBagDemo.main(ArrayBagDemo.java:12) + +*/ diff --git a/DataLabs/lab3/BagInterface.class b/DataLabs/lab3/BagInterface.class new file mode 100644 index 0000000000000000000000000000000000000000..6e4b165ae50881b3291e8b51279b146e48add26a GIT binary patch literal 524 zcmZ`#%TB^T6g`8|0wRJ^-ybmD$lh0?MiLSe77!P@8q3g>lqn8V68tn5et;ikyiAiu zscvTGo^$U#XU^x>`v-t4oVqA6)Ne)DQ%35s2&9WmhUP>pL?;$1?DStIGB6B{P@20` zYpKj2dXo$r-0v~C(focoGfP`P(J4kF29H0iZ@BP@tq!7436pA?cldBo^_Dpj!TkN?pmhnWsNDnX)*h}4{1o8(4oL9RXSKmR4_ z5N=iZH)-EdcuA)Z#7O^GN o3ExH|uXk+yn{T3J=XSA|_qD0dTidgbgPcF4-I>A>j;+$kH=iPG8vp +{ + /** Gets the current number of entries in this bag. + @return The integer number of entries currently in the bag. */ + public int getCurrentSize(); + + /** Sees whether this bag is empty. + @return True if the bag is empty, or false if not. */ + public boolean isEmpty(); + + /** Adds a new entry to this bag. + @param newEntry The object to be added as a new entry. + @return True if the addition is successful, or false if not. */ + public boolean add(T newEntry); + + /** Removes one unspecified entry from this bag, if possible. + @return Either the removed entry, if the removal. + was successful, or null. */ + public T remove(); + + /** Removes one occurrence of a given entry from this bag. + @param anEntry The entry to be removed. + @return True if the removal was successful, or false if not. */ + public boolean remove(T anEntry); + + /** Removes all entries from this bag. */ + public void clear(); + + /** Counts the number of times a given entry appears in this bag. + @param anEntry The entry to be counted. + @return The number of times anEntry appears in the bag. */ + public int getFrequencyOf(T anEntry); + + /** Tests whether this bag contains a given entry. + @param anEntry The entry to locate. + @return True if the bag contains anEntry, or false if not. */ + public boolean contains(T anEntry); + + /** Retrieves all entries that are in this bag. + @return A newly allocated array of all the entries in the bag. + Note: If the bag is empty, the returned array is empty. */ + public T[] toArray(); +} // end BagInterface diff --git a/Example.java b/Example.java new file mode 100644 index 0000000..7b19fa2 --- /dev/null +++ b/Example.java @@ -0,0 +1,9 @@ +public class Example +{ + public static void displayArray(T[] anArray) { + for (T arrayEntrey : anArray) { + System.out.print(arrayEntry); + System.out.print(" "); + } + } +} diff --git a/assignments/AssigmentS3/StorageBox.class b/assignments/AssigmentS3/StorageBox.class new file mode 100644 index 0000000000000000000000000000000000000000..0c62336a8fbf4dba5786bb796b584ab9886a1b2f GIT binary patch literal 1658 zcmaKtT~ixX7{~u733+2F5NHvibSac3K^w)^7lLSsV$ncrlfiL%;~_bvTQ<9y-3=pN zc;$z1ymGwpwsnfmFry#9&(TlOan%3WEKMkk!*I^o=bYzxe$W5B?qv}} zJcWdTAtVLH9?1h)wxzRIzO(yCH3NaM>ehCP(WQxEf`c`SfxPcrd1ct0YwS9q!`?Z(zRWi7UODRklcm>m^ zfa-@n-N@l~iFL8(YPsdRp5+Afz*DkaNh2?i>r~nq>#iI4fhRj#DtPF&{Lv(CWwDNG3LooD`b1!%f4VH^z};8n-d^_hZ9_JB zdU;xZ7~HXFVK3-y>9lO+FVtLjzuTz{U`B^xz;ep5aoADkEI;SG4=NXhs7l+eTY=(f z{*+swl{2|hsitV+iWk<3E;D&pBw&NK$f;)&fdUHhS0&BFg9Q z>AbIhFT^kZKI@Co(|wT$*C;~)^X!W#g$Xl={f(@6PL@QJc$L2(TE{g~fqKR95g|6h T_IB8Qh8kzGv~J-JzQFW<;B|B0 literal 0 HcmV?d00001 diff --git a/assignments/AssigmentS3/StorageBox.java b/assignments/AssigmentS3/StorageBox.java new file mode 100644 index 0000000..91b2e8c --- /dev/null +++ b/assignments/AssigmentS3/StorageBox.java @@ -0,0 +1,44 @@ +public class StorageBox { + + private T[] items; + private int size; + private int capacity; + +public StorageBox(int capacity) { + this.capacity = capacity; + this.size = 0; + this.items = (T[]) new Object[capacity]; +} + +public void addItem(T item) { + if(capacity == size) { + System.out.println("StorageBox is full"); + return; + } else { + items[size] = item; + size++; + System.out.println("Item added: "+ item); + } +} + +public T removeItem() { + if(size == 0) { + System.out.println("No more item left!"); + return null; + } else { + T temp = items[size - 1]; + items[size - 1] = null; + size--; + System.out.println("Removed Item: "+ temp); + return temp; + } +} + +public void listItem() { + System.out.println("Items in StorageBox: "); + for(int i = 0; i < size; i++) { + System.out.print(items[i]+ " "); + } +} + +} diff --git a/assignments/AssigmentS3/demo.java b/assignments/AssigmentS3/demo.java new file mode 100644 index 0000000..ced5c12 --- /dev/null +++ b/assignments/AssigmentS3/demo.java @@ -0,0 +1,36 @@ +public class demo { + public static void main(String[] args) { + StorageBox box = new StorageBox<>(3); + StorageBox box1 = new StorageBox<>(3); + + box.addItem("Math"); + box.addItem("Java"); + box.addItem("Statistics"); + box.addItem("capacityTest"); + + System.out.println(); + + box.listItem(); + + System.out.println(" "); + System.out.println(); + + box.removeItem(); + box.removeItem(); + box.removeItem(); + box.removeItem(); + box.removeItem(); + box.removeItem(); + + System.out.println();; + + box.listItem(); + + box1.addItem(1); + box1.addItem(2); + box1.addItem(3); + box1.addItem(4); + + box1.listItem(); + } +} diff --git a/assignments/AssigmentS4/AList.class b/assignments/AssigmentS4/AList.class new file mode 100644 index 0000000000000000000000000000000000000000..b49f2de946475e4d03dd91dbcfa36bc78b87f5a6 GIT binary patch literal 3316 zcmaJ@+fy6&89gg4NXPJ9~MTf+0%`RKnl?k(K zW()4B>^c<1VH_b?ku)@P-ko|8VOW+Oi=qqN8rtnzY0;|8EKS;OrC?PFkQRWRD0+oo zrvgaV8JKRtv1R^v6o$;VS$4HnvFZ$D>SPqBgj={|u2{Dnrxe0z4X1W!r0tybXr|`Q zEM0MGcCI@4C~K7^a2S0WUb$9yVA)35sZzCL8_tqp=5l>i!?qq87Fn(ug{tAyT$x!^ z0nSD6GLn+fl!n8J2E`eQvh%}|b`1kjoE2g%6|3Ytu&$ZqFa|aBr;9}^Zx(kT^NNA% z7~Vp|DO(k#oIn~bL@|U{G=vJ($x_)}RTWcJc`b_9@f}v&+b3Mo$p$uFg@?nqNHYHq zwOll_Rs(Dp!y3+h`;NTjO8r(FwusM0qZq@R%ad5m+F;}^-IqQ^HXO=W16Z`lno!nn^hgQxgnU4ykT1k9x;XMB$xQb*5QySts zxEU*3tMF_zVBVw-bxI9K9Xaun?YKt6IWx)?DSC006~7@t-{x79gPpcrtFpxE&_?}(Zdu#IQ_&ZaxA54tj8lOnd&U4p|%cIV7u%?h$pbZLlAkH5FQ zhGTs(hL~`2jMP3=u&tZwP|li*MUJ#GXW5l$v+TbIc^tl_lyfXqf=rTpIFd;3wVq6b z5@~-)GwrE(H)V^KS>aU0Qr6SZx9{$~0htCboQe~!8 zngv_DrUcw!UYwIErICNjb(p_f>>vSYpM1W}N(GSNk9|@-vl;W=jamLQyrahE`223e`+GRZId*nl=egn( z_iMa|Qn9X01fTIy!yR5DoB$U$vyaP$W`DzvIW8u-klN&?;OB_OV_i?t66+dSM>rMV zKrF5={2k%x)WGNHlodx)I+sc4fC`;raNrPhMA1Sm?KnzJqN0~dU&0w2M?bswdA{A{ z$~FYHxF8UMMyfiAd=Kw4mhituGD7rtY6J1qa{@lcQGKC5lbTl#g1&*5c61$~7O)%Z zIE@&gy3t3-grCmutKc8_!9QYf(K;c)z4TKjN;|3i2Kui^^Zv?y;v&^X%Sb6X%cc5k2CFMMv3 zb#AZujLs@DL(}T@sYkG1#)P`&bIdU>1D`2+=Y$@yyxMr|E|T3P7JnGWFhX{tOxBwi z#ARG$D;~y#Vs`+6uW&kq@RzKPXGfD97q`td#-OYi4w2*e$7oLpg$=y=?)uh$cM{U3 za(o>jq?wQ#Dzwg>;=3$zzTO3{(j{?qy>VZ!=<19Q-Bh=M%vn#>8@p6>)4sq>2AH9$ zTU7NnJ$9S^npJQ?XeWFH7EzbBvphpovDe8uYKM;+@lZXmOS`~26wi5H?-1-R!QQWf z9BW8Z9?QP8ywsT>Ndb`*@$^guM|&fc zhZ1aFDw$45M!(Q=BN8S41l>*X<Yc|X|!3Ki})40 wjo7pcu}2VlpVkrUxPnM;?Lqt_gZ+t!&xrVEB0eMH^ZgJ#YdiFz9F6<`1ED92_W%F@ literal 0 HcmV?d00001 diff --git a/assignments/AssigmentS4/AList.java b/assignments/AssigmentS4/AList.java new file mode 100644 index 0000000..3181601 --- /dev/null +++ b/assignments/AssigmentS4/AList.java @@ -0,0 +1,181 @@ +import java.util.Arrays; + +/** + * A class that implements a list of objects by using an array. + * Entries in a list have positions that begin with 1. + * Duplicate entries are allowed. + * @author Frank M. Carrano + */ +public class AList implements ListInterface { + private T[] list; // Array of list entries; ignore list[0] + private int numberOfEntries; + private boolean initialized = false; + private static final int DEFAULT_CAPACITY = 25; + private static final int MAX_CAPACITY = 10000; + + public AList() { + this(DEFAULT_CAPACITY); // Call next constructor + } // end default constructor + + public AList(int initialCapacity) { + // Is initialCapacity too small? + if (initialCapacity < DEFAULT_CAPACITY) + initialCapacity = DEFAULT_CAPACITY; + else // Is initialCapacity too big? + checkCapacity(initialCapacity); + + // The cast is safe because the new array contains null entries + @SuppressWarnings("unchecked") + T[] tempList = (T[]) new Object[initialCapacity + 1]; + list = tempList; + numberOfEntries = 0; + initialized = true; + } // end constructor + + public void add(T newEntry) { + checkInitialization(); + list[numberOfEntries + 1] = newEntry; + numberOfEntries++; + ensureCapacity(); + } // end add + + public void add(int newPosition, T newEntry) { + checkInitialization(); + if ((newPosition >= 1) && (newPosition <= numberOfEntries + 1)) { + if (newPosition <= numberOfEntries) { + makeRoom(newPosition); + } + list[newPosition] = newEntry; + numberOfEntries++; + ensureCapacity(); + } else { + throw new IndexOutOfBoundsException("Given position of add's new entry is out of bounds."); + } + } // end add + + public T remove(int givenPosition) { + checkInitialization(); + if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) { + T result = list[givenPosition]; + if (givenPosition < numberOfEntries) { + removeGap(givenPosition); + } + list[numberOfEntries] = null; + numberOfEntries--; + return result; + } else { + throw new IndexOutOfBoundsException("Illegal position given to remove operation."); + } + } // end remove + + public void clear() { + while (!isEmpty()) { + remove(numberOfEntries); + } + } // end clear + + public T replace(int givenPosition, T newEntry) { + checkInitialization(); + if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) { + T originalEntry = list[givenPosition]; + list[givenPosition] = newEntry; + return originalEntry; + } else { + throw new IndexOutOfBoundsException("Illegal position given to replace operation."); + } + } // end replace + + public T getEntry(int givenPosition) { + checkInitialization(); + if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) { + return list[givenPosition]; + } else { + throw new IndexOutOfBoundsException("Illegal position given to getEntry operation."); + } + } // end getEntry + + public T[] toArray() { + checkInitialization(); + + // The cast is safe because the new array contains null entries + @SuppressWarnings("unchecked") + T[] result = (T[]) new Object[numberOfEntries]; + for (int index = 0; index < numberOfEntries; index++) { + result[index] = list[index + 1]; + } // end for + + return result; + } // end toArray + + public boolean contains(T anEntry) { + checkInitialization(); + boolean found = false; + int index = 1; + while (!found && (index <= numberOfEntries)) { + if (anEntry.equals(list[index])) { + found = true; + } + index++; + } // end while + return found; + } // end contains + + public int getLength() { + return numberOfEntries; + } // end getLength + + public boolean isEmpty() { + return numberOfEntries == 0; // Or getLength() == 0 + } // end isEmpty + + // Doubles the capacity of the array list if it is full. + // Precondition: checkInitialization has been called. + private void ensureCapacity() { + int capacity = list.length - 1; + if (numberOfEntries >= capacity) { + int newCapacity = 2 * capacity; + checkCapacity(newCapacity); // Is capacity too big? + list = Arrays.copyOf(list, newCapacity + 1); + } // end if + } // end ensureCapacity + + // Throws an exception if the client requests a capacity that is too large. + private void checkCapacity(int capacity) { + if (capacity > MAX_CAPACITY) + throw new IllegalStateException("Attempt to create a list whose capacity exceeds " + + "allowed maximum of " + MAX_CAPACITY); + } // end checkCapacity + + // Throws an exception if receiving object is not initialized. + private void checkInitialization() { + if (!initialized) + throw new SecurityException("AList object is not initialized properly."); + } // end checkInitialization + + // Makes room for a new entry at newPosition. + // Precondition: 1 <= newPosition <= numberOfEntries + 1; + // numberOfEntries is list's length before addition; + // checkInitialization has been called. + private void makeRoom(int newPosition) { + int newIndex = newPosition; + int lastIndex = numberOfEntries; + + for (int index = lastIndex; index >= newIndex; index--) { + list[index + 1] = list[index]; + } + } // end makeRoom + + // Shifts entries that are beyond the entry to be removed to the + // next lower position. + // Precondition: 1 <= givenPosition < numberOfEntries; + // numberOfEntries is list's length before removal; + // checkInitialization has been called. + private void removeGap(int givenPosition) { + int removedIndex = givenPosition; + int lastIndex = numberOfEntries; + + for (int index = removedIndex; index < lastIndex; index++) { + list[index] = list[index + 1]; + } + } // end removeGap +} // end AList \ No newline at end of file diff --git a/assignments/AssigmentS4/ListClient.java b/assignments/AssigmentS4/ListClient.java new file mode 100644 index 0000000..994f421 --- /dev/null +++ b/assignments/AssigmentS4/ListClient.java @@ -0,0 +1,26 @@ +import java.util.Arrays; + +public class ListClient { + public static void main(String[] args) { + // Create an instance of AList + AList list = new AList<>(); + + // Test isEmpty() on a new list + System.out.println("Is the list empty? " + list.isEmpty()); // Expected: true + + // Test add(T newEntry) + list.add("Apple"); + list.add("Banana"); + list.add("Cherry"); + System.out.println("After adding 3 items: " + Arrays.toString(list.toArray())); // Expected: [Apple, Banana, Cherry] + + list.add(2, "Peach"); + System.out.println(list.getEntry(2)); + System.out.println("New List: "+ Arrays.toString(list.toArray())); + list.remove(2); + System.out.println("New List: "+ Arrays.toString(list.toArray())); + System.out.println("Changed item:"+list.replace(2, "Orange")); + System.out.println("New List: "+ Arrays.toString(list.toArray())); + System.out.println(list.contains("Apple")); + } +} \ No newline at end of file diff --git a/assignments/AssigmentS4/ListInterface.class b/assignments/AssigmentS4/ListInterface.class new file mode 100644 index 0000000000000000000000000000000000000000..b10edee02fb31a50f77cb8da36ecc5e382a7a32a GIT binary patch literal 632 zcmZ`$%TB^T6g`8|QWPI(@h!S?x{bGg&*KY8E*$| zBGlcSd(S=R-Z`IN?;ilJacZN)Q0qiv?I&8Q7ZFGs%M2R>F%_*?Bw_3Rc_0JLuq66@ z2A6l{TbJGggVT+|MCgf<3>NS8OtHcJVz$lwABv^qFrCtn%YAQ=oQe4!aT&@%EQO*y zc;;s-If`jphOpe8l7L z@$_)Wp(B$}znYzWGK$9S;YgDa-9QX})w@`EimIyw0;cECy1g zOo1xJSB6E{CR9SjU?;~}e+8>Kt`T0tI!x@?%?tF<2}OrI50Yg OI5OU|4UW+?=;Ry6@rGRh literal 0 HcmV?d00001 diff --git a/assignments/AssigmentS4/ListInterface.java b/assignments/AssigmentS4/ListInterface.java new file mode 100644 index 0000000..4fe9af3 --- /dev/null +++ b/assignments/AssigmentS4/ListInterface.java @@ -0,0 +1,70 @@ +public interface ListInterface { + /** + * Adds a new entry to the end of the list. + * @param newEntry The object to be added as a new entry. + */ + void add(T newEntry); + + /** + * Adds a new entry at a specified position within the list. + * @param newPosition An integer that specifies the desired position of the new entry. + * @param newEntry The object to be added as a new entry. + * @throws IndexOutOfBoundsException if newPosition is out of bounds. + */ + void add(int newPosition, T newEntry); + + /** + * Removes the entry at a given position from the list. + * @param givenPosition An integer that indicates the position of the entry to be removed. + * @return A reference to the removed entry. + * @throws IndexOutOfBoundsException if givenPosition is out of bounds. + */ + T remove(int givenPosition); + + /** + * Removes all entries from the list. + */ + void clear(); + + /** + * Replaces the entry at a given position in the list. + * @param givenPosition An integer that indicates the position of the entry to be replaced. + * @param newEntry The object that will replace the entry at the given position. + * @return The original entry that was replaced. + * @throws IndexOutOfBoundsException if givenPosition is out of bounds. + */ + T replace(int givenPosition, T newEntry); + + /** + * Retrieves the entry at a given position in the list. + * @param givenPosition An integer that indicates the position of the desired entry. + * @return A reference to the indicated entry. + * @throws IndexOutOfBoundsException if givenPosition is out of bounds. + */ + T getEntry(int givenPosition); + + /** + * Retrieves all entries that are in this list in the order in which they occur in the list. + * @return An array of all the entries in the list. + */ + T[] toArray(); + + /** + * Determines whether the list contains a given entry. + * @param anEntry The object that is the desired entry. + * @return True if the list contains anEntry, or false if not. + */ + boolean contains(T anEntry); + + /** + * Gets the length of this list. + * @return The integer number of entries currently in the list. + */ + int getLength(); + + /** + * Determines whether this list is empty. + * @return True if the list is empty, or false if not. + */ + boolean isEmpty(); +} \ No newline at end of file