Showing posts with label ordering. Show all posts
Showing posts with label ordering. Show all posts

Monday, May 17, 2010

google's guava library tutorial part 3: taste the functional programming flavor in java

Java is not a functional programming language but thanks to Google Guava Library
you can incorporate functional programming with it. In the third part of my tutorial I'll talk about Function which's one of the two classes related to the functional programming. The other is the Predicate class.

If you are not familiar to functional programming, I can briefly say that functions are like factories. They accept objects. They work using these objects and they return new and useful objects.

Usual Function definition in Guava contains two generics. The first one is the object type the function accepts, the second one is the object type it returns. The function below will accept a Person object, find the initial of this name and last name, create a StringBuilder containing these initials and return the StringBuilder object.


Function < Person, StringBuilder > returnNameInitials =
new Function < Person, StringBuilder > () {

@Override
public StringBuilder apply(Person person) {
// Sezin Karli
char firstCharOfName = Character.toUpperCase(person.getName().charAt(0)); // S
char firstCharOfLastName = Character.toUpperCase(person.getLastName().charAt(0)); // K

return new StringBuilder(firstCharOfName+
"."+firstCharOfLastName+"."); // S.K.
}
};


For the sake of completeness, lets give the Person object that'll be used during the examples.


class Person implements Comparable < Person > {
private String name;
private String lastName;

public Person(String name, String lastName){
this.name = name;
this.lastName = lastName;
}

public Person(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}

@Override
public int compareTo(Person arg0) {
return this.getName().compareTo(arg0.getName());
}

@Override
public String toString() {
return this.name+" "+this.lastName;
}
}


If you want, you can transform a whole list of Persons (the initial list) to a list of StringBuilders of person name initials (result list) using returnNameInitials function.



// process each Person in personList using
//returnNameInitials function
// return the result as a view of the initial list.
List < Person > personList =
Lists.newArrayList(new Person("sezin", "karli"),
new Person("brad", "delp"));
List < StringBuilder > transform3 =
Lists.transform(personList, returnNameInitials);
System.out.println("Name initials: "+transform3);
// o: Name initials: [S.K., B.D.]


Notice that any change in the initial list will result in updates in the obtained list. e.g. if you remove, change, add an element in the initial list you'll see that the corresponding element in the result list will get updated as well. The result list is basically the view of the initial list in hand. Functions work one way (from Person to StringBuilder here), so although it's said (in javadoc) that the updates are bi-directional you can't do much operation in the result (view) list. For instance, you can't add new elements. If I could add "T.P." to the result list, what name and last name will this Person have in the initial list? This information cannot be obtained from the Function we use. You can't change the element content of the result (view) list too. The reason is the same with the previous case. But as you probably guess, removing an element from the result (view) list has no negative impact. Corresponding element in the initial list will be removed as well.



personList.add(new Person("rick","nielsen"));
//added an element o: [S.K., B.D., R.N.]
System.out.println(transform3);
// R.N. is added so the addition to the initial
// list has an impact on the result list
personList.get(0).setName("tom"); //changed an element content
System.out.println(transform3);
// T.K. becomes M.K. so the update to the initial
// list has an impact on the result list
personList.remove(0);// remove the first element.
//o: [B.D., R.N.]
System.out.println(transform3);
//T.K. is no more so the update to the initial
//list again has an impact on the result list

transform3.remove(0);
System.out.println(personList);
// o: [rick nielsen]. as you can see the
// removal from the result list (view) has an impact
//on the initial list
transform3.get(0).append("B.");
// lets try to change to element content
System.out.println("transform 3: "+transform3);
// o: transform 3: [R.N.]. you cant see the change
//because you cant do updates on the result list
// if you check the initial list
// you'll see no change too



Collections2.transform() is similar to Lists.transform() with the difference that it can work on a larger number of classes. For instance, if you want to transform an HashSet of Person can't do that with Lists' or Sets' methods (though you can do it with Iterable.transform()). All the live view-related stuff is valid for Lists.transform().


