ArrayList issue

[blt51]

I need to write a program that handles a bank account and does a number of transactions using an arraylist. However, I'm having trouble getting the arraylist to store all the transactions and then output them. There are 2 classes, Bank and BankAccount. I also have a tester. Any help would be appreciated.

Bank

package bank;
 
import java.util.ArrayList;
 
/**
   This bank contains a collection of bank accounts.
*/
public class Bank
{   
   /**
      Constructs a bank with no bank accounts.
   */
   public Bank()
   {
      accounts = new ArrayList<BankAccount>();
   }
 
   /**
      Adds an account to this bank.
      @param a the account to add
   */
   public void addAccount(BankAccount a)
   {
      accounts.add(a);
   }
 
   /**
      Gets the sum of the balances of all accounts in this bank.
      @return the sum of the balances
   */
   public double getTotalBalance()
   {
      double total = 0;
      for (BankAccount a : accounts)
      {
         total = total + a.getBalance();
      }
      return total;
   }
 
   /**
      Counts the number of bank accounts whose balance is at
      least a given value.
      @param atLeast the balance required to count an account
      @return the number of accounts having least the given balance
   */
   public int count(double atLeast)
   {
      int matches = 0;
      for (BankAccount a : accounts)
      {
         if (a.getBalance() >= atLeast) matches++; // Found a match
      }
      return matches;
   }
 
   /**
      Finds a bank account with a given number.
      @param accountNumber the number to find
      @return the account with the given number, or null if there
      is no such account
   */
   public BankAccount find(int accountNumber)
   {
      for (BankAccount a : accounts)
      {
         if (a.getAccountNumber() == accountNumber) // Found a match
            return a;
      } 
      return null; // No match in the entire array list
   }
 
   /**
      Gets the bank account with the largest balance.
      @return the account with the largest balance, or null if the
      bank has no accounts
   */
   public BankAccount getMaximum()
   {
      if (accounts.size() == 0) return null;
      BankAccount largestYet = accounts.get(0);
      for (int i = 1; i < accounts.size(); i++) 
      {
         BankAccount a = accounts.get(i);
         if (a.getBalance() > largestYet.getBalance())
            largestYet = a;
      }
      return largestYet;
   }
 
   /**
    * adds a Bank Account with an initial balance
    */
   public void addAccount(int accountNumber, double initialBalance){
       accounts.add(new BankAccount(accountNumber, initialBalance));
   }
   /**
    * deposit method handles transactions that deposit money into bank account
    */
   public void deposit(int accountNumber, double amount){
       BankAccount anAccount = this.find(accountNumber);
       anAccount.deposit(amount);
   }
   /**
    * withdraw method handles transactions that withdraw money from the bank account
    */
   public void withdraw(int accountNumber, double amount){
       BankAccount anAccount=this.find(accountNumber);
       anAccount.withdraw(amount);
   }
   /**
    * @return returns bank account's balance
    */
   public double getBalance(int accountNumber){
       BankAccount anAccount = this.find(accountNumber);
       return anAccount.getBalance();           
   }
   /**
    * method which suspends an account
    */
   public void suspendAccount(int accountNumber){
       BankAccount temp = this.find(accountNumber);
       temp.suspend();
   }
   /**
    * method that reopens an account
    */
   public void reOpenAccount(int accountNumber){
       BankAccount temp = this.find(accountNumber);
       temp.reOpen();
   }
   /**
    * method that closes an account
    */
   public void closeAccount(int accountNumber){
       BankAccount anAccount = this.find(accountNumber);
       anAccount.close();
   }
   /**
    * @return returns the current status of an account
    */
   public String getAccountStatus(int accountNumber){
       BankAccount anAccount = this.find(accountNumber);
       return anAccount.getStatus();
   }
   /**
    * @return returns the transactions from an account
    */
   public String retrieveAccountTransactions(int accountNumber){
       return find(accountNumber).retrieveTransactions();
   }
   /**
    * Printout string of account summary
    */
   public String summarizeAllAccounts(){
       String string1 = "Bank Account Summary\n\nAccount \tBalance \t#Transactions \t\t Status\n";
       String string2 = new String();
       String string3 = new String();
       for(BankAccount a : accounts)
       {
           string2 += a.getAccountNumber() + "\t\t " +  a.getBalance() + "\t\t   " + a.retrieveNumberOfTransactions() + "\t\t\t" + a.getStatus() + "\n";
       }
       string3 += "End of Account Summary";   
       return string1 + string2 + string3;
   }
 
