caught Somewhere In Time = true;: August 8, 2010

In this blog entry, I'll try to explain another functional programming feature introduced by Google Guava library: Predicates. They work like the Function class with the difference that they just return a boolean value. It's possible to use Predicates for filtering elements in an Iterable that satisfy the given Predicate or to check if all/any element in an Iterable satisfies the given Predicate.

Lets write a Predicate that accepts Person objects with names that began with a vowel letter. But first, let me show you what's Person object.

01class Person implements Comparable < Person > {
02 public Person(String name, String lastName){
03  this.name = name;
04  this.lastName = lastName;
05 }
06 
07 public Person(){
08 }
09 public String getName() {
10  return name;
11 }
12 public void setName(String name) {
13  this.name = name;
14 }
15 public String getLastName() {
16  return lastName;
17 }
18 public void setLastName(String lastName) {
19  this.lastName = lastName;
20 }
21 private String name;
22 private String lastName;
23 @Override
24 public int compareTo(Person arg0) {
25  return this.getName().compareTo(arg0.getName());
26 }
27 
28 @Override
29 public String toString() {
30  return this.name+" "+this.lastName;
31 }
32 
33}

Now lets see what a Predicate looks like;

01Predicate < Person > allowNamesWithVowels = new Predicate < Person > (){
02 String[] vowels = { "a", "e", "i", "o", "u", "y" };
03 @Override
04 public boolean apply(Person person) {
05  String firstName = person.getName().toLowerCase();
06  // convert to lowercase just in case
07 
08  // for each vowel check if
09  // first name begins with that
10  // vowel
11  for(String vowel : vowels){
12   if(firstName.startsWith(vowel))
13    return true;
14  }
15 
16  return false;
17 }
18};

Now lets build a Person set and begin working using it.

01Person frodo = new Person("Frodo", "Baggins");
02Person sezin = new Person("Sezin", "Karli");
03Person luke = new Person("Luke", "Skywalker");
04Person anakin = new Person("Anakin", "Skywalker");
05Person eric = new Person("Eric", "Draven");
06 
07HashSet<person> setOfPerson = 
08Sets.newHashSet( eric, frodo, sezin, luke, anakin );
09System.out.println("set of person: "+setOfPerson);
10// [Sezin Karli, Luke Skywalker, Anakin Skywalker, Frodo Baggins]
11 
12</person>

filter() will use our Predicate and create a view from elements that satisfy the
Predicate

1Set < Person > view = Sets.filter(setOfPerson, allowNamesWithVowels);
2System.out.println("view: "+view); 
3// filter: [Eric Draven, Anakin Skywalker]
4// we remove eric from the view
5view.remove(eric);
6System.out.println("new view: "+view);
7//new view: [Anakin Skywalker]
8System.out.println("set of person: "+setOfPerson); 
9// [set of person: [Sezin Karli, Luke Skywalker, Anakin Skywalker, Frodo Baggins]

As you can see the removal of an item from the view causes the same removal from the origin set. This removal action is bidirectional. e.g. removal from the origin set will remove the corresponding element from the view.

Lets see what happens when I add to the original list.

1Person bilbo = new Person("Bilbo", "Baggins");
2Person alex = new Person("Alex", "Delarge");
3setOfPerson.add(bilbo);
4setOfPerson.add(alex);
5System.out.println("new view: "+view);
6// new view: [Anakin Skywalker, Alex Delarge]

The view is updated as well and the elements that are accepted by the predicate are added to the view. In the case above only alex is accepted. you can try add a new element to the view which does not met the predicate's requirement.

`1`	`Person jarjar =` `new` `Person("Jarjar",` `"Binks");`

`2`	`//view.add(jarjar);`

The commented line above will throw java.lang.IllegalArgumentException because the view does not accept elements that does not met the predicate's requirement.

The filter() method can be called from Iterables for all Iterable objects. All live-view tricks we saw earlier are still valid. But what I'll do for working on Maps? It's possible to filter Map objects using keys or values or both (entries) as input. First, I will build a game characters to appearance map.

1Map < String, Integer > characterAppearancesMap = Maps.newHashMap();
2characterAppearancesMap.put("Mario", 15);
3characterAppearancesMap.put("Snake", 8);
4characterAppearancesMap.put("Kratos", 4);

Now lets create the necessary Predicates. I'd like to have game characters with 'o' in their name and with lots of game appearances (more than 10 to be exact).

