Grouping Objects (I)

Transcription

1 KTH ROYAL INSTITUTE OF TECHNOLOGY Stockholm Sweden Grouping Objects (I) Managing collections of objects Ric Glassey

2 Main concepts to be covered Grouping Objects Using ArrayLists Looping with for-each syntax Collections in Java Generics 2

3 Grouping Objects 3

4 The requirement to group objects Many applications involve grouping objects: Personal organizers Library catalogs Student-record system The number of items varies across application lifecycle Items can be added Items can be accessed / modified Items be removed 4

5 QueueSystem Association with Aggregation of UserInterface Question User Inherits from FrontEnd Backend Student Assistant Administrator 5

6 Is this the best solution? class QueueSystem { // fields private User alice; private User bob; private User carol; private Question question1; private Question question2; private Question question3; private Question question4; // etc // constructors // methods 6

7 BlueJ Project: Music Organiser Manages a group of music files as String objects Track files may be added There is no limit to the number of files Mutable vs. Immutable groups Reports the current number of stored files Individual file names can be retrieved 7

8 Demo: Music Organiser v1 8

9 Using ArrayLists 9

10 Class Libraries in Java We don t have to write everything from scratch Most common problems have trusted solutions Official libraries of code 3rd Party libraries Java calls its libraries: packages Grouping objects is a recurring requirement The java.util package contains classes for doing this. 10

11 READ THE MANUAL

12 import java.util.arraylist; /** *... */ public class MusicOrganizer { // Storage for an arbitrary number of file names. private ArrayList<String> files; /** * Perform any initialization required for the * organizer. */ public MusicOrganizer() { files = new ArrayList<String>();... 12

13 The ArrayList Collection Java has a set of collections that vary in shape and behaviour (Lists, Maps, Sets, etc) ArrayList is a simple linear sequence of objects To use, we specify: the type of collection: ArrayList the type of objects it will contain: <String> private ArrayList<String> files; ArrayList of Strings called files 13

14 The ArrayList Collection ArrayList implements a List interface consisting of common operations on all Lists: add, get, size, etc. All Java collections are parameterised or generic types Most often, a collection will contain objects of a class By default, collections will accept multiple classes This should be avoided and collections should be parameterised The type parameter declares what we want a list of: ArrayList<Person> ArrayList<TicketMachine> 14

15 Creating an ArrayList object In versions of Java prior to version 7: files = new ArrayList<String>(); Java 7 introduced diamond notation files = new ArrayList<>(); The type parameter can be inferred from the earlier variable declaration statement: private ArrayList<String> files; 15

16 Object structures with collections 16

17 Adding a third file 17

18 Behaviour of the ArrayList It increases its capacity as necessary (mutable) It keeps a private count: size() accessor It keeps the objects in order Details of how all this is done are hidden Does that matter? Does not knowing how prevent us from using it? 18

19 Using the collection public class MusicOrganizer { private ArrayList<String> files;... public void addfile(string filename) { files.add(filename); Adding a new file public int getnumberoffiles() { return files.size(); Returning the number of files (delegation)... 19

20 Index numbering n.b. index starts from 0 20

21 Retrieving an object public void listfile(int index) { if(index >= 0 && index < files.size()) { String filename = files.get(index); System.out.println(filename); else { // This is not a valid index. Index validity checks Retrieve and print the file name Needed? (Error message?) 21

22 Removal may affect numbering 22

23 The general utility of indices Using integers to index collections has a general utility: next is: index + 1 previous is: index 1 last is: list.size() 1 the first three is: the items at indices 0, 1, 2 We could also think about accessing items in sequence: 0, 1, 2, 23

24 Review Collections allow an arbitrary number of objects to be stored via a single object e.g. files Class libraries usually contain tried-and-tested collection classes (official + 3rd party) Java s class libraries are called packages We have used the ArrayList class from the java.util package 24

25 Review Items may be added and removed via methods Each item has an index Index values may change if items are removed (or further items added) The main ArrayList methods are add, get, remove and size ArrayList is a parameterised or generic type 25

26 Demo: Music Organizer v2 26

27 Looping with for each syntax 27

28 Iteration We often want to repeatedly perform some action a number of times (e.g. iteration) E.g., print all the file names in the organizer. How many are there? Most programming languages include loop statement syntax to make iteration convenient Java has several sorts of loop statement We will start with its for-each loop Next week: for, while and Iterator objects 28

29 Iteration Strategies Visit all elements in a collection; perform action Visit all elements; selectively perform action Visit some elements until condition satisfied Visit some elements, but Starting and end point can vary Order is altered or reversed Not in natural sequence (stepping or skipping) Visit some or all elements; modify collection concurrently 29

30 For-each loop pseudo code General form of the for-each loop for keyword loop header for(elementtype element : collection) { loop body Statement(s) to be repeated Pseudo-code expression of the actions of a for-each loop For each element in collection, do the operations in the loop body. 30

31 Demo: Music Organizer v3 31

32 A Java example /** * List all file names in the organizer. */ public void listallfiles() { for(string filename : files) { System.out.println(filename); for each filename in files, print out filename 32

33 Selective processing Statements can be nested, giving greater selectivity: public void findfiles(string searchstring) { for(string filename : files) { if(filename.contains(searchstring)) { System.out.println(filename); 33

34 Critique of for-each Easy to write Termination happens naturally Some awkward questions for for-each loops: Can we start at a particular point in the collection? Can we step through / skip multiple objects? Can we stop mid-loop? Can we update the collection mid-loop? Explanation? Abstraction 34

35 Looping Review Loop statements conveniently allow a block of statements to be repeated many times The for-each loop allows iteration over a whole collection of objects Each object is guaranteed to be visited (definite iteration) Useful as this is the most common use-case Limitations: Indefinite iteration is not supported Index manipulation is not supported Concurrent collection modification is not supported 35

36 Short Syntax Quiz 36

37 What s wrong here? /** * Print out info (number of entries). */ public void showstatus() { if(files.size() == 0); { System.out.println("Organizer is empty"); else { System.out.print("Organizer holds "); System.out.println(files.size() + " files"); 37

38 This is the same as before! /** * Print out info (number of entries). */ public void showstatus() { if(files.size() == 0); { System.out.println("Organizer is empty"); else { System.out.print("Organizer holds "); System.out.println(files.size() + "files"); 38

39 This is the same again /** * Print out info (number of entries). */ public void showstatus() { if(files.size() == 0) ; { System.out.println("Organizer is empty"); else { System.out.print("Organizer holds "); System.out.println(files.size() + "files"); 39

40 and the same again /** * Print out info (number of entries). */ public void showstatus() { if(files.size() == 0) { ; { System.out.println("Organizer is empty"); else { System.out.print("Organizer holds "); System.out.println(files.size() + "files"); 40

41 What s wrong here? /** * Print out info (number of entries). */ public void showstatus() { if(isempty = true) { System.out.println("Organizer is empty"); else { System.out.print("Organizer holds "); System.out.println(files.size() + "files"); 41

42 The correct version /** * Print out info (number of entries). */ public void showstatus() { if(isempty == true) { System.out.println("Organizer is empty"); else { System.out.print("Organizer holds "); System.out.println(files.size() + "files"); 42

43 What s wrong here? /** * Store a new file in the organizer. If the * organizer is full, save it and start a new one. */ public void addfile(string filename) { if(files.size() == 100) files.save(); // starting new list files = new ArrayList<String>(); files.add(filename); 43

44 This is the same. /** * Store a new file in the organizer. If the * organizer is full, save it and start a new one. */ public void addfile(string filename) { if(files.size == 100) files.save(); // starting new list files = new ArrayList<String>(); files.add(filename); 44

45 The correct version /** * Store a new file in the organizer. If the * organizer is full, save it and start a new one. */ public void addfile(string filename) { if(files.size == 100) { files.save(); // starting new list files = new ArrayList<String>(); files.add(filename); 45

46 Collections in Java 46

47 Collections Framework Collections (like ArrayList) are essentially containers Store, retrieve, manipulate and communicate aggregations of objects Convenience for grouping objects in applications Java provides a Collections Framework Unified architecture for representing and manipulating multiple kinds of collections Common interface and operations 47

48 Collections Framework: Contents Interfaces (e.g. List) Provides a common vocabulary for interacting with a particular kind of collection, independent of its implementation details (info hiding) Implementations (e.g. ArrayList) Concrete implementations that are ready to use Algorithms (e.g. sort) Common operations that are required over collections independent of the objects 48

49 Collection Interface All collections derive from this interface List, Set, Map, Queue Supports operations common to all collections int size( ) boolean isempty( ) boolean containsobject(object element) boolean add(object element) boolean remove(object element) 49

50 List Interface & Implementation Extends from Collection interface Ordered collection or sequence Can contain duplicates Additional specific operations (level of detail) positional access, e.g. get, set, add search for object and return position/index iteration across elements in sequence The ArrayList and LinkedList are implementations 50

51 import java.util.*; class ListTest { public static void main(string[] args) { // Change to LinkedList and compare the time difference :) List<Integer> mylist = new ArrayList<>(); int size = ; // Add numbers to mylist for (int i=size; i>0 ; i-- ) { mylist.add(i); // Time the sort algorithm long start = System.nanoTime(); Collections.sort(myList); long stop = System.nanoTime(); // Print the runtime in nanoseconds System.out.println(stop-start);

52 Common Algorithms Many useful operations have been included and optimised for performance and stability sort shuffle reverse frequency etc 52

53 Common Algorithms import java.util.*; class Sorting { public static void main(string[] args) { ArrayList<String> words = new ArrayList<>(); words.add("what"); words.add("a"); words.add("wonderful"); words.add("day"); words.add("to"); words.add("code!"); Collections.sort(words); System.out.println(words); 53

54 Collections Framework: Benefits Reduces programmer effort Increases speed and quality Reduces learning effort Reduces complexity of creating new collections Encourages software reuse Very important to DD1338 in that we will be implementing their underlying behaviour and investigating their properties in time/space complexity 54

55 Generics 55

56 Motivation Java is statically typed and thus allows a lot of type-related bugs to be detected by the compiler Raw Type collections (no parameterisation) were default prior to Java 5.0 Collections could store any type without problem However this leads to potential runtime bugs 56

57 Raw Type vs Parameterised ArrayList myintlist = new ArrayList(); myintlist.add(new Integer(100)); myintlist.add(200); // auto-boxing // note use of type-casting operation Integer x = (Integer) myintlist.get(0); Integer y = (Integer) myintlist.get(1); 57

58 Raw Type vs Parameterised ArrayList<Integer> myintlist = new ArrayList<>(); myintlist.add(new Integer(100)); myintlist.add(200); Integer x = myintlist.get(0); Integer y = myintlist.get(1); Much better, but why? Less typing? 58

59 Raw Type vs Parameterised ArrayList myintlist = new ArrayList(); myintlist.add(new Integer(100)); // compiler is ok with that myintlist.add("200"); // oops! // note use of type-casting operation Integer x = (Integer) myintlist.get(0); // potential class cast exception at runtime Integer y = (Integer) myintlist.get(1); Any object can be added to collection 59

60 Raw Type vs Parameterised ArrayList<Integer> myintlist = new ArrayList<>(); myintlist.add(new Integer(100)); // compile-time error myintlist.add("200"); Integer x = myintlist.get(0); Integer y = myintlist.get(1); The compiler is once again helping 60

61 Creating Generic Classes Most often encountered when using collections You may create your own Provides stronger type checking at compilation Eliminates the need for cast operations We need to add new syntax to class definitions Formal type declarations 61

62 A basic container First, we make a simple class that can contain any object n.b It allows any type to be added, and may need cast operations, e.g. using + operator Then, we try to use generics to make it safer and with no need for casts 62

63 public class Container { private Object o; public void set(object o) { this.o = o; public Object get() { return this.o; public static void main(string[] args) { Container c = new Container(); c.set(10); c.set("10"); System.out.println(c.get()); 63

64 public class Container2<T> { private T t; public void set(t t) { this.t = t; public T get() { return this.t; public static void main(string[] args) { Container2<Integer> c = new Container2<>(); c.set(10); c.set( 10"); // will throw compile error System.out.println(c.get()); 64

65 Generics Roundup Emphasis on type safety and readability Generics will become more useful as we create our own collections in DD1338 The final version of Music Organiser (v5) highlights: use of collections use of class libraries (official and 3rd party) use of generics 65

66 Demo: Music Organizer v5 66

67 Concept Review 67

68 Concept Review Grouping objects together is another important form of abstraction in Java Java commonly refers to groups of objects as a collection The ArrayList stores a mutable sequence of (parameterised) objects and provides methods to manipulate the grouped objects 68

69 Concept Review The for each looping strategy provides a simple approach to iterating across an entire collection of objects, but has limitations Every object will be visited Does not support index manipulation, indefinite iteration and concurrent modification 69

70 Concept Review In Java, the collections framework provides a set of interfaces to common collection types and a set of common operations/methods to manipulate them Generics provide a convenient manner of introducing more type safety and less type conversions by removing cast operations 70

71 *Required Reading* Chapter 4 Sections 4.1 to 4.11 Objects First with Java, 4th/5th Edition Optional Texts! Code Complete and Effective Java 71