What is NumberFormatException

The NumberFormatException is an unchecked Java exception which happens when there is incorrect string input converted to a numeric value. When the input is wrong, NumberFormatException is thrown to inform the user that the conversion requires a correct input and the transformation did not happen. For example, the NumberFormatException is thrown when a numerical string is parsed to an integer, but the string contains also space.

As the NumberFormatException is an unchecked exception, it does not need to be declared in the throws clause of a method or constructor. However, when in doubt of input correctness, it should be handled in code using a try-catch block.

NumberFormatException Example

Let’s take a look at the simple example of NumberFormatException being thrown:

public class NumberFormatExceptionExample {
    public static void main(String args[]) {
        int orderNumber = Integer.parseInt("Order 66");
        System.out.println(orderNumber);
    }
}

The above code will throw NumberFormatException. While pure input of string “66” is a valid input, a string with non-numerical characters like “Order 66” is unsuitable for creating a number.

Exception in thread "main" java.lang.NumberFormatException: For input string: "Order 66"
    at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.base/java.lang.Integer.parseInt(Integer.java:652)
	at java.base/java.lang.Integer.parseInt(Integer.java:770)
    at NumberFormatExceptionExample.main(NumberFormatExceptionExample.java:6)

8 Different Ways How To Get NumberFormatException

There are various causes for throwing NumberFormatException, and the improper conversion of invalid input mainly causes them. Here is a list of different ways how to get NumberFormatException:

1. Input string is empty:

Integer.parseInt("");

2. Input string is null:

Integer.parseInt(null);

3. Input string with non-numeric data:

This case has several different options why it can happen.

a. Input string contains space character:

Integer.parseInt("66 66");

b. Input string contains non-numeric character:

Integer.parseInt("Sixty");

c. Numeric input with non-numeric character in input string

Integer.parseInt("Catch22");

4. Input string with inappropriate symbols in it:

Double.parseDouble("66,12345");

5. Input string with leading or tailing white space

Integer randomExample = new Integer("  12345  ");

Integer, Long, Short, Byte throw NumberFormatException; Double, Float does not.

6. Mismatch of data type between input string and the target data type

Integer.parseInt("12.34");

7. Input string exceeding the range of the target data type

Integer.parseInt("2147483648");

The example shown above is a case of NumberFormatException upon placing a numeric input string exceeding the range of the target data type, which is in our case Integer class object. The maximum range for Integer class object is from -2_147_483_648 to 2_147_483_647.

How to handle NumberFormatException

The NumberFormatException is an unchecked exception in Java. Therefore it can be handled as any other Java exception by wrapping critical code to try-catch block.

Look at the following example of catching NumberFormatException with a try-catch block:

public class NumberFormatExceptionExample {

    public static void main(String args[]) {
        String userInput = "Order 66";
        Optional<Integer> orderNumber = processOrder(userInput);
        if (orderNumber.isPresent()) {
            System.out.println("Execute order " + orderNumber.get());
        } else {
            System.out.println("Unrecognized order number. Please try again.");
        }
    }

    public static Optional<Integer> processOrder(String userInput) {
        try {
            int order = Integer.parseInt(userInput);
            return Optional.of(order);
        } catch (NumberFormatException ex) {
            System.out.println("Order exception: Invalid user input!");
        }
        return Optional.empty();
    }

}

Depending on the requirements of the application, take necessary action. For example, log the exception with an appropriate message or return an empty Optional object if you are using at least Java 8. Like in the example above, wrapping the code in try-catch blocks allows the program to continue execution after the code throws the exception.

Output:

Order exception: Invalid user input!
Unrecognized order number. Please try again.

Conclusion

This article led us to explain what NumberFormatException and how to handle it. It also showed over seven different ways how the NumberFormatException can occur and how we can defensively take care of it.

Do you know NumberFormatException? In what case did it throw to you? Do you have your trick, or do you see another way how to handle NumberFormatException? Let us know in the comments below the article. We would like to hear your ideas and stories.

