Warehouse Inventories Objective: Work with multiple objects and review reading data files. Description: A wholesale distributor has six warehouses (Atlanta, Baltimore, Chicago, Denver, Ely and Fargo) and sells five different items (identified by part number: 102, 215, 410, 525 and 711). Each warehouse may stock any or all of the five items. The company buys and sells these items constantly. Company transaction records contain a transaction code (‘P’ for a purchase or ‘S’ for a sale) followed by an item number and the quantity (bought or sold). The transaction records are contained in a transaction data file named Transactions.txt. Sample transaction records: Transactions.txt P 410 1000 S 215 120 S 711 300 | A separate data file contains the initial status of the six warehouses at the beginning of the day (i.e., the ending status from the night before). This data file has only six records (lines). Each record (line) contains five numbers that show the quantity on hand for the five items in that warehouse. This file is named Inventory.txt. Sample status data file: Inventory.txt 500 120 60 0 350 100 230 0 50 0 0 75 0 0 220 600 50 120 300 40 210 160 30 80 50 90 50 90 200 70 | The status data file is updated by processing the transaction records in the transaction data file according to these rules: 1 – For a sale (‘S’) – subtract the quantity sold from the warehouse that has the largest supply of that item on hand. 2 – For a purchase (‘P’) – add the quantity purchased to the warehouse that has the lowest supply of that item on hand. Instructions: Write an object-oriented Java program to do the above inventory warehouse processing. Each of the six warehouses should be treated as an individual object. For example, Atlanta would be an object with each of the five part numbers as instance fields. Each of the other warehouses should also be objects with the five part numbers as instance fields. Of course, there would be one class which would be the main (driver) class from which these 6 objects would be created. In the beginning of the program, the status data file (Inventory.txt) should be read and an object for each warehouse created. The Inventory.txt data file is in the following order: the first line is the Atlanta warehouse, the second line is the Baltimore warehouse, third Chicago, then Denver, Ely and Fargo. After the objects are created, the transactions data file (Transactions.txt) are read and processed. The objects should be updated as the transaction records are read and processed. The program should: 1 – Display the initial (beginning-of-day) status for all warehouses. 2 – Process each transaction from the transaction data file and show which warehouse’s inventory was updated to reflect that transaction. 3 – Display the final (end-of-day) status for all warehouses. Requirements: The class must be named Inventory. The main program (driver) must be named Warehouses. A driver (main class) as well as a programmer-defined class must be used. .

1. Warehouse Inventories
Objective:
Work with multiple objects and review reading data files.
Description: A wholesale distributor has six warehouses (Atlanta, Baltimore, Chicago, Denver,
Ely and Fargo) and sells five different items (identified by part number: 102, 215, 410, 525 and
711). Each warehouse may stock any or all of the five items. The company buys and sells these
items constantly. Company transaction records contain a transaction code (‘P’ for a purchase or
‘S’ for a sale) followed by an item number and the quantity (bought or sold).
The transaction records are contained in a transaction data file named Transactions.txt.
Sample transaction records: Transactions.txt
P 410 1000
S 215 120
S 711 300
|
A separate data file contains the initial status of the six warehouses at the beginning of the day
(i.e., the ending status from the night before). This data file has only six records (lines). Each
record (line) contains five numbers that show the quantity on hand for the five items in that
warehouse. This file is named Inventory.txt.
Sample status data file: Inventory.txt
500 120 60 0 350
100 230 0 50 0
0 75 0 0 220
600 50 120 300 40
210 160 30 80 50
90 50 90 200 70
|
The status data file is updated by processing the transaction records in the transaction data file
according to these rules:
1 – For a sale (‘S’) – subtract the quantity sold from the warehouse that
has the largest supply of that item on hand.
2 – For a purchase (‘P’) – add the quantity purchased to the warehouse
that has the lowest supply of that item on hand.
Instructions:
Write an object-oriented Java program to do the above inventory warehouse processing. Each of
the six warehouses should be treated as an individual object. For example, Atlanta would be an

