Parking Lot Design Java

One of the most prominent questions asked in a Java interview is the parking lot design in Java. Parking lot design in Java is a design problem that deals with how the vehicles are parked in a parking lot. It is mainly asked in the HLD or LLD (High Level or Low-Level Design) round of the top multinational companies such as Amazon, Google, Facebook, etc. Note that there is no right or wrong answer to this design problem. Therefore, such type of design problem requires a good discussion with the interviewer that what kind of parking design the interviewer wants. For example, one interviewer may want a parking lot to be of 5 floors, whereas another interviewer is fine with a single floor parking lot.

In this section, we will use the object-oriented paradigm of Java to design the parking lot. Before going through this section, readers are required to have a good understanding of the object-oriented principles of Java.

Designing the Parking lot

We are going to write the code for the parking lot as per the design described below.

The objects present in our design are the Vehicles, ParkingLot, Slots, and Levels.

ParkingLot: There are 'x' levels or floors and 'y' slots per floor.

Levels: Each level is an independent entity with a floor number, its slots and the lanes within it.

The number of lanes is designed on the basis of number of slots. In our case, 10 Slots comprise 1 lane.

Slots: One slot is independent of the other slot. The slot size matters for a vehicle to fill the slot. For example, a small slot cannot be filled by a large vehicle.

Vehicles: Object with the company name, vehicle number, and their type. A vehicle has the number plate and the properties of the company it is from.

We have considered the Slots and Levels as entities that are not dependent so that a level can be added by any number of slots later.

Whenever a vehicle goes out or comes in, the list of vehicles that represents the company of which the recent vehicle has left or come in is updated. Since a vehicle has entered or left, the number of available slots is also updated.

Methods:

parkVehicle(): The parkVehicle() method parks a vehicle accordingly, also take into consideration the company that has made the vehicle.

leaveOperation(): The operation exits a vehicle 'V' at a level 'x'.

companyParked(): The CompanyParked() method facilitates the user to observe the list of vehicles parked by a specific company.

Parking Lot Java Program

After accomplishing the design part, now we can write the code. The following program used the above-mentioned design to create a parking lot.

FileName: VSize.java

public enum VSize
{
    CarSize, Motorcycle,
}

FileName: Vehicle.java

// import statement
import java.util.ArrayList;

public abstract class Vehicle
{
// list of adding the slots that has been filled
protected ArrayList<ParkingSlot> parkingSlots = new ArrayList<ParkingSlot>();

// licence plate of the vehicle
protected String licPlate;

// field for the slot required by a vehicle
protected int slotsNeeded;

// size of the vehicle which is determined by the type of the vehicle
protected VSize siz;

// field of storing the company details from where the vehicle has come
// for example, if a car has come from Google, then companyName will be Google
protected String companyName;

// to get the slot required by a vehicle
public int getSlotsNeeded()
{
return slotsNeeded;
}

// the method adds the filled slot to the parkingSlots list
public void parkInSlot(ParkingSlot s)
{
parkingSlots.add(s);
}

// get the size of vehicle
public VSize getSize()
{
return siz;
}

public void clearSlots()
{
// remove car from slot, and notify the slot that the vehicle gone
for (int i = 0; i < parkingSlots.size(); i++)
{
parkingSlots.get(i).removeVehicle();
}
parkingSlots.clear();
}

// an abstract method that has to be defined by the child classess
public abstract boolean canFitInSlot(ParkingSlot spot);
}

FileName: Car.java

public class Car extends Vehicle
{
// constructor of the class Car
public Car(String licPlate, String companyName)
{
slotsNeeded = 1;
siz = VSize.CarSize;
this.licPlate = licPlate;
this.companyName = companyName;
}

public boolean canFitInSlot(ParkingSlot spot)
{
// checks if the spot is suitable for a car
return spot.getSize() == VSize.CarSize;
}
}

FileName: Motorcycle.java

public class Motorcycle extends Vehicle
{
// constructor of the class Motorcycle 
public Motorcycle(String licPlate, String companyName)
{
slotsNeeded = 1;
siz = VSize.Motorcycle;
this.licPlate = licPlate;
this.companyName = companyName;
}

public boolean canFitInSlot(ParkingSlot slot) 
{
// checks if the slot is a compact, motorcycle or a large

return slot.getSize() == VSize.CarSize || slot.getSize() == VSize.Motorcycle;
}
}

FileName: Lvl.java

