Reverse Coding

SOLID principles explained by Sandro Mancuso

2017-08-05T10:54:22+00:00

SOLID principles

Have you ever heard SOLID principles?

SOLID stands for:

Single responsibility principle
Open/closed principle
Liskov substitution principle
Interface segregation principle
Dependency inversion principle

Easy to understand, easier to violate

Those principles are not difficult to understand when you initially study them, however, stick to them in your daily job is not trivial at all. Let’s make an example on the first one - Single Responsibility Principle - the easiest and probably the most violated one.

Let’s imagine you have a function named _calculateTotalPrice(..) _and it’s long, I don’t know, let’s say 50 lines of code. Is the single responsibility principle respected?

Maybe yes, is doing one thing: calculate the total price of the cart. However, when we look at the code we see something like that:

Price calculateTotalPrice(){
  //15 lines to multiply price of the single product by ordered quantity 
  //10 to sum all the entries of the cart
  //15 to apply discounts
  //10 lines to apply taxes
}

Are you still convinced the method is following Single Responsibility Principle? Clearly not.

It does five things:

Coordinate total price calculation by applying sequentially four operations
Calculate single entry price
Sum all entries price
Apply discount
Apply taxes

If one of those five things changes, we have to touch this method - clearly it has more than one responsibility.

It’s really easy to violate them without even realizing it.

Functional is cool, but do you know OO: by Sandro Mancuso

So today we will not speak about Java 8 or Spring MVC but Objected Oriented principles.

We start by suggesting this talk by Sandro Mancuso.

Spring MVC @Requestparam - Binding request parameters

2017-02-26T23:54:19+00:00

In this article, we are going to see several examples on how to get request parameters with Spring MVC, how to bind them to different objects, how to use @RequestParam annotation and when the annotation is not needed.

@RequestParam examples

@RequestParam is an annotation which indicates that a method parameter should be bound to a web request parameter.

1. Biding method parameter with web request parameter

Let’s say we have our /books URL that requires a mandatory parameter named category:

/books?category=java

we just need to add @RequestParam("parameterName") annotation before the method parameter that we will use for biding the web request parameter.

Let’s see an example:

@RequestMapping("/books")
public String books(@RequestParam("category") String cat, Model model){
    //business logic...
    model.addAttribute("category", cat);
    return "books.jsp";
}

In the snippet above we’ve captured value of request parameter “category” into String cat method argument and we put its value into a Model object so that we can easily test it.

@Test
public void getCategoryParam() throws Exception {
    this.mockMvc.perform(get("/books").param("category", "java"))
            .andExpect(status().isOk())
            .andExpect(model().attribute("category", is("java")))
            .andDo(print());
}

In the test above we are using Spring MVC test library to perform an HTTP GET request to /books with a parameter - category - which has value “java”. Then we verify that the response status is OK (code: 200) and that the model contains an attribute named category and that its value is “java”.

For this test we’ve quickly setup a Spring Boot project, you can find the pom.xml at the end of this article.

Please note that category _is considered a mandatory parameter if we don’t pass _category parameter in our call as in the test below we receive a 400: BadRequestException.

@Test
public void whenNoParam_thenBadRequest() throws Exception {
    this.mockMvc.perform(get("/books"))
            .andExpect(status().isBadRequest());
}

2. Request parameter match method parameter name

If both variable and request parameter name matches we don’t need to specify the parameter name in the @RequestParam annotation.

@RequestMapping("/books")
public String books(@RequestParam String category, Model model){
    model.addAttribute("category", category);
    return "books.jsp";
}

In the example above, since** **both variable and request parameter name is ‘category’, binding is performed automatically.

3. Auto type conversion

If the request parameter is not a String but - for example - a number we can bind it to the corresponding type. Let’s say we have a call like this:

/books?rate=5&maxprice=150.00

In order to bind rate and maxprice respectively with an int and a BigDecimal, we just need to specify the target type after the annotation.

@RequestMapping("/books")
public String books(@RequestParam("rate") int rate,
                         @RequestParam("maxprice") BigDecimal maxprice, Model model){
    model.addAttribute("rate", rate);
    model.addAttribute("maxprice", maxprice);
    return "books.jsp";
}

