OCP - 1

You can add only objects that implement the Comparable interface!

Uing the Comparator static helper fuctions, eg:

Comparator<Squirrel> c = Comparator.comparing(s -> s.getSpices()).thenComparingInts(s -> s.getWeight));

• Static Methods
• Instance Methods on a particular instance
• Instance methods on an instance to be determined at runtime
• Constructors

Consumer<List<Integer>> methodRef1 = Colelctions::sort;

Consumer<List<Integer>> asLambda = l -> Colelctions.sort(l);

Predicate<String> methodRef = str::startsWith;

Predicate<String> asLambda =  s -> str.startsWith(s);

Predicate<String> methodRef = String::isEmpty;

Predicate<String> asLambda =  s -> s.isEmpty();

Supplier<ArrayList> constRef = ArrayList::new

Supplier<ArrayList> constRef = () -> new ArrayList();

boolean removeIf(Predicate<? super E> filter)

Iterates through the list and applies the Predicate to each element. If the Predicate returns true, it will be removed.

returns true if any elements were removed

void replaceAll(UnaryOperator<E> o)

Calls the UnaryOperator for every Element and replaces the value with the returned value

void forEach(Consumer<? super E> action)

• putIfAbsent
• merge
• computeIfPresent
• computeIfAbsent

V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)

merge(key, value,function)

• If the the value for the given key is null or not present, insert the provided value.
• Otherwise, replace the value for the given key with the result of function
  • function takes the value from the map as the first argument and the new value as the second one.

Map<String, String> leMap = new HashMap<String, String>();

String result;
result = leMap.merge("key", "v1", (k1, k2) -> k1 + k2);
result = leMap.merge("key", "v2", (k1, k2) -> k1 + k2);
result = leMap.merge("key", "v3", (k1, k2) -> k1 + k2);

System.out.println(result);

The compiler generates it on the enum class

All enums implicitly extend the enum in which these methods are defined

• For Classes: At Compiletime
• For Interfaces: At Runtime

It basically means that Jva will look at subclasses when finding the right method to call (override)

It is helpful because the compiler can tell you when you've messd up

public boolean equals(Object obj)

• "Should not change at random"
  • reflexive: x.equals(x) == true
  • symmetric: x.equals(y) == y.equals(x)
  • transitive: x.equals(y) == y.equals(z) == z.equals(x)
  • consistent: x.equals(y) == x.equals(y) (does not change when x and y are not modified)
• An object an null are not equal
  • x.equals(null) must return false

• The result must not change -> derive it from members that do not change (eg. an id)
• The hasCode() can use a subset of equals
  • two equal objects must return the same hashcode
• the hash code can be a constant, altough it is not efficient

public int hashCode()

By using the enum keyword instead of the class keyword

yes, think of them as static final constants

• Static:
  • MyEnum.values(): Returns an array containing the constants of this enum
  • MyEnum.valueOf("string"): Create an enum from a string
• Instance:
  • MyEnum.FIRST.name(): Returns the name of this enum constant, exactly as declared in its enum declaration
  • MyEnum.FIRST.ordinal(): ordinal of this enumeration constant

An IllegalArgumentException is Thrown

No

The enum type is implied in the case statements and it is not allowed to type it!

switch(myEnum){
  case ONE:  // NOT MyEnum.ONE
  // ...
}

No, it wont' compile!