// represents a level in the parking lot
public class Lvl
{
private int floor;
private ParkingSlot[] slots;	// number of slots in each level, including large, compact and motorcycle size
private int availableSlots = 0;	// number of free slots

// in each row at max there can be 10 slots
private static final int SLOT_PER_ROW = 10;

// constructor of the class Lvl
public Lvl(int flr, int numberSlots)
{
floor = flr;
availableSlots = numberSlots;
slots = new ParkingSlot[numberSlots];
int largeSlots = numberSlots / 4;
int bikeSlots = numberSlots / 4;
int compactSlots = numberSlots - largeSlots - bikeSlots;

for (int j = 0; j < numberSlots; j++)
{
VSize siz = VSize.Motorcycle;
if (j < largeSlots + compactSlots)
{
siz = VSize.CarSize;
}
int row = j / SLOT_PER_ROW;
slots[j] = new ParkingSlot(this, row, j, siz);
}
}

public int availableSlots()
{
return availableSlots;
}

public boolean parkVehicle(Vehicle vh)
{
//find a place to park this vehicle, return false if failed
if (availableSlots() < vh.getSlotsNeeded())
return false;

int slotNumber = findAvailableSlots(vh);
if (slotNumber < 0)
return false;
System.out.print(", Slot Number " + slotNumber);
return parkStartingAtSlot(slotNumber, vh);
}
private boolean parkStartingAtSlot(int num, Vehicle vh)
{
// park a vehicle at the slot slotNumber, and continuing till vehicle.slotsNeeded
vh.clearSlots();
boolean success = true;
for (int j = num; j < num + vh.slotsNeeded; j++)
{
success &= slots[j].park(vh);
}
availableSlots = availableSlots - vh.slotsNeeded;
return success;
}

// a method to find the vacant slot
private int findAvailableSlots(Vehicle vh)
{
int slotsNeeded = vh.getSlotsNeeded();
int lastRow = -1;
int slotsFound = 0;

for (int j = 0; j < slots.length; j++)
{
ParkingSlot spot = slots[j];
if (lastRow != slots[j].getLane())
{
slotsFound = 0;
lastRow = slots[j].getLane();
}
if (slots[j].canFitVehicle(vh))
{
slotsFound = slotsFound + 1;
}
else
{
slotsFound = 0;
}
if (slotsFound == slotsNeeded)
{
if(vh.siz == VSize.CarSize)
System.out.print("It is a Car parked in ");
else
System.out.print("It is a Motorcycle parked in ");
System.out.print("Lane Number  " + lastRow);
return j - (slotsNeeded - 1);
}
}
return -1;
}

// when the vehicle leaves the parking lot
// the numbyer of available slot increases by 1
public void slotFreed()
{
availableSlots = availableSlots + 1;
System.out.println("Available Slots in the current level :" + availableSlots);
}
}

FileName: ParkingSlot.java

public class ParkingSlot 
{
// fields of the class
private Vehicle vh;
private VSize siz;
private int lane;
private int slotNumber;
private Lvl l;

// constructor of the class
public ParkingSlot(Lvl lvl, int r, int num, VSize vs) 
{
l = lvl;
lane = r;
slotNumber = num;
siz = vs;
}


public boolean isAvailable() 
{
return vh == null;
}

public boolean canFitVehicle(Vehicle vh) 
{
//check if the spot is big enough and is available
return isAvailable() && vh.canFitInSlot(this);
}

public boolean park(Vehicle vObj) 
{
if (!canFitVehicle(vObj))
{
return false;
}

vh = vObj;
vh.parkInSlot(this);
return true;
}

// get method for lane
public int getLane() 
{
return lane;
}

// get method for slot number
public int getSlotNumber() 
{
return slotNumber;
}

// get method for getting the Size
public VSize getSize() 
{
return siz;
}

// method for removing the vehicle from the parking lot
public void removeVehicle() 
{
l.slotFreed();
vh = null;
}
}

FileName: ParkingLot.java

// important import statements
import java.util.ArrayList;
import java.util.*;
import java.util.HashMap;


