We will use the following simple code to print a code into the terminal or command prompt for demonstration purposes.

public class MyJavaApp {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

}

Compile and run Java code in a few steps

You must follow only a few basic steps to compile and run Java code.

1. As a precondition, ensuring the installation of Java Development Kit (JDK) on your system and the accessibility of the javac and java commands from the terminal or command prompt is important.
2. First, you have to have a Java source code in Java files. Open a text editor and write your Java code. Save the file with a .java file extension.
3. Then you are ready to compile the Java source file. Open a terminal or command prompt and navigate to the directory where your Java source file is placed. Utilize the javac command for compiling the Java source file into bytecode. For example:

   javac MyJavaApp.java

   You will generate a bytecode file named MyJavaApp.java if there are no compilation errors.

4. When you have successfully compiled the Java source file into a bytecode file, you can execute the bytecode using the java command. However, select the class which contains valid public static void main(String args[]) Java method in order for JVM to have an access point to your code.

   Here is an example of running MyJavaApp:

   java MyJavaApp

   And here is the output:

   

   java MyJavaApp will run your Java program, and if everything is correct, you should see the output in the console.

Compiling and running nested classes

So far, we have seen compile and run only a single class. However, running a multi-class project is no different from compiling and running a single class. Here is an example of a multi-class project we will use next.

public class MyJavaApp {

    public static void main(String[] args) {
        InsertedClass.printToWorld();
    }

}

public class InsertedClass {

    public static void printToWorld() {
        System.out.println("Hello World from other class!");
    }

}

For sure, the same as in a single class, you need to pick a class for compiling the class which contains the public static void main(String args[]). That is the only way the compiler can reach and compile all classes in your project.

And again, same as in the single class, you need to run the multi-class project with the java command on the file, which contains public static void main(String args[]) method.

Conclusion

This article has shown how to compile and run Java code on the Windows platform.

Did you find compiling and running your Java code easy? Do you have your trick or know another way how to compile and run Java code from the terminal or command prompt? Let us know in the comments below the article. We would like to hear your ideas and stories.

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.

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

Double star or double asterisk (**) in Python code can mean two different things based on the position in the code. First, if a double asterisk stands in the equation, it is part of it and is considered a Power operator. Otherwise, double-asterisk can occur in function and method argument input, and in such a case, it should be followed by kwargs shortcut (keyword arguments).

Power Operator

What is double start operator in equation?

