1 / 41

Reversing Input in Java: Arrays and Array Lists for CS

Read and print three numbers in reverse order - a Java application using arrays. Learn how to reverse 10 numbers efficiently.

rquinn
Download Presentation

Reversing Input in Java: Arrays and Array Lists for CS

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Arrays and Array Lists CS 21a

  2. Problem 1:Reversing Input • Problem: Read in three numbers and then print out the numbers in reverse order • Straightforward Java application • declare three variables of type double • read in String values for each of them and convert • print them out starting with the last variable read in public static void main( String[] args ) throws IOException { String temp; double num1, num2, num3; temp = console.readLine(); num1 = Double.parseDouble(temp); temp = cosole.readLine(); num2 = Double.parseDouble(temp); temp = console.readLine(); num3 = Double.parseDouble(temp); System.out.println( num3 ); System.out.println( num2 ); System.out.println( num1 ); }

  3. Generalizing a Program • Suppose we wanted the same program but wanted 10 instead of 3 numbers? • Suppose we wanted to read in 1000 numbers? • More than 3000 lines of code if we used the same approach! • Solution: arrays

  4. double nums[]is also legal, but double[] numsis preferred, since it emphasizes that the type is double[] (“double array” or “array of doubles”) Arrays • pronounced “ar-ray”, w/ stress on 2nd syllable • Definition • collection of elements of the same type • each element is accessed through an index • In Java, • declaration: double[] nums; • creation: nums = new double[8]; • use: nums[3] = 6.6; • Note: starting index is 0 (0 to 7, above)

  5. nums null Visualizing an Array Declare: double[] nums;

  6. 0.0 0 0.0 1 0.0 2 0.0 3 0.0 4 0.0 5 0.0 6 0.0 7 Visualizing an Array nums null Declare: double[] nums; Create: nums = new double[8];

  7. 0.0 0 0.0 1 0.0 2 0.0 3 0.0 4 0.0 5 0.0 6 0.0 7 Visualizing an Array nums 6.6 Declare: double[] nums; Create: nums = new double[8]; Use: nums[3] = 6.6;

  8. Reversing 10 numbers • Use arrays and loops • declare double[] nums • create new double[10] • use a for-statement to read in the numbers • use a for-statement to print them out in reverse public static void main( String[] args ) throws IOException { double[] nums = new double[10]; for ( int i = 0; i < 10; i++ ) { String temp = console.readLine(); nums[i] = Double.parseDouble(temp); } for ( int i = 9; i >= 0; i-- ) { System.out.println( nums[i] ); } }

  9. Scaling up • What if you want to change the number of elements? • would have to find and change all places using 10 (including the 9 in the for loop) • very tedious and error-prone public static void main( String[] args ) throws IOException { double[] nums = new double[10]; for ( int i = 0; i < 10; i++ ) { String temp = console.readLine(); nums[i] = Double.parseDouble(temp); } for ( int i = 9; i >= 0; i-- ) { System.out.println( nums[i] ); } }

  10. Using Constants public class ReverseArray { … public static final int MAX = 10; public static void main( String[] args ) throws IOException { double[] nums = new double[MAX]; for ( int i = 0; i < MAX; i++ ) { String temp = console.readLine(); nums[i] = Double.parseDouble(temp); } for ( int i = MAX - 1; i >= 0; i-- ) { System.out.println( nums[i] ); } } } • What if you want to change the number of elements? • would have to find and change all places using 10 (including the 9 in the for loop) • very tedious and error-prone • Solution: use a constant

  11. Using Constants public class ReverseArray { … public static final int MAX = 10; public static void main( String[] args ) throws IOException { double[] nums = new double[MAX]; for ( int i = 0; i < MAX; i++ ) { String temp = console.readLine(); nums[i] = Double.parseDouble(temp); } for ( int i = MAX - 1; i >= 0; i-- ) { System.out.println( nums[i] ); } } } • A constant has to be a class-wide variable (not a local variable) • Important keywords • static -- means value is shared by all instances (more later) • final -- means value can’t be changed (i.e., it’s a constant) • Capitalization • ALL_CAPS, words separated by underscore

  12. Constants and “Magic Numbers” • Constants are useful for “magic numbers”– i.e., specific values that are used throughout the code • e.g., MAX_LENGTH, SCREEN_WIDTH, PI, BLUE, DASHED_LINE, etc. • Useful because • makes code more readable and maintainable • e.g., WHITE is easier to understand and easier to remember than 255 • makes modifications easier • e.g., in reversing program example, we just need to change MAX. No need to look for 10 and 9 and change them.

  13. Problem 2: Collection of Objects • How can we write Bank so it can handle a larger number of BankAccounts? • Right now, we can only handle a small number of accounts (2 or 3) withdraw( “Alice”, “1234”, 200 ) getBalance( “Bob”, “4321” )

  14. Solution: Array of Objects • Declaration • BankAccount[] accounts; • Creation of the Array • accounts = new BankAccount[5]; • creates an array of references to BankAccounts • but no actual BankAccounts yet • Creation of Objects • for ( i = 0; i < 5; i++ ){ accounts[i] = new BankAccount();} • creates the BankAccounts themselves and assigns these to the references

  15. accounts null Visualizing an Array of Objects Declare: BankAccount[] accounts;

  16. BankAccount-type references null null null null null 0 1 2 3 4 Visualizing an Array of Objects accounts null Declare: BankAccount[] accounts; Create array: accounts = new BankAccount[5];

  17. null null null null null BankAccount balance 0 BankAccount balance 10 BankAccount balance 20 BankAccount balance 30 BankAccount balance 40 Visualizing an Array of Objects BankAccount-type references acounts 0 null 1 Declare: BankAccount[] accounts; 2 3 Create array: accounts = new BankAccount[5]; 4 • Create objects: • for ( i = 0; i < 5; i++ ){ accounts[i] = new BankAccount(i * 10);}

  18. null null null null null BankAccount balance 0 BankAccount balance 10 BankAccount balance 20 BankAccount balance 30 BankAccount balance 40 Visualizing an Array of Objects BankAccount-type references acounts 0 null 1 Declare: BankAccount[] accounts; 2 3 Create array: accounts = new BankAccount[5]; 4 • Create objects: • for ( i = 0; i < 5; i++ ){ accounts[i] = new BankAccount(i * 10);} Use objects:e.g., accounts[3].getBalance(); (returns 30)

  19. Approach • Include a name field in BankAccount • Create set and get methods for this field • Declare an array of BankAccount objects • Use a loop in the findAccount() method of Bank

  20. Approach • A field representing the acct name has been added: acctName • Constructor has been modified to accept an initial balance • Set and get methods were created to access acctName public class BankAccount { private double balance; private String acctName; public BankAccount( double initBalance ) { balance = initBalance; } public void setAcctName( String name ) { acctName = name; } public String getAcctName() { return acctName; } … }

  21. Approach • A field representing an array of BankAccounts was added: accounts • There is also a constant representing the maximum amount of bankAccounts bank can handle: MAX • The array is initialized in the constructor. It is also populated with 2 BankAccount objects named “john” and “marsha” public class Bank { private BankAccount[] accounts; private static final int MAX = 10; public Bank() { accounts = new BankAccount[MAX]; accounts[0] = new BankAccount(100); accounts[0].setAcctName(“john”); accounts[1] = new BankAccount(200); accounts[1].setAcctName(“marsha”); } … }

  22. Be careful when writing code like this. Doing this gives a NullPointerException if no BankAccount instance is assigned to that location. Approach • findAccount contains a for-statement that searches for the appropriate account • The getName() method of an account is used to get the name and compare it with the name parameter public class Bank { … private BankAccount findAccount( String name ) { for( int x = 0; x < MAX; x++ ) { if( accounts[x].getAcctName().equals(name) ) { return accounts[x]; } } return null; } … }

  23. One possible alternative as this first checks if the location contains an instance of BankAccount (i.e., not null) Approach • A reference to the correct account is returned when it is found, otherwise the value returned is null • A return statement is put inside the for-statement to “break out” of the loop when the correct account has been found public class Bank { … private BankAccount findAccount( String name ) { for(int x = 0; x < MAX; x++) { if ( accounts[x] != null ) { if( accounts[x].getAcctName().equals(name) ) { return accounts[x]; } } } return null; } … }

  24. Another possible alternative is to change the limit of x to the actual number of accounts the array contains. Approach public class Bank { … private BankAccount findAccount( String name ) { for(int x = 0; x < numAccounts; x++) { if( accounts[x].getAcctName().equals(name) ) { return accounts[x]; } } return null; } … }

  25. Approach • What is the value of numAccounts? public class Bank { private BankAccount[] accounts; private static final int MAX = 10; private int numAccounts = 0; public Bank() { accounts = new BankAccount[MAX]; accounts[0] = new BankAccount(100); accounts[0].setAcctName(“john”); accounts[1] = new BankAccount(200); accounts[1].setAcctName(“marsha”); numAccounts = 2; } … }

  26. Creating new BankAccounts public void openAccount( String name, int initbal ) { if ( numAccounts < MAX ) { accounts[numAccounts] = new BankAccount( initbal ); accounts[numAccounts].setAcctName( name ); numAccounts++; } else { System.out.println( "Maximum number of accounts reached" ); } }

  27. Using openAccount as a convenience method • In the Bank’s constructor: public Bank() { accounts = new BankAccount[MAX]; openAccount( "john", 1000 ); openAccount( "marsha", 2000 ); }

  28. More About Arrays • Arrays are objects • the array variable is just a reference to the actual array that contains the values • need to use “new” after declaring • passed as a reference when used as method parameter • Special features • a public final int length field returns the array size • in recent example, accounts.length would return 10 • [] operator only work with arrays

  29. More About Arrays • ArrayIndexOutOfBounds exception • valid indices for array of size n: 0 to n-1 • any access to other indices causes an error • Array size can’t be changed after array is created • To expand array, we need to create a new array, copy old array contents, then point array variable to new array

  30. Array Initializers • You can initialize an array with the following syntax: • String[] responses = { “Hello”, “Hi”, “How are you”, “How do you do” }; • Can be used for fields, local variables, and even constants

  31. Useful Pattern • Put different responses for different cases in an array • String[] responses = { “Hello”, “Hi”, “How are you”, “How do you do” }; • Assign an integer to represent different cases • In this case 0 means the program will say “Hello”, 1 means it will say “Hi”, etc. • Now you can generate the data for each case accordingly • e.g., What does the following code do? • int greetingCase = Math.random() * responses.length;String greeting = responses[greetingCase] + “World”;System.out.println( greeting );

  32. Multi-dimensional Arrays (Optional) • A natural extension of simple (1D) arrays • 2D declaration: char[][] grid; • think “array of arrays” • Array creation grid = new char[10][20]; // 10 rows, 20 columns • Another way grid = new char[10][]; // creates array of 10 char[]’s for (i = 0; i < 10; i++) { grid[i] = new char[20]; // creates a size-20 array } • This way allows for varying row sizes

  33. char[]-type references char[][] 0 1 null 2 3 4 Visualizing 2D Arrays Declare: char[][] grid; C Create array of rows: grid = new char[5][]; • Create rows: • for ( i = 0; i < 5; i++ ){ grid[i] = new char[3];} Use objects:e.g., grid[3][2] = ‘C’

  34. Using 2D Arrays • To refer to individual element, use two indices • e.g., grid[2][1] = ‘X’; • Using only one index refers to a single dimensional array • e.g., grid[4] refers to row 4 • grid[4].length is the length of row 4 (in this case, it’s 3) • The array variable by itself refers to the top-level array (i.e., the array of rows) • grid.length is the length of the array of rows (i.e., it’s the number of rows)

  35. Problem 3, Flexible collections • How can we write Bank so it can have an arbitrary number of BankAccounts? • Right now, we can only handle a small and fixed number of accounts (2 or 3) withdraw( “Alice”, “1234”, 200 ) getBalance( “Bob”, “4321” )

  36. The Java Collections Framework • A set of classes that you can use for containing arbitrarily large collections of objects • To use, you must say import java.util.*;at the top of your code • Some basic Collections classes • ArrayList, Vector • HashMap, Hashtable

  37. “Bart” “Lisa” “Maggie” ArrayList • Indexed list of objects that automatically resizes • The list is ordered, with each object in the list having an index, from 0 to n-1 • Most commonly used methods • boolean add( E element ) • int size() • E get( int index ) • E set( int index, E element ) • plus others (see API docs) ArrayList<String> names ArrayList 0 1 2 Note: ArrayLists in Java 5 is used slightly differently from its previous versions.

  38. “Bart” “Lisa” “Maggie” “Marge” You have to specify the type of object it has to store. ArrayList 0 1 2 3 ArrayList Example import java.util.*; public class ArrayListDemo1 { public void execute() { ArrayList<String> names = new ArrayList<String>(); names.add( "Bart" ); names.add( "Lisa" ); names.add( "Maggie" ); for ( int i = 0; i < names.size(); i++ ) { System.out.println( names.get( i ) ); } names.set( 1, "Homer" ); names.add( "Marge" ); for ( int i = 0; i < names.size(); i++ ) { System.out.println( names.get( i ) ); } } } ArrayList<String> names “Homer”

  39. BankAccount int balance 2000 String name ArrayList “Alice” 0 1 BankAccount int balance 1000 String name “Bob” Using Other Types ArrayList accts import java.util.*; public class ArrayListDemoWithBankAccounts { public void execute() { ArrayList<BankAccount> accts = new ArrayList<BankAccount>(); accts.add( new BankAccount( 2000 ) ); accts.get(0).setAcctName(“Alice”); accts.add( new BankAccount( 1000 ) ); accts.get(1).setAcctName(“Bob”)); for ( int i = 0; i < accts.size(); i++ ) { BankAccount curAccount = accts.get( i ); System.out.println( "Bank Account #" + i + "Owner: " + curAccount.getAcctName() + ", " + "Balance: " + curAccount.getBalance() ); } } }

  40. Simpler than a regular for loop. All you have to specify is the object (BankAccount) and the ArrayList (accts). Looping through ArrayLists • Using an index … for ( int i = 0; i < accts.size(); i++ ) { BankAccount curAccount = accts.get( i ); System.out.println( … ); } • Using an “enhanced for”… for ( BankAccount b : accts ) { System.out.println( b.getBalance() ); }

  41. Exercises • Modify the Bank class, add a createAccount() method that adds another BankAccount object for the Bank to manage. • First, do this using an array (accounts). • Then, convert Bank from arrays to ArrayLists.

More Related