F21SF Software Engineering Foundations

Dept of Computer Science F21SFSoftware Engineering Foundations L8 - Arrays 2 arrays – pros and cons, ArrayList Monica Farrow EM G30 email : M.Farrow@hw.ac.uk Material available on Vision Arrays 2

Topics • More about arrays • Pros and cons • ArrayList class Arrays 2

Arrays (summary) • An array in java is a special kind of object, with a unique syntax • An array is a fixed-length sequence of values of the same type • Arrays are good for: • Fixed length sequences • Finding or altering elements according to their index position • An array is a kind of list. Lists are good for: • Holding elements in order (ideally order of adding) • Processing each element in turn, by traversing the list Arrays 2

numItems = 6 numItems = 5 1 3 0 9 8 3 1 3 0 8 3 0 1 2 3 4 5 6 index 0 1 2 3 4 5 6 index Problems with arrays • An array is created with a fixed size. • If our list is variable in size, • We need to make sure that there is room to add items • We need to keep a note of how many items are in the array, and alter it if the number of items changes • Deleting items from the middle of the array is time-consuming • All the elements which come after the deleted item should be shuffled down, one by one Arrays 2

Arrays contd • If order is important, adding and maintaining order is time-consuimng • All the elements which will come after the inserted element have to shuffled up, one by one (starting at the end) • Using arrays involves the programmer in writing a block of code for manipulations such as • Deleting an item • Sorting the array • Searching the array for a value • There are standard algorithms for these blocks, but careful coding and testing is still necessary. Arrays 2

ArrayList • The ArrayList class in the Java Collections Framework stores items in an array and provides methods for adding, removing and getting • You can use reliable methods for these operations • The size of the array is automatically enlarged if necessary • There is a size()method so you don’t have to keep updating the number of items you have. Arrays 2

import statement • Up till now, the java classes that we have used have been in the package java.lang which is always automatically included in a program • To use classes in a different package, we have to include an import statement at the start of the class file. • The import statement includes the name of the package and the name of the classes imported • Some people just import all the classes in the package • Only one import statement per package • It’s not obvious which classes are imported from where • E.g. import java.util.*; • Other people just import the classes needed • E.g. import java.util.ArrayList; Arrays 2

Generic types • Earlier versions of java did not allow the programmer to specify the content type of an ArrayList . Generic types, new in java 5, are an improvement. • <..> encloses the class of objects to be stored in the collection private ArrayList <Student> studentList; • Checks at compile time that classes match • Whatever goes into this ArrayList must be a Student. • Whatever comes out will be a Student. Arrays 2

Keeping a collection of student details • We would like to keep details of a group of students • Using the Student class from the previous lecture • This example demonstrates using an ArrayList of objects, and making a frequency report (counting!) • We often have a separate class which maintains the list of objects, and provides methods such as • These methods return information that we can find using ArrayList methods • Find how many items in the list • Find the nth item • These methods return information needed by our particular program • Searching for a particular entry in the list • Counting, summing, etc Arrays 2

A manager class • Typically a program will have • Classes for distinct objects e.g. Student, Car etc • Classes for collections of similar objects e.g. StudentList • A ‘manager’ or ‘interface’ class which handles the main functions of the program, often interacting through a GUI or text interface. So far our programs have no interaction – just writing to standard output. • A main method alone in a class to start the manager or interface class. • Today we introduce a ‘manager’ class which handles the top-level functions. For the Student application, this involves setting up a list of students, calling some of the StudentList methods, and producing output to Standard output Arrays 2

Class Diagram Main main(arg[] : String) : void StudentList studentList : ArrayList <Student> StudentList() populate() : void getSize() : int getAtIndex(index:int) : Student Various methods traversing the list and returning details StudentManager allStudents : StudentList StudentManager() run() : void Student Instance variables and methods as before Name Instance variables and methods as before Arrays 2

Keeping a collection of student details • The StudentList class starts: import java.util.ArrayList; //demonstrates using an ArrayList publicclass StudentList { private ArrayList<Student> studentList; //create an empty arraylist public StudentList() { studentList = new ArrayList<Student> (); } Arrays 2

Adding in student details • Done in the populate() method, discussed later • At the moment, pretend that we have put in details of student objects into the list. Arrays 2

Traversing the ArrayList • There is a special ‘for-each’ loop for collections such as ArrayList for (Object-type object-name : collection-name) • For each item in the collection, perform the loop body, referring to the object as object-name //for each Student object (refer to as s) //in studentList for (Student s : studentList){ //do something with s } Arrays 2

