set
play

Set 7 January 2019 OSU CSE 1 Set The Set component family allows - PowerPoint PPT Presentation

Aug 18, 2022 •333 likes •1.02k views

Set 7 January 2019 OSU CSE 1 Set The Set component family allows you to manipulate finite sets of elements of any (arbitrary) type 7 January 2019 OSU CSE 2 Interfaces and Classes Standard extends SetKernel extends Set implements

  1. Set 7 January 2019 OSU CSE 1

  2. Set • The Set component family allows you to manipulate finite sets of elements of any (arbitrary) type 7 January 2019 OSU CSE 2

  3. Interfaces and Classes Standard extends SetKernel extends Set implements implements Set1L Set3 Set2 7 January 2019 OSU CSE 3

  4. Interfaces and Classes Standard extends Standard has contracts SetKernel for three methods: clear newInstance extends transferFrom Set implements implements Set1L Set3 Set2 7 January 2019 OSU CSE 4

  5. Interfaces and Classes Standard extends SetKernel SetKernel extends has contracts for five methods: Set add implements remove implements removeAny contains Set1L Set3 Set2 size 7 January 2019 OSU CSE 5

  6. Interfaces and Classes Set Standard has contracts for two other methods: extends add remove SetKernel extends Set implements implements Set1L Set3 Set2 7 January 2019 OSU CSE 6

  7. Mathematical Model • The value of a Set variable is modeled as a (finite) set of elements of type T • Formally: type Set is modeled by finite set of T 7 January 2019 OSU CSE 7

  8. Constructors • There is one constructor for each implementation class for Set • As always: – The name of the constructor is the name of the implementation class – The constructor has its own contract (which is in the kernel interface SetKernel ) 7 January 2019 OSU CSE 8

  9. No-argument Constructor • Ensures: this = { } 7 January 2019 OSU CSE 9

  10. Example Code State Set<Integer> si = new Set1L<>(); 7 January 2019 OSU CSE 10

  11. Example Code State Set<Integer> si = new Set1L<>(); si = { } 7 January 2019 OSU CSE 11

  12. Methods for Set • All the methods for Set are instance methods , i.e., you call them as follows: s.methodName(arguments) where s is an initialized non-null variable of type Set<T> for some T 7 January 2019 OSU CSE 12

  13. add void add(T x) • Adds x to this . • Aliases: reference x • Updates: this • Requires: x is not in this • Ensures: this = # this union {x} 7 January 2019 OSU CSE 13

  14. Example Code State si = { 49, 3 } k = 70 si.add(k); 7 January 2019 OSU CSE 14

  15. Example Code State si = { 49, 3 } k = 70 si.add(k); si = { 49, 3, 70 } k = 70 7 January 2019 OSU CSE 15

  16. Example Note the aliasing here Code State between the “70s”, not shown in the tracing table si = { 49, 3 } but visible if you draw a diagram of this situation. k = 70 si.add(k); si = { 49, 3, 70 } k = 70 7 January 2019 OSU CSE 16

  17. remove T remove(T x) • Removes x from this , and returns it. • Updates: this • Requires: x is in this • Ensures: this = # this \ {x} and remove = x 7 January 2019 OSU CSE 17

  18. Example Code State si = { 49, 3, 70 } k = 3 m = -17 m = si.remove(k); 7 January 2019 OSU CSE 18

  19. Example Code State si = { 49, 3, 70 } k = 3 m = -17 m = si.remove(k); si = { 49, 70 } k = 3 m = 3 7 January 2019 OSU CSE 19

  20. Example Code State si = { 49, 3, 70 } k = 3 The precondition for m = -17 remove ( x is in this ) is satisfied whether or not m = si.remove(k); there is aliasing involving the “3s” in this situation. si = { 49, 70 } Why? k = 3 m = 3 7 January 2019 OSU CSE 20

  21. removeAny T removeAny() • Removes and returns an arbitrary element from this . • Updates: this • Requires: | this | > 0 • Ensures: removeAny is in # this and this = # this \ {removeAny} 7 January 2019 OSU CSE 21

  22. Example Code State si = { 49, 3, 70 } k = 134 k = si.removeAny(); 7 January 2019 OSU CSE 22

  23. Example Code State si = { 49, 3, 70 } k = 134 k = si.removeAny(); si = { 3, 70 } k = 49 7 January 2019 OSU CSE 23

  24. Example Other possible outcomes are: Code State si = { 49, 70 } k = 3 si = { 49, 3, 70 } or: k = 134 si = { 49, 3 } k = 70 k = si.removeAny(); si = { 3, 70 } k = 49 7 January 2019 OSU CSE 24

  25. contains boolean contains(T x) • Reports whether x is in this . • Ensures: contains = (x is in this ) 7 January 2019 OSU CSE 25

  26. Example Code State si = { 49, 3, 70 } k = –58 boolean b = si.contains(k); 7 January 2019 OSU CSE 26

  27. Example Code State si = { 49, 3, 70 } k = –58 boolean b = si.contains(k); si = { 49, 3, 70 } k = –58 b = false 7 January 2019 OSU CSE 27

  28. Example Code State si = { 49, 3, 70 } k = 70 boolean b = si.contains(k); 7 January 2019 OSU CSE 28

  29. Example Code State si = { 49, 3, 70 } k = 70 boolean b = si.contains(k); si = { 49, 3, 70 } k = 70 b = true 7 January 2019 OSU CSE 29

  30. Example The condition checked by Code State contains ( x is in this ) is satisfied whether or not si = { 49, 3, 70 } there is aliasing involving the k = 70 “70s” in this situation. Why? boolean b = si.contains(k); si = { 49, 3, 70 } k = 70 b = true 7 January 2019 OSU CSE 30

  31. size int size() • Reports the size (cardinality) of this . • Ensures: size = | this | 7 January 2019 OSU CSE 31

  32. Example Code State si = { 49, 3, 70 } n = –45843 n = si.size(); 7 January 2019 OSU CSE 32

  33. Example Code State si = { 49, 3, 70 } n = –45843 n = si.size(); si = { 49, 3, 70 } n = 3 7 January 2019 OSU CSE 33

  34. Overloading • A method with the same name as another method, but with a different parameter profile (number, types, and order of formal parameters) is said to be overloaded • A method may not be overloaded on the basis of its return type • Java disambiguates between overloaded methods based on the number, types, and order of arguments at the point of a call 7 January 2019 OSU CSE 34

  35. add void add(Set<T> s) • Adds to this all elements of s that are not already in this , also removing just those elements from s . • Updates: this , s • Ensures: this = # this union #s and s = # this intersection #s 7 January 2019 OSU CSE 35

  36. add void add(Set<T> s) • Adds to this all elements of s that are The add method for receivers not already in this , also removing just of type Set<T> is overloaded: those elements from s . • one method takes an argument of type T , and • Updates: this , s • one method takes an argument of type Set<T> . • Ensures: this = # this union #s and s = # this intersection #s 7 January 2019 OSU CSE 36

  37. Example Code State s1 = { 1, 2, 3, 4 } s2 = { 3, 4, 5, 6} s1.add(s2); 7 January 2019 OSU CSE 37

  38. Example Code State s1 = { 1, 2, 3, 4 } s2 = { 3, 4, 5, 6} s1.add(s2); s1 = { 1, 2, 3, 4, 5, 6 } s2 = { 3, 4 } 7 January 2019 OSU CSE 38

  39. Example In other words, this moves all elements of #s2 \ #s1 from s2 into s1 ; Code State it “conserves” objects of type T . s1 = { 1, 2, 3, 4 } s2 = { 3, 4, 5, 6} s1.add(s2); s1 = { 1, 2, 3, 4, 5, 6 } s2 = { 3, 4 } 7 January 2019 OSU CSE 39

  40. remove Set<T> remove(Set<T> s) • Removes from this all elements of s that are also in this , leaving s unchanged, and returns the elements actually removed. • Updates: this • Ensures: this = # this \ s and remove = # this intersection s 7 January 2019 OSU CSE 40

  41. remove Set<T> remove(Set<T> s) • Removes from this all elements of s that are also in this , leaving s unchanged, and The remove method for receivers returns the elements actually removed. of type Set<T> is overloaded: • one method takes an argument • Updates: this of type T , and • one method takes an argument • Ensures: of type Set<T> . this = # this \ s and remove = # this intersection s 7 January 2019 OSU CSE 41

  42. Example Code State s1 = { 1, 2, 3, 4 } s2 = { 3, 4, 5, 6} s3 = { 10 } s3 = s1.remove(s2); 7 January 2019 OSU CSE 42

  43. Example Code State s1 = { 1, 2, 3, 4 } s2 = { 3, 4, 5, 6} s3 = { 10 } s3 = s1.remove(s2); s1 = { 1, 2 } s2 = { 3, 4, 5, 6} s3 = { 3, 4 } 7 January 2019 OSU CSE 43

  44. Example In other words, this “conserves” all elements of #s1 and #s2 ; they all wind up in some Set<T> Code State rather than being “lost”. s1 = { 1, 2, 3, 4 } s2 = { 3, 4, 5, 6} s3 = { 10 } s3 = s1.remove(s2); s1 = { 1, 2 } s2 = { 3, 4, 5, 6} s3 = { 3, 4 } 7 January 2019 OSU CSE 44

  45. Iterating Over a Set • Suppose you want to do something with each of the elements of a Set<T> s • How might you do that? 7 January 2019 OSU CSE 45

  46. Iterating With removeAny Set<T> temp = s.newInstance(); temp.transferFrom(s); while (temp.size() > 0) { T x = temp.removeAny(); // do something with x s.add(x); } 7 January 2019 OSU CSE 46

  47. Iterating With removeAny Set<T> temp = s.newInstance(); temp.transferFrom(s); while (temp.size() > 0) { T x = temp.removeAny(); Recall that newInstance returns a // do something with x new object of the same object type s.add(x); ( dynamic type ) as the receiver, as if it were a no-argument constructor; } but we don’t need to know the object type of s to get this new object. 7 January 2019 OSU CSE 47

Recommend

More recommend