1 / 30

Arrays, List<E> and Iterator<E>

Arrays, List<E> and Iterator<E>. COMP 401, Spring 2014 Lecture 7 1 / 30 /2014. Array Review. Ordered sequence of elements Elements must be of the same type Fixed size once created Valid indices from 0 to length-1 Arrays are reference types

Download Presentation

Arrays, List<E> and Iterator<E>

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, List<E> and Iterator<E> COMP 401, Spring 2014 Lecture 7 1/30/2014

  2. Array Review • Ordered sequence of elements • Elements must be of the same type • Fixed size once created • Valid indices from 0 to length-1 • Arrays are reference types • Have fields and methods like other object types • In particular, size of array is available through length field • Declaring variables that can hold an array reference • type[] variable_name

  3. Creating Empty Arrays • With new keyword as in: • int[] iarray = new int[10]; • Point[] parray = new Point[7]; • What do we mean by empty? • For array of value of types • Elements get default value • 0 for numeric • false for boolean • For array of reference types • Elements set to null • You need to set each element after you create the array to point to either existing or new object. • Can create and initialize array with literal syntax as in: • int[] iarray = new int[] {1, 2, 6, 8, 10}; • Point[] parray = new Point[] {new Point(0,0), new Point(1,2), new Point(3,4)};

  4. Arrays as Reference Types • Same reference, same array • Implication for arrays passed to methods • When an array is passed to a method, any changes that the method makes to its elements is permanent. • Potential danger with object state • If holding object state in an array, easy to accidentally break encapsulation and expose object state to alteration. • Array cloning • Easy way to create a “shallow” copy of an array • Just call clone() method • Result will be a new array of same size with same values or references

  5. Multidimensional Arrays • Multidimension array is simply an array of arrays • Fill out dimensions left to right. int[][] marray = new int[5][]; for(inti=0; i<5; i++) { marray[i] = new int[10]; } • Each Sub-dimension can have independent size. • Sometimes known as as a “ragged” or “uneven” array int[][] marray = new int[5][]; for (inti=0; i<5; i++) { marray[i] = new int[i+1]; } • If each sub-dimension is same size, can create with a single new statement • int[][] marray = new int[5][10];

  6. Arrays utility class • Arrays is a library of useful functions for manipulating arrays • Note “s” in Arrays • Like Math class, all methods are static • binarySearch • sort • filling and copying subranges • http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html

  7. Java Collection Framework • Arrays are not resizeable • Often need a collection of items that acts like an array that can grow or shrink • Java Collection Framework • In package java.util • Defines a set of interfaces for resizeable collections • List • Ordered by integer index • Set • Unordered, no duplicate elements • Map • Indexed by an arbitrary key • Sometimes known as a “dictionary” • Provides a set of classes that implement these interfaces in specific ways • Examples for List: ArrayList, LinkedList,

  8. Java Collections as Generics • Java Collection Framework interfaces and classes are “generic” • Interface/class name is modified to specify type in the collection. • ArrayList<E> implements List<E> • E is a placeholder • Must be filled in by an actual type name when used. • For now, just want to have working knowledge of List as an interface and ArrayList as a collection that implements the interface.

  9. List<E> • boolean add(E val) • Adds val to end of list and returns true • void add(int index, E val) • Inserts val as position index • E get(int index) • Returns element at position index • E set(int index, E val) • Sets element at position index, returns original value for element • E remove(int index) • Removes element at position index, list shrinks • int size() • Returns current size of list • booleanisEmpty() • Same as testing size() == 0 • E[] toArray(E[] a) • Converts list to an array given current elements

  10. ArrayList<E> • ArrayList<E> is an implementation of List<E> • Uses an array internally • lec07.ex1

  11. Design Situation • Suppose we have an object that encapsulates some sort of collection. • SongLibrary • A collection of songs in an iTunes-like system • PolygonModel • A collection of polygons in a 3D modeling system

  12. Design Situation • Now suppose we have code outside of this collection object that needs to examine each element of the underlying collection in turn. • SongFilter • A object that represents a search criteria to be applied to a collection of songs • An intersection test in which each polygon of a PolygonModel needs to be evaluated

  13. Strategy 1: Provide access to underlying collection as an array. • SongLibrary • public Song[] getSongs() • PolygonModel • public Polygon[] getPolygons() • Drawbacks? • May have to do a lot of work to create the array • Collection may be result of generative process • There may be no “end” to the collection. • Or the collection may be large so we don’t want to provide the whole thing at once.

  14. Strategy 2: Provide index access to each underlying item in collection • SongLibrary • public intgetNumSongs(); • public Song getSong(intsong_idx); • PolygonModel • public intgetNumPolygons(); • public Polygon getPolygon(intpolygon_idx); • Drawbacks? • Doesn’t help with generative collections • Imposes restrictions on how collection is represented and linearized • Deteriorates encapsulation

  15. Strategy 3: Internalize a “cursor” • SongLibrary • public void resetSongCursor(); • public Song getNextSong(); • public booleanisCursorAtEnd(); • Drawbacks? • Can’t have two traversals going at the same time. • But, this does come close.

  16. Iterator Design Pattern • “Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation” • Gang of Four, Design Patterns • Consider: for(inti=0; i<slist.size(); i++) { Song next_song = slist.get(i); // Do something with next_song. }

  17. Iterator Design Pattern • Iterator object encapsulates details of item traversal. • Understands details of the underlying collection. • Manages order of items • May want a traversal that is not just first to last. • Underlying collection may not have a natural linear order. • Manages state of traversal • Allows traversal to be picked up again later. • Assumption: underlying collection is not changed or modified while the traversal is occurring. • Iterator should be able to detect this and signal an error • Variant of pattern will have iterator provide methods that modify underlying collection safely

  18. Componentsof Iterator Pattern • Collection object is “iterable” • Provides a method that returns an object that acts as an iterator. • Iterator object provides access to the elements in turn. • At the very least: • A method to test whether more items exist. • A method to retrieve the next item. • Other possible features: • Methods that remove an item safely. • Method to “peek” at the next item. • Method to reset the traversal.

  19. Java Iterator Pattern Interfaces • The Java Collections Framework defines two generic interfaces for supporting the iterabledesign pattern • Implemented by the various collection types such as List<E>, Map<E>, Set<E>, etc. • Iterable<E> • Interator<E> iterator() • Iterator<E>

  20. Iterator<E> • booleanhasNext() • Are we at the end of the traversal? • E next() • Get the next item of the traversal. • Throws a runtime exception if no next item. • void remove() • Not supported by all implementations. • Safely removes last item retrieved by next() from the underlying collection.

  21. Iterable examples • lec07.ex2 • Main1 • Simple use • Main2 • Parallel iterators • Main3 • Simultaneous iterators • Main4 • for – each syntactic sugar

  22. Main1 Visualized (1) ArrayList<Song> slist Words and Guitar 0 Dig Me Out 1 Jenny 2 Little Babies 3 Buy Her Candy 4

  23. Main1 Visualized (2) Iterator<Song> iter ArrayList<Song> slist list Words and Guitar 0 next_idx 0 Dig Me Out 1 Jenny 2 Little Babies 3 Buy Her Candy 4

  24. Main1 Visualized (3) Iterator<Song> iter ArrayList<Song> slist list Words and Guitar 0 next_idx 0 Dig Me Out 1 Jenny 2 public booleanhasNext() { if (next_idx < list.size()) { return true; } return false; } Little Babies 3 Buy Her Candy 4 NOTE: This may or may not be how it is actually implemented, but it is effectively what is going on.

  25. Main1 Visualized (4) Iterator<Song> iter ArrayList<Song> slist list Words and Guitar 0 next_idx 1 Dig Me Out 1 Jenny 2 public Song next() { Song s = list.get(next_idx); next_idx++; return s; } Little Babies 3 Buy Her Candy 4 NOTE: Real implementation would first check to see if hasNext() is still true and throw an exception otherwise.

  26. lec07.ex2.Main2 • Parallel iteration • Processes two different lists • Iterator associated with each. • Iterators advance unevenly

  27. lec07.ex2.Main3 • Simultaneous iteration • 2 Iterators, 1 List • Insert your own joke here.

  28. for - each • Java provides “syntactic sugar” for a particularly common use of iterators. • for-each loop • Supposing e_coll is Iterable<E>, then these are equivalent: Iterator<E> iter = e_coll.iterator(); while (iter.hasNext()) { E elem = iter.next(); // Do something with element } for (E elem : e_coll) { // Do something with elem } • lec07.ex2.Main4

  29. for-each with Array • The for-each construct also works with Arrays • Useful if you need to process the elements of an array but do not need the index. String[] names = new String[] {“Amy”, “Mike”, “Cameron”, “Claire”}; for (String n : names) { System.out.println(n); }

  30. lec07.ex3 • A more complicated iterator • Can build iterators that do things other than just go through every item. • Prior examples made use of Iterator<E> built into List<E>, here we are going to implement our own specialized version of Iterator<E>

More Related