@Test
public void whenNumber_thenAutoType() throws Exception {
    this.mockMvc.perform(get("/books")
            .param("rate", "5")
            .param("maxprice", "150.00")
    )
            .andExpect(status().isOk())
            .andExpect(model().attribute("rate", is(5)))
            .andExpect(model().attribute("maxprice", is(new BigDecimal("150.00"))));
}

Similarly, if we want to pass a date like:

/books?from=2011-01-01

We need to bind it with respective object:

@RequestMapping("/books")
public String books(@DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
                    @RequestParam("from") LocalDate from, Model model){
    model.addAttribute("from", from);
    return "books.jsp";
}

@Test
public void whenDate_thenAutoType() throws Exception {
    this.mockMvc.perform(get("/books")
            .param("from", "2011-01-01")
    )
            .andExpect(status().isOk())
            .andExpect(model().attribute("from", is(LocalDate.of(2011,01,01))));
}

Since dates have different formats, it’s necessary to specify which one should be used in order to parse the value parameter correctly. In our example, we’ve used @DateTimeFormat to specify iso DateTimeFormat.ISO.DATE that is the most common ISO: yyyy-MM-dd.

All simple types such as int,long, Date, etc. are supported.

The conversion process can be configured and customized according to your needs using WebBinder or by registering _Formatters. _

4. @RequestParam with not mandatory parameters

When we add@RequestParam annotation, as we’ve seen, by default we are assuming that request parameter is mandatory. In case we want to specify that is not, we can just add required=false.

@RequestMapping("/books")
public String books(@RequestParam(name="category", required = false) String category, 
    Model model){
    model.addAttribute("category", category);
    return "books.jsp";
}

In this case, if we call just /books _without parameter, we won’t receive a 400 as before. String category in this case will remain _null.

@Test
public void whenParameterNotSent_thenStatusOk() throws Exception {
    this.mockMvc.perform(get("/books"))
            .andExpect(status().isOk())
            .andExpect(model().attribute("category", is(nullValue())));
}

5. @RequestParam with Default value

It’s also possible to specify a default value that will be applied if the parameter is not sent. Let’s say our default value is “fantasy” we can add defaultValue = "fantasy" in the annotation as follows:

@RequestMapping("/books")
public String books(@RequestParam(name="category", defaultValue = "fantasy") String category, 
                         Model model){
    model.addAttribute("category", category);
    return "books.jsp";
}

Let’s then perform our test in which we don’t pass category request parameter, expected value it’s gonna be “fantasy”.

public void whenParameterNotSent_thenDefault() throws Exception {
    this.mockMvc.perform(get("/books"))
            .andExpect(status().isOk())
            .andExpect(model().attribute("category", is("fantasy")));
}

@Test

When request parameter is sent, the value should be, of course, the one sent and not our default.

@Test
public void whenParameterSent_thenParameter() throws Exception {
    this.mockMvc.perform(get("/books")
            .param("category", "java")
    )
            .andExpect(status().isOk())
            .andExpect(model().attribute("category", is("java")));
}

6. @RequestParam with List or array

We can also perform a call in which we specify several values for a parameter, like:

/books?authors=martin&authors=tolkien

In this case, we can bind it using a List or an array_ - _this is with a List:

@RequestMapping("/books")
public String books(@RequestParam List<String> authors,
                         Model model){
    model.addAttribute("authors", authors);
    return "books.jsp";
}

@Test
public void whenMultipleParameters_thenList() throws Exception {
    this.mockMvc.perform(get("/books")
            .param("authors", "martin")
            .param("authors", "tolkien")
    )
            .andExpect(status().isOk())
            .andExpect(model().attribute("authors", contains("martin","tolkien")));
}

and with an array:

@RequestMapping("/books")
public String books(@RequestParam String[] authors,
                         Model model){
    model.addAttribute("authors", authors);
    return "books.jsp";
}

@Test
public void whenMultipleParameters_thenArray() throws Exception {
    this.mockMvc.perform(get("/books")
            .param("authors", "martin")
            .param("authors", "tolkien")
    )
            .andExpect(status().isOk())
            .andExpect(model().attribute("authors", arrayContaining("martin","tolkien")));
}