01Predicate < String >  allowNamesWithO = new Predicate < String > (){
02 @Override
03 public boolean apply(String name) {
04  String lowerCaseName = name.toLowerCase();
05 
06  return lowerCaseName.contains("o");
07 }
08};
09 
10Predicate < Integer > allowLotsOfAppearances = new Predicate < Integer > (){
11 @Override
12 public boolean apply(Integer appearance) {
13  int numberOfAppearance = appearance.intValue();
14 
15  return (numberOfAppearance > 10);
16 }
17};

First we will filter using the names (keys) and then we will filter using the number of appearances (values).

01Map < String, Integer >  filterKeys = 
02new HashMap  < String, Integer  > ( Maps.filterKeys(characterAppearancesMap, allowNamesWithO) );
03// I copy the live view
04System.out.println("Game Characters with 'o' in their name: "+filterKeys);
05// {Mario=15, Kratos=4}
06 
07Map < String, Integer >  filterValues = Maps.filterValues(filterKeys, allowLotsOfAppearances);
08System.out.println(
09"Game Characters with 'o' in their name and with more than 10 appearances: "+filterValues);
10//{Mario=15}

You can obtain the desired map by writing a single Predicate that will contain both predicates and use this Predicate on entries of a Map. It's not possible for Predicates.and() because we have to apply the Predicate on both keys and values but new Predicate built using and() can only be applied on keys or values. Lets create a new Predicate for our case.

01Predicate < Map.Entry < String, Integer > > characterPredicate =
02 new Predicate < Map.Entry < String, Integer  >  > (){
03 
04 @Override
05 public boolean apply(Entry<string, integer=""> entry) {
06  String key = entry.getKey();
07  int value = entry.getValue().intValue();
08 
09  return (key.contains("o") && value  > 10);
10 }
11 
12};
13 
14Map < String, Integer  > filterEntries =
15 Maps.filterEntries(characterAppearancesMap, characterPredicate);
16System.out.println("Are the game character results same? "+filterEntries.equals(filterValues));
17// As you can see the result is the same
18</string,>

Functions class has a static method that'll convert your Predicate to a Function. The said Function will use your Predicate and return the result as a Boolean.

01Function < Person, Boolean > vowelVerifier = Functions.forPredicate(allowNamesWithVowels);
02ArrayList < Person >  people = Lists.newArrayList(anakin, bilbo, alex);
03List<boolean> transform2 = Lists.transform(people, vowelVerifier);
04// Vowel verifier will return TRUE (FALSE) for each
05// person with TRUE (FALSE) Predicate result 
06System.out.println("Result: "+transform2); 
07//[true, false, true]
08// anakin and alex are true because the Predicate
09// was checking to see if the first name of the Person
10// begins with a vowel
11 
12</boolean>

CharMatcher is basically a Predicate who accepts Character (instead of objects). Due to this fact you can easily convert your Predicate to a CharMatcher. Lets assume that we have a Predicate that allows vowels only.

01Predicate < Character > allowVowel = new Predicate < Character > (){
02 char[] vowels = { 'a', 'e', 'i', 'o', 'u', 'y' };
03 @Override
04 public boolean apply(Character character) {
05  char lowerCase = Character.toLowerCase(character.charValue());
06 
07  for(char chr : vowels){
08   if(chr == lowerCase)
09    return true;
10  }
11 
12  return false;
13 }
14};

With forPredicate() we can build a CharMatcher from a Predicate. Lets use our new CharMatcher for counting vowels in a String.

1CharMatcher vowelMatcher = CharMatcher.forPredicate(allowVowel);
2int vowelCount = vowelMatcher.countIn("starkiller");
3System.out.println("Vowel Count in 'starkiller': "+vowelCount);

Predicates class contains several useful methods for creating Predicates. If you plan using Predicates you should take a look. Lets see its methods.

Assume that we don't want people with long last names. Our character limit can be 8 for instance. Lets write a Predicate for the purpose.

01Predicate < Person >  allowShortLastNames =
02 new Predicate < Person > (){
03 @Override
04 public boolean apply(Person person) {
05  String lastName = person.getLastName();
06 
07  return (lastName.length() < 8);
08 }
09};
10 
11System.out.println(setOfPerson);
12// [Alex Delarge, Frodo Baggins, Anakin Skywalker,
13//  Luke Skywalker, Bilbo Baggins, Sezin Karli]
14Set<person> onlyShortLastNames = 
15Sets.filter(setOfPerson, allowShortLastNames);
16System.out.println(
17"People with short last names: "+onlyShortLastNames);
18//[Sezin Karli, Alex Delarge, Bilbo Baggins, Frodo Baggins]
19 
20</person>