The getTableOfStudents method • It is better to have a method which returns a String rather than one that prints to System.out. In this way, the value which is returned can be written to standard output (today), to a text file, or displayed in a GUI (both, later in the course) public String getTableOfStudents() { String report = "ID NAME YEAR QUALIFICATIONS"; for (Student s : studentList){ report += String.format("%-6s", s.getId()); report += String.format("%-15s", s.getName().getFullName() ); report += String.format("%-4d", s.getYear()); report += "\n"; } return report; } Arrays 2

Getting input from the user • This code uses the method JOptionPane.showInputDialogwhich returns the user input as a String String id = JOptionPane.showInputDialog(null, "Enter id"); • To use this method, you also need an import statement • import javax.swing.JOptionPane; • More details about JOptionPane when we discuss GUIs • If you want integer input, you would have to convert it • An example of this is shown in the FileI/O and Exceptions lecture • intidnum = Integer.parseInt(id); Arrays 2

Searching the list • This code gets an id from the user, and uses a method in the StudentList class, findById() to find the student with the id given in the parameter. • It assumes that the student will be found. String id = JOptionPane.showInputDialog(null, "Enter id"); Student s = allStudents.findById(id); String firstName = s.getName().getFirstName(); System.out.println("The person with id " + id + " is called " + firstName); Arrays 2

Searching the list - findById • This method in the StudentList class searches the ArrayList of Student objects (studentList) for an entry with id which matches that given in the parameter. • Returns the object if found, null otherwise • Methods returning positive integers usually return -1 if not found public Student findById(String id) { for (Student s : studentList) if (s.getId().equals(id)) return s; returnnull; } Arrays 2

If id not found in list • The run method in StudentManager checks to see if the returned object is null or not, and gives the user 3 chances to enter a correct one. while (not found && count <3) get id and search for it inc count of tries if object returned get name and print it change found to true else if count < 3 print ‘Try again’ Arrays 2

The populate method • The populate method creates some people and adds them into the list • In a real system, this information would probably come from a database or text file //populate the array list publicvoid populate() { String [] quals1 = {"MIC", "ARA" }; Student s1 = new Student ("0011",new Name("Helen Scott"), quals1, 1); this.addOneStudent(s1); //method in same class etc... Arrays 2

Adding to the list • This method uses the ArrayList add method to provide Student objects to be added to the list • It doesn’t add it if there is already a Student object in the list with the same id. • It is quite common for methods to return true or false, to let the user know that they worked (next slide) publicboolean addOneStudent(Student s) { String id = s.getId(); Student inList = this.findById(id); if (inList == null) { studentList.add(s); //ArrayList add method returntrue; } returnfalse; } Arrays 2

Method purpose • Often methods do one of two things: • return a value which can be used later in the program • E.g. getModel(), estimateDistance() etc • Perform an action, and do not return a value (void) • E.g. System.out.println(), setModel(“Ka”) • The addOneStudent does both • It performs the add, and lets us know whether it has worked Arrays 2

Checking the add • We can then check the return value and see whether the add worked or not boolean ok = this.addOneStudent(s6); if (!ok) { System.out.println("Duplicate entry " + s6.getId()); } • But we can also choose to ignore the fact that the method returns a value. The populate() method shows both. this.addOneStudent(s6); Arrays 2

A frequency array • There is a method in the StudentList class which returns how many students are in each year. • First, find what the highest year is. • Then, declare an array of integers, each element represents the number of students in the corresponding year. Years go 1,2,3,4 etc. Indexes go 0,1,2, etc • Traverse list of students. For each student, find their year, and add 1 to the count with the index position ‘year-1’ Frequency = the count of the number students in the corresponding year 6 3 2 1 0 1 2 Maxyear -1 Index positions year 1 2 3 Maxyear Arrays 2

Frequency count int maxYear = getMaxYear(); //work out how many people at each year int [] freqYears = newint [maxYear]; for (Student s : studentList) { int y = s.getYear(); freqYears[y-1]++; } //create a report String report = "NUMBER OF STUDENTS IN EACH YEAR\n"; for (int i = 0; i < freqYears.length; i++) { report += "Year " + (i+1) + " : " + freqYears[i] + "\n"; } Arrays 2

The StudentList class continued • Examine the rest of the code in your own time. • In particular, notice differences between having integers in a java array, and objects in an ArrayList class • Using ArrayList methods such as add, get, size • Get the object from the array, then use the object’s methods • Special for-each loop for ArrayLists Arrays 2

Why Arrays • Arrays • Some programming languages only provide arrays as a form of list • Fast for accessing elements directly • Slow for adding and deleting elements if we want to keep the list in a sorted order • There are lots of alternative ways of storing lists • More about all this in Advanced Software Engineering Arrays 2

To Do Now • Read over lecture and example code. • A class with an ArrayList of objects is used in the remainder of the examples in this course Arrays 2

F21SF Software Engineering Foundations