7. @RequestParam with Map

It’s also possible to bind all request parameters in a Map just by adding a Map object after the annotation:

@RequestMapping("/books")
public String books(@RequestParam Map<String, String> requestParams,
                         Model model){
    model.addAttribute("category", requestParams.get("category"));
    model.addAttribute("author", requestParams.get("author"));
    return "books.jsp";
}

In this example we’ve added a Map<String,String>, the key is the request parameter name, so we just get the parameters from the Map using their name. I think it’s worth highlight that with this approach you can’t specify which parameters are mandatory and which not and that the code can be insidious to read since might need to read it all in order to figure out which are the possible parameters used by this method.

In order to validate the snippet let’s perform a little test:

/books?category=fantasy&author=Tolkien

@Test
public void getParameter() throws Exception {
    this.mockMvc.perform(get("/books")
                .param("category", "fantasy")
                .param("author", "Tolkien"))
            .andExpect(status().isOk())
            .andExpect(model().attribute("category", is("fantasy")))
            .andExpect(model().attribute("author", is("Tolkien")));
}

Note that if you have multiple values for the same parameter name, you should use MultiValueMap. In the example below, we use@RequestParam with MultiValueMap<String,List<String>> so that we can store multiple values for the same parameter in a List.

@RequestMapping("/books")
public String books(@RequestParam MultiValueMap<String, List<String>> requestParams,
                         Model model){
    model.addAttribute("category", requestParams.get("category"));
    model.addAttribute("authors", requestParams.get("authors"));
    return "books.jsp";
}

Let’s test it passing two authors and one category:

/books?authors=martin&authors=tolkien&category=top250

@Test
public void whenMultiValues_thenRetrieveFromList() throws Exception {
    this.mockMvc.perform(get("/books")
            .param("authors", "martin")
            .param("authors", "tolkien")
            .param("category", "top250")
    )
            .andExpect(status().isOk())
            .andExpect(model().attribute("category", contains("top250")))
            .andExpect(model().attribute("authors", contains("martin","tolkien")));
}

Examples without @RequestParam

Based on the list of HandlerMethodArgumentResolver configured in your application, @RequestParam can also be omitted. If you have a look at the code of method getDefaultArgumentResolvers() of RequestMappingHandlerAdapter there is the following piece of code at the end:

// Catch-all
resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
resolvers.add(new ServletModelAttributeMethodProcessor(true));

Basically, it’s added to the resolvers a RequestParamMethodArgumentResolver with useDefaultResolution set to true. Looking at the documentation we can see that this means that method argument that is a simple type, as defined in _BeanUtils.isSimpleProperty(java.lang.Class<?>), is treated as a request parameter even if it isn’t annotated. The request parameter name is derived from the method parameter name.

Let’s see in the next example what it means.

8. Binding without annotation

We define our controller without adding the usual @RequestParam annotation before the method argument String category

@RequestMapping("/books")
public String helloWorld(String category, Model model){
    model.addAttribute("category", category);
    return "books.jsp";
}

If we run our usual test we will see that it pass! This happens because both variable and request parameter name is category and in the list of default handlers, we have RequestParamMethodArgumentResolver with useDefaultResolution set to true.

Despite it might look convenient, I prefer to always specify the annotation since it clearly states that the argument represents a request parameter.

9. Bind with a field of an object

In a similar way, if we pass as argument a simple pojo object that has a field - with getter and setter - named like the request parameter, the value of the request parameter will be stored in this field.

Let’s define our pojo class:

public class SearchFilterForm{
    private String category;

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }
}

then our Controller:

@RequestMapping("/books")
public String helloWorld(SearchFilterForm myForm, Model model){
    model.addAttribute("category", myForm.getCategory());
    return "books.jsp";
}

and we run our usual test, we will see that also in this case value of request parameter is correctly stored into myForm.getCategory().

pom.xml

For these tests we’ve quickly setup a Spring Boot project, you can find below the pom.xml.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>net.reversecoding</groupId>
	<artifactId>spring-mvc</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>spring-mvc</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

Java 8 Comparator - How to sort a List

2016-11-21T23:10:17+00:00