Set < Person > personSet =
Sets.newHashSet(new Person("sezin", "karli"),
new Person("brad", "delp"));
Collection < StringBuilder > transform4 =
Collections2.transform(personSet, returnNameInitials);
System.out.println(transform4); // o: [S.K., B.D.]




Functions' compose() method allowsus to compose functions. if f: A->B and g: B->C then f o g: A->C. The output of the first function will be the input of the second function.


//Assume that we used to have a function
//for taking the square of a double.
Function < Double, Double > squareOfADouble =
new Function < Double, Double > () {

@Override
public Double apply(Double double1) {
return double1 * double1;
}
};


But I have a list of floats, what should I do in this case? I'd like to change the squareOfADouble function but there are previous code that uses it. What if I write a float to double function and compose both functions? First I'll convert float to double, then I'll apply square of a double function.


Function < Float, Double > floatToDouble =
new Function < Float, Double > () {

@Override
public Double apply(Float float1) {
return float1.doubleValue();
}
};

// thanks to autoboxing
// float values will be put to Float wrappers.
ArrayList < Float > floatList =
Lists.newArrayList(12.3536343f, 142.3346435633f, 1.44564564f);


// first the second function then the first
// function must be written.
Function < Float, Double > floatToDoubleSquare =
Functions.compose(squareOfADouble, floatToDouble);


List < Double > squareOfFloatsAsDoubles =
Lists.transform(floatList, floatToDoubleSquare);
System.out.println(squareOfFloatsAsDoubles);
// o: [152.61227005628461, 20259.149887098232,
// 2.089891460912341]


Functions class contains a number of useful methods. One of them is toStringFunction(). This predefined Function takes each object and returns their toString() result.


List < Person > newPersonList =
Lists.newArrayList(new Person("sezin", "karli"),
new Person("bilbo", "baggins"));
List < String > toStringList =
Lists.transform(newPersonList, Functions.toStringFunction());
System.out.println(toStringList);
// o: [sezin karli, bilbo baggins]



There are 2 quite useful methods in Functions for working with Maps.
The first forMap() performs a lookup from the given map and returns the value corresponding to the key in hand.


Map < String, Long > emailToEmployeeNo = Maps.newHashMap();
emailToEmployeeNo.put("luke@starwars.com", 1684684684L);
emailToEmployeeNo.put("darth@starwars.com", 245468687687L);
emailToEmployeeNo.put("obiwan@starwars.com", 368684674684L);

Function < String, Long > lookupFunction =
Functions.forMap(emailToEmployeeNo);
ArrayList < String > cantinaVisitOrder =
Lists.newArrayList("luke@starwars.com",
"darth@starwars.com", "obiwan@starwars.com", "luke@starwars.com", "darth@starwars.com");
List < Long > cantinaVisitOrderById =
Lists.transform(cantinaVisitOrder, lookupFunction);
System.out.println("cantina Visit Order By Id: "
+cantinaVisitOrderById);
//cantina Visit Order By Id:
//[1684684684, 245468687687, 368684674684,
// 1684684684, 245468687687]



First "luke@starwars.com" is checked from the map and 1684684684L is returned by the function. Beware that you have to be sure that every element in the initial list is available in the function's map as a key else you'll get IllegalArgumentException.

The other forMap() is more useful if you don't want to check the initial list's validity. If the corresponding key is not found during the lookup then the given value is returned by the function.



Long defaultId = 0L;
Function < String, Long > lookupFunctionWithDefault = Functions.forMap(emailToEmployeeNo, defaultId);
cantinaVisitOrder.add("greedo@starwars.com");
cantinaVisitOrder.add("yoda@starwars.com");

// greedo and yoda visited the cantina
// but they are not in the employee_email=id
// map

System.out.println("cantina visit order by emails: "
+cantinaVisitOrder);
//cantina visit order by emails:
//[luke@starwars.com, darth@starwars.com, obiwan@starwars.com,
// luke@starwars.com, darth@starwars.com,
// greedo@starwars.com, yoda@starwars.com]

List < Long > cantinaVisitOrderById2 =
Lists.transform(cantinaVisitOrder, lookupFunctionWithDefault);

