airbnbSingleLinkedList

/*
 * Hailey Martin
 * Description:
 * This program will create two linked lists to hold
 * Airbnbs, the information for the Airbnbs will be read
 * from file. A single linked list will order the Airbnbs
 * by the number of guests. The double linked list will
 * order Airbnbs as they were read from file. The single
 * linked list will print linked list moving forward and
 * the doubly linked list will print backwards. Using a
 * priority queue, Airbnbs will be checked if they meet
 * the requirements(read from another file), and if they
 * do they will be then placed in the priority queue. 
 * Airbnbs will then be removed from single linked list 
 * if they are of a specific type. Last the single linked
 * list will print the list after removal of specific type
 * of Airbnbs
 */


import java.io.IOException;
import java.util.PriorityQueue;
import java.io.File;
import java.util.Scanner;




public class MartinHaileyAssignment9 {


public static void main(String[] args)throws IOException {
// TODO Auto-generated method stub
//fill single and double linked lists with airbnbs
// Name of files to read from
final String LINKEDLIST_FILE_NAME = "Airbnbs.txt";
final String REQUIREMENTS_FILE_NAME = "AirbnbRequirements.txt";


// Setup file reference variables to refer to each text file
File LinkedListFileName = new File(LINKEDLIST_FILE_NAME);
File RequirementsFileName = new File(REQUIREMENTS_FILE_NAME);
//create linked lists
AirbnbLinkedList singleLL = new AirbnbLinkedList();
DoubleLinkedList doubleLL = new DoubleLinkedList();
//fill Linked lists with file information 
Scanner linkedListFile = new Scanner (LinkedListFileName);
Scanner requirementsFile = new Scanner (RequirementsFileName);
while(linkedListFile.hasNext()){ 
// Read Airbnb information from the file into separate variables
int rate = linkedListFile.nextInt();
int numberGuests = linkedListFile.nextInt();
int numberBedrooms = linkedListFile.nextInt();
String airbnbType = linkedListFile.nextLine().trim();
// Create a Airbnb object
Airbnb airbnb = new Airbnb(rate, numberGuests, numberBedrooms,
airbnbType);
//add instance of Airbnb to single linked list
singleLL.addByGuests(airbnb); 
//add instance of airbnb
doubleLL.addToEnd(airbnb);
}//end while loop
//Priority queue of airbnbs that meet requirements
PriorityQueue<Airbnb> airbnbMeetsRequirements = new PriorityQueue<>();
while(requirementsFile.hasNext()) {
// Read requirements info from the file into separate variables
final int RATE = requirementsFile.nextInt();
final int NUMBER_GUESTS = requirementsFile.nextInt();
final String AIRBNB_TYPE = requirementsFile.nextLine().trim();
//find the airbnbs that meet these requirements
airbnbMeetsRequirements = singleLL.findAirbnb(RATE, 
NUMBER_GUESTS, AIRBNB_TYPE);
}//end while loop
System.out.println("Airbnbs in Single Linked List - Ordered "
+ "by Number of Guests\r\n");
//display single linked list ordered
singleLL.print();
//display double linked list backwards
System.out.println("Airbnbs in Doubly Linked List - Airbnbs Printed Backwards");
doubleLL.printBackwards();
//find airbnbs that meet requirements
System.out.println("Airbnbs in Priority Queue Meeting Parrot Requirements:\n");
System.out.println("Airbnbs Type \t\tNightly Rate \t\tGuests \t\tBedrooms\r\n"
+ "--------------------------------------------------------------");
//loop through priority queue to print, until queue is empty
while(!airbnbMeetsRequirements.isEmpty()) {
System.out.println(airbnbMeetsRequirements.remove().toString());
}


//remove airbnbs form single linked list
int numApartments = singleLL.removeSpecificType("Apartment");
int numCondos = singleLL.removeSpecificType("Condo");
System.out.printf("Airbnbs in Single Linked List - Apartments and "
+ "Condos Removed\nNumber apartments removed: %d\nNumber "
+ "condos removed: %d\n",numApartments,numCondos);
//display single linked list without apartments and condos
singleLL.print();
linkedListFile.close();
requirementsFile.close();
}//end main


}//end class