Because Skywalker is more than 7 characters it's filtered out. All other last names are in line with the predicate but what if I want a more complicated Predicate? For instance one which will accept people with first name that begins with a vowel and with short last name. I can combine 2 Predicates in this case.

1Predicate < Person >  combinedPredicates = 
2Predicates.and(allowShortLastNames, allowNamesWithVowels );
3Set < Person >  filter = Sets.filter(setOfPerson, combinedPredicates);
4System.out.println("Combined Predicates: "+filter); 
5// Alex Delarge

We know that longer last names will return false and we will be left with shorter last names. e.g. [Bilbo Baggins, Alex Delarge, Sezin Karli, Frodo Baggins].Then we will apply the vowel Predicate which will give [Alex Delarge] because Alex is the only first name that begins with a vowel. All Predicates that are combined will be applied for each element in the Iterable (Set, here). If one of the Predicates are false then the overall result is false else it will return true.

There are three and() methods. We show the one that'll work with 2 Predicates. There's a version that'll work with more than 2 Predicates (var-arg as argument). The last one takes Predicates from an Iterable that contains them (Iterable ). We previously used the boolean and() operator. It's also possible to combine Predicates with or() operator. or() will return true even one of the results is true if none is true then it'll return false. Assume that I want either short first names or short last names. I have a Predicate for last names. Lets add a new one for first names.

01Predicate < Person > allowShortFirstNames = new Predicate < Person > (){
02 @Override
03 public boolean apply(Person person) {
04  String firstName = person.getName();
05 
06  return (firstName.length()  <  8);
07 }
08};
09 
10Predicate < Person >  predicatesCombinedWithOr = 
11Predicates.or(allowShortLastNames, allowShortFirstNames);
12filter = Sets.filter(setOfPerson, predicatesCombinedWithOr);
13System.out.println(setOfPerson);
14System.out.println("Combined with or:"+filter);
15 
16// As you can see nothing is filtered because
17// setOfPerson elements have either short
18// first names or short last names
19// Lets add a person with a long first name
20// and last name
21 
22setOfPerson.add(new Person("Abdullah", "Jabbarian"));
23filter = Sets.filter(setOfPerson, predicatesCombinedWithOr);
24System.out.println("Combined with or 2: "+filter);
25// [Alex Delarge, Frodo Baggins, Anakin Skywalker, 
26// Luke Skywalker, Bilbo Baggins, Sezin Karli]
27 
28// As you can see Abdullah who has a long first and last name
29// is not in the new set.

It's possible to negate the Predicate in hand using not() method. Lets negate the combined predicate we created using and(). Normally we are accepting people with first name that begins with a vowel and with short last name. If we negate this the Predicate will accept people with first name that begin with a consonant and with a long last name.

01Predicate<person> negatedPredicates =
02 Predicates.not(combinedPredicates);
03 
04//Alex delarge was the only person with the predicate in hand.
05//When we negate the predicate
06//we will get a predicate that will return
07//every element but alex delarge
08 
09filter = Sets.filter(setOfPerson, negatedPredicates);
10System.out.println("Negated and combined Predicates: "+filter); 
11// [Frodo Baggins, Anakin Skywalker, Abdullah Jabbarian, 
12// Luke Skywalker, Bilbo Baggins, Sezin Karli]
13 
14</person>

Anakin is the only one with a vowel in the first name but as his last name is long he's allowed by the Predicate.

You can create two interesting Predicates using isNull() and notNull(). isNull() (notNull()) returns a Predicate that returns true if the object in hand is null (not null).

01setOfPerson.add(null);
02System.out.println(setOfPerson);
03//[null, Alex Delarge, Frodo Baggins, Anakin Skywalker,
04// Abdullah Jabbarian, Luke Skywalker, Bilbo Baggins, Sezin Karli]
05 
06Predicate < Person >  notNullPredicate = Predicates.notNull();
07// this predicate will return true if and 
08// only if the Person in hand is not null
09Set < Person >  filter2 = Sets.filter(setOfPerson, notNullPredicate);
10System.out.println(filter2);
11 
12//[Alex Delarge, Frodo Baggins, Anakin Skywalker, 
13//Abdullah Jabbarian, Luke Skywalker, Bilbo Baggins, Sezin Karli]