Developer notes will be an irregular series of articles where I will briefly go through some of my notes to make notes for posterity. The notes themself can be pretty long, yet their length is not enough for writing a meaningful article.

Let’s take a look at a list of content:

• Oracle Error: Value Larger Than Specified Precision Allowed For This Column
• Switch on String with Enum Name in Java 8
• Lombok’s serialization error for Jackson
• Interpunct
• How To Do curl in Postman

Oracle Error: Value Larger Than Specified Precision Allowed For This Column

I was getting errors on inserting data into the Oracle database “ORA-01438: value larger than specified precision allowed for this column.”

The reason why I was getting an error was a too big number. When I looked over UI to database column definition, I saw something like this NUMBER(15,2).

Official Oracle documentation, as for Oracle database v21, depicts NUMBER datatype defined as NUMBER (precision,scale).

NUMBER datatype notation can be rather rewritten to NUMBER (size,precision)) where the first number depicts the total size of the digits in a number, and the second means the decimal point scale.

In other words, for example, for NUMBER(2,2), we can place the column number consisting of 2 digits, both of which will be decimals. i.e. 0.15, 0.45 etc. But if we would like to have a bigger number in the column, we need to upgrade the size of the column reserved for the whole number – NUMBER(5,2) will get us five digits, of which 2 are decimals. i.e 125.40, 18.00.

Switch on String with Enum Name in Java 8

Here is an example of how to use Enum values as strings in a switch case. You can only use the strings which are known at compile time. The compiler cannot determine the result of expression. However, in Java Enum case VALUE1, VALUE2 are static.

String name = ...
switch(CustomEnum.valueOf(name)) {
   case VALUE1:
        ...
        break;
   case VALUE2:
        ...
        break;
    ...
}

Lombok’s serialization error for Jackson

When I created a new aggregated DTO class on my REST output, I got the following error:

Type definition error: [simple type, class CUSTOM_DTO_CLASS_NAME]; nested exception is com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class CUSTOM_DTO_CLASS_NAME and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: CUSTOM_DTO_CLASS_NAME[\"aggregation-class-property\"]->java.util.ArrayList[0])

I am sure this error will be thrown quiet often as the solution on it is very simple. All I was missing on my Custom DTO class was Lombok’s @Getters annotation for serialization. So fix consisted on adding missing @Getters annotation on the top of my custom class for Lombok generating getter methods at compile time.

Interpunct

I was editing my resume this month and wanted to create a nice date range in positions I held in the past. I got this from my LinkedIn profile, where LinkedIn use dates in the form as Jan 2020 – Feb 2020 · 2 mos. But I could not figure out where to take the dot sign as it was an image. However, the character for such sign as little black dot · really exists and its name is Interpunct, or middle dot. So every time you would like to create a nice division of text with the help of ·, think about the Interpunct.

How To Do curl in Postman

Is there a way hot to make a curl command in Postman? What if we would like to import the curl command easily into Postman and make a Postman GUI request from it.
Is it even possible to easily translate all the curl command parameters into the Postman request?

Surely it is. Postman request are eventually nothing else than more fancy curl requests and Postman supports the curl import feature. Importing curl is very simple. Here is simple list of steps which will lead you to success:

1. Open Postman.
2. Go to navigation menu, click File and Import option
3. In Import window select the raw text tab.
4. Paste the raw text e.g. curl --location --request GET "https://www.google.com/", then click continue.
5. Check the name, format and import as.
6. If everything is correct, click Import button.

Following the steps will automatically import the curl command into the Postman on the new tab.

Introduction

The answer is simply to use flatMap to flatten the lists of elements into one coherent list of the same elements. flatMap converts lists to streams in a single Stream and then collects the result into a list.

The best explanation will probably show the example of flatMap in action.

Flattening the List with flatMap – Simple Example

Let’s start with a simple example and continue with a more complex case later in the article. Our simple example will have a list of list with String elements. Each inner list contains a list of String elements which is a tuplet denoting at the first position the level of list and in the second position the overall total position of String element.

List<List<String>> nestedList = asList(
    asList("1-1", "1-2", "1-3"),
    asList("2-4", "2-5", "2-6", "2-7", "2-8"),
    asList("3-9", "3-10")
);

We take this simple list above, and we will push it to our simple flattening method flatteningTheListOfLists(List<List<String>> list).

public  List<String> flattenListOfLists(List<List<String>> list) {
    return list.stream()
               .flatMap(Collection::stream)
               .collect(Collectors.toList());
}

As a result, we will get a list with all the String elements in one list.

@Test
public void testFlatteningTheListOfLists_simpleScenario() {
     List<String> flattenedList = flattenListOfLists(nestedList);

    assertNotNull(flattenedList);
    assertEquals(10, flattenedList.size());

    for (String element : flattenedList) {
        System.out.print(element);
    }
}

Output

1-1, 1-2, 1-3, 2-4, 2-5, 2-6, 2-7, 2-8, 3-9, 3-10, 

Flattening the List with flatMap – Realistic Scenario

Instead of a simple play with a happy case scenario, hypothetically, let’s have a more advanced system where we will generate the list of objects directly in the stream. We will have a list of employees with their job position. And we would like to collect all their possible career options for employees above junior engineer level into a single list of all career options across all employees through a department. The resulting list will give us a list of possible combinations of employee promotions above the junior level.

Here is an example of Employee class:

public class Employee {

    private Position position;

    public Employee(Position position) {
        this.position = position;
    }

    public int getPosition() {
        return this.position;
    }
}

And here is an example of Employee and Position class:

public class Employee {

    private final String name;
    private final Position position;

    public Employee(String name, Position position) {
        this.name = name;
        this.position = position;
    }

    public Position getPosition() {
        return position;
    }

}

public enum Position {

    JUNIOR_ENGINEER(1),
    SENIOR_ENGINEER(2),
    SOFTWARE_ARCHITECT(3),
    ENGINEERING_MANAGER(4);

    private final int level;

    Position(int level) {
        this.level = level;
    }

    public int getLevel() {
        return this.level;
    }
}

In order to get the list of all possible career options for all employees above junior level we would create for example something like getAllCareerOptionsAboveJunior(List<Employee> employees) where class employee property is a list of employees of Employee class. getAllCareerOptionsAboveJunior(List<Employee> employees) method will go through all the employees, filter employees from the list with level above junior level and create a list of possible career options for that specific employee. All the career options should be than pushed to List and outputted from stream to List collector.

public List<Position> getAllCareerOptionsAboveJunior(List<Employee> employees) {
    return employees.stream()
                    .filter(employee -> employee.getPosition().getLevel() > Position.JUNIOR_ENGINEER.getLevel())
                    .map(employee -> createPossibleCareerOptions(employee.getPosition().getLevel())) // This is bad practice and will not work
                    .collect(Collectors.toList());
}

Example of createPossibleCareerOptions():

public List<Position> createPossibleCareerOptions(int level) {
    return Arrays.stream(Position.values())
                 .filter(position -> position.getLevel() > level)
                 .collect(Collectors.toList());
}

As we can see above, we mapped an employee to the list of her/his career options. But we want to collect list of all possibilities, not list of lists. Therefore, the code above does not work while stream map function maps employee instance into the list, but stream collector can not collect list of position list into the single list.

To make this code work, we need to introduce a consequent function in a stream that will flatten the list’s mapping into one stream. We need to place flatMap function for flattening the stream of list of positions into single steam positions for our Java stream.

public List<Position> getAllCareerOptionsAboveJunior(List<Employee> employees) {
    return employees.stream()
                    .filter(employee -> employee.getPosition().getLevel() > Position.JUNIOR_ENGINEER.getLevel())
                    .map(employee -> createPossibleCareerOptions(employee.getPosition().getLevel()))
                    .flatMap(List::stream) // I need to flatten list streams into one stream
                    .collect(Collectors.toList());
}

Finally, let’s put all parts together and try the solution on the list of employees.

List<Employee> employees = asList(
        new Employee("Mark", Position.JUNIOR_ENGINEER),
        new Employee("Thomas", Position.SENIOR_ENGINEER),
        new Employee("Janet", Position.SOFTWARE_ARCHITECT),
        new Employee("Percy", Position.ENGINEERING_MANAGER)
);

We can test the result with the test written below:

@Test
public void testFlatteningTheListOfLists_realisticScenario() {
    List<Position> allPossiblePromotions = getAllCareerOptionsAboveJunior(employees);

    assertNotNull(allPossiblePromotions);
    assertEquals(3, allPossiblePromotions.size());

    for (Position position : allPossiblePromotions) {
        System.out.print(position + ", ");
    }
}

Output

SOFTWARE_ARCHITECT, ENGINEERING_MANAGER, ENGINEERING_MANAGER, 

Note : If you have better idea for Map sorting, let me know in comments below.

Flattening the List With forEach

To flatten this nested collection into a list of the same elements, we can also use forEach together with a Java 8 method reference. However, the solution with forEach might be discouraged by some developers as it needs to create a new reference on the list with results before it returns the complete results. Thus, creating the result variable will make the code more cumbersome and brittle. And while it might be suitable for small lists and simple applications, it brings pointlessly more complexity with its wrapping code for more complex scenarios as described above. On the contrary, it provides no advantage in the form of, for example, code readability.

Neither to say, let’s take a look at the option of flattening the stream of element’s list with the help of forEach method.

public List<String> useOfForEach(Stream<List<String>> streamOfLists) {
    List<String> result = new ArrayList<>();
    streamOfLists.forEach(result::addAll);
    return result;
}

If we use the same list of simple String elements as for happy case scenario with flatMap we will get the same results.

Conclusion

We have seen in this article how to use a Java 8 Stream method flatMap first on a simple example and then on a more realistic scenario. We have also seen the option of flattening the stream with forEach. However, use of forEach might be discouraged on more realistic scenario when used on stream of Objects which generates the lists.

Did you find use of flatMap hard? Do you have your trick or you know another way how to use flatMap? Let us know in the comments below the article. We would like to hear your ideas and stories.

As always, you can find all our examples on our GitHub project!

Introduction

A software developer encounters the trivial task of joining string elements in the list from time to time into one coherent text. Reasons vary widely – from printing elements to logs to showing the text to the user. But be sure that the solution for this problem should be straightforward when you want to use the Java programming language the most effectively.

We will use a list of random US states codes such as TX, WA, NY etc., for demonstration in our showcases.

First of all, let me show you the proper way to utilize the Java language most effectively. These solutions will require to use of at least version Java 8.

String build-in join method

Java 8 implemented to core String class, in a same way as many other programming languages, join() method. join() method has two arguments:

• The first argument is called separator. Separator is single character or sequence of characters with which elements should be joined together.
• The second argument is the Java’s object implementing the List interface from which the elements will be taken and joined.

Be noted that a separator can be a single character or sequence of characters. We will connect our US state codes on the sequence of characters: space + comma + space. You can use only a comma to get a more concise text.

package com.codepills;

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

public class JoiningStatesWithJoinMethod {

    public static void main(String[] args) {
        List states = Arrays.asList("TX", "WA", "NY", "AZ", "MI", "AL", "CA");
        String text = String.join(" , ", states);
        System.out.println(text);
    }

}

Output

TX , WA , NY , AZ , MI , AL , CA

Joining String elements in Java Stream

Another way to join string elements and create a single line of text is to stream through all the list elements and join them on a collection of characters or sequences of characters. Unfortunately, this solution also requires using at least the Java 8 version since handling and collecting streams is a significant release feature of Java 8. Let’s use Collector’s joining() static method with single argument – separator.

package com.codepills;

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

public class JoiningStatesWithStreamCollection {

    public static void main(String[] args) {
        List states = Arrays.asList("TX", "WA", "NY", "AZ", "MI", "AL", "CA");
        String text = states.stream().collect(Collectors.joining(","));
        System.out.println(text);
    }

}

Output

TX , WA , NY , AZ , MI , AL , CA

Brute force

The last way to join strings together is to use simply brute force. Using brute force is the last option as it creates more code than necessary. Especially for newer versions of Java, it is recommended to use String’s build-in join() method. Therefore brute-force is more or less an option for legacy code, code written in Java 7 and less.

package com.codepills;

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

public class JoiningStatesWithBruteForce {

    public static void main(String[] args) {
        System.out.println(customJoin(",", Arrays.asList("TX", "WA", "NY", "AZ", "MI", "AL", "CA")));
        System.out.println(customJoin(",", Arrays.asList("TX")));
        System.out.println(customJoin(",", Arrays.asList("")));
        System.out.println(customJoin(",", null));
    }

    private static String customJoin(String separator, List input) {

        if (input == null || input.size() <= 0) return "";

        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < input.size(); i++) {
            stringBuilder.append(input.get(i));
            // Do not print separator for the last element
            if (i != input.size() - 1) {
                stringBuilder.append(separator);
            }
        }

        return stringBuilder.toString();
    }

}

