Implementing Java Classes for Efficient Car Park Management
Introduction
The problem of Sussex car park mainly focuses on increasing process smoothness and has been applied through better Java implementation. The building's front entry leads to the parking lot, and a road surrounds it that prohibits passing vehicles or turning around. Now, whenever a car approaches the structure, it parks as far away as it can and pulls into the next slot. All the vehicles that are obstructing a car's exit must leave the parking lot and line up on the road. Following the departure of the departing vehicle, the remaining vehicles enter the parking lot in the same sequence as they departed. A Java class d ‘SussexCarPark’ has been used to implement the simulation.
There has been the creation of 7 classes within this, these are ‘CarPark’, ‘CircularArrayQueue’, ‘LinkedListStack’, ‘Queue’, ‘Stack’, ‘SussexCarPark’ (contains main class), and Tests. It is evident from the above figure after running tests, none of the classes has any errors (Higo et al. 2022). Thus, it is also evident that the creation of classes has been successful for the project.
Methods applied
import java.util.LinkedList;
import java.util.Queue;
public class CarPark{
private Queue<String> carQueue; // to store the car owners
public CarPark() {
carQueue = new LinkedList<>();
}
public int arrive(String carOwner) {
carQueue.add(carOwner); // add car owner to the queue
return carQueue.size(); // return the number of cars in the queue
}
public String leave(String carOwner) {
String result = "Alice"; // initialize result string
// check if the car owner is in the queue
if (!carQueue.contains(carOwner)) {
System.out.println(carOwner + " is not in the car park.");
return null;
}
// remove cars from the front of the queue until the car owner is reached
while (!carQueue.peek().equals(carOwner)) {
result += carQueue.poll() + "-"; // add car owner to the result string
}
carQueue.remove(); // remove the car owner from the queue
return result;
}
}
Grab the best Academic Assistance in just one click
Arrive (String carOwner): This ‘arrive’ method which is implemented here effectively adds a new car owner to the end of the queue. Moreover, it also returns the ‘new size’ of the queue.
Leave (String carOwner): This system eliminates the given car owner from the queue and returns a string that includes the s of the car owners who have been pushed to the front of the line up to the time the given car owner is reached. The procedure returns null if the specified owner of the car cannot be identified in the queue.
It can be seen from the above mentioned that the ‘Queue’ interface which is applied as a method, provides a ‘LinkedList’ implementation of a ‘queue’. It should be mentioned that the ‘Queue’ interface determines methods like “add(), remove(), and peek()” in terms of adding, removing, or getting the first element of the queue respectively. Thus, it is evident from this that method has been applied effectively (Rani et al. 2021). The ‘add ()’ method is employed in the ‘arrive ()’ method to add a new automobile owner to the end of the queue. The queue's current size is returned via the ‘size ()’ method. The ‘contains ()’ method is used in the ‘leave ()’ method to determine whether the specified automobile owner is ahead of the line. The method prints a message and returns null if the owner of the car cannot be located.
import java.util.LinkedList;
// SussexCarPark which extends a CarPark class
public class SussexCarPark extends CarPark {
//private instance variable cars which is a LinkedList of Strings
private LinkedList<String> cars = new LinkedList<>();
The class ‘SussexCarPark’, which extends the ‘CarPark’ class, is defined which can be seen from the above Java code snippets. ‘cars’, a LinkedList of Strings is also a ‘private instance variable’ (Higo et al. 2020). The arrival function uses the ‘addLast’ method to add the String parameter ‘carOwner’ to the end of the LinkedList. The LinkedList's new size is then returned. On the other hand, the ‘indexOf’ method is used by the leave method to locate the String parameter ‘carOwner’ in the LinkedList. It returns null if the ‘carOwner’ cannot be located (Ogala and Ojie, 2020). In case it's not, then it uses the remove function to remove the ‘carOwner’ from the linked list and produces a string that contains a list of all the cars parked before the one being removed, each car's separated by a dash. The ‘main function’ creates a ‘SussexCarPark’ instance, which uses the ‘arrive’ method to add three vehicles, and the ‘leave’ method to take away two of them from the parking lot. Finally, the values returned by the leave method are then printed. The below figure is suggesting on the successful completion of the main class and the resulting output.
* Returns the item at the front of the queue without removing it
* @return
*/
@Override
public String front() {
String item = null;
if (size != 0) {
item = arrayQueue[front];
}
return item;
}
/**
* Returns the number of items in the queue
* @return
*/
@Override
public int size() {
return size;
}
/**
* Returns true if the queue is empty
* @return
*/
@Override
public boolean isEmpty() {
return size == 0;
}
/**
* Prints the contents of the queue
*/
@Override
public void printAll() {
if (size > 0) {
int i = front;
do {
System.out.print(arrayQueue[i] + " ");
i = ++i % maxSize;
} while (i != rear);
System.out.println();
} else {
System.out.println("Queue empty");
}
}
}
Class ‘CircularArrayQueue’
The above mentioned is suggesting on the circular array class which effectively implements Queue. The above code essentially defines a “Java class” by the of “CircularArrayQueue” which implements the “Queue” interface. This is the generic implementation regarding the “queue” data structure utilizing an “array” with the circular buffer for storing the elements.
The class contains “private” instance variables “arrayQueue”, “maxSize”, “size”, “rear”, and “front” respectively. The “aeeayQueue” refers to the array which holds the concerned elements of the “queue”. The “size’ is the maximum quantity of the elements within the queue. The “maxSize” if the most quantity of the elements which can be stored in particular. The “front” is also the index regarding the very first element within the queue, whereas the rear pertains to the index of the very last element inside the queue.
The constructor d “class” initializes the size, arrayQueue, maxSize instance variables to the values specified. The sets front as well as reas to zero showcases the very beginning of the concerned queue. The method d “front” returns all of the elements at the very front of the “queue” without even removing them. Essentially it returns the null when the queue stays empty. The method d “size” returns the present quantity of the elements within the queue. Moreover, the method called “isEmpty” returns the Boolean values which indicates whether that queue stays empty or not in particular.
The “printAll” method essentially prints all of the elements pertaining to the “queue” inside the order in which they are added into the queue. When the underlying size of that “queue” is zero, then this method prints the message that represents the fact that the “queue” is empty.
Data structures justification to showcase the car park and road
The “circular array queue” data structure has been selected for showcasing the car park and the road. The sole reason is that it permits the effective insertion as well as deletion of the elements in a “FIFO” manner, which turns out to be an ideal to simulate the vehicles entering as well as leaving the car park. This circular nature enables the efficient usage of space along with preventing the wastage of the memory for that matter. Moreover, this has got a fixed size that limits the very number of all the vehicles which can easily be simulated in this regard. Furthermore, the resizing of the queues might turn out to be very expensive when the factors of memory and time are taken into account.
Advantages of Linked List for the Stack ADT
A primary advantage in utilizing the “Linked List” as a concrete “data structure” for the “Stack ADT” is its very dynamic nature. The “Linked Lists” can easily shrink or grow dynamically on the basis of the amount of the elements they contain, enabling the efficient usage of memory. Furthermore, the “Linked Lists” permits for the constant “time insertion” along with deletion of the elements form the very top of the “stack”. This in turn makes it extremely suitable for the applications which need frequent push as well as pop operations.
One limitations when it comes to the “Linked Lists” is that these need an extra amount of memory for storing the pointers towards that very next element, which makes it less “memory” efficient in comparison to the arrays. The accessing of the elements at a particular index within a ‘Linked Lists” requires iteration all throughout the lists from the very beginning. This in turn can be much slower than the direct access rendered by the arrays.
import java.util.LinkedList;
import java.util.ListIterator;
public class LinkedListStack <T> implements Stack<T>{
private LinkedList<T> stack;
private int size;
public LinkedListStack() {
stack = new LinkedList<>();
size = 0;
}
@Override
public T peek() {
return stack.peekFirst();
}
@Override
public T pop() {
T t = stack.removeFirst();
size--;
return t;
}
@Override
public void push(T t) {
stack.addFirst(t);
size++;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public int size() {
return size;
}
@Override
public void printAll() {
// Setting the ListIterator
ListIterator listIter = stack.listIterator();
// Iterating through the created list from the position
while(listIter.hasNext()){
System.out.println(listIter.next());
}
}
}
Class ‘LinkedListStack.class’
This is explained all above in the class ‘’LinkedListStack’and it can be seen implementing Stack.
public interface Queue {
/**
* Adds an object to the back of the queue
* @param data
*/
public void enqueue(String data);
/**
* Removes an object from the front of the queue
* @return
*/
public String dequeue();
/**
* Returns the item at the front of the queue without removing it
* @return
*/
public String front();
/**
* Returns the number of items in the queue
* @return
*/
public int size();
/**
* Returns true if the queue is empty
* @return
*/
public boolean isEmpty();
/**
* Prints the contents of the queue
*/
public void printAll();
}
Class ‘Queue.class’
This is suggested in the above of the Queue class that uses public interface as ‘Queue’.
public interface Stack<T> {
public T peek();
public T pop();
public void push(T t);
public boolean isEmpty();
public int size();
public void printAll();
}
Class ‘Stack.class’
It can be viewed from the above mentioned that Class Stack has been implemented.
public class Tests {
private static final String[] owners = {"Anne", "Bob", "Chen", "Diego"};
/**
* Adds one owner to the car park
* @return true if arrive returns 1
*/
public static boolean testOne() {
SussexCarPark sussexCarPark = new SussexCarPark();
return sussexCarPark.arrive(owners[0]) == 1;
}
/**
* Adds and then removes one owner to the car park
* @return empty String as car park is empty
*/
public static boolean testTwo() {
SussexCarPark sussexCarPark = new SussexCarPark();
sussexCarPark.arrive(owners[0]);
return sussexCarPark.leave(owners[0]).isEmpty();
}
/**
* The first car in the car park leaves
* @return true if String is "Chen-Bob-"
*/
public static boolean testThree() {
SussexCarPark sussexCarPark = new SussexCarPark();
Finally, the above is explaining that 11 tests have been completed. The result should be viewed as either true or false statement.
Result and tests
Figure 9: 11 tests run and obtained results
The above figure is suggesting that all the predetermined tests have been successfully passed, thereby complying with the methods. It is evident from the figure that all the tests have run successfully defining the effectiveness of the system.
Conclusion
It can be said from the entire project that the successful completion of each of the scopes has been done with the correct Java methodologies.
References
Higo, Y., Hayashi, S. and Kusumoto, S., 2020. On tracking Java methods with Git mechanisms. Journal of Systems and Software, 165, p.110571.
Higo, Y., Matsumoto, S., Kusumoto, S. and Yasuda, K., 2022, May. Constructing dataset of functionally equivalent Java methods using automated test generation techniques. In Proceedings of the 19th International Conference on Mining Software Repositories (pp. 682-686).
Ogala, J.O. and Ojie, D.V., 2020. Comparative analysis of c, c++, c# and java programming languages. GSJ, 8(5), pp.1899-1913.
Rani, P., Panichella, S., Leuenberger, M., Di Sorbo, A. and Nierstrasz, O., 2021. How to identify class comment types? A multi-language approach for class comment classification. Journal of Systems and Software, 181, p.111047.
Share this
Cite This Work
Go Through the Best and FREE Case Studies Written by Our Academic Experts!