   private ArrayList<BankAccount> accounts;
}
 

BankAccount

package bank;
 
import java.util.ArrayList;
 
/**
   A bank account has a balance that can be changed by 
   deposits and withdrawals.
*/
public class BankAccount
{
 
    public static final String OPEN = "open";
    public static final String SUSPENDED = "suspended";
    public static final String CLOSED = "closed";
 
    private String status;
    private int accountNumber;
    private double balance;
    private ArrayList<Double> transactions;
 
   /**
      Constructs a bank account with a zero balance
      @param anAccountNumber the account number for this account
   */
   public BankAccount(int anAccountNumber)
   {   
      status = new String(); 
      transactions = new ArrayList<Double>();
      setStatus(OPEN);
      accountNumber = anAccountNumber;
      balance = 0;
 
   }
 
   /**
      Constructs a bank account with a given balance
      @param anAccountNumber the account number for this account
      @param initialBalance the initial balance
   */
   public BankAccount(int anAccountNumber, double initialBalance)
   {   
      status = new String(); 
      setStatus(OPEN); 
      transactions = new ArrayList<Double>();
      accountNumber = anAccountNumber; 
      deposit(initialBalance);
   }
 
   /**
      Gets the account number of this bank account.
      @return the account number
   */
   public int getAccountNumber()
   {   
      return accountNumber;
   }
 
   /**
      Deposits money into the bank account.
      @param amount the amount to deposit
   */
   public void deposit(double amount){    
       if (status.equals(OPEN) && amount > 0){ 
             double newBalance = balance + amount;
             balance = newBalance;
             addTransaction(amount);
       }
   }
 
   /**
      Withdraws money from the bank account.
      @param amount the amount to withdraw
   */
   public void withdraw(double amount)
   {   
       if (status.equals(OPEN) && amount > 0 && amount <= balance){ 
            double newBalance = balance - amount;
            balance = newBalance;
            addTransaction(amount);
       }
   }
  /**
   * Suspends an account
   */
   public void suspend(){
       {
           if (!isSuspended() && !isClosed())
               {
               setStatus(SUSPENDED);
               }
           }
   }
/**
 * Closes an ccount
 */
   public void close(){
       if (isSuspended())
       {
           reOpen();
           withdraw(getBalance());
           setStatus(CLOSED);
       }
      else
      {
          withdraw(getBalance());
          setStatus(CLOSED);
      }
   }
   /**
    * reopens an account
    */
   public void reOpen(){
       if (isSuspended())
           {
           setStatus(OPEN);
           }
   }
   /**
    * @return returns whether or not the status is open
    */
   public boolean isOpen(){
       if (status.equals(OPEN)){
           return true;
       }
       else
           return false;
   }
   /**
    * @return returns whether or not the status is suspended
    */
   public boolean isSuspended(){
       if (status.equals(SUSPENDED)){
           return true;
       }
       else
           return false;
   }
   /**
    * @return returns whether or not the status is closed
    */
   public boolean isClosed(){
       if (status.equals(CLOSED)){
           return true;
       }
       else
           return false;
   }
  /**
   * adds a transaction
   */
   private void addTransaction(double amount){       
       transactions.add(amount);       
   }
   /**
    * @return returns the output message
    */
   public String retrieveTransactions(){
       String output = "Account #" + accountNumber + " transactions\n\n";
       int count = 1;
 
       for (double i : transactions){
           output += (count + ": " + i +"\n");
           count++;
       }
       output += "balance = "+ balance + "\nEnd of transactions\n";
 
       return output;
 
   }
   /**
    * @return returns the number of transactions
    */
   public int retrieveNumberOfTransactions(){
       return transactions.size();
   }
   /**
    * @return returns the status of account
    */
   private String setStatus(String newStatus){
       if (status.equals(OPEN))
           {
           this.status = OPEN;
           }
       if (status.equals(SUSPENDED))
           {
           this.status = SUSPENDED;
           }
       if (status.equals(CLOSED))
           {
           this.status = CLOSED;
           }
       return status;
   }
   /**
    * @return returns the status of account
    */
   public String getStatus(){
       return status;
   }
 
