JAVA Stupidity... or not ?

for(int i = 0; i < 1000 ; ++i)
{
    Integer x = i;
    Integer y = i;

    if(x == y) {
        System.out.println("True");
    } else {
        System.out.println("False");        
    }
}

a "for" loop - assigning same iteration number to two seemingly different objects

Guess ?

What does "cached" means

The same object ("reference") would be returned from "new" operation for those Integers !

Actually - this is a guaranty  by the JRE - but it's possible some JRE implementations would cache a bigger portion

-128 < i < 127 : Integers are "cached" by the JRE

   128 < i       : Integers are not "cached"

• We have a bunch of them in a list
• We want to do something with them - let's say - PRINT :)

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    public int getAge() {
        // ...
    }

    public void printPerson() {
        // ...
    }
}

public static void printPersonsOlderThan(List<Person> roster, int age) {
    for (Person p : roster) {
        if (p.getAge() >= age) {
            p.printPerson();
        }
    }
}

• Readability - seems OK
• Extentiability - No

public static void printPersonsWithinAgeRange(List<Person> roster, int low, int high) {
    for (Person p : roster) {
        if (low <= p.getAge() && p.getAge() < high) {
            p.printPerson();
        }
    }
}

• Readability - same as before
• Extentiability - Still no

public static void printPersons(List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

interface CheckPerson {
    boolean test(Person p);
}

class CheckPersonEligibleForService implements CheckPerson {
    public boolean test(Person p) {
        return p.gender == Person.Sex.MALE &&
            p.getAge() >= 18 &&
            p.getAge() <= 25;
    }
}

printPersons(roster, new CheckPersonEligibleForSelectiveService());

And finally

printPersons(
    roster,
    new CheckPerson() {
        public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
        }
    }
);

• Readability - less code

  • still bulky - remember that the interface has only ONE method 

• Extentiability - Still no

interface CheckPerson {
    boolean test(Person p);
}

Still need this:

printPersons(
    roster,
    (Person p) -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25
);

• Readability - NO CLASS !!

  • ​but why do we need the interface ?

• Extentiability - YES

interface CheckPerson {
    boolean test(Person p);
}

Still need this:

public static void printPersonsWithPredicate(
    List<Person> roster, Predicate<Person> tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

• Readability - NO CLASS & no INTERFACE

• Extentiability - YES, but we can do better

interface Predicate<T> {
    boolean test(T t);
}

JDK defines several standard functional interfaces:

look in java.util.function

Change the print method:

use same approach as "5" to invoke

public static void processPersons(
   List<Person> roster,
   Predicate<Person> tester,
   Consumer<Person> block) {
        for (Person p : roster) {
            if (tester.test(p)) {
                block.accept(p);
            }
        }
}

• Readability - err... ok...

• Extentiability - over kill ;)

processPersons(
     roster,
     p -> p.getGender() == Person.Sex.MALE
         && p.getAge() >= 18
         && p.getAge() <= 25,
     p -> p.printPerson()
);

public static void processPersonsWithFunction(
    List<Person> roster,
    Predicate<Person> tester,
    Function<Person, String> mapper,
    Consumer<String> block) {
    for (Person p : roster) {
        if (tester.test(p)) {
            String data = mapper.apply(p);
            block.accept(data);
        }
    }
}

processPersonsWithFunction(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),
    email -> System.out.println(email)
);

• Readability - err... yicks...

• Extentiability - same

public static <X, Y> void processElements(
    Iterable<X> source,
    Predicate<X> tester,
    Function <X, Y> mapper,
    Consumer<Y> block) {
    for (X p : source) {
        if (tester.test(p)) {
            Y data = mapper.apply(p);
            block.accept(data);
        }
    }
}

processElements(
    roster,
    p -> p.getGender() == Person.Sex.MALE
        && p.getAge() >= 18
        && p.getAge() <= 25,
    p -> p.getEmailAddress(),
    email -> System.out.println(email)
);

• Readability - YES

• Extentiability - YES

roster
    .stream()
    .filter(
        p -> p.getGender() == Person.Sex.MALE
            && p.getAge() >= 18
            && p.getAge() <= 25)
    .map(p -> p.getEmailAddress())
    .forEach(email -> System.out.println(email));

The operations filter, map, and forEach are aggregate operations.

Aggregate operations process elements from a stream - a "pipeline" of elements

but in the Utils-Server - this might be cool

one of the most hated classes...

ever...

adding to the "sasspool" - SimpleDateFormatter, Calander and many more

Optional<User> tryFindUser(int userID) {
...
}

if(person.isPresent()){
  System.out.println(person.get());
}

NEXT LECTURE...