In this article, we’re going to see several examples on how to sort a List in Java 8.

1. Sort a List of String alphabetically

List<String> cities = Arrays.asList(
       "Milan",
       "london",
       "San Francisco",
       "Tokyo",
       "New Delhi"
);
System.out.println(cities);
//[Milan, london, San Francisco, Tokyo, New Delhi]

cities.sort(String.CASE_INSENSITIVE_ORDER);
System.out.println(cities);
//[london, Milan, New Delhi, San Francisco, Tokyo]

cities.sort(Comparator.naturalOrder());
System.out.println(cities);
//[Milan, New Delhi, San Francisco, Tokyo, london]

By purpose, we’ve written London with ‘L’ in low-case to better highlight difference between Comparator.naturalOrder() that returns a Comparator that sorts by placing capital letters first and String.CASE_INSENSITIVE_ORDER that returns a case-insensitive Comparator.

Basically, in Java 7 we were using Collections.sort() that was accepting a List and, eventually, a Comparator - in Java 8 we have the new List.sort() that accepts a Comparator.

2. Sort a List of Integer

List<Integer> numbers = Arrays.asList(6, 2, 1, 4, 9);
System.out.println(numbers); //[6, 2, 1, 4, 9]

numbers.sort(Comparator.naturalOrder());
System.out.println(numbers); //[1, 2, 4, 6, 9]

3. Sort a List by String field

Let’s suppose we’ve our Movie class and we want to sort our List by title. We can use Comparator.comparing() and pass a function that extracts the field to use for sorting - title - in this example.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings"),
        new Movie("Back to the future"),
        new Movie("Carlito's way"),
        new Movie("Pulp fiction"));

movies.sort(Comparator.comparing(Movie::getTitle));

movies.forEach(System.out::println);

The output will be:

Movie{title='Back to the future'}
Movie{title='Carlito's way'}
Movie{title='Lord of the rings'}
Movie{title='Pulp fiction'}

As you’ve probably noticed we haven’t passed any Comparator but the List is correctly sorted. That’s because of the title - the extracted field - that is a String and String implements Comparable interface. If you peek at Comparator.comparing() implementation you will see that it calls compareTo on the extracted key.

return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));

4. Sort a List by double field

In a similar way, we can use Comparator.comparingDouble() for comparing double value. In the example, we want to order our List of Movie by rating, from the highest to the lowest.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8),
        new Movie("Back to the future", 8.5),
        new Movie("Carlito's way", 7.9),
        new Movie("Pulp fiction", 8.9));

movies.sort(Comparator.comparingDouble(Movie::getRating)
                      .reversed());

movies.forEach(System.out::println);

We used reversed function on the Comparator in order to invert default natural-order that is from lowest to highest. Comparator.comparingDouble() uses Double.compare() under the hood.

If you need to compare int or long you can use comparingInt() and comparingLong() respectively.

5. Sort a List with custom Comparator

In the previous examples we haven’t specified any Comparator since it wasn’t necessary but let’s see an example in which we define our own Comparator. Our Movie class has a new field - starred - set using the third constructor parameter. In the example, we want to sort the list so that we have starred movie at the top of the List.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8, true),
        new Movie("Back to the future", 8.5, false),
        new Movie("Carlito's way", 7.9, true),
        new Movie("Pulp fiction", 8.9, false));

movies.sort(new Comparator<Movie>() {
    @Override
    public int compare(Movie m1, Movie m2) {
        if(m1.getStarred() == m2.getStarred()){
            return 0;
        }
        return m1.getStarred() ? -1 : 1;
     }
});

movies.forEach(System.out::println);

The result will be:

