kaltinsoy/java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

assignments

Browse Source
This commit is contained in:
k0rrluna 2025-04-09 02:32:02 +03:00
parent ec083c6254
commit f0b5074ac7
14 changed files with 798 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
DataLabs/lab3/ArrayBag.class Normal file
View File

Binary file not shown.

143
DataLabs/lab3/ArrayBag.java Normal file
View File

@ -0,0 +1,143 @@
public class ArrayBag<T> implements BagInterface<T> {
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<T> union(ArrayBag<T> otherBag) {
ArrayBag<T> 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<T> intersection(ArrayBag<T> otherBag) {
ArrayBag<T> 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;
}
}

241
DataLabs/lab3/ArrayBagDemo.java Normal file
View File

@ -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<String> 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<String>(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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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.<init>(ArrayBag.java:38)
at ArrayBagDemo.main(ArrayBagDemo.java:12)
*/

BIN
DataLabs/lab3/BagInterface.class Normal file
View File

Binary file not shown.

48
DataLabs/lab3/BagInterface.java Normal file
View File

@ -0,0 +1,48 @@
/**
An interface that describes the operations of a bag of objects.
@author Frank M. Carrano
@version 4.0
*/
public interface BagInterface<T>
{
/** 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

9
Example.java Normal file
View File

@ -0,0 +1,9 @@
public class Example
{
public static <T> void displayArray(T[] anArray) {
for (T arrayEntrey : anArray) {
System.out.print(arrayEntry);
System.out.print(" ");
}
}
}

BIN
assignments/AssigmentS3/StorageBox.class Normal file
View File

Binary file not shown.

44
assignments/AssigmentS3/StorageBox.java Normal file
View File

@ -0,0 +1,44 @@
public class StorageBox<T> {
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]+ " ");
}
}
}

36
assignments/AssigmentS3/demo.java Normal file
View File

@ -0,0 +1,36 @@
public class demo {
public static void main(String[] args) {
StorageBox<String> box = new StorageBox<>(3);
StorageBox<Integer> 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();
}
}

BIN
assignments/AssigmentS4/AList.class Normal file
View File

Binary file not shown.

181
assignments/AssigmentS4/AList.java Normal file
View File

@ -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<T> implements ListInterface<T> {
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

26
assignments/AssigmentS4/ListClient.java Normal file
View File

@ -0,0 +1,26 @@
import java.util.Arrays;
public class ListClient {
public static void main(String[] args) {
// Create an instance of AList
AList<String> 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"));
}
}

BIN
assignments/AssigmentS4/ListInterface.class Normal file
View File

Binary file not shown.

70
assignments/AssigmentS4/ListInterface.java Normal file
View File

@ -0,0 +1,70 @@
public interface ListInterface<T> {
/**
* 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();
}