// in the previous forMap() example we would
//take IllegalArgumentException
//for yoda and greedo. now you'll get the defaultId for them

System.out.println("cantina Visit Order By Id 2: "
+cantinaVisitOrderById2);

// as you can see the last 2 employees have 0 as id
//cantina Visit Order By Id 2: [1684684684,
//245468687687, 368684674684, 1684684684, 245468687687, 0, 0]




Maps class has two interesting methods that work with Functions; uniqueIndex() and transformValues(). The first one's a bit counterintuive but the second one is similar to the transform() methods we saw before.

Maps' uniqueIndex() takes two args: an iterable i and a function f. For each element e in the iterable i, function f is called and the result of f is used as the key to the value e. For the mathematically inclined, a new map of f(e)-e pairs will be built using f() and i.

In the example below, extractNickName extracts nicknames from the names (name in between '') when we call uniqueIndex with this function we will have nicknames as keys and full names as values. The result is an immutable map of nickname=fullname pairs. We will explain immutables at another part of the tutorial.


ArrayList < String > characterList =
Lists.newArrayList("Luke 'Blondie' Skywalker",
"Darth 'DarkHelmet' Vader", "Obiwan 'Ben' Kenobi");

Function < String, String > extractNickname =
new Function < String, String > () {

@Override
public String apply(String name) {
//Luke 'Blondie' Skywalker
//as there will be no space in our nicknames
//we can apply the split below
Iterable < String > tokens = Splitter.on(" ").trimResults().split(name);

for(String token : tokens){
// Luke, 'Blondie', Skywalker
if(token.startsWith("'")) //'Blondie'
return token.substring(1, token.length()-1);
// will remove ' in both ends
}

return "none";
}
};
ImmutableMap < String, String > nicknameToNameMap =
Maps.uniqueIndex(characterList, extractNickname);

System.out.println("nicknameToNameMap: "+nicknameToNameMap);
//nicknameToNameMap: {Blondie=Luke 'Blondie' Skywalker,
//DarkHelmet=Darth 'DarkHelmet' Vader, Ben=Obiwan 'Ben' Kenobi}



Lets see the other useful method of Maps; transformValues()


//For the example I write a Function that'll
// extract the username part of an e-mail.
Function < String, String > onlyUsernamePart =
new Function < String, String > () {

@Override
public String apply(String string) { //luke@starwars.com
int index = string.indexOf("@");
return string.substring(0, index); //luke
}
};

//lets create a star wars map with nicknames as
//keys and emails as values
Map < String, String > nicknameToMailMap =
Maps.newHashMap();
nicknameToMailMap.put("luke skywalker", "luke@starwars.com");
nicknameToMailMap.put("darth vader", "vader@starwars.com");


//Function will process the values
Map < String, String > viewMap =
Maps.transformValues(nicknameToMailMap, onlyUsernamePart);
System.out.println(viewMap);
//After the transformation only username part of the emails is left
//{darth vader=vader, luke skywalker=luke}
viewMap.remove("darth vader");
System.out.println(nicknameToMailMap);
// removal on the initial map has an impact on the view as before
//{luke skywalker=luke@starwars.com}

/*
* As Lists.transform() the Maps.transformValues()
* return us a view which's backed by the initial map.
* All view-related stuff is similar with List' transform() method.
* */



While we were explaining Ordering in part 2 of this tutorial, we skipped an important method because we didn't explain Functions. It's time for onResultOf() of Ordering class. Before the ordering the chosen function is applied to the iterable and then the sorting takes places.

I'd like to sort emails based on their domain name. For the purpose I wrote a Function that'll extract the domain part of an e-mail.


Function < String, String > onlyDomainPart =
new Function < String, String > () {

@Override
public String apply(String string) {
//luke@lightside.com
int index = string.indexOf("@");
return string.substring(index);
// lightside.com
}
};


ArrayList < String > usernames =
Lists.newArrayList("luke@lightside.com", "darth@darkside.com", "obiwan@lightside.com", "leia@starwars.com");