Movie{starred=true, title='Lord of the rings', rating=8.8}
Movie{starred=true, title='Carlito's way', rating=7.9}
Movie{starred=false, title='Back to the future', rating=8.5}
Movie{starred=false, title='Pulp fiction', rating=8.9}

We can, of course, use Lambda expression instead of Anonymous class as follows:

movies.sort((m1, m2) -> {
    if(m1.getStarred() == m2.getStarred()){
        return 0;
    }
    return m1.getStarred() ? -1 : 1;
});

And we can also use again Comparator.comparing():

movies.sort(Comparator.comparing(Movie::getStarred, (star1, star2) -> {
    if(star1 == star2){
         return 0;
    }
    return star1 ? -1 : 1;
}));

In the latest example Comparator.comparing() takes as first parameter the function to extract the key to use for sorting and a Comparator as second parameter. This Comparator uses the extracted keys for comparison, star1 and star2 are indeed boolean and represents m1.getStarred() and m2.getStarred() respectively.

6. Sort a List with chain of Comparator

In the latest example, we want to have starred movie at the top and then sort by rating.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8, true),
        new Movie("Back to the future", 8.5, false),
        new Movie("Carlito's way", 7.9, true),
        new Movie("Pulp fiction", 8.9, false));

movies.sort(Comparator.comparing(Movie::getStarred)
                      .reversed()
                      .thenComparing(Comparator.comparing(Movie::getRating)
                      .reversed())
);

movies.forEach(System.out::println);

And the output is:

Movie{starred=true, title='Lord of the rings', rating=8.8}
Movie{starred=true, title='Carlito's way', rating=7.9}
Movie{starred=false, title='Pulp fiction', rating=8.9}
Movie{starred=false, title='Back to the future', rating=8.5}

As you’ve seen we first sort by starred and then by rating - both reversed since we want the highest value and true first.

Java 8 Optional - Replace your get() calls

2016-06-19T15:19:43+00:00

Optional class were introduced in order to prevent NullPointerException, but method get() used to retrieve the value inside the Optional might still throw a NoSuchElementException.

Different name, same issue?

Calling get() without checking that the value is actually present it’s a problem. So we should always write something like this in order to use get().

Optional<String> myString = Optional.ofNullable(nullableString());
   if(myString.isPresent()){
       doSomething(myString.get());
   }

But are Optional really meant to be used in this way? Actually, no.

Writing block of isPresent/get is not so different from writing a classic null check.

String myString = nullableString();
   if(myString != null){
       doSomething(myString);
   }

How can we really benefit from Optional object?

1. Optional orElse example

It returns the value if is present, or the other specified otherwise.

Let’s see an example:

@Test
public void namePresent(){
  Optional<String> petName = Optional.of("Bobby");

  assertEquals("Bobby", petName.orElse(""));
}

@Test
public void orElse(){
  Optional<String> petName = Optional.empty();

  assertEquals("", petName.orElse(""));
}

As you can see the code is much more readable and correct compared to the isPresent/get version:

String petName = "";
if(petNameOptional.isPresent()){
    petName = petNameOptional.get();
}

2. Optional orElseThrow example

It returns the value if it is present, or throws the specified exception otherwise.

@Test
public void namePresent(){
  Optional<String> petName = Optional.of("Bobby");

  assertEquals("Bobby", petName.orElseThrow(IllegalArgumentException::new));
}

@Test(expected=IllegalArgumentException.class)
public void throwException(){
  Optional<String> petName = Optional.empty();

  petName.orElseThrow(IllegalArgumentException::new);
}

3. Optional filter example

filter() is useful to specify other conditions on our object. It returns an Optional containing the value if it is not empty and satisfies the specified predicate, an Optional.empty() otherwise.

In this example we want that the name length should be greater than 3.

@Test
public void valueNotFilteredOut()
{
  Optional<String> petName = Optional.of("Bobby")
                                     .filter(name -> name.length() > 3);
  assertEquals(Optional.of("Bobby"), petName);
}

@Test
public void valueFilteredOut()
{
  Optional<String> petName = Optional.of("Bob")
                                     .filter(name -> name.length() > 3);
  assertEquals(Optional.empty(), petName);
}

4. Optional map example

map() is a method used to apply a transformation to the content of the Optional if it’s present.

In this example we want to transform the name of the pet from String to Int by applying String.length() function.

@Test
public void transformWhenValueIsPresent()
{
  Optional<Integer> nameLength = Optional.of("Bobby")
                                         .map(String::length);
  assertEquals(Optional.of(5), nameLength);
}

@Test
public void mapNotExecutedWhenEmpty()
{
  Optional<Integer> nameLength = Optional.<String>empty()
                                         .map(String::length);
  assertEquals(Optional.empty(), nameLength);
}

What’s interesting with the map method is that we are able to declare sequentially our operation without worrying if the value is present or not. We can focus on the success case, we don’t need to branch our code, the scenario in which the value is not present is automatically handled by the abstraction Optional that we are using.

5. Optional flatMap example

flatMap() it’s similar to map() but should be used when the transformation function returns an Optional of some <T>. flatMap() executes the transformation function like the map() but instead of returning Optional<Optional<T>> if will just return Optional<T>. Basically it flattens the Optional.

Let’s clarify it with an example. We define a function that returns an Optional, let’s say a function that returns the last gift received by the pet.

private Optional<String> lastGiftReceivedBy(String petName) = ???

If we call our lastGiftReceivedBy function in a map() we will have an Optional<Optional<String>>.

Optional<Optional<String>> lastGiftReceived = Optional.of("Bobby")
                                                      .map(petName -> lastGiftReceivedBy(petName));

In order to flatten them we can use flatMap()

Optional<String> lastGiftReceived = Optional.of("Bobby")
                                            .flatMap(petName -> lastGiftReceivedBy(petName));

Writing this solution by using isPresent/get would have meant using a nested if: one for the first Optional, one for the other.

6. Optional ifPresent example

IfPresent, that it’s different from isPresent, accept a function, a Consumer, and executes it only if the value is present.

Basically ifPresent() should be used for function that does side-effect (returning a void).

Instead of writing something like:

if(optional.isPresent){
  doSomething(optional.get)
}

We can write:

optional.ifPresent(val -> doSomething(val))

Let’s say we want to do a System.out.println() of the name:

Optional.of("Bobby")
        .ifPresent(name -> System.out.println(name));

Resources:

JavaDoc

Short Tutorial By Example

Java 8 Stream - From List to Map

2016-06-04T15:34:33+00:00

An example to convert a List<?> to a Map<K,V> using Java 8 Stream.

Java 8 - Collectors.toMap()

Let’s define a Pojo class:

public class Person {

  private String email;
  private String name;
  private int age;

  public Person(String email, String name, int age) {
    this.email = email;
    this.name = name;
    this.age = age;
  }

  //Getters
  //toString
}

In the first example, we convert a List<Person> in a Map<String, Person> that has the email as key and the object itself as value.

List<Person> people = Arrays.asList(
     new Person("mario@reversecoding.net", "Mario", 27),
     new Person("luigi@reversecoding.net", "Luigi", 30),
     new Person("steve@reversecoding.net", "Steve", 20)
 );

 Map<String, Person> mapEmailPerson = people.stream()
                .collect(Collectors.toMap(Person::getEmail, Function.identity()));

or with the lambda instead of the method reference:

Map<String, Person> mapEmailPerson = people.stream()
               .collect(Collectors.toMap(person -> person.getEmail(), 
                                         person -> person));

Basically mapEmailPerson is a Map<Strig, Person> in which the key is the email and the value is the Person instance with that specific email.

Let’s break this out

First of all, we create a Stream of Person from the List<Person> defined.

Then we collect this stream in a Map. Java 8 helps us to define the needed Collector by providing us the method: Collectors.toMap().

Collectors.toMap() takes two functions - one for mapping the key and one for the value - and returns a Collector that accumulates elements into a Map.

We have chosen the email as key, so the first parameter of the toMap is a function that given the input - a Person - returns its email:

//Given a person, we get his email
person -> person.getEmail()

//Or using method reference
Person::getEmail()

The value is the object itself, so the second parameter of the toMap is simply an identity function:

//Given a person, we want as value the person itself
person -> person

//Or
Function.identity()

These are basically the two parameters for toMap.

Another example

Given a List<Person> we want to create a Map<String, Integer> that contains the name as key and the age as value.

We just need to change the two parameters of the Collectors.toMap, by specifying:

//Name as key
person -> person.getName()

//Age as value
person -> person.getAge();

So the code will look like:

List<Person> people = Arrays.asList(
    new Person("mario@reversecoding.net", "Mario", 27),
    new Person("luigi@reversecoding.net", "Luigi", 30),
    new Person("steve@reversecoding.net", "Steve", 20)
);

Map<String, Integer> mapNameAge = people.stream()
          .collect(Collectors.toMap(person -> person.getName(), 
                                    person -> person.getAge()));

System.out.println(mapNameAge);
//{Steve=20, Luigi=30, Mario=27}

If you are a good observer you may have noticed that the order has not been respected. That’s because the default implementation used by toMap() is the HashMap that does not guarantee that the insert order will be respect.

Java 8 - Collectors.toMap with a LinkedHashMap

If we want to preserve the order we should use a LinkedHashMap instead of the HashMap.

Let’s try the previous example by passing a LinkedHashMap to Collectors.toMap()

Map<String, Integer> mapNameAge = people.stream()
      .collect(Collectors.toMap(
          Person::getName,
          Person::getAge,
          (u,v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); },
          LinkedHashMap::new
          ));