Output

TX , WA , NY , AZ , MI , AL , CA
TX
 // empty

We placed all possible options for input to main() method in order to test our customJoin() method properly.

Eventually, you can see we are using more custom code than is necessary. All this custom functionality can be replaced by single line in case of String's join() method. Therefore use this custom solution only when it does make sense.

Conclusion

This article has shown three different ways to print string elements of the list into one coherent test.

Did you find concatenating easy? Do you have your trick or know another way how to join list elements? Let us know in the comments below the article. We would like to hear your ideas and stories.

Introduction

Every approach for sorting a map consists of a few consequent steps, no matter by which map’s property (key/value)n we want to sort Map.

Basic sorting algorithm

Sorting Map algorithm goes like this:

• First, we convert a Map into a Stream
• Second, we sort streaming elements
• Third, we collect sorted elements, and we maintain order by placing elements into the correct data structure (LinkedHashMap)

HashMap entrySet() method in Java

The java.util.HashMap.entrySet() method in Java is used to create a set out of the same elements contained in the HashMap. It returns a set of entries from the HashMap. Alternatively we can create a new set and store the map elements into it.

Sort Map by Keys

public void sortMapByKeys() {

    Map<String, Integer> unsortedMap = new HashMap<>();

    unsortedMap.put("z", 0);
    unsortedMap.put("b", 5);
    unsortedMap.put("a", 6);
    unsortedMap.put("e", 7);
    unsortedMap.put("k", 8);
    unsortedMap.put("f", 9);
    unsortedMap.put("n", 100);
    unsortedMap.put("o", -4);
    unsortedMap.put("m", 2);
    unsortedMap.put("d", 1);

    System.out.println("Unsorted map: ");
    System.out.println(unsortedMap);

    // We need a LinkedHashMap to keep an order of newly returned sorted map.
    Map<String, Integer> result = unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

    // Alternative way
    Map<String, Integer> resultAlternative = new LinkedHashMap<>();
    unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .forEachOrdered(x -> resultAlternative.put(x.getKey(), x.getValue()));

    System.out.println("Sorted map by keys: ");
    System.out.println(result);
    System.out.println(resultAlternative);
}