2. object with each of the five part numbers as instance fields. Each of the other warehouses should
also be objects with the five part numbers as instance fields. Of course, there would be one class
which would be the main (driver) class from which these 6 objects would be created.
In the beginning of the program, the status data file (Inventory.txt) should be read and an object
for each warehouse created. The Inventory.txt data file is in the following order: the first line is
the Atlanta warehouse, the second line is the Baltimore warehouse, third Chicago, then Denver,
Ely and Fargo. After the objects are created, the transactions data file (Transactions.txt) are read
and processed.
The objects should be updated as the transaction records are read and processed.
The program should:
1 – Display the initial (beginning-of-day) status for all warehouses.
2 – Process each transaction from the transaction data file and show which
warehouse’s inventory was updated to reflect that transaction.
3 – Display the final (end-of-day) status for all warehouses.
Requirements:
The class must be named Inventory.
The main program (driver) must be named Warehouses.
A driver (main class) as well as a programmer-defined class must be used.
Submit program through the assignment tool in Moodle2.
Include a comment stating your name.
Each student must create his/her own independent program.
Warehouse Inventories
Objective:
Work with multiple objects and review reading data files.
Description: A wholesale distributor has six warehouses (Atlanta, Baltimore, Chicago, Denver,
Ely and Fargo) and sells five different items (identified by part number: 102, 215, 410, 525 and
711). Each warehouse may stock any or all of the five items. The company buys and sells these
items constantly. Company transaction records contain a transaction code (‘P’ for a purchase or
‘S’ for a sale) followed by an item number and the quantity (bought or sold).
The transaction records are contained in a transaction data file named Transactions.txt.
Sample transaction records: Transactions.txt
P 410 1000
S 215 120
S 711 300
|
A separate data file contains the initial status of the six warehouses at the beginning of the day

3. (i.e., the ending status from the night before). This data file has only six records (lines). Each
record (line) contains five numbers that show the quantity on hand for the five items in that
warehouse. This file is named Inventory.txt.
Sample status data file: Inventory.txt
500 120 60 0 350
100 230 0 50 0
0 75 0 0 220
600 50 120 300 40
210 160 30 80 50
90 50 90 200 70
|
The status data file is updated by processing the transaction records in the transaction data file
according to these rules:
1 – For a sale (‘S’) – subtract the quantity sold from the warehouse that
has the largest supply of that item on hand.
2 – For a purchase (‘P’) – add the quantity purchased to the warehouse
that has the lowest supply of that item on hand.
Instructions:
Write an object-oriented Java program to do the above inventory warehouse processing. Each of
the six warehouses should be treated as an individual object. For example, Atlanta would be an
object with each of the five part numbers as instance fields. Each of the other warehouses should
also be objects with the five part numbers as instance fields. Of course, there would be one class
which would be the main (driver) class from which these 6 objects would be created.
In the beginning of the program, the status data file (Inventory.txt) should be read and an object
for each warehouse created. The Inventory.txt data file is in the following order: the first line is
the Atlanta warehouse, the second line is the Baltimore warehouse, third Chicago, then Denver,
Ely and Fargo. After the objects are created, the transactions data file (Transactions.txt) are read
and processed.
The objects should be updated as the transaction records are read and processed.
The program should:
1 – Display the initial (beginning-of-day) status for all warehouses.
2 – Process each transaction from the transaction data file and show which
warehouse’s inventory was updated to reflect that transaction.
3 – Display the final (end-of-day) status for all warehouses.
Requirements:
The class must be named Inventory.

