Having problems loading a csv file into a combobox in java - javafx

Question

Ok so I have my code done, or so I thought, but it is not loading the account numbers from the csv file that I have to read from. I am completely lost and not understanding why it is not reading those accounts into the combobox. Can someone please help me figure out why the accounts are not showing up in the combobox. The following is Controller Package that runs the program:
import edu.tridenttech.cpt237.bank.model.Bank;
import edu.tridenttech.cpt237.bank.view.StartWindow;
import javafx.application.Application;
import javafx.stage.Stage;
public class MainApp extends Application
{
#Override
public void start(Stage primaryStage) throws Exception
{
Bank bank = new Bank();
bank.loadTransactions("Transactions.csv");
StartWindow ui = new StartWindow(primaryStage);
ui.show();
}
public static void main(String [] args)
{
Application.launch(args);
}
}
The following is the Bank class in the Model Package:
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Scanner;
public class Bank
{
private static Bank instance = new Bank();
private ArrayList<Account> accounts = new ArrayList<>();
/**
* Gets the Singleton Bank instance
* #return Returns the singleton Bank instance
*/
public static Bank getInstance()
{
return instance;
}
/**
* Open a new savings account and place it in the list of bank accounts.
*
* #param accntNum the number of the new account
* #param initialBal the initial balance
* #return Returns <i>true</i> if an account is created; <i>false</i> if the account already exists or the balance is invalid
*/
public boolean openSavingsAccount(String accntNum, double initialBal)
{
if (findAccountByNum(accntNum) != null || initialBal < 0) {
return false;
}
SavingsAccount savings = new SavingsAccount(accntNum, initialBal);
return accounts.add(savings);
}
/**
* Open a new checking account and place it in the list of bank accounts.
*
* #param accntNum the number of the new account
* #param initialBal the initial balance
* #return Returns <i>true</i> if an account is created; <i>false</i> if the account already exists or the balance is invalid
*/
public boolean openCheckingAccount(String accntNum, double initialBal, double minBalance)
{
if (findAccountByNum(accntNum) != null || initialBal < 0) {
return false;
}
CheckingAccount checking = new CheckingAccount(accntNum, initialBal);
return accounts.add(checking);
}
/**
* Finds the account specified by the given account number
* #param accntNum the number of the account to be found
* #return Returns the account matching the number if found; <i>null</i> if the account is not found
*/
public Account findAccountByNum(String accntNum)
{
Account acnt = null;
Optional<Account> match = accounts.stream().filter(e -> e.getAccountNumber().equals(accntNum)).findFirst();
if (match.isPresent()) {
acnt = match.get();
}
return acnt;
}
/**
* Transfers the specified amount from the fromAccount to the toAccount. This method can fail if either
* of the account numbers is invalid, or if the fromAccount has insufficient funds to make the transfer.
* #param fromAccountNum The account number of the account from which the money is to be withdrawn.
* #param toAccountNum The account number of the account to which the money is to be deposited.
* #param amount The amount to be transfered.
* #return Returns <i>true</i> if the transfer was successful, <i>false</i> otherwise
*/
public boolean makeTransfer(String fromAccountNum, String toAccountNum, double amount)
{
Account fromAccnt;
Account toAccnt;
fromAccnt = findAccountByNum(fromAccountNum);
toAccnt = findAccountByNum(toAccountNum);
if (fromAccnt == null || toAccnt == null) {
return false;
}
if (fromAccnt.withdraw(amount)) {
toAccnt.deposit(amount);
return true;
} else {
return false;
}
}
/**
* Pulls all of the account numbers from the accounts and returns them as a list of strings.
* #return The list of account numbers.
*/
public List<String> getAllAccountNumbers()
{
ArrayList<String> accountNums = new ArrayList<>();
accounts.stream().forEach(e -> accountNums.add(e.getAccountNumber()));
return accountNums;
}
/**
* Loads the transactions from the specified comma separated values file. The format of the file is as follows:
* O,num,type,amount
* D,num,type,amount
* W,num,type,amount
* T,from,to,amount
* #param filePath Path to the file containing the transactions
* #throws FileNotFoundException
*/
public void loadTransactions(String filePath) throws FileNotFoundException
{
Scanner input;
input = new Scanner(new File(filePath));
while (input.hasNext())
{
String line = input.nextLine();
// creates an string array called fields and populates each item
// splitting by comma.
String[] fields = line.split(",");
// System.out.println("number of fields: " + fields.length);
// first field and first character
switch (fields[0].charAt(0)) {
case 'O':
case 'o': {
double minBalance = 0;
// open a new account
String accntNum = fields[1];
String type = fields[2];
double initialBalance = Double.parseDouble(fields[3]);
if (fields.length == 5)
{
minBalance = Double.parseDouble(fields[4]);
}
createAccount(accntNum, type, initialBalance, minBalance);
} break;
case 'D':
case 'd': {
// deposit into an account
String accntNum = fields[1];
String type = fields[2];
double amount = Double.parseDouble(fields[3]);
Account account = findAccountByNum(accntNum);
account.deposit(amount);
} break;
case 'W':
case 'w': {
String accntNum = fields[1];
String type = fields[2];
double amount = Double.parseDouble(fields[3]);
Account account = findAccountByNum(accntNum);
account.withdraw(amount);
} break;
case 'T':
case 't': {
String fromAccount = fields[1];
String toAccount = fields[2];
double amount = Double.parseDouble(fields[3]);
makeTransfer(fromAccount, toAccount, amount);
} break;
default: {
System.out.println("Does not meet requirements");
}
}
}
input.close();
}
private void createAccount(String accntNum, String type, double initialBalance, double minBalance)
{
switch (type.charAt(0)) {
case 's':
case 'S': {
openSavingsAccount(accntNum, initialBalance);
} break;
case 'c':
case 'C': {
openCheckingAccount(accntNum, initialBalance, minBalance);
} break;
}
}
}
And this last class is the StartWindow in the View Package:
import edu.tridenttech.cpt237.bank.model.Bank;
import edu.tridenttech.cpt237.bank.view.NewAccount;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.layout.FlowPane;
import javafx.stage.Stage;
public class StartWindow implements EventHandler<ActionEvent>
{
private Stage myStage;
private Transaction transaction;
private NewAccount account;
private Transfer t;
private ComboBox<String> AccountsCB = new ComboBox<>();
Button display;
Button open;
Button transfer;
Button exit;
public StartWindow(Stage stage)
{
transaction = new Transaction();
FlowPane pane = new FlowPane();
Scene scene = new Scene(pane);
myStage = stage;
myStage.setScene(scene);
myStage.setTitle("Starting Window");
pane.getChildren().add(AccountsCB);
AccountsCB.getItems().setAll(Bank.getInstance().getAllAccountNumbers());
account = new NewAccount(AccountsCB);
display = new Button("Display Current Account");
pane.getChildren().add(display);
display.setOnAction(this);
open = new Button("Open New Account");
pane.getChildren().add(open);
open.setOnAction(this);
transfer = new Button("Transfer Funds Between Accounts");
pane.getChildren().add(transfer);
transfer.setOnAction(this);
t = new Transfer();
exit = new Button("Exit");
pane.getChildren().add(exit);
exit.setOnAction(this);
}
public void handle(ActionEvent event)
{
Button button = (Button) (event.getSource());
if (button == display)
{
if (!transaction.isShowing())
{
transaction.show(AccountsCB.getValue());
}
else
{
transaction.toFront();
}
}
if (button == open)
{
if (!account.isShowing())
{
account.show();
}
else
{
account.toFront();
}
}
if (button == transfer)
{
if (!t.isShowing())
{
t.show();
}
else
{
t.toFront();
}
}
if (button == exit)
{
myStage.close();
}
}
public void show()
{
myStage.show();
}
}
When I run the program, it lets me create a new account, but when I want to transfer funds between accounts or open an existing account, it is not loading the accounts from the Transactions.csv file.

