Map to JSON converter and JSON to Map parser with support JSON5 https://spec.json5.org/

By simple:

What is a json-object? This is a string representation of javascript object.

What is a javascript-object? This is a associative array where the string as key and any object as value.

The most similar structure in the java is a Map<String, Object>.
This is natural json representation, and this is very useful for debug, research, and in support of production system.

Of course, for json-object and json-array you can use any types which implement java.util.Map and java.util.Collection interface.

• Java 1.8
• Not have any dependency

Version 2.x

Created decorator 'TnJson' for greater convenience in large projects. Autocomplete in IDE produces a more relevant result with less effort. More short syntaxis.

While serializating:

• Supporting incoming data with any type - Map, Collection, array, or any other object.
• Supporting LocalDate, LocalTime and LocalDateTime.
• Handlers for generating json in concrete path and by concrete type.

Incompatible with tnjson-1.x because:

• Java with version less then 1.8 is unsupported.
• Classes JsonSerializer and JsonParser now is internal, and you not haw access to there.
• You must use decorator TnJson for access to functional.
• Internal class JsonSerializer.Settings migrated to TnJsonBuilder.

You can use maven dependensy

    <dependency>
      <groupId>com.github.anymaker</groupId>
      <artifactId>tnjson</artifactId>
      <version>2.0</version>
    </dependency>

Or download jar from sonatype.org
SNAPSHOT: https://oss.sonatype.org/content/repositories/snapshots/com/github/anymaker/tnjson/
RELEASE: https://oss.sonatype.org/service/local/repositories/public/content/com/github/anymaker/tnjson/2.0/tnjson-2.0.jar

Suppose we have the json5-string:

{
  // comments
  unquoted: 'and you can quote me on that',
  singleQuotes: 'I can use "double quotes" here',
  lineBreaks: "Look, Mom! \
No \\n's!",
  hexadecimal: 0xdecaf,
  leadingDecimalPoint: .8675309, andTrailing: 8675309.,
  positiveSign: +1,
  trailingComma: 'in objects', andIn: ['arrays',],
  "backwardsCompatible": "with JSON",
}

In a code:

import a2u.tn.utils.json.TnJson;
...

Map<String, Object> result = TnJson.parse(json);

And we get this result :

    LinkedHashMap: result {
      unquoted            -> Stirng: "and you can quote me on that"
      singleQuotes        -> Stirng: "I can use \"double quotes\" here"
      lineBreaks          -> Stirng: "Look, Mom! \nNo \\n's!"
      hexadecimal         -> Integer: 912559
      leadingDecimalPoint -> Double: 0.8675309
      andTrailing         -> Double: 8675309.0
      positiveSign        -> Integer: 1
      trailingComma       -> Stirng: "in objects"
      andIn               -> ArrayList:[ Stirng: "arrays" ] size = 1
      backwardsCompatible -> Stirng: "with JSON"
    }

By default in this parsing for collections using LinkedHashMap and ArrayList. This is very useful for debug.
If you unlike LinkedHashMap or ArrayList, you can use method

public static Map<String, Object> parse(String data, IGetCollection listener)

For example:

    String json;
    Map<String, Object> result;
    json = "{obj1:{num1:123, obj2:{list:[456, 789]}}}";

    result = TnJson.parse(json,
                          new JsonParser.IGetCollection() {
                            @Override
                            public Map<String, Object> forObject(String path) {
                              if (path.equals("root.obj1.obj2")) {
                                return new HashMap<String, Object>();
                              }
                              return null;
                            }

                            @Override
                            public Collection forList(String path) {
                              if (path.equals("root.obj1.obj2.list")) {
                                return new HashSet();
                              }
                              return null;
                            }
                          });

Suppose we must generate next json:

{
  "num": 123,
  "str": "str",
  "innermap": {
    "innernum": 345
  },
  "list1": [789, 987],
  "list2": [{
    "innernum": 345
  },
  {
    "innernum": 345
  }]
}

import a2u.tn.utils.json.TnJson;

    Map<String, Object> map = new LinkedHashMap<String, Object>();
    map.put("num", 123);
    map.put("str", "str");

    Map<String, Object> innermap = new LinkedHashMap<String, Object>();
    innermap.put("innernum", 345);
    map.put("innermap", innermap);

    List<Object> list1 = new ArrayList<Object>();
    list1.add(789);
    list1.add(987);
    map.put("list1", list1);

    List<Object> list2 = new ArrayList<Object>();
    list2.add(innermap);
    list2.add(innermap);
    map.put("list2", list2);

    String json = TnJson.toJson(map);

For serialization you can use any data - Map, Collection, array, or any other object. But, as default some types return next result:

Character, CharSequence, Number, Boolean, Date, LocalDate, LocalTime, LocalDateTime, Map, Collection, and is not array

then attempt is made to get value from the method toJson().
If this method is absent, then value collect from fields with public or default modifiers, exclude transient and synthetic.

You can override this behavior using handlers

• TnJsonBuilder.IPathHandler - for handing generating json in concrete path
• TnJsonBuilder.ITypeHandler - or handing generating json by concrete type.

You can use additional method for specify output format.

    json = TnJson.toJson(data, TnJson.Mode.HARD);

Will be generated compact json-string, where any non-digital and non-letter character in string will be replaced with sequence uXXXX.
This mode is default, because it has max compatibility with other clients.

{"num":123,"str":"str\u0020one\u0020twho",...

    json = TnJson.toJson(data, TnJson.Mode.LIGHT);

Will be generated compact json-string, where non-digital and non-letter character in string will be stay in readable format, if it possible.
This format is more compact, but is not all client can parse it.

{"num":123,"str":"str one twho",...

    json = TnJson.toJson(data, TnJson.Mode.FORMATTED);

Will be generated json-string in pretty read format, where non-digital and non-letter character in string will be stay in readable format, if it possible.

{
  "num": 123,
  "str": "str one twho",
  "emptyobj": {

  },
  "emptylist": [
    
  ],
  "innermap": {
    "innernum": 345
  },
  "list1": [
    789,
    987
  ],
  "list2": [
    {
      "innernum": 345
    },
    {
      "innernum": 345
    }
  ]
}

    json = TnJson.toJson(data, TnJson.Mode.JSON5);

Will be generated json-string in max human readable format json5.
See detail about json5 on https://json5.org/

{
  unquoted: "and you can quote me on that",
  singleQuotes: "I can use \"double quotes\" here",
  lineBreaks: "Look, Mom! /
No \\n's!",
  hexadecimal: 912559,
  leadingDecimalPoint: 0.8675309,
  andTrailing: 8675309.0,
  positiveSign: 1,
  trailingComma: "in objects",
  andIn: [
    "arrays"
  ],
  backwardsCompatible: "with JSON"
}

For advanced you can use builder for specify any aspect JSON generation

String json = TnJson.builder() ... TUNING ... .buildJson(data);

or

TnJson jsonBuilder = TnJson.builder() ... TUNING
...
String json = jsonBuilder.buildJson(data);

Where

TUNING - some functions:

Example, for generate json5 you can use

String json = TnJson.builder().readable().formated().withoutKeyQuote().allowMultiRowString().buildJson(map);

or

TnJson jsonBuilder = TnJson.builder().readable().formated().withoutKeyQuote().allowMultiRowString();
String json1 = jsonBuilder.buildJson(data1);
String json2 = jsonBuilder.buildJson(data2);
String json3 = jsonBuilder.buildJson(data3);

--