4. The main program (driver) must be named Warehouses.
A driver (main class) as well as a programmer-defined class must be used.
Solution
publicclass Inventory {
publicfinalstatic String[] WAREHOUSES = {"Atlanta", "Baltimore", "Chicago", "Denver",
"Ely", "Fargo"};
//Instance variables
privateint part_number_102;
privateint part_number_215;
privateint part_number_410;
privateint part_number_525;
privateint part_number_711;
/**
* Default Construtor
*/
public Inventory() {
this.part_number_102 = 0;
this.part_number_215 = 0;
this.part_number_410 = 0;
this.part_number_525 = 0;
this.part_number_711 = 0;
}
/**
* Parameterized Constructor
* @param part_number_102
* @param part_number_215
* @param part_number_410
* @param part_number_525
* @param part_number_711
*/
public Inventory(int part_number_102, int part_number_215, int part_number_410, int
part_number_525,
int part_number_711) {
this.part_number_102 = part_number_102;

5. this.part_number_215 = part_number_215;
this.part_number_410 = part_number_410;
this.part_number_525 = part_number_525;
this.part_number_711 = part_number_711;
}
/**
* @return the part_number_102
*/
publicint getPart_number_102() {
return part_number_102;
}
/**
* @param part_number_102 the part_number_102 to set
*/
publicvoid setPart_number_102(int part_number_102) {
this.part_number_102 = part_number_102;
}
/**
* @return the part_number_215
*/
publicint getPart_number_215() {
return part_number_215;
}
/**
* @param part_number_215 the part_number_215 to set
*/
publicvoid setPart_number_215(int part_number_215) {
this.part_number_215 = part_number_215;
}
/**
* @return the part_number_410
*/
publicint getPart_number_410() {
return part_number_410;
}
/**

6. * @param part_number_410 the part_number_410 to set
*/
publicvoid setPart_number_410(int part_number_410) {
this.part_number_410 = part_number_410;
}
/**
* @return the part_number_525
*/
publicint getPart_number_525() {
return part_number_525;
}
/**
* @param part_number_525 the part_number_525 to set
*/
publicvoid setPart_number_525(int part_number_525) {
this.part_number_525 = part_number_525;
}
/**
* @return the part_number_711
*/
publicint getPart_number_711() {
return part_number_711;
}
/**
* @param part_number_711 the part_number_711 to set
*/
publicvoid setPart_number_711(int part_number_711) {
this.part_number_711 = part_number_711;
}
@Override
public String toString() {
System.out.printf("%6s %6s", "Part #", "Quantity");
System.out.printf(" %-6s %6d", "102", this.part_number_102);
System.out.printf(" %-6s %6d", "215", this.part_number_215);
System.out.printf(" %-6s %6d", "410", this.part_number_410);
System.out.printf(" %-6s %6d", "525", this.part_number_525);

7. System.out.printf(" %-6s %6d", "711", this.part_number_711);
return "";
}
/**
* Gets the warehouse name from the WAREHOUSE static final String array
* based on the index passed as the parameter
* @param index
* @return
*/
publicstatic String getWarehouseName(int index) {
returnWAREHOUSES[index];
}
/**
* Gets the total supply for a part number
* @param index
* @return
*/
publicint getSupply(int partNum) {
int supply = 0;
switch(partNum) {
case 102:
supply = this.getPart_number_102();
break;
case 215:
supply = this.getPart_number_215();
break;
case 410:
supply = this.getPart_number_410();
break;
case 525:
supply = this.getPart_number_525();
break;
case 711:
supply = this.getPart_number_711();
}
return supply;

8. }
}
-------
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
publicclass Warehouses {
//File names
privatestaticfinal String INVENTORY_FILE = "Inventory.txt";
privatestaticfinal String TRANSACTION_FILE = "Transactions.txt";
privatestaticfinal String EOF_CHAR = "|";
/**
* Read inventory.txt file
* @param inventory
* @return
*/
publicstatic Inventory[] getInventory(Inventory[] inventory) {
BufferedReader br = null;
try {
FileReader reader = new FileReader(new File(INVENTORY_FILE));
br = new BufferedReader(reader);
String line;
int index = 0;
while(!(line = br.readLine()).equalsIgnoreCase(EOF_CHAR)) {
String[] rec = line.split(" ");
//Set quantity for each part number of each warehouse
inventory[index]= new Inventory(Integer.parseInt(rec[0]), Integer.parseInt(rec[1]),
Integer.parseInt(rec[2]), Integer.parseInt(rec[3]),
Integer.parseInt(rec[4]));
index += 1;
}
} catch (FileNotFoundException fnfe) {
fnfe.printStackTrace();
} catch (IOException ioe) {

9. ioe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(br != null)
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return inventory;
}
/**
* Get warehouse with the largest supply for a part number
* @param inventory
* @return
*/
publicstatic Inventory[] updateLargestSupply(Inventory[] inventory, String[] rec) {
int partNum = Integer.parseInt(rec[1]);
int max = inventory[0].getSupply(partNum);
int index = 0;
for(int i = 1 ; i < inventory.length ; i++) {
if(inventory[i].getSupply(partNum) > max) {
index = i;
max = inventory[index].getSupply(partNum);
}
}
//Update supply
System.out.println("Updating the quantity of part number " + rec[1] + " at warehouse " +
Inventory.getWarehouseName(index));
switch(partNum) {
case 102:
inventory[index].setPart_number_102(max - Integer.parseInt(rec[2]));
break;
case 215:

10. inventory[index].setPart_number_215(max - Integer.parseInt(rec[2]));
break;
case 410:
inventory[index].setPart_number_410(max - Integer.parseInt(rec[2]));
break;
case 525:
inventory[index].setPart_number_525(max - Integer.parseInt(rec[2]));
break;
case 711:
inventory[index].setPart_number_711(max - Integer.parseInt(rec[2]));
}
return inventory;
}
/**
* Get warehouse with the lowest supply for a part number
* @param inventory
* @return
*/
publicstatic Inventory[] updateLowestSupply(Inventory[] inventory, String[] rec) {
int partNum = Integer.parseInt(rec[1]);
int min = inventory[0].getSupply(partNum);
int index = 0;
for(int i = 1 ; i < inventory.length ; i++) {
if(inventory[i].getSupply(partNum) < min) {
index = i;
min = inventory[index].getSupply(partNum);
}
}
//Update supply
System.out.println("Updating the quantity of part number " + rec[1] + " at warehouse " +
Inventory.getWarehouseName(index));
switch(partNum) {
case 102:
inventory[index].setPart_number_102(min + Integer.parseInt(rec[2]));
break;
case 215:

11. inventory[index].setPart_number_215(min + Integer.parseInt(rec[2]));
break;
case 410:
inventory[index].setPart_number_410(min + Integer.parseInt(rec[2]));
break;
case 525:
inventory[index].setPart_number_525(min + Integer.parseInt(rec[2]));
break;
case 711:
inventory[index].setPart_number_711(min + Integer.parseInt(rec[2]));
}
return inventory;
}
/**
* Read transactions.txt file and update the inventory array
* @param inventory
* @return
*/
publicstatic Inventory[] processTransaction(Inventory[] inventory) {
BufferedReader br = null;
try {
FileReader reader = new FileReader(new File(TRANSACTION_FILE));
br = new BufferedReader(reader);
String line;
while(!(line = br.readLine()).equalsIgnoreCase(EOF_CHAR)) {
String[] rec = line.split(" ");
if(rec[0].equalsIgnoreCase("P")) {
System.out.println();
System.out.println("Reading transaction for Purchase of " + rec[2] + " quantites of part number
" + rec[1]);
updateLowestSupply(inventory, rec);
} elseif(rec[0].equalsIgnoreCase("S")) {
System.out.println();
System.out.println("Reading transaction for Sale of " + rec[2] + " quantites of part number " +
rec[1]);
updateLargestSupply(inventory, rec);

12. }
}
} catch (FileNotFoundException fnfe) {
fnfe.printStackTrace();
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(br != null)
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return inventory;
}
publicstaticvoid main(String[] args) {
//Create an array of Inventory for each of the warehouses
//mentioned in the WAREHOUSES string array
Inventory[] inventory = new Inventory[Inventory.WAREHOUSES.length];
//Display the initial (beginning-of-day) status for all warehouses.
getInventory(inventory);
System.out.println("***Initial (beginning-of-day) status for all warehouses***");
for(int i = 0 ; i < inventory.length ; i++) {
System.out.println("Inventory details of " + Inventory.getWarehouseName(i));
System.out.println(inventory[i]);
}
//Process each transaction from the transaction data file and show which
//warehouse’s inventory was updated to reflect that transaction.
processTransaction(inventory);
//Display the final (end-of-day) status for all warehouses.
System.out.println(" ***Final (end-of-day) status for all warehouses***");
for(int i = 0 ; i < inventory.length ; i++) {
System.out.println("Inventory details of " + Inventory.getWarehouseName(i));

13. System.out.println(inventory[i]);
}
}
}
SAMPLE OUTPUT:
***Initial (beginning-of-day) status for all warehouses***
Inventory details of Atlanta
Part # Quantity
102 500
215 120
410 60
525 0
711 350
Inventory details of Baltimore
Part # Quantity
102 100
215 230
410 0
525 50
711 0
Inventory details of Chicago
Part # Quantity
102 0
215 75
410 0
525 0
711 220
Inventory details of Denver
Part # Quantity
102 600
215 50
410 120
525 300
711 40
Inventory details of Ely
Part # Quantity

14. 102 210
215 160
410 30
525 80
711 50
Inventory details of Fargo
Part # Quantity
102 90
215 50
410 90
525 200
711 70
Reading transaction for Purchase of 1000 quantites of part number 410
Updating the quantity of part number 410 at warehouse Baltimore
Reading transaction for Sale of 120 quantites of part number 215
Updating the quantity of part number 215 at warehouse Baltimore
Reading transaction for Sale of 300 quantites of part number 711
Updating the quantity of part number 711 at warehouse Atlanta
***Final (end-of-day) status for all warehouses***
Inventory details of Atlanta
Part # Quantity
102 500
215 120
410 60
525 0
711 50
Inventory details of Baltimore
Part # Quantity
102 100
215 110
410 1000
525 50
711 0
Inventory details of Chicago
Part # Quantity
102 0

15. 215 75
410 0
525 0
711 220
Inventory details of Denver
Part # Quantity
102 600
215 50
410 120
525 300
711 40
Inventory details of Ely
Part # Quantity
102 210
215 160
410 30
525 80
711 50
Inventory details of Fargo
Part # Quantity
102 90
215 50
410 90
525 200
711 70