System.out.println(mapNameAge);
//{Mario=27, Luigi=30, Steve=20}

We are using the definition of toMap that takes four parameters:

keyMapper - a mapping function to produce the keys
valueMapper - a mapping function to produce the values
mergeFunction - a merge function used to resolve collisions between values associated with the same key
mapSupplier - a function which returns a new, empty Map into which the results will be inserted

We’ve already discussed the first two parameters.

In case of a collision we just want to throw an exception, so as third parameter we define exactly this behaviour. In the example, we used the same implementation of the static method _throwingMerger _defined in the java.util.stream.Collectors class.

The fourth parameter it’s the one in which we define a function that returns our LinkedHashMap.

Java 8 - Convert List to String comma separated

2016-05-22T10:30:12+00:00

Convert a List<String> in a String with all the values of the List comma separated using Java 8 is really straightforward. Let’s have a look on how to do that.

Java 8 (or above)

We simply can write String.join(..), pass a delimiter and an Iterable, then the new StringJoiner will do the rest:

List<String> cities = Arrays.asList("Milan",
                                    "London",
                                    "New York",
                                    "San Francisco");

String citiesCommaSeparated = String.join(",", cities);

System.out.println(citiesCommaSeparated);
// prints 'Milan,London,New York,San Francisco' to STDOUT.

In case we are working with a stream we can write as follow and still have the same result:

String citiesCommaSeparated = cities.stream()
                                    .collect(Collectors.joining(","));

System.out.println(citiesCommaSeparated);

//Output: Milan,London,New York,San Francisco

Note: you can statically import java.util.stream.Collectors.joining if you prefer just typing joining(“,”).

Java 7

For the old times’ sake, let’s have a look at Java 7 implementation.

private static final String SEPARATOR = ",";