/*
 * Represents an Airbnb which could be a house,
 * apartment, condo, townhome, etc. Implement 
 * Comparable, so Airbnbs can be compared.
 */
class Airbnb implements Comparable<Airbnb>{
//Private Date fields
private int nightlyRate;
private int numGuests;
private int numBedrooms;
private String type;
//Public Methods
//Constructor
public Airbnb(int nightlyRate, int numGuests,
int numBedrooms,String type) {
//initializes all private data fields with 
//incoming values read from file
this.nightlyRate = nightlyRate;
this.numGuests = numGuests;
this.numBedrooms = numBedrooms;
this.type = type;
}
//Getters for private data fields
public int getNightlyRate() {
return nightlyRate;
}
public int getNumGuests() {
return numGuests;
}
public int getNumBedrooms() {
return numBedrooms;
}
public String getType() {
return type;
}
/*
* toString method returns formated string
*/
@Override
public String toString() {
//Returns a string that combines the Airbnb’s
//type, nightly rate, # guests, #bedrooms 
//in a nice format:
return String.format("\n%-10s\t\t %-10d\t\t "
+ "%-10d\t\t %-10d\n", 
type, nightlyRate, numGuests,numBedrooms);
}
/*
* Parameters: Airbnb otherAirbnb
* Return: and int based on otherAirbnb
*/
@Override
public int compareTo(Airbnb otherAirbnb) {
//Compares two Airbnbs based on the number of guests
//where a lower number of guests has higher priority 
//Returns integer value (-1, 0, 1) based on result of
//comparing two Airbnbs This method is used by the 
//priority queue.
if(this.numGuests < otherAirbnb.numGuests) {
return -1;
}else if(this.numGuests > otherAirbnb.numGuests){
return 1;
}else {
return 0;
}
}
}//end Airbnb class


