Java print Arraylist

Question

I have three classes, BankLogic, Customer and SavingsAccount. I want to print out an arraylist of all the customers, but I'm only getting a blank result. This should be the simplest thing to do, but i can't get it to work. What am I doing wrong?

This is how it looks in BankLogic:

import java.util.ArrayList;
import java.util.Scanner;

public class BankLogic
{
private double amount;
private double balance;
private ArrayList<Customer> customerlist;
private ArrayList<SavingsAccount> accounts;

Scanner in = new Scanner(System.in);

public BankLogic()
{
    customerlist = new ArrayList<Customer>();
    accounts = new ArrayList<SavingsAccount>();
}


//----------------------------------------------------------------------
// Beskrivning: returnerar presentation av alla kunder(pers.nr och namn)
// Returvärde: String 
//----------------------------------------------------------------------
public String infoBank()
{
    String customers = customerlist.toString();
    return customers.substring(1, customers.length() - 1);
}

//----------------------------------------------------------------------
// Beskrivning: lägger till ny kund om personnumret pNr inte redan finns
// Inparametrar: String name, long pNr - namn och personnummer som sparas 
// Returvärde: boolean - add om namnet sparas, false om personnumret 
// redan finns
//----------------------------------------------------------------------
public boolean addCustomer(String name, long pNr)
{
boolean add = true;

    for(int i = 0; i < customerlist.size(); i++)
    {
        if (customerlist.get(i).getPCode() == pNr)
        {
            add = false;
        }
    }

    if(add) 
    {
        customerlist.add(new Customer(name, pNr));
        add = true;
    }

    return add;

}

//----------------------------------------------------------------------
// Beskrivning: returnera info om vald kund
// Inparametrar: long pNr - personnummer kontrolleras 
// Returvärde: String - returnerar personnummer, namn och ev. konton
//----------------------------------------------------------------------
public String infoCustomer(long pNr){


String result = "";

    for(int i = 0; i < customerlist.size(); i++)
    {
        if(customerlist.get(i).getPCode() == pNr)
        {

        }
    }


    return result;
}

//----------------------------------------------------------------------
// Beskrivning: byter namn på kund
// Inparametrar: String name, long pNr - nytt namn med personnummer sparas 
// Returvärde: boolean - true om namnet ändrades, false om det inte ändrades
//----------------------------------------------------------------------
public boolean changeCustomerName(String name, long pNr){

boolean result = false;

    for(int i = 0; i < customerlist.size(); i++)
    {
        if (customerlist.get(i).getPCode() == pNr)
        {
            Customer customer = customerlist.get(i);
            customer.setName(name);
            customerlist.set(i, customer);
            result = true;
        }
    }

    return result;
}

//----------------------------------------------------------------------
// Beskrivning: tar bort kund och dess konton och returnerar info om
// vilka konton som tagits bort, kvarvarande saldo och ränta
// Inparametrar: long pNr - personnummer kontrolleras 
// Returvärde: String - info om raderade konton och kvarvarande saldo
//----------------------------------------------------------------------
public String removeCustomer(long pNr){

    for (int i = 0; i < customerlist.size(); i++)
    {
        Customer customer = customerlist.get(i);
        if (customer.getPCode() == pNr)
        {
            customer = customerlist.remove(i);
        }
        else
            i++;
    }
    return "Removeinfo: ";

}

//----------------------------------------------------------------------
// Beskrivning: skapar ett konto till kund utifrån pers.nr
// Inparametrar: long pNr - personnummer kontrolleras 
// Returvärde: int - returnerar kontonummer, alternativt returneras -1
// om inget konto skapades    
//----------------------------------------------------------------------
public int addSavingsAccount(long pNr){

    for (Customer customer : customerlist)
    {
        if (customer.getPCode() == pNr)
        {           
            accounts.add(new SavingsAccount());
        }
        else 
            return -1;
    }
    return SavingsAccount.getAccountId();
}
//----------------------------------------------------------------------
// Beskrivning: returnerar info om konto med kontonummer accountId som
// tillhör kunden pNr
// Inparametrar: long pNr, int accountId - personnummer och kontonummer 
// kontrolleras 
// Returvärde: String - returnerar kontonummer,saldo, kontotyp och räntesats
//----------------------------------------------------------------------
public String infoAccount(long pNr, int accountId)
{
    String info = "";
    for(Customer customer : customerlist)
    {
        if(pNr == customer.getPCode())
        {
            for(SavingsAccount account : accounts)
            {
                if(accountId == account.getAccountId())
                {
                    info = "Personnummer: " + pNr + "\nKontonummer: " + accountId
                    + "\nSaldo: " + amount + "\nRänta: " + SavingsAccount.RATE;
                }
            }
        } 
    }
    return info; 
}

//----------------------------------------------------------------------
// Beskrivning: gör en insättning på kontonummer med accountId som
// tillhör kunden med personnummer pNr
// Inparametrar: long pNr, int accountId, double amount
// Returvärde: true om insättningen lyckades annars false
//----------------------------------------------------------------------
public boolean deposit(long pNr, int accountId, double amount)
{   
    for(Customer customer : customerlist)
    {
        if(pNr == customer.getPCode())
        {
            for(SavingsAccount account : accounts)
            {
                if(accountId == account.getAccountId())
                {
                    balance += amount;
                    return true;
                }
            }
            return false;
        }
    }
    return false;
}

//----------------------------------------------------------------------
// Beskrivning: gör ett uttag på kontonummer med accountId som
// tillhör kunden pNr
// Inparametrar: long pNr, int accountId, double amount
// Returvärde: true om insättningen lyckades annars false
//----------------------------------------------------------------------
public boolean withdraw(long pNr, int accountId, double amount){

    for(Customer customer : customerlist)
    {
        if(pNr == customer.getPCode())
        {
            for(SavingsAccount account : accounts)
            {
                if(accountId == account.getAccountId())
                {
                    balance -= amount;
                    return true;
                }
            }
            return false;
        }
    }
    return false;
}

//----------------------------------------------------------------------
// Beskrivning: stänger konto accountId
// Inparametrar: long pNr, int accountId - personnummer och 
// kontonummer kontrolleras
// Returvärde: String - returnerar saldo och ränta
//----------------------------------------------------------------------

//stänger ett konto och returnerar saldo och ränta
public String closeAccount(long pNr, int accountId){

            if(customerlist.size() > accountId)
            {
                balance = SavingsAccount.getBalance();
                customerlist.remove(accountId);
            }

            return  "Saldo: " + balance + "\nRänta: " + SavingsAccount.getIntRate();
} 

}

