Java 8 Interview Questions

Question: How to parse a JSON object in Java?

Answer:

In Java, parsing a JSON object can be done using various libraries. The most commonly used libraries for parsing JSON are:

1. org.json (JSON-java)
2. Google’s Gson library
3. FasterXML’s Jackson library

Let’s walk through examples for parsing JSON using each of these libraries.

---

1. Using org.json (JSON-java)

The org.json library provides a simple API to parse and handle JSON data.

Steps:

1. Add the org.json dependency (usually via Maven or Gradle).
2. Use the JSONObject class to parse the JSON string.

Example (with org.json):

import org.json.JSONObject;

public class JSONParseExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";

        // Parse JSON string into JSONObject
        JSONObject jsonObject = new JSONObject(jsonString);

        // Access JSON object fields
        String name = jsonObject.getString("name");
        int age = jsonObject.getInt("age");
        String city = jsonObject.getString("city");

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("City: " + city);
    }
}

Explanation:

• JSONObject is used to represent the JSON object.
• getString("key"), getInt("key") are used to retrieve values from the JSONObject by their respective keys.

---

2. Using Gson Library

Google’s Gson is a very popular library for parsing and serializing Java objects to JSON and vice versa.

Steps:

1. Add the Gson dependency (via Maven or Gradle).
2. Use the JsonObject class to parse JSON.

Example (with Gson):

import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class GsonExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";

        // Parse the JSON string into a JsonObject
        JsonObject jsonObject = JsonParser.parseString(jsonString).getAsJsonObject();

        // Access JSON object fields
        String name = jsonObject.get("name").getAsString();
        int age = jsonObject.get("age").getAsInt();
        String city = jsonObject.get("city").getAsString();

        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("City: " + city);
    }
}

Explanation:

• JsonParser.parseString() is used to convert the JSON string to a JsonObject.
• get("key").getAsString() and get("key").getAsInt() are used to retrieve values.

---

3. Using Jackson Library

Jackson is a widely used library for JSON parsing, and it provides more features for dealing with complex JSON structures.

Steps:

1. Add the Jackson dependency (via Maven or Gradle).
2. Use the ObjectMapper class to parse JSON.