Output

Unsorted map:
{a=6, b=5, d=1, e=7, f=9, z=0, k=8, m=2, n=100, o=-4}

Sorted map by keys:
{a=6, b=5, d=1, e=7, f=9, k=8, m=2, n=100, o=-4, z=0}
{a=6, b=5, d=1, e=7, f=9, k=8, m=2, n=100, o=-4, z=0}

Order in unsortedMap is not secured. However, after the map sorting with the key, we can see that the map is ordered. The newly created map is placed in LinkedHashMap implementation, which maintains the elements’ order.

Sort Map by Values

public void sortMapByValues() {

    Map<String, Integer> unsortedMap = new HashMap<>();

    unsortedMap.put("z", 0);
    unsortedMap.put("c", 7);
    unsortedMap.put("q", 4);
    unsortedMap.put("a", 6);
    unsortedMap.put("e", 7);
    unsortedMap.put("k", 8);
    unsortedMap.put("n", 100);
    unsortedMap.put("o", -4);
    unsortedMap.put("m", 2);
    unsortedMap.put("d", 1);

    System.out.println("Unsorted map: ");
    System.out.println(unsortedMap);

    // We need a LinkedHashMap to keep an order of newly returned sorted map.
    Map<String, Integer> result = unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

    // Alternative way
    Map<String, Integer> resultAlternative = new LinkedHashMap<>();
    unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
        .forEachOrdered(x -> resultAlternative.put(x.getKey(), x.getValue()));

    System.out.println("Sorted map by values: ");
    System.out.println(result);

    System.out.println("Sorted map by values (alternative approach): ");
    System.out.println(resultAlternative);
}