   /**
      Gets the current balance of the bank account.
      @return the current balance
   */
   public double getBalance()
   {   
      return balance;
   }
 
}
 

Tester

package bank;
public class BankTester
{
 
    public static void main(String[] args)
    {
      Bank firstBankOfJava = new Bank();
      firstBankOfJava.addAccount(new BankAccount(1001, 500.00));
      firstBankOfJava.deposit(1001, 300.00);
      firstBankOfJava.deposit(1001, 50.00);
      firstBankOfJava.withdraw(1001, 500.00);
      firstBankOfJava.closeAccount(1001);
      firstBankOfJava.addAccount(new BankAccount(1002, 2500.00));
      firstBankOfJava.deposit(1002, 1500.00);
      firstBankOfJava.withdraw(1002, 2000.00);
      firstBankOfJava.withdraw(1002, 500.00);
      firstBankOfJava.deposit(1002, 4000.00);
      firstBankOfJava.suspendAccount(1002);
      firstBankOfJava.addAccount(new BankAccount(1003,1000));
      firstBankOfJava.deposit(1003, 100);
      firstBankOfJava.withdraw(1003,250);
      firstBankOfJava.deposit(1003,750);
      //MasterTester will close account before this is reached
      //firstBankOfJava.withdraw(1003,1600);
      firstBankOfJava.closeAccount(1003);
      String transactionReport1001 = firstBankOfJava.retrieveAccountTransactions(1001);
      System.out.println(transactionReport1001);
      String transactionReport1002 = firstBankOfJava.retrieveAccountTransactions(1002);
      System.out.println(transactionReport1002);
      String transactionReport1003 = firstBankOfJava.retrieveAccountTransactions(1003);
      System.out.println(transactionReport1003);
      String summaryReport = firstBankOfJava.summarizeAllAccounts();
      System.out.println(summaryReport);
   }
}
 

[Frinavale]

Could you please explain what "problems" you are having storing and outputting the transactions?

[blt51]

It's supposed to print a summary of transactions for each account but it doesn't. I think the status is a problem but I can't follow why it won't store and print the transactions

[mrjohn]

I took a quick look at it with the debugger, and it looks as though you don't ever assign a value to status in BankAccount.java. I think this may be the problem.

   private String setStatus(String newStatus){
       if (status.equals(OPEN))
           {
           this.status = OPEN;
           }
       if (status.equals(SUSPENDED))
           {
           this.status = SUSPENDED;
           }
       if (status.equals(CLOSED))
           {
           this.status = CLOSED;
           }
       return status;
   }

I think you meant to check newStatus in those if-statements, rather than status itself. Is this the problem?

[blt51]

Yes actually it is. I meant to post that I had figured this out.

Thanks for the help.

Stupid mistake!

[pjerald]

private void setStatus(String newStatus){
       this.status = newStatus;
       /*
       if (status.equals(OPEN))
           {
           this.status = OPEN;
           }
       if (status.equals(SUSPENDED))
           {
           this.status = SUSPENDED;
           }
       if (status.equals(CLOSED))
           {
           this.status = CLOSED;
           }
        */
   }
 

Change this and it should work. you are not setting the status of the BankAccount. Also i change the method to void as no need to return the status.