Answer 1

You are attempting to implement Bank as a singleton, but you have not prevented creation of additional instances of Bank. Consequently, in your start() method you are able to create a new instance of Bank and load the transactions in that instance:
Bank bank = new Bank();
bank.loadTransactions("Transactions.csv");
Clearly this is not the same instance of Bank as is returned by Bank.getInstance(), so in your StartWindow class, when you call Bank.getInstance(), you receive a Bank instance with no transactions loaded.
If you want to make Bank a singleton, you should make the constructor private so as to prevent creation of any additional instances:
public class Bank {
private static Bank instance = new Bank();
private ArrayList<Account> accounts = new ArrayList<>();
/**
* Gets the Singleton Bank instance
* #return Returns the singleton Bank instance
*/
public static Bank getInstance() {
return instance;
}
// private constructor:
private Bank() { }
// existing code....
}
and then of course do
#Override
public void start(Stage primaryStage) throws Exception {
Bank.getInstance().loadTransactions("Transactions.csv");
StartWindow ui = new StartWindow(primaryStage);
ui.show();
}
The singleton pattern is generally considered an anti-pattern by many programmers. I would recommend just creating a Bank instance in the usual way and passing it to the StartWindow instance (and to anywhere else that needs it):
public class Bank {
// private static Bank instance = new Bank();
private ArrayList<Account> accounts = new ArrayList<>();
/**
* Gets the Singleton Bank instance
* #return Returns the singleton Bank instance
*/
// public static Bank getInstance() {
// return instance;
//}
/**
* Open a new savings account and place it in the list of bank accounts.
*
* #param accntNum the number of the new account
* #param initialBal the initial balance
* #return Returns <i>true</i> if an account is created; <i>false</i> if the account already exists or the balance is invalid
*/
public boolean openSavingsAccount(String accntNum, double initialBal)
{
if (findAccountByNum(accntNum) != null || initialBal < 0) {
return false;
}
SavingsAccount savings = new SavingsAccount(accntNum, initialBal);
return accounts.add(savings);
}
// existing code ...
}
Then create a bank instance, load its transactions, and pass it to your StartWindow:
public class MainApp extends Application {
#Override
public void start(Stage primaryStage) throws Exception {
Bank bank = new Bank();
bank.loadTransactions("Transactions.csv");
StartWindow ui = new StartWindow(primaryStage, bank);
ui.show();
}
public static void main(String [] args) {
Application.launch(args);
}
}
and
public class StartWindow implements EventHandler<ActionEvent> {
private Bank bank ;
private Stage myStage;
private Transaction transaction;
private NewAccount account;
private Transfer t;
private ComboBox<String> AccountsCB = new ComboBox<>();
Button display;
Button open;
Button transfer;
Button exit;
public StartWindow(Stage stage, Bank bank) {
this.bank = bank ;
transaction = new Transaction();
FlowPane pane = new FlowPane();
Scene scene = new Scene(pane);
myStage = stage;
myStage.setScene(scene);
myStage.setTitle("Starting Window");
pane.getChildren().add(AccountsCB);
// note:
AccountsCB.getItems().setAll(bank.getAllAccountNumbers());
account = new NewAccount(AccountsCB);
display = new Button("Display Current Account");
pane.getChildren().add(display);
display.setOnAction(this);
open = new Button("Open New Account");
pane.getChildren().add(open);
open.setOnAction(this);
transfer = new Button("Transfer Funds Between Accounts");
pane.getChildren().add(transfer);
transfer.setOnAction(this);
t = new Transfer();
exit = new Button("Exit");
pane.getChildren().add(exit);
exit.setOnAction(this);
}
// etc ...
}