Double star (or double-asterisk) in mathematical equation is one of the arithmetic operator (like +, -, *, **, /, //, %) in Python programming language. Double stars are also known as Power operator.

What Power Operator does?

For numerical data types Power operator works as an Exponential operator – anything on the right is the power of the left side.

Rather than talking about it, let’s demonstrate the Exponential operator on example:

two = 2
three = 3
# We can read the following notation as two to the power of the three
result = two ** three
# Result is according to the math laws, and it is equal to 2 * 2 * 2
print(result)

# Example of using double asterisk operator.
result_2 = 10 * (4 ** 2) - (2 ** 2) * 20
print(result_2)

Output

8
80

What is the order of arithmetic operators?

Arithmetic operators in Python follow the same precedence rule as in mathematics. The order is as follows: first performs exponential operator, then multiplication and division; as last executed are addition and subtraction, retrospectively.

Arithmetic operators ordered in decreasing order by priority:

() -> ** -> * -> / -> // ->  % -> + -> -

** as variable argument length in functions and methods

Interestingly, in Python, two starts fulfil also a different role. In Python’s function and method definition, the double-asterisk is also known for its role in defining variable argument length. Double asterisk concatenate with kwargs word and form **kwargs. So every time you see it, it means that the method or function it contains has a variable-length argument dictionary in the place of **kwargs occurrence. So when we use **kwargs as a parameter, we don’t need to know how many arguments we will need to pass to a function/method.

Btw. kwargs is not a Python reserved word and can be used in Python code independently.

**kwargs examples

Let’s write a simple function with **kwargs, taking various length arguments and passing them to a function.

def function(**kwargs):
    for key, value in kwargs.items():
        print("key: {} - value: {}".format(key, value))

function(pos1="John", pos2="Thomas", pos3="Paul")

Output

key: pos1 - value: John
key: pos2 - value: Thomas
key: pos3 - value: Paul

And now, let’s use the same function with additional arguments. Then, we will see how the function with **kwargs will accept a different number of arguments:

def function(**kwargs):
    for key, value in kwargs.items():
        print("key: {} - value: {}".format(key, value))

function(pos1="John", pos2="Thomas", pos3="Paul", pos4="Isabella", pos5="Carry", pos6="Angela")

Output

key: pos1 - value: John
key: pos2 - value: Thomas
key: pos3 - value: Paul
key: pos4 - value: Isabella
key: pos5 - value: Carry
key: pos6 - value: Angela

Note: It is a good idea to create functions that accept **kwargs where you expect the number of inputs within the argument list to remain relatively small.

Conclusion

This article has shown two different ways how the double asterisk is used. First, we have seen the order of arithmetic operators in Python and how a double asterisk denotes a mathematical Power operator. The second usage is variable argument length in Python’s functions and class methods. Usage of **kwargs provides us flexibility to use keyword arguments in our program.

Did you find the usage of double stars in Python confusing? Do you have any tricks or know another way how to use double stars in Python? Let us know in the comments below the article. We would like to hear your ideas and stories.

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

In order to turn Java Map to array, it always depend what you actually want to take from the Map itself. You can only want keys or values or transform key-value pairs on a completely different object while turning them into an array.

Note

We need to note, that in most of our examples we will use HashMap implementation as underlying layer upon which the algorithms are build. If the implementation change and it will affect the algorithm, it will be notably depicted and described.

Map Map.Entry to Array

Our first approach is the simplest and probably covers most of the cases in real life. The approach obtains Map.Entry from Map and then turn the collection to an array.

We will use non-parametrized call of Set.toArray() for Entry collection. Let’s look at the example below:

// Method to convert Map entry set into an Array in Java
public static void entrySetToArray()
{
    final Map map = new HashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Gets the Map entry set and turns it into an Array of Objects
    final Object[] objectArray = map.entrySet().toArray();

    System.out.println(Arrays.toString(objectArray));
}

Output

[Paul Smith=555-400-321, John Doe=555-869-759, Thomas Cook=555-906-941]

Map Keys to Array

Sometimes we want to map Map keys to an array. For this we need to use combination of Map.keySet() for obtaining keys and parametrized call of Set.toArray(T[] a) method for keeping a set of keys. Than we can turn key set to an Array.

// Method to convert Map keys into an Array in Java
public static void keySetToArray()
{
    final Map map = new HashMap<>();<>

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Gets the Map set of keys which is turned to an Array of Strings
    String[] keys = map.keySet().toArray(new String[0]);

    System.out.println(Arrays.toString(keys));
}

Output

[Paul Smith, John Doe, Thomas Cook]

Map Values to Array

Other times, we want to map Map values to an array. For this we need to use combination of Map.values() for obtaining keys and parametrized call of Collection.toArray(T[] a) method for keeping a collection of values. Than we can turn value collection to an Array.

// Method to convert Map values into an Array in Java
public static void valuesCollectionToArray()
{
    final Map map = new HashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Gets the Map collection of values and turn it into the Array of Strings
    String[] values = map.values().toArray(new String[0]);

    System.out.println(Arrays.toString(values));
}

Output

[555-400-321, 555-869-759, 555-906-941]

Map to Array with element order secured

We have seen that we can get an array of keys and values of the Map using Map.keySet() and Map.values(). Using both methods we can keep the individual elements in separate arrays and construct a new array of key-value pairs from them.

However we will need to use different Map interface implementation than HashMap. We have to use LinkedHashMap which can secure the order of elements in the order of their insertion into the Map data structure implementation. In this way, we can create two different arrays, one for keys and the second for values, but we can rest assure that the order of elements in individual arrays will be matching their mutual pair in the Map.

// Method to convert Map elements to an Array in Java
// However, the core of this method lies in the Map's implementation LinkedHashMap
// which maintains the order of inserted elements in the order of their insertion.
public static void useLinkedHashMapElementOrderForArrayConversion()
{
    final Map map = new LinkedHashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Get an array of keys in order of the LinkedHashMap
    final String[] keys = map.keySet().toArray(new String[0]);

    // Get an array of values in order of the LinkedHashMap
    final String[] values = map.values().toArray(new String[0]);

    for (int i = 0; i < map.size(); i++) {
        System.out.println( "[ " + keys[i] + " = " + values[i] + " ]" );
    }
}

Output

[ John Doe = 555-869-759 ]
[ Thomas Cook = 555-906-941 ]
[ Paul Smith = 555-400-321 ]

Map to Array with element order unsecured

Finally, we need to discuss the option when the elements' order is not secured, but we want to use two different arrays for help.

When we look on the algorithm above, it seems a little bit straightforward how to map elements to an array. However, when HashMap or TreeMap implementation of Map is used, the order of element in both arrays might change. For example for any index i, there is no guarantee that key[i] will represents the pairing key for value[i] value. To guarantee the correct pair position we need to construct helping arrays and map the pair position into the same indexes in helping arrays.

// Method to convert Map to an Array in Java
public static void maintainKeySetAndValueCollectionArray()
{
    final Map map = new HashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Temporary array to store map keys
    final String[] keys = new String[map.size()];

    // Temporary array to store map values
    final String[] values = new String[map.size()];

    int i = 0;

    for (Map.Entry entry : map.entrySet()) {
        keys[i] = entry.getKey();
        values[i] = entry.getValue();
        i++;
    }

    for (i = 0; i < map.size(); i++) {
        System.out.println( "[ " + keys[i] + " = " + values[i] + " ]" );
    }
}

Note

i is local variable. We can insert i incrementation into the values[i] if you like concise code. However for more readable code, we recomment the incrementation to place on to the new line.

Also, local i variable is reseted for System.out line printing.

Output

[ Paul Smith = 555-400-321 ]
[ John Doe = 555-869-759 ]
[ Thomas Cook = 555-906-941 ]

Conclusion

This article has shown how to convert Java's Map to an Array by various approaches.

All algorithms are placed in the Java method for quick copy and paste into your projects.

While the first three algorithms (Entry, Keys, Values) will cover most of the real-life scenarios of Map to Array conversion, we have shown two more approaches which give you a space for more transformation and conversion. Plus, last two approaches (Map element order secured, Map element order unsecured) pointing out solutions for element order Map security issues.

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

Overview

Arrays are essential cornerstones of every modern programming language. On a specific occasion, you need to initialize an array with zero values. This article will take you through the pros and cons of the various way how to initialize Java array with default zero values.

Introduction to Java data types

In Java we have several different data types. Majority of data types are called primitive data types. To this group belong byte, short, int, long, float, double, boolean and char.

For more information about Java’s data type, please read our article about primitive data types.

Speaking about Java’s data type, there is also a general notation of different data type represented by referencing the object’s type. We are talking about object references, where the type of the object is classified by the object’s referencing type. Sound confusing? If you are new to Java, let me point you out to one of the most asked Java questions Is Java pass by value or pass by reference?

Java data type default values

Let’s take a look what is initial (default) value in Java language for any variable initialization.

• The default value for type byte is zero. That means in byte the value of (byte) is 0.
• The default value for type short is zero. That means in the short the value of (short) is 0.
• The default value for type int is zero. That means in int the value of (int) is 0.
• The default value for type long is zero. That means in long the value of (long) is 0L.
• The default value for type float is positive zero. That means in float the value of (float) is 0.0f.
• The default value for type double is positive zero. That means in double the value of (double) is 0.0d.
• The default value for type boolean is false.
• The default value for type char is the null character. That means in char the value of (char) is ‘\u0000’.
• The default value for all reference types (Sting or any Object parent or its child) is null.

If you have noticed, primitive data types are initialized in their form of number zero. The exception is boolean, where the default state is false. However, this representation of the default state comes from generation-lasting philosophical discussion beyond this blog’s scope.

Default data type for String and arrays

It is important to remember that in Java, an array is a container object that holds a fixed number of values of a single type.

The String object is unique in a certain way. It is because it is wrapping object around an array collection of primitive char data types. However, we always reference the String object, not String‘s internal array.

Array of primitive types keeps initialization value equal default value for each element of primitive data type.

double[] treePrimitiveDoubles = new double[3];

double zeroElementPrimitive = treePrimitiveDoubles[0];
System.out.print(zeroElementPrimitive);

Output

>> 0.0

Array of reference type keeps initialization value equal null. The String is the same; it keeps the initialization value equal null.

Double[] treeReferenceDoubles = new Double[3];

Double zeroElementReference = treeReferenceDoubles[0];
System.out.print(zeroElementReference);

Output

>> null

We instantly see that we need to create the objects to fill the arrays of the reference type array.

Filling default values to reference type arrays

There are two different approaches for reference type arrays on how to fill up an array by a particular type. First is the classic iterative approach, where you loop through the collection and fill the position individually.

BankAccount[] arrayOfAllBankAccounts = new BankAccount[50];

for(int i = 0; i < arrayOfAllBankAccounts.length; i++) {
    arrayOfAllBankAccounts[i] = new BankAccount();
}

The second option is to use a more procedural approach with the help of java.util.Arrays. If you want to initialize a one-dimensional array with default values, you can use the static .fill() method. Although, internally .fill() method uses a loop. However, code notation is much more concise. Let's look at the code notation:

BankAccount[] arrayOfAllBankAccounts = new BankAccount[50];

Arrays.fill(arrayOfAllBankAccounts, new BankAccount());

Performance

Consider the array of arbitrary length which will store reference type for Object counterparts of primitive types such as Byte, Short, Integer, Long, Float, Double, Boolean and Char class. And imagine now that you would do this for many many arrays like this in your program. This would dramatically decrease performance of your application; you would waste a lot of machine cycles just for initialization. It would affect your application performance by considerable level.

Each array consisted of an Object version of primitive types that would not only take longer to initialize than a regular primitive type array, but it would even require allocating more memory than necessary. Consequently, if you want to use Object version of a primitive type, use them only when essential for your code solution.

Initialization of arrays with primitive types is quick and fast, does not allocate a lot of memory. You can prefer them over their reference type versions.

String performance

Java's String class has a special place in our hearts. As we said, String class uses an array of primitive characters for storing text. On each addition or change text, String needs to compute if the allocated array length is sufficient. If it is not, it needs to allocate a new - more significant size for the internal array of primitive characters and copy the existing text to a new array of primitive characters. Resizing mechanism naturally decrease performance. There are two ways how to mitigate this issue. First, it is highly recommended to not use concatenation on Strings in your code. And second, if you know you will be using a lot of text manipulation, use the StringBuilder class.

Conclusion

In this article, we have seen how to initialize the array in Java with zero values. As always, you can find all codes in this article in out GitHub repository.

We can divide bit manipulating operators into two categories categorized by the kind of operation operators do. We have bitwise operators such as AND, OR, XOR and bitwise complement; and shift operators such as Signed right shift, Unsigned right shift and Unsigned left shift operators. Let’s take a closer look at individual operators with real-life examples.

Bitwise operators

Bitwise operators are used to perform individual bits manipulation. However, we can also use them with integral types such as char, short, int, etc.

Bitwise operator AND – &

AND operator is binary operator, denoted by ‘&’ character in Java. It returns bit result of AND operation on input variables.

Let’s take a look on AND table and explain the OR bit operator on example below:

    A = 3 = 0011 [Binary]
    B = 5 = 0101 [Binary]

    Bitwise AND Operation of 3 and 5
    0011 &
    0101
    ________
    0001  = 1 [Decimal]

& assignment trick

& can be in Java also combined with assignment operator to provide shorthand assignment e.g.:

    a = a&b
    a &= b;

Bitwise operator OR – |

OR operator is binary operator, denoted by ‘|’ character in Java. It returns bit result of OR operation on input variables.

Let’s take a look on OR table and explain the OR bit operator on example below:

    A = 3 = 0011 [Binary]
    B = 5 = 0101 [Binary]

    Bitwise OR Operation of 3 and 5
    0011 |
    0101
    ________
    0111  = 7 [Decimal]

Bitwise operator XOR – ^

XOR operator is binary operator, denoted by ‘^’ character in Java. It returns bit result of XOR operation on input variables.

Let’s take a look on XOR table and explain the OR bit operator on example below:

    A = 3 = 0011 [Binary]
    B = 5 = 0101 [Binary]

    Bitwise XOR Operation of 3 and 5
    0011 ^
    0101
    ________
    0110  = 6 [Decimal]

Bitwise complement – ~

This is unary operator, denoted by ‘~’ character in Java. It means it returns one’s complement representation of the input value. It means flipping bits on the opposite value where 1 is 0 and 0 is 1.

Let’s take a look on XOR table and explain the OR bit operator on example below:

    A = 3 = 0011 [Binary]

    Bitwise OR Operation of 3 and 5
    ~0011
    ________
    1100  = 12 [Decimal]

Shift operators

Shift operators are used to shift the bits for a number of positions to the left or right. Due to bits movement, shifting bits multiply or divide the number by two, respectively.

Generally, shift operators can be used when we have to multiply or divide a number by two.

Signed right shift operator – >>

Signed right operator is denoted by ‘>>’ characters in Java. The signed right operator shifts the bits for the number of positions to the right and fills the blank bit positions with 0 as a result.

The leftmost bit depends on the sign of the initial number. With signed right shift we preserve the sign bit.

Similarly, shifting bits right affects number as if it would be divided by the power of two.

      5 => 0 0101>>2 =  1 = 0 0001
    -10 => 1 0110>>2 = -3 = 1111 1111 1111 1111 1111 1111 1111 1101

Unsigned right shift operator – >>>

Unsigned right operator is denoted by ‘>>>’ characters in Java. The unsigned right operator shifts the bits for the number of positions to the right and fills the blank bit positions with 0s.

The leftmost bit is set to 0. Difference between signed and unsigned right shift operator is that unsigned-shift operator (>>>) will insert 0 while signed operator (>>) will extend the sign bit. With unsigned right shift we do not preserve the sign bit.

      5 => 0 0101>>>2 = 1          = 0 0001
        // Similar to 5/(2^2)
      8 => 0 1000>>>2 = 2          = 0 0010
        // Similar to 8/(2^2)
    -10 => 1 0110>>>2 = 1073741821 = 11 1111 1111 1111 1111 1111 1111 1101 = 0011 1111 1111 1111 1111 1111 1111 1101
        // !!! Remember unsigned right shift operator for negative numbers - first 2 bits become 0 (and do not display in binary string)

Signed left shift operator – <<

Signed left operator is denoted by ‘<<<' characters in Java. The signed left operator shifts the bits for the number of positions to the left and fills the blank bit positions with 0s.

The leftmost bit depends on the sign of the initial number. With signed left shift we preserve the sign bit.

Similarly, shifting bits left affects the number as if it would be multiplied by the power of two.

      5 => 0 0101<<2 =  20 = 10100
            // Similar to 5*(2^2)
    -10 => 1 0110<<2 = -40 = 1111 1111 1111 1111 1111 1111 1101 1000
            // Similar to -10*(2^2)

Unsigned left shift operator - <<<

Unlike unsigned light shift, there is no "<<<" operator in Java. The logical (<<) and arithmetic left-shift (<<<) operations are identical.

Example code

public class Test {
     public static void main(String []args) {

        int a = 3;
        int b = 5;
        int c = -7;
        int d = -10;

        // For testing of bitwise and assigning operators use
        // Integer.toBinaryString();


        // Bitwise AND
        // 0 0011 & 0 0101 = 0 0001 = 1
        System.out.println("A & B = " + (a & b));
        // 1 0111 & 1 1010 = 1 0000 = -16 = 1111 1111 1111 1111 1111 1111 1111 0000
        System.out.println("C & D = " + (c & d));


        // Bitwise OR
        // 0 0011 | 0 0101 = 0 0111 = 7
        System.out.println("A | B = " + (a | b));
        // 1 0111 | 1 1010 = 1 1111 = -1 = 1111 1111 1111 1111 1111 1111 1111 1111
        System.out.println("C | D = " + (c | d));


        // Bitwise XOR
        // 3 => 0 0011 ^ 0 0101 = 0 0110 = 6
        System.out.println("A ^ B = " + (a ^ b));
        // -7 => 1 0111 ^ 1 1010 = 0 1111 = 15
        System.out.println("C ^ D = " + (c ^ d));


        // Bitwise complement
        // ~0 0011 = -4 = 1111 1111 1111 1111 1111 1111 1111 1100
        System.out.println("~A = " + ~a);
        // 1 0111 = 6 = 110
        // will give 2's complement of 1010 = -6
        System.out.println("~C = " + ~c);


        // Signed right shift operator
        // 5 => 0 0101>>2 = 1 = 0 0001
        System.out.println("B>>2 = " + (b >> 2));
        // -10 => 1 0110>>2 = -3 = 1111 1111 1111 1111 1111 1111 1111 1101
        System.out.println("D>>2 = " + (d >> 2));


        // Unsigned right shift operator
        // 5 => 0 0101>>>2 = 1 = 0 0001
        System.out.println("B>>>2 = " + (b >>> 2));
        // -10 => 1 0110>>>2 = 1073741821 = 11 1111 1111 1111 1111 1111 1111 1101
        System.out.println("D>>>2 = " + d >>> 2);
        // !!! Important observation for negative numbers - first 2 bits become 0
        // (and do not display in binary string)


        // 5 => 0 0101<<2 = 20 = 10100
        // Similar to 5*(2^2)
        System.out.println("C<<2 = " + (b << 2));
        // -10 => 1 0110<<2 = -40 = 1111 1111 1111 1111 1111 1111 1101 1000
        // Similar to -10*(2^2)
        System.out.println("D<<2 = " + (d << 2));
     }
}

Note: Just to help with some bit transformation, here is a bit integer number transformation table to binary 4-bit and 8-bit representation.

What is the difference between slice(), substr() and substring() string methods?

The slice() method extracts parts of a string and returns the extracted parts in a new string. slice() does not change original string.

Syntax

string.slice(start_position, end_position_excluded)

The substr() method extracts parts of a string, beginning at the character at the specified position, and returns the limited number of characters. substr() does not change original string.

Syntax

string.substr(start_position, length)

The substring() method extracts parts of a string and returns the extracted parts in a new string. substring() does not change original string.

Syntax

string.substring(start_position, end_position_excluded)

As a conclusion we can say that there is a difference between slice() and substr(), while substring() is basically a copy of slice().

Let’s take a better look at the differences between the individual methods.

Slice()

var string = "1234567890"
var substr=string.slice(4);
console.log(substr);

Output

567890

substr(4) will remain everything after first 4 characters.

var string = "1234567890"
var substr = string.slice(0, 4);
console.log(substr);

Output

1234

substr(0, 4) will keep the first 4 characters. Second argument exclude the argument position (upper bound excluded).

var string = "1234567890"
var substr = string.slice(-4);
console.log(substr);

Output

890

substr(-4) will keep the last 4 characters.

Substr()

var string = "1234567890"
var substr=string.substr(4);
console.log(substr);

Output

567890

substr(4) will remain everything after first 4 characters.

var string = "1234567890"
var substr = string.substr(0, 4);
console.log(substr);

Output

1234

substr(0, 4) will keep the first 4 characters. Second argument denotes the number of characters to extract.

var string = "1234567890"
var substr = string.substr(-4);
console.log(substr);

Output

890

substr(-4) will keep the last 4 characters.

Substring()

var string = "1234567890"
var substr=string.substring(4);
console.log(substr);

Output

567890

substr(4) will remain everything after first 4 characters.

var string = "1234567890"
var substr = string.substring(0, 4);
console.log(substr);

Output

1234

substr(0, 4) will keep the first 4 characters. Second argument exclude the argument position (upper bound excluded).

General note regarding indexes in all 3 methods: Strings are arrays of characters. Therefore they start character order from 0.

Conclusion

As you can see, using substring is nearly identical to split() or substr() method. However there are some small differences. For example substring() does not have option to add negative number and count string split backwards. Also if first argument is greater than the second, substring will swap the two arguments, and perform as usual.

Basically, if you know the the position (index) on which you will start and the length of the of characters to be extracted, use subst(start_position, length). Otherwise if you know the position (index) you want to start and end, but NOT include the end position, use slice(start_position, end_position_excluded).

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