// onResultOf() will apply the given Function first
//and do the sort as it's desired.
List < String > sortedCopy8 =
Ordering.natural().onResultOf(onlyDomainPart).
sortedCopy(usernames);
System.out.println(sortedCopy8);
//[darth@darkside.com, luke@lightside.com,
// obiwan@lightside.com, leia@starwars.com]

/*As you can see the usernames list is
ordered based on the domain name
* */

Thursday, May 13, 2010

google's guava library tutorial part 2: joys of Ordering

In the first part of my tutorial , I explained anything related to Strings in Guava. In this part of my tutorial, I will explain the Ordering class which combines the power of Comparators with Collections' functionality and which adds other interesting features (such as compound comparators). This class is really useful if you need to order your Iterable, find the maximum/minimum element in your Iterable, find the index of an arbitrary element. It implements Comparator interface for backward compatibility.

I will use a basic Employee class during my examples. Employee is a mutable class with three attributes: id, name and years of service..



class Employee implements Comparable < Employee > {
private int id;
private String name;
private int yearsOfService;

public Employee(int id, String name, int yearsOfService){
this.id = id;
this.name = name;
this.yearsOfService = yearsOfService;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getYearsOfService() {
return yearsOfService;
}
public void setYearsOfService(int yearsOfService) {
this.yearsOfService = yearsOfService;
}
@Override
public int compareTo(Employee employee) {
return this.getName().compareTo(employee.getName());
}

@Override
public String toString() {
String toString = "id="+id
+"-name="+name+"-years of service="+yearsOfService;

return toString;
}

}


As I implemented Comparable in the Employee class, I have to add compareTo(). In this method I only compare the name of the employees. I'll create three employees and add them to an ArrayList.


Employee sezinKarli = new Employee(4, "Sezin Karli", 4);
Employee darthVader = new Employee(3, "Darth Vader", 5);
Employee hanSolo = new Employee(2, "Han Solo", 10);
List < Employee > employeeList =
Lists.newArrayList(sezinKarli, hanSolo, darthVader);
System.out.println("employee list: "+employeeList);
//output:
//employee list: [id=4-name=Sezin Karli-years of service=4,
// id=2-name=Han Solo-years of service=10,
// id=3-name=Darth Vader-years of service=5]


There are many ways to create an Ordering. You can create one using the good old Comparator, using a predefined list of objects that explicitly imposes the ordering strategy, using the toString() method of the objects in hand and using the compareTo() method of the objects. You'll need to implement Comparable in your object if you want to take the compareTo() road. Lets create two comparators. One for comparing the years of service and another for employee id.


Comparator < Employee > yearsComparator =
new Comparator < Employee >(){
@Override
public int compare(Employee employee1, Employee employee2) {
return (
employee1.getYearsOfService() - employee2.getYearsOfService());
}
};

Comparator < Employee > idComparator =
new Comparator < Employee >(){
@Override
public int compare(Employee employee1, Employee employee2) {
return (employee1.getId() - employee2.getId());
}
};


//Create an Ordering from a Comparator
Ordering < Employee > orderUsingYearsComparator =
Ordering.from(yearsComparator);
//Sort the employee list using years comparator
List < Employee > sortedCopy =

orderUsingYearsComparator.sortedCopy(employeeList);
System.out.println(
"sorted copy based on years of service comparator: "+sortedCopy);
/*
output:
sorted copy based on years of service comparator:
[id=4-name=Sezin Karli-years of service=4,
id=3-name=Darth Vader-years of service=5,
id=2-name=Han Solo-years of service=10]

*/


The example above is not different from calling Collections.sort() with the comparator in hand but notice that we don't sort Collections but Iterables.

With explicit(), we create an Ordering where we impose an order explicitly.
I want to order en enum type (colors) and I want red, blue, green as order. I created the enum type as instance variable.

static enum Colors{RED, GREEN, BLUE, YELLOW};


Not lets see the Ordering part.

Ordering < Colors > explicitOrdering =
Ordering.explicit(Colors.RED, Colors.BLUE, Colors.GREEN);

List < Colors > colorList =
Lists.newArrayList(Colors.BLUE, Colors.RED,
Colors.BLUE, Colors.GREEN, Colors.RED);

List < Colors > sortedCopy8 =
explicitOrdering.sortedCopy(colorList);
System.out.println("ordered color list: "+sortedCopy8);
//ordered color list: [RED, RED, BLUE, BLUE, GREEN]
//we imposed the RED, BLUE, GREEN order and
//the result conforms to that


Notice that explicit() works only with the given objects. You can't sort you iterable if you didnt specify the order in explicit(). If you try to to that you'll get IncomparableValueException.

Let me show you how to create an Ordering using toString() method of the object in hand.


Ordering < Object > usingToString = Ordering.usingToString();
// returns an ordering which uses the natural
// order comparator on toString() results of objects
List < Employee > sortedCopy3 =
usingToString.sortedCopy(employeeList);
System.out.println("sorted usingToString: "+sortedCopy3);

/*
sorted usingToString:
[id=2-name=Han Solo-years of service=10,
id=3-name=Darth Vader-years of service=5,
id=4-name=Sezin Karli-years of service=4]
*/


Lets create an Ordering with natural ordering (using compareTo() of the objects)


Ordering < Employee > natural = Ordering.natural();
List < Employee > sortedCopy4 = natural.sortedCopy(employeeList);
System.out.println("sorted with natural: "+sortedCopy4);
/*
sorted with natural:
[id=3-name=Darth Vader-years of service=5,
id=2-name=Han Solo-years of service=10,
id=4-name=Sezin Karli-years of service=4]

*/


We can do binary search on the sorted list for an element. Notice that the Ordering that calls the binary search method and Ordering that sorted the Iterable in hand must be the same. binarySearch() was available in Collections class just like min() and max() we'll see in next examples.


int binarySearch = natural.binarySearch(sortedCopy4, sezinKarli);
System.out.println("My index in the list: "+binarySearch); // 2


I will add elements of employee list, 2 null elements to a new list so we can explore new methods related to the handling of null elements.


List < Employee > employeeListWithNulls =
new ArrayList < Employee > (employeeList);
employeeListWithNulls.add(null);
employeeListWithNulls.add(null);



2 methods can be used for changing the handling of null elements. nullsFirst(), (nullsLast()) returns an Ordering which puts null elements to the beginning (end) of every non-null value.


// sort the employee list with natural ordering
// and put the null elements to the beginning
List < Employee > sortedCopy5 =
natural.nullsFirst().sortedCopy(employeeListWithNulls);
System.out.println("nulls first: "+sortedCopy5);
/*
nulls first:
[null, null, id=3-name=Darth Vader-years of service=5,
id=2-name=Han Solo-years of service=10,
id=4-name=Sezin Karli-years of service=4]

*/

// sort the employee list with natural ordering
//and put the null elements to the ending
List < Employee > sortedCopy6 =
natural.nullsLast().sortedCopy(employeeListWithNulls);
System.out.println("nulls last: "+sortedCopy6);

/*
nulls last:
[id=3-name=Darth Vader-years of service=5,
id=2-name=Han Solo-years of service=10,
id=4-name=Sezin Karli-years of service=4, null, null]

*/


I'd like to find the employee with the highest (lowest) time of service. I can do a sort based on years of service but that'll be slower then doing a single sweep for finding the element with max (min) year of service.


Employee employeeWithMaxYearsOfService =
orderUsingYearsComparator.max(employeeList);
System.out.println(employeeWithMaxYearsOfService);
// Han solo has the biggest year of service for the company

//lets find the minimum
Employee employeeWithMinYearsOfService =
orderUsingYearsComparator.min(employeeList);
System.out.println(employeeWithMinYearsOfService);
// Sezin has the smallest year of service for the company


/*
* min() and max() can be used for any iterable.
* Notice that these methods are overloaded and
* it's possible to use them on two elements or
* an arbitrary number of elements (var-arg)
* */

//Sezin or Darth has the longest year of service?
Employee max =
orderUsingYearsComparator.max(sezinKarli, darthVader);
System.out.println(max); //Vader

//Lets see the var-arg version,
// The result below must be the same
//with employeeWithMaxYearsOfService
//because we used each element in the
// employee list and the same Ordering
Employee max2 =
orderUsingYearsComparator.max(sezinKarli, darthVader, hanSolo);
System.out.println(
"Are the max results the same?: "
+max2.equals(employeeWithMaxYearsOfService)); //true



In each ordering we defined an increasing order. We can reverse the Ordering calling reverse() and obtaining a new Ordering. Lets build a new ordering that'll use the idComparator.


Ordering < Employee > reverseIdOrdering =
Ordering.from(idComparator).reverse();

// We will have an ordering of decreasing employee ids if we use
// this Ordering
List < Employee > employeeWithReverseIdOrder =

reverseIdOrdering.sortedCopy(employeeList);
System.out.println(
"employeeWithReverseIdOrder:"+ employeeWithReverseIdOrder);
/*
employeeWithReverseIdOrder:[
id=4-name=Sezin Karli-years of service=4,
id=3-name=Darth Vader-years of service=5,
id=2-name=Han Solo-years of service=10]

*/
// As you can see the ids are 4, 3 and
//2 (an array with decreasing order



A useful ability of Orderings is the fact that you can combine multiple Comparators with it. Call compound() for this. If the result of comparator1 is 0 then the second one will be called and this will continue until a non-zero value (a larger/smaller relationship) is obtained from the comparator. If all comparators return 0 then the elements are treated as equal (we get 0 from the combined comparator).


List < Employee > newEmployeeList =
Lists.newArrayList(new Employee(1, "Mr Pink", 8),
new Employee(2, "Mr Brown", 8), new Employee(3, "Mr Green", 3),
new Employee(4, "Mr Yellow", 5));

//We previously created an Ordering
// by id (orderUsingYearsComparator)
//Now lets add id comparator to this Ordering

Ordering < Employee > combinedComparatorOrdering =
orderUsingYearsComparator.compound(idComparator);
List < Employee > sortedCopy7 =
combinedComparatorOrdering.sortedCopy(newEmployeeList);
//First by years of service then by id
System.out.println("Combined comparators: "+sortedCopy7);
/*Combined comparators:
[id=3-name=Mr Green-years of service=3,
id=4-name=Mr Yellow-years of service=5,
id=1-name=Mr Pink-years of service=8,
id=2-name=Mr Brown-years of service=8]
*/



As you can see the years of service increase (3 then 5 then two 8). When years of service comparator see that the result is a draw the second comparator is called. As you can see Mr Pink and Mr Brown have the same years of service so their id are inspected and the order between them is calculated. As the id of Mr Pink is less than Mr Brown's he's before Mr Brown.

This is all for compound comparators.
There are two slightly different methods for checking if the iterable in hand is ordered. isOrdered() checks if each element is less than/equal to the subsequent element. isStrictlyOrdered() checks if each element is strictly less than the subsequent element.


List < Integer > integers = Lists.newArrayList(1, 2, 3, 4);
// This should return true from isOrdered() and isStrictlyOrdered()
// because the numbers are increasing( isOrdered() = true)
// and there's no consecutive and equal
// elements (isStrictlyOrdered = true)

boolean ordered = Ordering.natural().isOrdered(integers);
System.out.println("isOrdered: "+ordered);
boolean strictlyOrdered =
Ordering.natural().isStrictlyOrdered(integers);
System.out.println("isStrictlyOrdered: "+strictlyOrdered);

//Lets use another list with equal elements inside

List < Integer > newIntegers =
Lists.newArrayList(1, 2, 3, 3, 4);
// The numbers are increasing( isOrdered() = true)
// and there's consecutive and equal
// elements (isStrictlyOrdered = false)

ordered = Ordering.natural().isOrdered(newIntegers);
System.out.println("isOrdered: "+ordered);
strictlyOrdered =
Ordering.natural().isStrictlyOrdered(newIntegers);
System.out.println("isStrictlyOrdered: "+strictlyOrdered);



Using functions as Ordering is quite interesting, but I will explain functional programming capabilities later so lets skip it for the moment.