As you can see the null value is not present in the new view Set.

It's possible to use Predicates' contains() or containsPattern() methods for building a Predicate that'll accept only CharSequences that contain the given pattern. contains() takes a Pattern object while containsPattern() takes a regular expression as a String.

01// the Predicate below only accepts words with a number inside
02Predicate < CharSequence >  containsPattern = 
03Predicates.containsPattern("[0-9]");
04Set<string> sw = Sets.newHashSet("r2-d2", "luke", "c3po", "darth");
05Set<string> filter3 = Sets.filter(sw, containsPattern);
06System.out.println("New set of sw characters "+filter3);
07 
08// contains and containsPattern are similar
09Predicate < CharSequence >  containsPattern2 = 
10Predicates.contains( Pattern.compile("[0-9]") );
11Set < String >  filter4 = Sets.filter(sw, containsPattern2);
12System.out.println("Do they have the same result? "+filter4.equals(filter3));
13</string></string>

Another useful method of Predicates is in(). It allows elements that are inside a given Collection and rejects all others.

01ArrayList < String >  fruitList =
02 Lists.newArrayList("apple", "melon", "strawberry");
03Predicate < String >  fruitPredicate = Predicates.in(fruitList);
04List < String >  fruitBasket = 
05Lists.newArrayList("apple", "mango", "melon", "banana", "apple", "melon", "strawberry", "melon", "strawberry");
06Iterable < String >  filter5 = Iterables.filter(fruitBasket, fruitPredicate);
07// As Lists does not have a filter method I used from Collections2
08 
09System.out.println("Filtered Fruit Basket: "+filter5); 
10// Filtered Fruit Basket: [apple, melon, apple, 
11// melon, strawberry, melon, strawberry]
12// only 3 types of fruits are left as you can see
13 
14// If you dont need a live view you can easily use retainAll()
15// for both List and Set which has a similar effect.
16fruitBasket.retainAll(fruitList);
17System.out.println("Filtered Fruit Basket: "+fruitBasket);

Predicates' instanceOf() checks if the object in hand is an instance of the given Class.

01Predicate < Object >  listPredicate = Predicates.instanceOf(List.class);
02List < Collection <  collectionsList = 
03new ArrayList < Collection > ();
04collectionsList.add(new HashSet());
05collectionsList.add(new ArrayList());
06collectionsList.add(new LinkedList());
07collectionsList.add(new TreeSet());
08collectionsList.add(new LinkedHashSet());
09 
10Collection < Collection >  filter6 = 
11Collections2.filter(collectionsList, listPredicate);
12System.out.println("Are only Lists filtered? "
13+ (filter6.size() == 2) ); 
14// only two elements are allowed

Only instances of List are allowed so the result contains only the ArrayList and LinkedList.

Another interesting method of Predicates is compose(). compose() method allows you to process all your elements using the given Function and apply a Predicate on the result. You can do that in 2 steps but when you can do that in a single step do you need it? I have a set of objects of type Circle. I'd like to filter Circles with their area less than a value. It's possible do the calculation of the area in the Predicate or we can put the method in a helper class (e.g. Circles.getArea()). Another possibility is to write a Function for this operation.

01Function < Circle, Double >  calculateArea = 
02new Function < Circle, Double > () {
03 
04 @Override
05 public Double apply(Circle circle) {
06  double radius = circle.getRadius();
07  double area = Math.PI * radius * radius;
08 
09  return area;
10 }
11};
12 
13Predicate < Double >  allowCirclesWithLargeArea = 
14new Predicate < Double > () {
15 double value = 10d;
16 @Override
17 public boolean apply(Double area) {
18  return area > value;
19 }
20};
21 
22Predicate < Circle > allowCircles = 
23Predicates.compose(allowCirclesWithLargeArea, calculateArea);
24 
25HashSet < Circle > circleSet = 
26Sets.newHashSet( new Circle(3.5, 4.5, 0.3),
27 new Circle(2.5, 1.5, 0.03), new Circle(3.4, 4.6, 4.3),
28 new Circle(3.5, 6.5, 5.3), new Circle(0.5, 4.5, 12.3));
29 
30Set < Circle > filter7 = 
31Sets.filter(circleSet, allowCircles);
32System.out.println(
33"Allow circle with area less than 10: "+filter7);
34// output: Allow circle with area less than 10: 
35//[{x=0.5, y=4.5, radius=12.3},
36// {x=3.5, y=6.5, radius=5.3}, 
37//{x=3.4, y=4.6, radius=4.3}]