Example (with Jackson):

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";

        try {
            // Create ObjectMapper instance
            ObjectMapper objectMapper = new ObjectMapper();

            // Parse JSON string into JsonNode
            JsonNode jsonNode = objectMapper.readTree(jsonString);

            // Access JSON object fields
            String name = jsonNode.get("name").asText();
            int age = jsonNode.get("age").asInt();
            String city = jsonNode.get("city").asText();

            System.out.println("Name: " + name);
            System.out.println("Age: " + age);
            System.out.println("City: " + city);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation:

• ObjectMapper.readTree() is used to parse the JSON string into a JsonNode.
• get("key").asText() and get("key").asInt() are used to retrieve values from the JsonNode.

---

Conclusion:

• org.json: A simple library for working with JSON data in Java. It provides straightforward methods for parsing and accessing JSON.
• Gson: A popular library for serializing and deserializing Java objects to/from JSON, useful for more complex use cases and easier handling of Java objects.
• Jackson: A powerful library for JSON processing, capable of handling large JSON data structures and offering advanced features like streaming, tree models, and data binding.

Choose the library based on your project requirements:

• If you need simplicity, org.json or Gson is sufficient.
• For more advanced or complex use cases (e.g., working with Java objects), Jackson is often the best choice.

Question: How to check if a string is numeric in Java?

Answer:

To check if a string is numeric in Java, you can use several approaches depending on your requirements. Common methods include using regular expressions, parsing the string to a number, or leveraging utility methods in Java libraries.

Here are different approaches for checking if a string is numeric:

---

1. Using try-catch Block (Parsing with Integer, Double, etc.)

You can try parsing the string into a numeric type (e.g., Integer, Double) and catch any exceptions if the string is not numeric.

Example (using Integer.parseInt()):

public class NumericCheckExample {
    public static void main(String[] args) {
        String input = "12345";

        try {
            Integer.parseInt(input); // Try parsing to integer
            System.out.println(input + " is numeric.");
        } catch (NumberFormatException e) {
            System.out.println(input + " is not numeric.");
        }
    }
}

Explanation:

• Integer.parseInt() attempts to parse the string into an integer.
• If the string is not a valid integer, a NumberFormatException will be thrown, indicating that the string is not numeric.
• You can also use Double.parseDouble() or Float.parseFloat() for floating-point numbers.

---

2. Using Regular Expressions (Regex)

You can use regular expressions to check if a string contains only digits (or numeric characters). This method is flexible and can be extended to handle negative numbers, decimals, etc.

Example (using regex for integers):

public class NumericCheckExample {
    public static void main(String[] args) {
        String input = "12345";
        
        // Regular expression to match an integer (positive or negative)
        String regex = "^-?\\d+$";
        
        if (input.matches(regex)) {
            System.out.println(input + " is numeric.");
        } else {
            System.out.println(input + " is not numeric.");
        }
    }
}

Explanation:

• The regex "^-?\\d+$" matches strings that:
  • Start with an optional minus sign (^-?).
  • Followed by one or more digits (\\d+).
• This checks if the string represents an integer. If you want to check for decimal numbers, you can extend the regex to handle them.

Example (for floating-point numbers):

public class NumericCheckExample {
    public static void main(String[] args) {
        String input = "123.45";
        
        // Regular expression to match a number (integer or floating-point)
        String regex = "^-?\\d*(\\.\\d+)?$";
        
        if (input.matches(regex)) {
            System.out.println(input + " is numeric.");
        } else {
            System.out.println(input + " is not numeric.");
        }
    }
}

Explanation:

• The regex "^-?\\d*(\\.\\d+)?$" checks for both integers and floating-point numbers:
  • \\d* allows the integer part (which can be empty, e.g., .45).
  • (\\.\\d+)? optionally matches a decimal point followed by one or more digits.

---

3. Using NumberUtils.isDigits() from Apache Commons Lang

The Apache Commons Lang library provides a utility class NumberUtils that contains the method isDigits(), which returns true if the string consists only of digits.

Example:

import org.apache.commons.lang3.math.NumberUtils;

public class NumericCheckExample {
    public static void main(String[] args) {
        String input = "12345";

        if (NumberUtils.isDigits(input)) {
            System.out.println(input + " is numeric.");
        } else {
            System.out.println(input + " is not numeric.");
        }
    }
}

Explanation:

• NumberUtils.isDigits() checks if the string is composed only of digits and does not consider negative numbers or decimal points.
• You need to include Apache Commons Lang as a dependency if you choose to use this approach.

---

4. Using Scanner.hasNextInt() or hasNextDouble()

You can use a Scanner object to check if the string can be interpreted as an integer or a floating-point number.

Example (using Scanner for integer):

import java.util.Scanner;

public class NumericCheckExample {
    public static void main(String[] args) {
        String input = "12345";
        Scanner scanner = new Scanner(input);

        if (scanner.hasNextInt()) {
            System.out.println(input + " is numeric.");
        } else {
            System.out.println(input + " is not numeric.");
        }

        scanner.close();
    }
}

Explanation:

• scanner.hasNextInt() checks if the next token in the input can be parsed as an integer.
• Similarly, you can use hasNextDouble() to check for floating-point numbers.

---

Summary of Methods:

Method	Description	Limitations
try-catch with parseInt() or parseDouble()	Try parsing the string into a numeric type.	Catches exceptions for non-numeric values.
Regular Expressions (regex)	Use regex patterns to validate numeric format (integer/decimal).	Can be tricky for complex cases (e.g., leading zeros, special formats).
NumberUtils.isDigits() (Apache Commons)	Use the utility method for digit-only check (positive integers).	Does not support negative numbers or decimals.
Scanner.hasNextInt() or hasNextDouble()	Use Scanner to check if the input can be interpreted as numeric.	Best for user input or streaming data.

---

Conclusion:

• Use try-catch for simplicity, especially when working with various numeric types.
• Use regular expressions when you need more control over the format (e.g., integers, floating-point numbers).
• Apache Commons Lang’s NumberUtils.isDigits() can be useful if you want a simple utility for digit-only checks.
• Use Scanner for reading and validating input in interactive or user-driven applications.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as Java interview questions, Java interview experiences, and details about various Java job positions. Click here to check it out.