Bdtjtk

This code is pretty fast but I would like to make it faster without using HashMap.

I have a list of Accounts and I am currently looping them to check if account.getAccountNumber().equals(accountNumber)

Is there a way to improve this using Java 8?

public Account getAccountFromCustomer(String customerID, String accountNumber) {

    List<Account> accounts = getAccountsFromCustomer(customerID);

    for(Account account : accounts) {

        if(account.getAccountNumber().equals(accountNumber)) {

            return account;

        }

    }

    return null;

}

Maybe I understood the question wrong but there is a performance improvement if I use parallel:

@Test

public void testIt(){

    Integer accountNumberLookingFor = 50001;



    List<Account> accounts = new ArrayList<>();

    for (int i = 0 ; i < 100000; i++){

        accounts.add(new Account(i));

    }



    Stopwatch stopwatch = Stopwatch.createStarted();

    accounts.stream().filter(account -> account.accountNumber.equals(accountNumberLookingFor)).findFirst().orElse(null);

    System.out.println("Time of execution in milliseconds:" + stopwatch.stop().elapsed(TimeUnit.MILLISECONDS));





    stopwatch = Stopwatch.createStarted();

    accounts.stream().parallel().filter(account -> account.accountNumber.equals(accountNumberLookingFor)).findFirst().orElse(null);

    System.out.println("Time of execution in milliseconds:" + stopwatch.stop().elapsed(TimeUnit.MILLISECONDS));



}



private class Account{

    Integer accountNumber;



    private Account(Integer accountNumber){

        this.accountNumber = accountNumber;

    }



    @Override

    public String toString(){

        return "Account number: ".concat(String.valueOf(accountNumber));

    }



}

leads to:

Time of execution in milliseconds without parallel:50  

Time of execution in milliseconds with parallel:9

I'm not familiar with the classes, used in this example, but from an algorithm point of view, it looks like your are doing the following:

// Create an unordered list.

getAccountsFromCustomer();

// Run through it

for(Account account : accounts) {

  if matches()...

}

The speed of this algorithm is O(n).

If you put the results in an ordered list, you might use a binary search. You'll need a O(n*log n) algorithm to create that list (not just adding account names at the end of the list, but inserting in an alphabetical ordered way), and afterards you use a binary search for finding the account name within that list (performance O(log n).

Obviously, you'll need two separate functions for that:

• One function which creates the list (this function is called only once).


• One function for finding the account number (this function is called every time you need to find the account, based on its account number).