// Creates a Parking Lot with the Number of levels and the slots in each of the given 
// levels.
public class ParkingLot
{
private Lvl[] lvls;
private final int NUM_LVLS = 2;
private int numberSlots;

// key contains the company name and 
// value is the vehicles present in the list
Map<String, ArrayList<String>> CompanytoVeh;

// constructor of the class
public ParkingLot(int numberSlots)
{
this.numberSlots = numberSlots;
this.CompanytoVeh = new HashMap<String, ArrayList<String>>();
lvls = new Lvl[NUM_LVLS];
for (int j = 0; j < NUM_LVLS; j++)
{
lvls[j] = new Lvl(j, numberSlots);
System.out.println("Level " + j + " created with " + numberSlots + " " +  "slots");
}
}

// a method for handling the scenario when a vehicle is parked
public boolean parkVehicle(Vehicle vh)
{
System.out.println(" ------------------------------------ ");

for (int i = 0; i < lvls.length; i++)
{
if (lvls[i].parkVehicle(vh)) 
{
System.out.println(" Level " + i + " with Vehicle Number " + vh.licPlate + " from " + vh.companyName);
if (this.CompanytoVeh.containsKey(vh.companyName)) 
{
ArrayList<String> regNoList = this.CompanytoVeh.get(vh.companyName);
this.CompanytoVeh.remove(vh.companyName);
regNoList.add(vh.licPlate);
this.CompanytoVeh.put(vh.companyName, regNoList);
} 
else 
{
ArrayList<String> regNoList = new ArrayList<String>();
regNoList.add(vh.licPlate);
this.CompanytoVeh.put(vh.companyName, regNoList);
}
return true;
}
}
System.out.println("PARKING IS FULL");
return false;
}

// method for handling the scenario when a vehicle leaves
public boolean leave(Vehicle vh, int lvl)
{
System.out.println(" ------------------------------------------ ");
lvls[lvl].slotFreed();
System.out.println("Slot freed from  Level " + lvl + " and exited  " + vh.licPlate + " of " + vh.companyName);
ArrayList<String> vhList = this.CompanytoVeh.get(vh.companyName);

// check if the vehicle is present in the list or not
// if present, remove the vehicle from the list
if (vhList.contains(vh.licPlate)) 
{
vhList.remove(vh.licPlate);
}

return true;
}

// method for displaying the list of vehicle of the given company
public void ComapnyParked(String companyName)
{
System.out.println(" ------------------------------------------ ");
ArrayList<String> vhList = this.CompanytoVeh.get(companyName);
System.out.print("The vehicles of " + companyName + " : ");
for(String vl : vhList)
{
System.out.print(vl + "\t");
}
System.out.println();
}
}

FileName: Main.java

public class Main 
{
// main mehtod
public static void main(String argvs[]) 
{
// creating an object of the class ParkingLot
ParkingLot pl = new ParkingLot(2);

// car1 has license number 1234 and the company name is Microsoft
Car car1 = new Car("1234", "Microsoft");

// m1 has license number 4016 and the company name is Microsoft
Motorcycle m1 = new Motorcycle("4016", "Microsoft");

// car2 has license number 1609 and the company name is Google
Car car2 = new Car("1609", "Google");

// m2 has license number 1389 and the company name is Google
Motorcycle m2 = new Motorcycle("1389", "Google");

// car3 has license number 1809 and the company name is Microsoft
Car car3 = new Car("1809", "Microsoft");

//  parking the vehicles
pl.parkVehicle(car1);
pl.parkVehicle(m1);
pl.parkVehicle(car2);

// for displaying the list of vehicles that has company name Microsoft
pl.ComapnyParked("Microsoft");

// for displaying the list of vehicles that has company name Google
pl.ComapnyParked("Google");

pl.leave(m1,0); // Note that m1 is from Microsoft


// for displaying the list of vehicles that has company name Microsoft
pl.ComapnyParked("Microsoft");


pl.parkVehicle(m2);
pl.parkVehicle(car3);


}
}

Output:

Level 0 created with 2 slots
Level 1 created with 2 slots
 ------------------------------------
It is a Car parked in Lane Number 0, Slot Number 0 Level 0 with Vehicle Number 1234 from Microsoft
 ------------------------------------
It is a Motorcycle parked in Lane Number 0, Slot Number 1 Level 0 with Vehicle Number 4016 from Microsoft
 ------------------------------------
It is a Car parked in Lane Number 0, Slot Number 0 Level 1 with Vehicle Number 1609 from Google
 ------------------------------------------
The vehicles of Microsoft: 1234        4016
 ------------------------------------------
The vehicles of Google: 1609
 ------------------------------------------
Available Slots in the current level :1
Slot freed from Level 0 and exited 4016 of Microsoft
 ------------------------------------------
The vehicles of Microsoft: 1234
 ------------------------------------
It is a Motorcycle parked in Lane Number 0, Slot Number 1 Level 1 with Vehicle Number 1389 from Google
 ------------------------------------
PARKING IS FULL

Next TopicBoyer Moore Java

← prev next →