Output

Unsorted map:
{q=4, a=6, c=7, d=1, e=7, z=0, k=8, m=2, n=100, o=-4}

Sorted map by values:
{n=100, k=8, c=7, e=7, a=6, q=4, m=2, d=1, z=0, o=-4}

Sorted map by values (alternative approach):
{n=100, k=8, c=7, e=7, a=6, q=4, m=2, d=1, z=0, o=-4}

Order in unsortedMap is not secured. However, after the map is sorted by value, we can see it is in order. The newly created map is kept in LinkedHashMap implementation, which maintains the elements’ order.

Sort special case of Map<Object,Object>

There exist special case in Map sorting. It is when we place Object type into the Map parameters. The Stream can’t sort the Map<Object, Object> directly. To solve this case we need to convert Map<Object, Object> into Map<String, String>. Let’s take a look on the code example below:

Note : If you have better idea for Map sorting, let me know in comments below.

public void sortObjectMap() {

    // Example of the Object map
    Properties properties = System.getProperties();
    Set<Map.Entry<Object, Object>> entries = properties.entrySet();

    System.out.println("Unsorted Object map: ");
    entries.forEach(System.out::println);

    LinkedHashMap<String, String> collect = entries.stream()
        .collect(Collectors.toMap(k -> (String) k.getKey(), e -> (String) e.getValue()))
        .entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

    System.out.println("Sorted Object map by keys: ");
    result.forEach((key, value) -> System.out.println(key + " : " + value));
}

Output

Unsorted Object map:
sun.desktop=windows
java.specification.version=8
...

Sorted Object map by keys:
awt.toolkit:sun.awt.windows.WToolkit
file.encoding:UTF-8
file.separator:\
java.awt.graphicsenv:sun.awt.Win32GraphicsEnvironment
...

Conclusion

In this article we have shown how to sort Map by key and by value. As some implementation of Map do not maintain order we created ordered maps with LinkedHashMap.

Eventually we have shown a special case of Map<Object, Object> which require transformation of Object into the string in order to to be compared by key or value.

As always, you can find all our examples on our GitHub project!

Java 8 come with beautiful solution on this pattern. It is called IntStream.

Example of IntStream range() method

Static method range(startInclusive, endExclusive) of IntStream class returns a sequential ordered of integer numbers from range of startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1. Therefore startInclusive is inclusive initial value and endInclusive is exclusive upper bound.

All this is equivalent of sequence increasing values sequentially using a for loop as follows: for (int i = startInclusive; i < endInclusive ; i++) { ... }

Example code:

IntStream intStream = IntStream.range(1, 5);
intStream.forEach(i -> {
    System.out.print(i + " ");
});

Example output:

1 2 3 4 

Example of IntStream rangeClosed() method

Static method rangeClosed(startInclusive, endInclusive) of IntStream class returns a sequential ordered of integer numbers from range of startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1. Therefore startInclusive is inclusive initial value and endInclusive is inclusive upper bound.

All this is equivalent of sequence increasing values sequentially using a for loop as follows: for (int i = startInclusive; i <= endInclusive ; i++) { ... }

Example code:

IntStream intStream = IntStream.rangeClosed(1, 5);
intStream.forEach(i -> {
    System.out.print(i + ", ");
});

Example output:

1 2 3 4 5