public static void main(String[] args) {
  List<String> cities = Arrays.asList(
                                "Milan",
                                "London",
                                "New York",
                                "San Francisco");

  StringBuilder csvBuilder = new StringBuilder();

  for(String city : cities){
    csvBuilder.append(city);
    csvBuilder.append(SEPARATOR);
  }

  String csv = csvBuilder.toString();
  System.out.println(csv);
  //OUTPUT: Milan,London,New York,San Francisco,

  //Remove last comma
  csv = csv.substring(0, csv.length() - SEPARATOR.length());

  System.out.println(csv);
  //OUTPUT: Milan,London,New York,San Francisco

As you can see it’s much more verbose and easier to make mistakes like forgetting to remove the last comma. You can implement this in several ways - for example by moving the logic that removes the last comma inside the for loop - but none will be so explicative and immediate to understand as the declarative solution expressed in Java 8.

The focus should be on what you want to do - joining a List of String - not on how.

Java 8: Manipulate String before joining

Before joining you can manipulate your String as you prefer by using map() or cutting some String out by using filter(). I’ll cover those topics in further articles. Meanwhile, this a straightforward example on how to transform the whole String in upper-case before joining them.

Java 8: From List to upper-case String comma separated

String citiesCommaSeparated = cities.stream()
                                    .map(String::toUpperCase)
                                    .collect(Collectors.joining(","));

//Output: MILAN,LONDON,NEW YORK,SAN FRANCISCO

If you want to find out more about stream, I strongly suggest this cool video of Venkat Subramaniam.

Let’s play

The best way to learn it’s playing! Copy this class with all the implementations discussed and play with that. There is already a small test for each of them 🙂

package net.reversecoding.examples;

import static java.util.stream.Collectors.joining;
import static org.junit.Assert.assertEquals;

import java.util.Arrays;
import java.util.List;

import org.junit.Test;

public class CsvUtil {
    private static final String SEPARATOR = ",";

    public static String toCsv(List<String> listToConvert){
        return String.join(SEPARATOR, listToConvert);
    }

    @Test
    public void toCsv_csvFromListOfString(){
        List<String> cities = Arrays.asList(
                "Milan", "London", "New York", "San Francisco");

        String expected = "Milan,London,New York,San Francisco";

        assertEquals(expected, toCsv(cities));
    }


    public static String toCsvStream(List<String> listToConvert){
        return listToConvert.stream()
                    .collect(joining(SEPARATOR));
    }

    @Test
    public void toCsvStream_csvFromListOfString(){
        List<String> cities = Arrays.asList(
                "Milan", "London", "New York", "San Francisco");

        String expected = "Milan,London,New York,San Francisco";

        assertEquals(expected, toCsv(cities));
    }

    public static String toCsvJava7(List<String> listToConvert){
        StringBuilder csvBuilder = new StringBuilder();

        for(String s : listToConvert){
            csvBuilder.append(s);
            csvBuilder.append(SEPARATOR);
        }

        String csv = csvBuilder.toString();

        //Remove last separator
        if(csv.endsWith(SEPARATOR)){
            csv = csv.substring(0, csv.length() - SEPARATOR.length());
        }

        return csv;
    }

    @Test
    public void toCsvJava7_csvFromListOfString(){
        List<String> cities = Arrays.asList(
                "Milan", "London", "New York", "San Francisco");

        String expected = "Milan,London,New York,San Francisco";

        assertEquals(expected, toCsvJava7(cities));
    }

    public static String toUpperCaseCsv(List<String> listToConvert){
        return listToConvert.stream()
                    .map(String::toUpperCase)
                    .collect(joining(SEPARATOR));
    }

    @Test
    public void toUpperCaseCsv_upperCaseCsvFromListOfString(){
        List<String> cities = Arrays.asList(
                "Milan", "London", "New York", "San Francisco");

        String expected = "MILAN,LONDON,NEW YORK,SAN FRANCISCO";

        assertEquals(expected, toUpperCaseCsv(cities));
    }
}

Let’s start this journey!

2015-08-02T15:56:43+00:00

Ciao!

I’m Mario and I’m starting this new adventure thanks to John Sonmez. I’ve been following his blog for long time, but only a couple of weeks ago I’ve decided to subscribe to his free course How To Build A Blog That Will Boost Your Career.

I’ve never paused to properly think about how valuable it could be having a blog or works on something that’s simply yours. When I say properly think” I mean consider finding hours to work on that, to get started, to forget about perfection” and just jump into it. So…here we go!

Let’s be honest!

There are hundreds of good tutorials on the web that explains to you how to easily create a blog, install WordPress and get started because, apparently, that is all that you need.

So why do I think this course is different?

As I said, I’ve never tried to create a blog, I’ve always thought would’ve been nice working on something that was mine, but I’ve never given the right priority to that. But then John, through his course, said:

Hey man, I know you are busy, I know you think that you aren’t a great author, I know you prefer to invest your spare time on doing something else..but you know what, if you don’t try, you will always be one of the others! So let’s start, follow me and in 3 weeks you’ll have your blog up and running. Simply as that!

In a nutshell: what is this course about?

It’s a course focused on boosting your career thanks to your blog, on helping you find a better job, have a better salary, MAKE THE DIFFERENCE and be in the top 1% of all software developers! It helps you find a theme that enhances your passions, know what to write about, get some traffic on it and keep it up. Moreover, it’s a specialized course, it’s for software engineers, so it will be easy find an answer to the questions you may have..And if you can’t find an answer, drop him an email and he will answer. I promise. At least, that’s what happened to me.

That’s why, in my opinion, this tutorial is completely different from what you can find on the web. I really recommend you to subscribe and..let me know what you think about this course.

Ciao,
Mario