Java Convert INI to JSON

INI files are a common configuration file format that uses a simple structure with sections and key-value pairs. JSON, on the other hand, is a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate. In Java, converting an INI file to a JSON object can be useful in many scenarios, such as migrating legacy configuration systems or integrating different software components that use different data formats.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Common Pitfalls
  4. Best Practices
  5. Code Examples
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

INI Files#

INI files are text-based configuration files. They are organized into sections, where each section starts with a name enclosed in square brackets [ ]. Key-value pairs are defined within each section, separated by an equal sign =. For example:

[database]
host = localhost
port = 3306
username = root
password = secret
 
[server]
port = 8080

JSON#

JSON (JavaScript Object Notation) represents data as key-value pairs, arrays, and nested objects. It uses curly braces { } to define objects and square brackets [ ] to define arrays. The example INI file above can be represented in JSON as:

{
    "database": {
        "host": "localhost",
        "port": "3306",
        "username": "root",
        "password": "secret"
    },
    "server": {
        "port": "8080"
    }
}

Typical Usage Scenarios#

  • Configuration Migration: When migrating an application from an old system that uses INI files to a new system that prefers JSON, conversion is necessary.
  • Inter-Component Communication: Different components in a software system may use different data formats. Converting INI to JSON can facilitate communication between them.
  • Data Visualization: JSON is more suitable for data visualization tools, so converting INI data to JSON can make it easier to visualize the configuration data.

Common Pitfalls#

  • Encoding Issues: INI files may be encoded in different character sets. If not handled properly, it can lead to incorrect data conversion.
  • Section and Key Naming: INI files allow special characters in section and key names, which may cause issues when converting to JSON. JSON keys must follow a more restricted naming convention.
  • Data Type Handling: INI files store all values as strings. When converting to JSON, it may be necessary to convert certain values to appropriate data types (e.g., numbers, booleans).

Best Practices#

  • Use Existing Libraries: Instead of writing a parser from scratch, use well-established Java libraries for INI parsing and JSON generation, such as Apache Commons Configuration for INI parsing and Jackson for JSON generation.
  • Error Handling: Implement proper error handling to deal with issues like file not found, malformed INI files, and encoding problems.
  • Data Validation: Validate the INI data before conversion to ensure that the resulting JSON is valid and useful.

Code Examples#

import org.apache.commons.configuration2.INIConfiguration;
import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
import org.apache.commons.configuration2.builder.fluent.Parameters;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
 
public class IniToJsonConverter {
    public static String convertIniToJson(String iniFilePath) {
        try {
            // Parse the INI file
            Parameters params = new Parameters();
            FileBasedConfigurationBuilder<INIConfiguration> builder =
                    new FileBasedConfigurationBuilder<>(INIConfiguration.class)
                            .configure(params.fileBased().setFile(new File(iniFilePath)));
            INIConfiguration iniConfig = builder.getConfiguration();
 
            // Create a map to hold the JSON data
            Map<String, Map<String, Object>> jsonMap = new HashMap<>();
            for (String sectionName : iniConfig.getSections()) {
                Map<String, Object> sectionMap = new HashMap<>();
                for (String key : iniConfig.getKeys(sectionName)) {
                    sectionMap.put(key, iniConfig.getProperty(sectionName + "." + key));
                }
                jsonMap.put(sectionName, sectionMap);
            }
 
            // Convert the map to JSON
            ObjectMapper mapper = new ObjectMapper();
            return mapper.writeValueAsString(jsonMap);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    public static void main(String[] args) {
        String iniFilePath = "config.ini";
        String json = convertIniToJson(iniFilePath);
        if (json != null) {
            System.out.println(json);
        }
    }
}

In this code:

  1. We use Apache Commons Configuration to parse the INI file.
  2. We create a nested Map structure to represent the JSON data.
  3. We use Jackson's ObjectMapper to convert the Map to a JSON string.

Conclusion#

Converting INI files to JSON in Java is a useful operation in many real-world scenarios. By understanding the core concepts, being aware of common pitfalls, and following best practices, developers can perform this conversion effectively. Using existing libraries simplifies the process and reduces the chances of errors.

FAQ#

Q1: Can I convert a JSON file back to an INI file?#

Yes, it is possible. You need to parse the JSON file, extract the data, and then generate an INI file by following the INI file format rules.

Q2: Are there any limitations to the size of the INI file that can be converted?#

The main limitation is the available memory of the Java Virtual Machine (JVM). If the INI file is extremely large, it may cause an out-of-memory error. You may need to process the file in chunks if this is the case.

Q3: What if the INI file has duplicate keys in a section?#

The behavior depends on the INI parser. Some parsers may overwrite the previous value, while others may throw an error. It's important to choose a parser that suits your requirements.

References#

2025-10