My Customer class:

public class Customer
{
private String name;
private long pNr;

//----------------------------------------------------------------------
// Beskrivning: konstruktor
//----------------------------------------------------------------------
public Customer(String cName, long pCode)
{
    name = cName;
    pNr = pCode;
}



//----------------------------------------------------------------------
// Beskrivning: hämtar kundens namn
// Inparametrar: 
// Returvärde: String returnerar namn
//----------------------------------------------------------------------
public String getName(){
    return name;
}

//----------------------------------------------------------------------
// Beskrivning: hämtar kundens personnummer
// Inparametrar: 
// Returvärde: long returnerar personnummer
//----------------------------------------------------------------------
public long getPCode(){
    return pNr;
}

//----------------------------------------------------------------------
// Beskrivning: ändrar en kunds namn
// Inparametrar: String newName - nytt namn genereras
// Returvärde: String returnerar kundens nya namn
//----------------------------------------------------------------------
public void setName(String newName){
    name = newName;
}

//----------------------------------------------------------------------
// Beskrivning: skriver ut all info om kunden
// Inparametrar: 
// Returvärde: String returnerar personnummer och namn
//----------------------------------------------------------------------
public String toString(){
    return "Personnummer: " + pNr + ", Namn: " + name; 
}

}

And SavingsAccount:

public class SavingsAccount
{
private static double balance;
private static String accounttype = "Sparkonto";
private static int accountId;
private static int accountCount = 1000;
public static final double RATE = 2.0;

public SavingsAccount()
{
    accountId = accountCount;
    accountCount++;
}

//----------------------------------------------------------------------
// Beskrivning: hämtar saldo
// Inparametrar: 
// Returvärde: double returnerar saldo
//----------------------------------------------------------------------
public static double getBalance(){
    return balance;
}

//----------------------------------------------------------------------
// Beskrivning: hämtar kontotyp
// Inparametrar: 
// Returvärde: String returnerar kontotyp
//----------------------------------------------------------------------
public static String getAccountType(){
    return accounttype;
}

//----------------------------------------------------------------------
// Beskrivning: hämtar kontonummer
// Inparametrar: 
// Returvärde: int returnerar kontonummer
//----------------------------------------------------------------------
public static int getAccountId(){
    return accountId;
}

//----------------------------------------------------------------------
// Beskrivning: hämtar ränta
// Inparametrar: 
// Returvärde: double returnerar räntesatsen
//----------------------------------------------------------------------
public static double getIntRate(){
    return RATE;
}
//----------------------------------------------------------------------
// Beskrivning: beräknar ränta per år
// Inparametrar: 
// Returvärde: double returnerar saldot inkl. årsräntan i kronor
//----------------------------------------------------------------------
public static double calculateIntRate(){
    return balance += (balance * RATE) / 100;
}

//----------------------------------------------------------------------
// Beskrivning: utför transaktioner; insättning / uttag, och lämnar 
// meddelande om kontot understiger 0
// (Här fick jag hjälp från en föreläsning från Chalmers.
// http://www.cse.chalmers.se/edu/year/2009/course/TDA143/Lectures/F5.pdf)
// Inparametrar: double amount
// Returvärde: double returnerar nytt saldo om det finns täckning på konto
//----------------------------------------------------------------------
public double transaction(double amount){

    if(amount < 0 && balance + amount < 0)
        return -0;
    else
        return balance += amount;
}

//----------------------------------------------------------------------
// Beskrivning: variablerna blir utskrivbara
// Inparametrar: 
// Returvärde: String returnerar kontonummer, kontotyp, saldo och ränta
//----------------------------------------------------------------------
public String toString(){
    String infoAccount = "Kontonr: " + accountId + ", Kontotyp: " + accounttype +
    "\nSaldo: " + balance + ", Räntesats: " + RATE;
    return infoAccount;
}

}

Testclass:

import java.util.Scanner;
public class BankMenu
{
private BankLogic bank = new BankLogic();

//-----------------------------------------------------------------------------------
// Kör igenom ett testscenario
//-----------------------------------------------------------------------------------
public void test()
{
// Skriver ut bankinfo
    printBank();

    // Skapar testkunder...
    addCustomer("Karl Karlsson", 8505221898L, true );
    addCustomer("Donald Duck",   8505221898L, false);
    addCustomer("Pelle Persson", 6911258876L, true );   
    addCustomer("Lotta Larsson", 7505121231L, true );   

    // Skriver ut en lista med kunder
    printBank();

    // Byt namn på kund
    changeName("Kalle Karlsson", 8505221898L, true);

    // Byt namn på kund som inte finns...
    changeName("Olle Karlsson", 9905221898L, false);


    // Ssriver ut kund med konton
    printCustomer(8505221898L);


    // Skapa konton
    addSavingsAccount(8505221898L); // 1001
    addSavingsAccount(6911258876L); // 1002
    addSavingsAccount(8505221898L); // 1003 
    addSavingsAccount(7505121231L); // 1004


    // SKriver ut kunderna inklusive konton
    printCustomer(8505221898L);
    printCustomer(6911258876L);
    printCustomer(7505121231L);


    // Sätter in 700 kr på konto 1002 (ska ej gå pga fel kontoägare)
    deposit(8505221898L, 1002, 700, false);     

    // Sätter in 500 kr på konto 1001
    deposit(8505221898L, 1001, 500, true);                      

    // Ta ut 500 kr  på konto 1001
    withdraw(8505221898L, 1001, 500, true);                     

    // Ta ut 1 kr  på konto 1001 (ska ej gå)
    withdraw(8505221898L, 1001, 1, false);

    // Sätter in 1000 kr  på konto 1001
    deposit(8505221898L, 1001, 1000, true); 

    // Skriver ut kunderna inklusive konton
    printCustomer(8505221898L);
    printCustomer(6911258876L);
    printCustomer(7505121231L);

    // Skriv ut kontoinformation
    printAccount(8505221898L, 1001);
    printAccount(8505221898L, 1002);    // Går ej pga fel kontoägare

    // Avslutar konto
    closeAccount(8505221898L, 1001);    

    printBank();

    // Sätter in 5000 kr på konto 1003
    deposit(8505221898L, 1003, 5000, true);                         

    // Sätter in 5000 kr på konto 1003
    deposit(8505221898L, 1003, 5000, true); 
    printBank();

    addSavingsAccount(7505121231L); // Skapar konto 1005

    printCustomer(8505221898L);
    printCustomer(6911258876L);
    printCustomer(7505121231L);


    // Sätter in 1000 kr på konto 1005
    deposit(7505121231L, 1005, 1000, true);     

    // Tar ut 100 kr tre gånger på konto 1005
    withdraw(7505121231L, 1005, 100, true);
    withdraw(7505121231L, 1005, 100, true);                     
    withdraw(7505121231L, 1005, 100, true); 

    printBank();

    // Skriv ut kontoinformation
    printCustomer(7505121231L);

    // Tar bort kund
    removeCustomer(7505121231L);

    printBank();
    printAccount(6911258876L, 1003);

    // Insättningen går inte pga fel kontoägare
    deposit(6911258876L, 1003, 900, false);

    // Sätter in 900 kr på konto 1002
    deposit(6911258876L, 1002, 900, true);

    printCustomer(8505221898L);
    printCustomer(6911258876L);
    printCustomer(7505121231L);

    // Tar ut 900 kr från konto 1002
    withdraw(6911258876L, 1002, 900, true);

    // Tar bort kund
    removeCustomer(6911258876L);
    printBank();

    // Tar bort kund
    removeCustomer(8505221898L);
    printBank();
}

/**
 * Hjälpmetod för att skriva ut kundlistan
 */
private void printBank()
{
    System.out.println("\n## BANKEN INNEHÅLLER ##");
    System.out.println(bank.infoBank());
}

/**
 * Hjälpmetod för att skriva ut en kund
 * @param pNr - Personnummer
 */
private void printCustomer(long pNr)
{
    System.out.println("\n# UTSKRIFT AV KUND\t" + pNr);
    System.out.println(bank.infoCustomer(pNr));
}

/**
 * Hjälpmetod för att skriva ut information om ett konto
 * @param pNr - Personnummer
 * @param accountId - Kontonummer
 */
private void printAccount(long pNr, int accountId)
{
    System.out.println("\n# UTSKRIFT AV KONTO\t" + pNr + "\t" + accountId);
    System.out.println(bank.infoAccount(pNr, accountId));
}

/**
 * Hjälpmetod som skapar upp en kund samt skriver ut om testet blev godkänt
 * @param name - Kundens namn (för och efternamn)
 * @param pNr  - Kundens personnummer
 * @param check - skicka in true om det borde fungera eller false om det inte borde gå skapa kund
 */
private void addCustomer(String name, long pNr, boolean check)
{
    System.out.println("# SKAPA KUND\t" + pNr + "\t" + name);
    if(bank.addCustomer(name, pNr) == check)        
        System.out.println("\t- OK!");
    else
        System.out.println("\t- FEL!");
}

/**
 * Hjälpmetod som byter namn på en kund samt skriver ut om testet blev godkänt
 * @param name - Kundens namn (för och efternamn)
 * @param pNr  - Kundens personnummer
 * @param check - skicka in true om det borde fungera eller false om det inte borde gå skapa kund
 */
private void changeName(String name, long pNr, boolean check)
{
    System.out.println("# ÄNDRA NAMN\t" + pNr + "\t" + name);
    if(bank.changeCustomerName(name, pNr) == check)     
        System.out.println("\t- OK!");
    else
        System.out.println("\t- FEL!");
}


/**
 * Hjälpmetod som skapar upp ett konto samt skriver ut OK! om kontot skapades eller FEL! om kontot inte skapades
 * Konto kan bara skapas om man kunden existerar
 * @param pNr - kontoägaren
 */
private void addSavingsAccount(long pNr)
{
    int id = bank.addSavingsAccount(pNr);
    System.out.println("# SKAPA KONTO\t" + pNr + "\t" + id);
    if(id == -1)
        System.out.println("\t- FEL!");
    else
        System.out.println("\t- OK!");
}


/**
 * Hjälpmetod som sätter in pengar på konto samt skriver ut om testet blev godkänt
 * Ska bara gå göra om man skickar in personnummer och kontonummer som hör ihop
 * @param pNr - kontoägaren
 * @param accountId - kontonummret
 * @param amount  - belopp
 * @param check - skicka in true om det borde fungera eller false om det inte borde gå sätta in pengar
 */
private void deposit(long pNr, int accountId, int amount, boolean check)
{
    System.out.println("# INSÄTTNING\t" + pNr + "\t" + accountId + "\t" + amount + " kr");
    if(bank.deposit(pNr, accountId, amount) == check)                           
        System.out.println("\t- OK!");
    else
        System.out.println("\t- FEL!");
}

/**
 * Hjälpmetod som tar ut pengar från konto samt skriver ut om testet blev godkänt
 * Ska bara gå göra om man skickar in personnummer och kontonummer som hör ihop samt om belopp finns
 * @param pNr - kontoägaren
 * @param accountId - kontonummret
 * @param amount  - belopp
 * @param check - skicka in true om det borde fungera eller false om det inte borde gå sätta in pengar
 */
private void withdraw(long pNr, int accountId, int amount, boolean check)
{
    System.out.println("# UTTAG\t" + pNr + "\t" + accountId + "\t-" + amount + " kr");
    if(bank.withdraw(pNr, accountId, amount) == check)                          
        System.out.println("\t- OK!");
    else
        System.out.println("\t- FEL!");
}

/**
 * Hjälpmetod som stänger ett konto samt skriver ut information inklusive ränta man får
 * Ska bara gå göra om man skickar in personnummer och kontonummer som hör ihop
 * @param pNr - kundägaren
 * @param accountId - kontonummret
 */
private void closeAccount(long pNr, int accountId)
{
    System.out.println("# AVSLUTA KONTO\t" + pNr + "\t" + accountId);
    System.out.println(bank.closeAccount(pNr, accountId));                          
}

/**
 * Hjälpmetod som tar bort en kund inklusive konton från banken
 * @param pNr - kund
 */
private void removeCustomer(long pNr)
{
    System.out.println("# TA BORT KUND (+ KONTON)\t" + pNr);
    System.out.println(bank.removeCustomer(pNr));               
}

/**
 * Skapar en instans av BankMenu-klassen och kör igång menyn
 * @param   args    argument används inte
 */
public static void main(String[] args)
{

    BankMenu bankMenu = new BankMenu();
    bankMenu.test();
}

}