Each circle is first processed by calculateArea Function and their areas are obtained. Then allowCirclesWithLargeArea Predicate can be used for filtering the areas in hand.

Iterables class contains several methods for working using Predicates. all() and any() are quite straightforward as methods. all (any) returns true if all (any) elements in the given Iterable satisfy the given Predicate. I'm going to create Band class for storing two attributes of a Band (its name and country of origin). Then create a country Predicate so we can see what all() and any() do.

01class Band{
02 String name, country;
03 public Band(String name, String country) {
04  this.name = name;
05  this.country = country;
06 }
07 public String getName() {
08  return name;
09 }
10 
11 public void setName(String name) {
12  this.name = name;
13 }
14 
15 public String getCountry() {
16  return country;
17 }
18 
19 public void setCountry(String country) {
20  this.country = country;
21 }
22  
23 @Override
24 public String toString() {
25  return "{name= "+name+", country= "+country+"}";
26 }
27}

Now lets create the bands.

01Band stratovarius = new Band("Stratovarius", "Finland");
02Band amorphis = new Band("Amorphis", "Finland");
03 
04Set < Band > metalBands = 
05Sets.newHashSet(stratovarius, amorphis);
06 
07Predicate < Band > finlandPredicate = 
08new Predicate < Band > () {
09 @Override
10 public boolean apply(Band band) {
11  boolean result = 
12band.getCountry().equals("Finland"); 
13// is band country Finland?
14   
15  return result;
16 }
17};
18 
19 
20// Easy to predict what I'll do right?
21 //I have two bands from Finland and a Finland Predicate.
22 //So all() should return true to me because every band
23 //is from Finland.
24 
25 
26boolean all = 
27Iterables.all(metalBands, finlandPredicate);
28System.out.println(
29"every band is from Finland? "+all); // TRUE
30 
31// Lets add Mezarkabul to the band set
32// With this addition not every element
33// satisfies the Predicate
34 
35Band mezarkabul = new Band("Mezarkabul", "Turkey");
36metalBands.add(mezarkabul) ;
37 
38all = Iterables.all(metalBands, finlandPredicate);
39System.out.println(
40"every band is from Finland? "+all); // FALSE
41 
42 
43// Still any() should return true because
44// at least one element is still satisfying the
45// Predicate.
46 
47 
48boolean any = Iterables.any(metalBands, finlandPredicate);
49System.out.println(
50"at least one band is from Finland? "+any);

Lets remove all bands form Finland and see any()s behavior. There are more than one way to do that. The most straightforward way is to use removeIf() method of Iterables class which removes elements that satisfy the given Predicate from the given Iterable.

1Iterables.removeIf(metalBands, finlandPredicate);
2// you can see that none of the bands are from Finland as of now
3System.out.println(metalBands); 
4// output: [{name= Mezarkabul, country= Turkey}]
5 
6//lets see any()'s behavior now
7 
8any = Iterables.any(metalBands, finlandPredicate);
9System.out.println("at least one band is from Finland? "+any);

Iterables' filter() method can be used for filtering any Iterable using Predicates. It's similar to Collections2's filter method but usable for a larger number of Classes.

Iterables class has two more interesting methods. indexOf() which returns the index of the first element that satisfies the given Predicate. If it cant find a matching element it returns -1. The other method is find() which returns the first element which satisfies the given Predicate. If it cant find a matching element it throws NoSuchElementException. To sum up find() returns the object, indexOf() returns its index in the Iterable. As find() throws an exception in the case it couldnt find a matching element it would be wise to check first with indexOf() and then either use the index to obtain the object or to use find().

01metalBands.add(new Band("Lordi", "Finland"));
02 
03// returns the index of the
04// first element that satisfies
05// the predicate which's
06// Lordi
07 
08if(Iterables.indexOf(metalBands, finlandPredicate) != -1){
09 // here we are sure that
10 // such a band exists
11 Band bandFromFinland = 
12        Iterables.find(metalBands, finlandPredicate);
13 System.out.println("The first band from Finland: "
14                           +bandFromFinland);
15}

This is all for the Predicates. I hope I was able to give you a taste of functional programming in Java using Guava.

Thursday, August 12, 2010

google's guava library tutorial part 4: taste the functional programming flavor in java with predicates

caught Somewhere In Time = true;

About Me

Elasticsearch in Action

mail me

Search

Blog Archive

Labels

visitor count