//A singly-linked list constructed from nodes 
//containing Airbnbs
class AirbnbLinkedList{
//Private Data fields
private Node head;//reference to the 1st node in the linked list
//public methods
//Constructor
public AirbnbLinkedList() {
//Initializes head reference to null
head = null;
}
/*
* Parameters: Airbnb airbnbToAdd
* Return: void
*/
public void addByGuests (Airbnb airbnbToAdd) {
//Add a new node to the linked list based on the 
//Airbnb’s number of guests. The Airbnb’s compareTo
//method will be used to help find the correct 
//location to insert the new Airbnb
Node newNode = new Node(airbnbToAdd);
Node current = head;
Node previous = null;
//first check if head is null, if it is then
//list is empty and this is the first node
if(head == null) {
head = newNode;
}else {
while(current != null && current.airbnb.compareTo(airbnbToAdd)< 0) {
//move current and previous
previous = current;
current = current.next;
}
//if previous is null assign head to newNode otherwise
//previous next will point to newNode
if(previous == null) {
head = newNode;
}else {
previous.next = newNode;
}
//newnode will point to current
newNode.next = current;
}//end of else 
}//end of add guests
/*
* Parameters: integer-nightlyRate,
* numGuests, type
* Return: PriorityQueue
*/
public PriorityQueue<Airbnb> findAirbnb (int nightlyRate, 
int numGuests, String type){
//Traverse the single linked list and find all Airbnbs
//that are: Less than or equal to nightly rate 
//Greater than or equal to number of guests 
//equal to the type 
//place these Airbnbs into a priority queue
PriorityQueue<Airbnb> priority = new PriorityQueue<>();
Node currentNode = head;
while(currentNode!= null) {
if(currentNode.airbnb.getNightlyRate() <= nightlyRate) {
if(currentNode.airbnb.getNumGuests() >= numGuests) {
if(currentNode.airbnb.getType().equals(type)) {
priority.add(currentNode.airbnb);
}
}
}


currentNode = currentNode.next;
}
return priority;
}
/*
* Parameters: String typeToRemove
* Return: int
*/
public int removeSpecificType(String typeToRemove) {
//Remove all Airbnbs from the single linked list 
//with the incoming specified type. Return the
//number of Airbnbs removed
int numberAirbnbsRemoved = 0;
Node currentNode = head;
Node previousNode = null;
//while current is not null search for type based on incoming
//type to be removed. If type is found exit loop
while(currentNode!=null) {
boolean found = false;
while(currentNode!=null && !found) {
if(currentNode.airbnb.getType().equals(typeToRemove)) {
found = true;
numberAirbnbsRemoved++;
}else {
//move pointers to loop forward
previousNode = currentNode;
currentNode = currentNode.next;
}
}
//if node was found then remove
if(found) {
if(previousNode == null) {
//removing first node
head = currentNode.next;
}else {
previousNode.next = currentNode.next;
}
currentNode = currentNode.next;
}
}
return numberAirbnbsRemoved;
}
/*
* Parameters: NA
* Return: void
*/
public void print() {
//Display Airbnbs in order from the head of the
//linked list to the end. Be sure head is still 
//referring to the 1st node when print is complete.
//Use the Airbnbs’ toString() method to print the 
//Airbnb details.
// Walk list and create a string with the values
Node current = head;
//while current does not point to null print current
//node using toString method
System.out.println("\nAirbnb Type\t\t Nightly Rate "
+ "\t\tGuests \t\tBedrooms\r\n------------------------------"
+ "--------------------------------");
while(current != null) {
String result = current.airbnb.toString();
current = current.next;
System.out.println(result);
}
}
//Private Inner Class
//Represents one node in the linked list A node 
//stores an Airbnb object in the data field and a 
//reference to the next node (Airbnb) in the next 
//field
private class Node{
//Private Data Fields
private Airbnb airbnb;//data stored in a node
private Node next;//reference to next node in linked list
//Public Methods
//Constructor
public Node(Airbnb airbnb) {
//Initializes airbnb to the incoming Airbnb and
//next reference to null
this.airbnb = airbnb;
next = null;
}
}//end Node class
}//end AirbnbLinkedList class


//A doubly-linked list constructed from nodes containing
//Airbnbs
class DoubleLinkedList {
//Private Data fields
private Node head;
private Node tail;
//public methods
//constructor
public DoubleLinkedList() {
//Initializes head and tail references to null
head = null;
    tail = null;
}
/*
* Parameter: Airbnb airbnbToAdd
* Return: void
*/
public void addToEnd (Airbnb airbnbToAdd) {
//Create a new node, placing the incoming element into the
//data field
Node newNode = new Node(airbnbToAdd);
// If list is empty
if(tail == null) {
head = tail = newNode;
}else {
// add node to last node in list by setting the tail's
//next reference to newNode and the tail to newNode
tail.next = newNode;
newNode.previous = tail;
tail = newNode;
}
}//end addToEnd
/*
* Parameter: NA
* Return: void
*/
public void printBackwards() {
Node current = tail;
System.out.println("\nAirbnb Type\t\t Nightly Rate "
+ "\t\tGuests \t\tBedrooms\r\n------------------------------"
+ "--------------------------------");
//current starts at the tail and moves to previous reference
while(current != null) {
System.out.println(current.airbnb.toString());
current = current.previous;
}
}
//Private Inner Class
//Represents one node in the linked list. A node
//stores an Airbnb in the data field and a reference
//to the next node (Airbnb)in the next field
private class Node{
//Private Data Fields
private Airbnb airbnb;
private Node previous;
private Node next;
//Public Methods
//Constructor
public Node(Airbnb airbnb) {
//Initializes airbnb to the incoming Airbnb and
//next and previous references to null
this.airbnb = airbnb;
previous = null;
next = null;
}
}//end Node class
}//end DoubleLinkedList