Is there a Java way to format an array output by removing the curly brackets around each key-value pair?

My code works OK by returning the expected key-value pair output from an sql query, however the formatting of the output needs to be changed. I tried removing the curly brackets around each key-value pair contained in the array, but I couldnt succeed with that.

This is what I have tried, but it didn't work:

public List<Map<String, String>> getDemoNames() {
    List<Map<String, String>> demoNames = new ArrayList<>();
    for (Object result : resultList) {
        Object[] row = (Object[]) result;
        Map<String, String> map = new HashMap<>();
        String key = String.valueOf(row[0]).trim().replaceAll("[{}]", ""); //I tried removing the curly bracket this way
        String value = String.valueOf(row[1]).trim().replaceAll("[{}]", "");
        map.put(key, value);
        demoNames.add(map);
    
        System.out.println(demoNames);
    }
    return demoNames;
}

Output: [{001=DEMO}, {002=APPLE}, {003=GOOGLE}, {004=ALAMANCE COUNTY}]

What I want is to get the output in this format:

[{001=DEMO, 002=APPLE, 003=GOOGLE, 004=ALAMANCE COUNTY}]

How do I achieve this?

You have a list of maps with each map only having a single entry (because the map is created inside the loop and then added to the list).

There are at least three options to get the output in the format you request:

1. Populate your data structure in the expected layout in the first place. Meaning that you have a list with a single map (and the map contains all the entries). Presumably, this is the solution which you actually want: Create the map outside the loop, then populate it from within the loop (each loop iteration puts an entry into the map).

2. Manually build the output string:

   boolean first = true;
   final StringBuilder sb = new StringBuilder();
   sb.append("[{");
   for (final Map<String, String> map : demoNames) {
     for (final Map.Entry<String, String> entry : map.entrySet()) {
       if (!first) sb.append(", ");
       first = false;
       sb.append(entry.getKey()).append('=').append(entry.getValue());
     }
   }
   sb.append("}]");
   System.out.println(sb);
   

3. Transform the map into the expected format, then use toString on the map:

   final Map<String, String> map = new HashMap<>();
   for (final Map<String, String> demoName : demoNames) {
     map.putAll(demoName);
   }
   System.out.println(map);
   

I think you want a Map returned, not a List of Maps:

public Map<String, String> getDemoNames() {
    Map<String, String> map = new LinkedHashMap<>();
    for (Object result : resultList) {
        Object[] row = (Object[]) result;
        String key = String.valueOf(row[0]);
        String value = String.valueOf(row[1]);
        map.put(key, value);
    }
    // Consider printing from the call point instead to keep this code clean
    System.out.println(map);
    return map;
}

Using a LinkedHashMap instead of a HashMap iterates over its entries in insertion order, so calling its toString() will render in the same order as resultList.

Consider storing objects of a class with appropirately named String fields in resultList instead of Object[], which would make your code less brittle and more readable.

This seems like an XY problem. It seems like your real problem is generating output that looks a certain way, and you have picked the wrong intermediate data structure. Now you are trying to compensate for the wrong choice with some clever transformation of the toString() output from the data structure to get your desired output.

If you have no knowledge of what is in the map's key / value pairs, then using replaceAll to remove unwanted brackets is fragile.

But I think the problem is deeper than that. You are creating a list of maps where each map contains one element, but you are trying to make it look like a list containing a single (combined) map. So ... why not create it as a single map?

    public List<Map<String, String>> getDemoNames() {
        List<Map<String, String>> demoNames = new ArrayList<>();
        Map<String, String> map = new LinkedHashMap<>();
        for (Object result : resultList) {
            Object[] row = (Object[]) result;

            // The following removes braces from the key and
            // value strings.  This is unnecessary ... unless
            // you are expecting such stuff in the result list.
            String key = String.valueOf(row[0]).trim().replaceAll("[{}]", ""); 
            String value = String.valueOf(row[1]).trim().replaceAll("[{}]", "");

            map.put(key, value);
        }
        demoNames.add(map);
        System.out.println(demoNames);
        return demoNames;
    }

Furthermore, there isn't any obvious reason to have the list here. It doesn't appear to serve any purpose. (Except maybe to preserve the order of the key-value pairs. And the LinkedHashMap preserves that.)

On the other hand ... if you really do need to generate a list of maps, then the best way to format that data as you want would be iterate the maps using for loops or streams. See @knittl's answer for example.

You could possibly try it this way too:

String output = getDemoNames().stream().
    flatMap(m ->m.entrySet().stream()).
    map(e ->e.getKey() + "=" + e.getValue()).
    collect(Collectors.joining(", ", "[{", "}]"));
System.out.println(output);