Answer 1

First of all debug your program and see if the ArrayLists aren't empty. If they aren't good, if they are empty then there must something wrong with your code.

And I think you've made your classes wrong.

Do you even use Interfaces ?

Answer 2

You need to call BankLogic infoCustomer() after putting some objects in the customerlist.

like you shoudn't use constructor to initialize the customerlist,better u can send a customerlist in this constructor as below

 public BankLogic(customerlist )
{
    this.customerlist = customerlist;

}

In the main method fromwhere you are calling this method you can add customer there

  Customer ob = new Customer("Sam",123)
  List<Customer> custlist = new Arraylist<Customer>();
  custlist.add(ob);
  BankLogic bank = new BankLogic(custlist );
 bank. infoCustomer(123);

Answer 3

There is a problem with your addCustomer method. what you are doing is that from your current code you never add any of the customers to the List before running your test methods in BankMenu class. So change the addCustomer method from

public boolean addCustomer(String name, long pNr)
{
    for (Customer customer : customerlist)
   {
        if (customer.getPCode() == pNr)
            return false;
       else
       {   
            customerlist.add(new Customer(name, pNr));
       }
  }
   return true;

}

to this

 public boolean addCustomer(String name, long pNr)
 {
    customerlist.add(new Customer(name, pNr));
    return true;
 }

and all the tests will work fine.