JSON in Java

https://github.com/stleary/json-java
Admin
JSON in Java is a reference implementation that provides JSON encoders and decoders for Java, with...
Tokens:62,761
Snippets:475
Trust Score:9.1
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Main method with commented example calls

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Main method listing all example conversion methods as commented-out calls. Uncomment the desired method to run that example.

```java
public static void main(String[] args) {
	//JSONObjectToArray();
	//JSONExampleArray1();
	//JSONExampleArray2();
	//JSONExampleStringer();
	//JSONExampleObject1();
	//JSONExampleObject2();
	//JSONExampleObject3();
	//JSONExamplWriter();
	//XMLToExampleConversion();
	//XMLFromExampleConversion();
	//CookieToExampleConversion();
	//CookieFromExampleConversion(); 
	//HTTPToExampleConversion();
	//HTTPFromExampleConversion();
	//CDLToExampleConversion();
	//CDLFromExampleConversion();
	//PropertyToExampleConversion();
	//PropertyFromExampleConversion();
}
```

--------------------------------

### Test.java example using JSONObject

Source: https://github.com/stleary/json-java/blob/master/README.md

Test file contents that create a JSONObject from a JSON string and print it. This is the example code referenced in the build instructions.

```java
import org.json.JSONObject;
public class Test {
    public static void main(String args[]){
       JSONObject jo = new JSONObject("{ \"abc\" : \"def\" }");
       System.out.println(jo);
    }
}
```

--------------------------------

### Imports for JSON examples

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Common imports used by all examples on this page.

```java
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
```

--------------------------------

### XML input for configuration comparison

Source: https://github.com/stleary/json-java/wiki/Home

Example XML string used to demonstrate the difference in conversion when keepStrings is enabled or disabled.

```xml
<person age="30">John Doe</person>
```

--------------------------------

### Set Java 8 with jenv

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-make-a-new-JSON-java-release

Set the Java version to 8 using jenv on macOS before starting the release process.

```bash
jenv global 1.8
```

--------------------------------

### JSONTokener example: parsing a string into JSONObject and JSONArray

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Shows how to create a JSONTokener from a string and use it to construct a JSONObject and JSONArray. The example uses a string that is not valid JSON, but the code demonstrates the usage pattern.

```java
private static void JSONExampleTokener() {

	//A partir de una String podemos crear un JSONTokener, que lo podemos usar alternativamente para JSONArray,JSONObject

	String string = "this is not a valid JSON string";
	JSONTokener token = new JSONTokener(string);

	//Now you can use the token in JSONObject and Array the same way as a String

	JSONObject object = new JSONObject(token);
	JSONArray array = new JSONArray(token);

}
```

--------------------------------

### Consistent JSONArray using putAll only (Option 1)

Source: https://github.com/stleary/json-java/blob/master/docs/NOTES.md

Option 1 for consistent JSONArray: start with an empty JSONArray and use putAll for all items, so none are wrapped.

```java
SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
JSONArray jArr = new JSONArray();
// these will not be wrapped
jArr.putAll(myArr);
// these will not be wrapped
jArr.putAll(new SomeBean[]{ new SomeBean(3), new SomeBean(4) });
// our jArr is now consistent.
```

--------------------------------

### HTTP to JSONObject conversion using HTTP.toJSONObject

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts an HTTP string to a JSONObject using the HTTP.toJSONObject method. The example uses a string that appears to be the output of HTTP.toString.

```java
private static void HTTPFromExampleConversion() {

	//We start with a string with  the HTTP format

	String string = "Final HTTP: POST '/' HTTP/1.1 Value3: -2.345E+68 Value1: true Value2: 2";

	//We obtain a JSONObject with toJSONOBject()

	JSONObject output = HTTP.toJSONObject(string);
	System.out.println("Final JSONObject: " + output);
}
```

--------------------------------

### JSONWriter example: building JSON with StringBuilder

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Shows how to use JSONWriter with an Appendable (StringBuilder) to construct a JSON object. The output is written to the StringBuilder and printed. Note that unlike JSONObject, this does not return a JSONObject.

```java
private static void JSONExamplWriter() {

	//This method works in a very similar way to Object  and Stringer in the construction of the JSON.
	//The difference is that it needs a Java object called "Appendable" like StringBuilder

	StringBuilder write = new StringBuilder();
	JSONWriter jsonWriter = new JSONWriter(write);

	//We behave now the same way as Stringer

	jsonWriter.object();

	jsonWriter.key("trueValue").value(true);
	jsonWriter.key("falseValue").value(false);
	jsonWriter.key("nullValue").value(null);
	jsonWriter.key("stringValue").value("hello world!");
	jsonWriter.key("complexStringValue").value("h\be\tllo w\u1234orld!");
	jsonWriter.key("intValue").value(42);
	jsonWriter.key("doubleValue").value(-23.45e67);

	jsonWriter.endObject();

	//The resoult should be in the "write" object

	System.out.println("JSON: " + write.toString());

	//The difference is that we don't get a JSONObject in this one.


}
```

--------------------------------

### JSONObject to XML conversion using XML.toString

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a JSONObject to an XML string using the XML.toString method. The example creates a JSONObject from a string and prints the resulting XML.

```java
private static void XMLToExampleConversion() {

	//We start with a JSONObject

	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
	JSONObject example = new JSONObject(string);

	//We obtain a String with XML format with toString()

	String output = XML.toString(example);
	System.out.println("Final XML: " + output);
}
```

--------------------------------

### Cookie to JSONObject conversion using Cookie.toJSONObject

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a Cookie string to a JSONObject using the Cookie.toJSONObject method. The example uses a cookie string with key-value pairs.

```java
private static void CookieFromExampleConversion() {

	//We start with a string with  the Cookie format

	String string = "Cookie-Name=name;1=5;2=-2.345E%2b68;3=true";

	//We obtain a JSONObject with toJSONOBject()

	JSONObject output = Cookie.toJSONObject(string);
	System.out.println("Final JSONObject: " + output);
}
```

--------------------------------

### Convert XML to JSON with XML.toJSONObject

Source: https://github.com/stleary/json-java/wiki/Home

Basic example of converting an XML string to a JSONObject using the org.json.XML class. The resulting JSONObject is printed with an indentation factor of 2.

```java
import org.json.XML;
import org.json.JSONObject;

public class Main {
    public static void main(String[] args) {
        String xmlString = "<book><title>The Catcher in the Rye</title><author>J.D. Salinger</author></book>";
        JSONObject jsonObject = XML.toJSONObject(xmlString);
        System.out.println(jsonObject.toString(2));
    }
}
```

--------------------------------

### JSONObject to JSONArray conversion using toJSONArray

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a JSONObject to a JSONArray using a list of key strings. The example creates a JSONObject from a string, generates a key list, and calls toJSONArray to produce the array.

```java
private static void JSONObjectToArray() {
	//We start with a JSONObject

	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";

	JSONObject example = new JSONObject(string);

	//We need a list of key strings like the reverse operation

	JSONArray keyStrings = listNumberArray(example.length());

	//Then we convert to the Array using both elelements

	JSONArray array = example.toJSONArray(keyStrings);

	System.out.println("Final JSONArray: " + array);
}
```

--------------------------------

### Convert JSONArray to CDL with CDL.toString()

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a JSONArray of JSONObjects to a CDL string using CDL.toString(). The example creates two JSONObjects with different values, puts them into a JSONArray, and prints the resulting CDL output.

```java
private static void CDLToExampleConversion() {

	//We start with some JSONObjects with the same values in the keys but different values in the "values"

	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
	JSONObject example = new JSONObject(string);

	String string2 = "{\"0\":\"value2\",\"1\":6,\"2\":-8.345E68,\"3\":false}";
	JSONObject example2 = new JSONObject(string2);

	//We need now a JSONArray with those JSONObjects

	JSONArray array = new JSONArray();
	array.put(example);
	array.put(example2);

	//We obtain a String with XML format with toString()

	String output = CDL.toString(array);
	System.out.println("Final CDL: \r\n" + output);
}
```

--------------------------------

### Build and package json-java JAR (OSX/Linux and Windows)

Source: https://github.com/stleary/json-java/wiki/FAQ

Build the project and create a redistributable JAR. The first block is for OSX/Linux, the second for Windows. Run these commands from the project directory after compiling with javac.

```shell
javac *.java
mkdir -p org/json
mv *.class org/json
jar cf json-java.jar org
```

```shell
javac *.java
mkdir org\json
move *.class org\json
jar cf json-java.jar org
```

--------------------------------

### Run unit tests with Gradle

Source: https://github.com/stleary/json-java/wiki/FAQ

Use this Gradle command to execute the project's unit tests. It runs a clean build and then the test suite.

```bash
./gradlew clean build test
```

--------------------------------

### Create and upload GPG keys for Maven releases

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-make-a-new-JSON-java-release

Commands to create and upload GPG keys for Maven Central releases. Includes key generation, listing, exporting, and sending to keyserver.ubuntu.com. Note that keys.gnupg.net is deprecated.

```bash
# create a new key, using name, comment, email, and passphrase
gpg --gen-key  
# look for the 'sec' line
gpg --list-secret-keys --keyid-format long 
# may not need this
git config user.signingkey (your secret key)
# get your public key
gpg --armor --export (your secret key pub string)
# In GitHub, click your profile pic, select settings > ssh & gpg keys, add the entire public key including framing
# Get your public key hash (I think)
gpg --list-keys
# may not need this - these files seem not to found here anymore - make sure your permissions are good 
chmod 400 /(directory)/.gnupg/gpg.conf
chmod 600 /(directory)/.gnupg
# recently keys.gnupg.net seems to have been deprecated, specify a different one
# $ gpg --keyserver keys.gnupg.net --send-keys (output from list-keys)
$ gpg --keyserver keyserver.ubuntu.com --send-keys (pub key string from list-keys)
gpg: sending key (key) to hkp://keyserver.ubuntu.com
```

--------------------------------

### Verify JSON-java release signatures with PGP and Gradle dependency verification

Source: https://github.com/stleary/json-java/blob/master/docs/SECURITY.md

Commands to import and verify the project's PGP signing key, verify a downloaded artifact's signature, and a Gradle dependency verification entry. The first three bash commands are used in sequence to import the key, confirm its fingerprint, and verify a signed artifact. The XML entry is for Gradle's dependency verification feature.

```bash
gpg --keyserver hkps://keyserver.ubuntu.com \
    --recv-keys FB35C8D02B4724DADA23DE0AFD116C1969FCCFF3
```

```bash
gpg --fingerprint FB35C8D02B4724DADA23DE0AFD116C1969FCCFF3
```

```bash
curl -O https://repo1.maven.org/maven2/org/json/json/20251224/json-20251224.jar
curl -O https://repo1.maven.org/maven2/org/json/json/20251224/json-20251224.jar.asc
gpg --verify json-20251224.jar.asc json-20251224.jar
```

```xml
<trusted-key id="FB35C8D02B4724DADA23DE0AFD116C1969FCCFF3" group="org.json" name="json"/>
```

--------------------------------

### Run unit tests with Maven

Source: https://github.com/stleary/json-java/wiki/FAQ

Use this Maven command to execute the project's unit tests. It performs a clean compile and then runs the tests.

```bash
mvn clean compile test
```

--------------------------------

### Deploy release to Maven Central

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-make-a-new-JSON-java-release

Commands to prepare and deploy the release to Maven Central. Run from the project root after confirming Java 8 is active.

```bash
git checkout master
git pull
git status # to confirm no local changes
mvn clean
mvn deploy
```

--------------------------------

### Run tests with Maven

Source: https://github.com/stleary/json-java/blob/master/README.md

Executes the test suite with Maven.

```shell
mvn clean test
```

--------------------------------

### Run tests with Gradlew

Source: https://github.com/stleary/json-java/blob/master/README.md

Executes the test suite with Gradlew.

```shell
gradlew clean build test
```

--------------------------------

### Run Test with json-java.jar

Source: https://github.com/stleary/json-java/blob/master/README.md

Executes the Test file with the classpath including the current directory and json-java.jar. Windows uses a semicolon, Unix uses a colon.

```shell
java -cp .;json-java.jar Test (Windows)
java -cp .:json-java.jar Test (Unix Systems)
```

--------------------------------

### Maven settings.xml for central server

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-make-a-new-JSON-java-release

Maven settings.xml file with server credentials for the central repository. Place in ~/m2/settings.xml.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.1.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.1.0 http://maven.apache.org/xsd/settings-1.1.0.xsd">
  <servers>
    <server>
       <id>central</id>
       <username>(myUsername)</username>
       <password>(myPassword)</password>
    </server>
  </servers>
</settings>
```

--------------------------------

### Command to run Ant and create the jar

Source: https://github.com/stleary/json-java/wiki/Tech:-Building-a-Jar-file-with-Apache-Ant

Run Ant from the repository root after saving the build.xml file. This triggers the default 'dist' target, which compiles the Java sources and creates the JSON-java.jar file.

```shell
$ ant 

```

--------------------------------

### Run strict mode tests with Gradlew

Source: https://github.com/stleary/json-java/blob/master/README.md

Optional: Executes the test suite in strict mode with Gradlew.

```shell
gradlew testWithStrictMode
```

--------------------------------

### Create json-java.jar with jar

Source: https://github.com/stleary/json-java/blob/master/README.md

Creates the json-java.jar file in the current directory from the compiled class files.

```shell
jar cf json-java.jar org/json/*.class
```

--------------------------------

### Ant build.xml to build JSON-java.jar

Source: https://github.com/stleary/json-java/wiki/Tech:-Building-a-Jar-file-with-Apache-Ant

Use this Ant build file to compile and package the json-java sources into a JAR named JSON-java.jar. It defines a build target that compiles all *.java files with deprecation warnings and unchecked lint, and a dist target that jars the resulting classes. Save it as build.xml in the cloned repository root.

```xml
<?xml version="1.0"?>
<project name="JSON-java" default="dist" basedir=".">
   <property name="jar" value="JSON-java.jar"/>

   <target name="build">
      <javac srcdir="." destdir="." includes="*.java" deprecation="yes" includeantruntime="false">
         <compilerarg value="-Xlint:unchecked"/>
      </javac>
   </target>

   <target name="dist" depends="build">
      <jar destfile="${jar}">
         <fileset dir="." includes="**/*.class"/>
      </jar>
   </target>
</project>
```

--------------------------------

### central-publishing-maven-plugin configuration

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-make-a-new-JSON-java-release

Maven plugin entry for publishing to Maven Central via Sonatype. Must be present in pom.xml.

```xml
<plugin>
    <groupId>org.sonatype.central</groupId>
    <artifactId>central-publishing-maven-plugin</artifactId>
    <version>0.9.0</version>
    <extensions>true</extensions>
    <configuration>
        <publishingServerId>central</publishingServerId>
    </configuration>
</plugin>
```

--------------------------------

### Compile org.json package with javac

Source: https://github.com/stleary/json-java/blob/master/README.md

Compiles all Java source files in the org/json package from the package root directory src/main/java.

```shell
javac org/json/*.java
```

--------------------------------

### Run strict mode tests with Maven

Source: https://github.com/stleary/json-java/blob/master/README.md

Optional: Executes the test suite in strict mode with Maven using the test-strict-mode profile.

```shell
mvn test -P test-strict-mode
```

--------------------------------

### Expected output from Test

Source: https://github.com/stleary/json-java/blob/master/README.md

Expected output from running the Test program.

```json
{"abc":"def"}
```

--------------------------------

### Convert Properties to JSONObject with Property.toJSONObject()

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a Properties object back to a JSONObject using Property.toJSONObject(). It obtains the Properties input by calling PropertyToExampleConversion() and prints the resulting JSONObject.

```java
private static void PropertyFromExampleConversion() {

	//We start with a Properties object

	Properties input = PropertyToExampleConversion();

	//We obtain a JSONObject with toJSONOBject()

	JSONObject output = Property.toJSONObject(input);
	System.out.println("Final JSONObject: " + output);
}
```

--------------------------------

### List the jar contents with jar tf JSON-java.jar

Source: https://github.com/stleary/json-java/wiki/Tech:-Building-a-Jar-file-with-Apache-Ant

Displays the contents of the generated JSON-java.jar, showing the correct package directory structure (org/json/...) and the list of compiled class files. Use this to verify that the jar was built successfully.

```shell
$ jar tf JSON-java.jar 
META-INF/
META-INF/MANIFEST.MF
org/
org/json/
org/json/CDL.class
org/json/Cookie.class
org/json/CookieList.class
org/json/HTTP.class
org/json/HTTPTokener.class
org/json/JSONArray.class
org/json/JSONException.class
org/json/JSONML.class
org/json/JSONObject$1.class
org/json/JSONObject$Null.class
org/json/JSONObject.class
org/json/JSONPointer$Builder.class
org/json/JSONPointer.class
org/json/JSONPointerException.class
org/json/JSONString.class
org/json/JSONStringer.class
org/json/JSONTokener.class
org/json/JSONWriter.class
org/json/Property.class
org/json/XML.class
org/json/XMLTokener.class
```

--------------------------------

### Update JavaDocs and link to Oracle v7 docs

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-update-the-JavaDocs

Run these commands from the project directory to update the JavaDocs on the gh-pages branch. Assumes the repo is in the JSON-Java directory. The javadoc command generates docs into \JSON-Java with a link to the Oracle Java 7 API. After pushing, changes may take up to an hour to appear.

```shell
cd <project directory>
git checkout master
git pull
git checkout gh-pages
git merge master
cd JSON-Java\src\main\java
javadoc -d \JSON-Java -link https://docs.oracle.com/javase/7/docs/api/ org.json
git add <all changed files>
git commit
git push 
```

--------------------------------

### Compile Test.java with json-java.jar

Source: https://github.com/stleary/json-java/blob/master/README.md

Compiles a program that uses the jar. The Windows command uses a semicolon as the classpath separator, while Unix systems use a colon.

```shell
javac -cp .;json-java.jar Test.java (Windows)
javac -cp .:json-java.jar Test.java (Unix Systems)
```

--------------------------------

### Create JSONArray with put() and convert to JSONObject

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Builds a JSONArray by adding elements with put(), then converts it to a JSONObject with a label array from the same helper method.

```java
private static void JSONExampleArray2() {

	//We can also create an Array without a String by creating an empty array and adding elements to it

	JSONArray array = new JSONArray();

	//Adding elements with .put()

	array.put("value");
	array.put(5);
	array.put(-23.45e67);
	array.put(true);

	//We convert it to JSONObject providing a label arrray like last time

	JSONArray list = listNumberArray(array.length());
	JSONObject object = array.toJSONObject(list);
	System.out.println("Final JSONOBject: " + object);
}
```

--------------------------------

### Create JSONObject with put() (null not allowed)

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Builds a JSONObject by calling put() with key-value pairs. Attempting to put a null value is commented out because it is not allowed.

```java
private static void JSONExampleObject2() {

	//We can also create a JSONObject directly without messing around with any of the other functions.

	JSONObject example = new JSONObject();


	//Now we add the keys and values in a similar way as the Stringer method
	example.put("key", "value");

	//As you can see, the first entry is the key and the second would be its associeted value.

	example.put("key2", 5);
	example.put("key3", -23.45e67);
	example.put("trueValue", true);

	//We can't add null values thougth

	//example.put("nullValue", null); //This is not possible

	 System.out.println("Final JSONOBject: " + example);
}
```

--------------------------------

### Create XMLParserConfiguration with keepStrings

Source: https://github.com/stleary/json-java/wiki/Home

Creates an XMLParserConfiguration instance with keepStrings set to true, which preserves all numerical strings as strings during XML to JSON conversion.

```java
XMLParserConfiguration config = new XMLParserConfiguration().withKeepStrings(true);
```

--------------------------------

### Convert JSONObject to Properties with Property.toProperties()

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a JSONObject to a java.util.Properties object using Property.toProperties(). The method returns the Properties object and prints it.

```java
private static Properties PropertyToExampleConversion() {

	//We start with a JSONObject

	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
	JSONObject example = new JSONObject(string);

	//We obtain a String with Properties format with toString()

	Properties output = Property.toProperties(example);
	System.out.println("Final Properties: " + output);

	return output;
}
```

--------------------------------

### Build JSONObject using JSONStringer

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Uses JSONStringer to build a JSON object step by step with key() and value(), then converts it to a JSONObject via toString(). Note that null values are allowed here.

```java
private static void JSONExampleStringer() {

	//We initializate the JSONStringer

	JSONStringer jsonStringer = new JSONStringer();

	//Now we start the process of adding elements with .object()

	jsonStringer.object();

	//We can now add elements as keys and values with .values () and .key()

	jsonStringer.key("trueValue").value(true);
	jsonStringer.key("falseValue").value(false);
	jsonStringer.key("nullValue").value(null);
	jsonStringer.key("stringValue").value("hello world!");
	jsonStringer.key("complexStringValue").value("h\be\tllo w\u1234orld!");
	jsonStringer.key("intValue").value(42);
	jsonStringer.key("doubleValue").value(-23.45e67);

	//We end this prcedure with .ednObject

	jsonStringer.endObject();

	//Once we have a JSONStringer, we convert it to JSONObject generating a String and using JSONObject's contructor.

	String str = jsonStringer.toString();
	JSONObject jsonObject = new JSONObject(str);

	System.out.println("Final JSONOBject: " + jsonObject);
}
```

--------------------------------

### GitHub release description table

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-make-a-new-JSON-java-release

Table format for the GitHub release description, listing merged pull requests in reverse chronological order with one-line descriptions.

```markdown
| Pull Request | Description |
|----|----|
| #1000 | one-line description|
```

--------------------------------

### Convert XML with custom configuration (keepStrings)

Source: https://github.com/stleary/json-java/wiki/Home

Converts the XML string with a custom XMLParserConfiguration that has keepStrings set to true, preserving the age attribute as a string. The output is shown in the following JSON block.

```java
XMLParserConfiguration config = new XMLParserConfiguration(true);
JSONObject jsonObject = XML.toJSONObject("<person age=\"30\">John Doe</person>", config);
System.out.println(jsonObject.toString());
```

```json
{"person": {"age": "30", "content": "John Doe"}}
```

--------------------------------

### Mixed JSONArray from putAll without wrapping

Source: https://github.com/stleary/json-java/blob/master/docs/NOTES.md

Shows the mixed JSONArray that results when putAll is used without wrapping, leading to inconsistent object representation.

```java
SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
// these will be wrapped
JSONArray jArr = new JSONArray(myArr);
// these will not be wrapped
jArr.putAll(new SomeBean[]{ new SomeBean(3), new SomeBean(4) });
```

--------------------------------

### XMLParserConfiguration fluent setters

Source: https://github.com/stleary/json-java/wiki/Home

The XMLParserConfiguration class provides fluent setter methods to customize the XML parser. Each method can be chained with the constructor to configure parsing behavior.

```APIDOC
## XMLParserConfiguration

### Description
Configuration class for customizing the XML parser behavior. Use fluent setter methods to set properties.

### Methods

#### withKeepStrings(boolean)
- **Description**: If true, values will not be attempted to be converted to a number, boolean, or null.
- **Parameters**:
  - **keepStrings** (boolean) - Required - If true, keep values as strings.

#### withcDataTagName(String)
- **Description**: If not null and not the empty string, this is the name of the XML tag that will be used to store the content of tags that contain CDATA sections.
- **Parameters**:
  - **cDataTagName** (String) - Required - The tag name for CDATA content.

#### withConvertNilAttributeToNull(boolean)
- **Description**: If true, and the nil attribute of a tag is set to true, the value of the tag will be set to a JSONNull object.
- **Parameters**:
  - **convertNilAttributeToNull** (boolean) - Required - If true, convert nil attributes to null.

#### withXsiTypeMap(Map<String, XMLXsiTypeConverter<?>>)
- **Description**: Specifies that the values with attribute xsi:type will be converted to a target type defined in the map.
- **Parameters**:
  - **xsiTypeMap** (Map<String, XMLXsiTypeConverter<?>>) - Required - Map of xsi:type values to converters.

#### withForceList(Set<String>)
- **Description**: Tags listed in the set are converted to JSONArray list entries.
- **Parameters**:
  - **forceList** (Set<String>) - Required - Set of tag names to force as list entries.

#### withMaxNestingDepth(int)
- **Description**: Defines the maximum nesting depth the parser will descend before throwing an exception. The default is 512.
- **Parameters**:
  - **maxNestingDepth** (int) - Required - Maximum nesting depth.

### Example
```java
new XMLParserConfiguration()
    .withKeepStrings(true)
    .withcDataTagName("MyCDATA")
```
```

--------------------------------

### Convert XML without custom configuration

Source: https://github.com/stleary/json-java/wiki/Home

Converts the XML string without a custom configuration, resulting in the age attribute being converted to a number. The output is shown in the following JSON block.

```java
JSONObject jsonObject = XML.toJSONObject("<person age=\"30\">John Doe</person>");
System.out.println(jsonObject.toString());
```

```json
{"person": {"age": 30, "content": "John Doe"}}
```

--------------------------------

### Consistent JSONArray by wrapping before putAll (Option 2)

Source: https://github.com/stleary/json-java/blob/master/docs/NOTES.md

Option 2 for consistent JSONArray: wrap the second array in a JSONArray before calling putAll, so all items are wrapped.

```java
SomeBean[] myArr = new SomeBean[]{ new SomeBean(1), new SomeBean(2) };
// these will be wrapped
JSONArray jArr = new JSONArray(myArr);
// these will be wrapped
jArr.putAll(new JSONArray(new SomeBean[]{ new SomeBean(3), new SomeBean(4) }));
// our jArr is now consistent.
```

--------------------------------

### Create JSONObject from a Map

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Constructs a JSONObject from a Map with String keys. The map values can be any type.

```java
private static void JSONExampleObject3() {

	//We can also create a JSONObject with a Java Map
	//YoU will need a Map whose keys are Strings. The values can be whatever you want

	Map<String,Double> map = new HashMap<String, Double>();

	map.put("key1", 1.0);
	map.put("key2", -23.45e67);

	//We create the JSONObject with the map with its class builder

	JSONObject example = new JSONObject(map);
	 System.out.println("Final JSONOBject: " + example);
}
```

--------------------------------

### Apply XMLParserConfiguration to toJSONObject

Source: https://github.com/stleary/json-java/wiki/Home

Passes the XMLParserConfiguration instance to the XML.toJSONObject method to customize the conversion behavior.

```java
JSONObject jsonObject = XML.toJSONObject(xmlString, config);
```

--------------------------------

### JSONObject to HTTP conversion using HTTP.toString

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a JSONObject to an HTTP string using the HTTP.toString method. The JSONObject must contain the minimum headers for an HTTP request or header.

```java
private static void HTTPToExampleConversion() {

	//We start with a JSONObject
	//The JSONObject must have the minimun header for a HTTP request or header

	String string = "{\"Method\":\"POST\",\"Request-URI\":'/',\"HTTP-Version\":'HTTP/1.1',\"Value1\":true,\"Value2\":2,\"Value3\":-2.345E68}";

	JSONObject example = new JSONObject(string);

	//We obtain a String with HTTP format with toString()

	String output = HTTP.toString(example);
	System.out.println("Final HTTP: " + output);
}
```

--------------------------------

### Create JSONArray from String and convert to JSONObject

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Creates a JSONArray from a string containing a JSON array, then converts it to a JSONObject using a label array generated by the helper method listNumberArray(). The labels must be strings.

```java
private static void JSONExampleArray1() {
	//We create a JSONObject from a String containing an array using JSONArray
	//Firstly, we declare an Array in a String

	String arrayStr = 
		    "["+"true,"+"false,"+ "\"true\","+ "\"false\","+"\"hello\","+"23.45e-4,"+
			"\"23.45\","+"42,"+"\"43\","+"["+"\"world\""+"],"+
				"{"+
			    "\"key1\":\"value1\","+
			    "\"key2\":\"value2\","+
			    "\"key3\":\"value3\","+
			    "\"key4\":\"value4\""+
			"},"+
			"0,"+"\"-1\""+
		    "]";

	//Then, we initializate the JSONArray thanks to its constructor

	JSONArray array = new JSONArray(arrayStr);
	System.out.println("Values array: "+ array);

	//We convert that array into a JSONObject, but first, we need the labels, so we need another JSONArray with the labels.
	//Here we will use an auxiliary function to get one for the example.

	JSONArray list = listNumberArray(array.length());
	System.out.println("Label Array: "+ list.toString());
	//Now, we construct the JSONObject using both the  value array and the label array.
	JSONObject object = array.toJSONObject(list);
	System.out.println("Final JSONOBject: " + object);
}

//This method creates an JSONArray of labels in which those are generated by their positions

private static JSONArray listNumberArray(int max){
	JSONArray res = new JSONArray();
	for (int i=0; i<max;i++) {
		//The value of the labels must be an String in order to make it work
		res.put(String.valueOf(i));
	}
	return res;
}
```

--------------------------------

### JSONObject to Cookie conversion using Cookie.toString

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Converts a JSONObject to a Cookie string using the Cookie.toString method. The JSONObject must have a 'name' entry and a 'value' entry; booleans are not supported in Cookie format.

```java
private static void CookieToExampleConversion() {

	//We start with a JSONObject
	//The JSONOBject needs to entries that gives the cookie a name and gives the field "name" a name too.
	//The Cokkie format doesn't support booleans

	String string = "{\"name\":\"Cookie-Name\",\"value\":\"name\",\"1\":5,\"2\":-2.345E68,\"3\":'true'}";
	JSONObject example = new JSONObject(string);

	//We obtain a String with Cookie format with toString()

	String output = Cookie.toString(example);
	System.out.println("Final Cookie: " + output);
}
```

--------------------------------

### Create JSONObject from JSON string

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Creates a JSONObject directly from a JSON string using the constructor.

```java
private static void JSONExampleObject1() {

	//We can create a JSONObject from a String with the class builder

	String string = "{\"0\":\"value\",\"1\":5,\"2\":-2.345E68,\"3\":true}";
	JSONObject example = new JSONObject(string);
	System.out.println("Final JSONObject: " + example);

}
```

--------------------------------

### Parse CDL string to JSONArray with CDL.toJSONArray()

Source: https://github.com/stleary/json-java/blob/master/Examples.md

Parses a CDL-formatted string into a JSONArray using CDL.toJSONArray(). The input string contains a header row and two data rows; the resulting JSONArray is printed.

```java
private static void CDLFromExampleConversion() {

	//We start wtih a String with the CDL format

	String string = "0,1,2,3\n"
			+ "value,5,-2.345E+68,true\n"
			+ "value2,6,-8.345E+68,false";

	//We obtain a JSONArray with toJSONOBject()

	JSONArray output = CDL.toJSONArray(string);
	System.out.println("Final JSONArray: " + output);
}
```

--------------------------------

### Parse JSON from a Reader with JSONTokener

Source: https://github.com/stleary/json-java/wiki/Home

Parses JSON text accessed via a Reader object using a JSONTokener to create a JSONObject. The reader should be closed by the calling code after the JSONObject is created.

```java
        Reader reader;
        /* initialize the reader */
        JSONObject jsonObject = new JSONObject(new JSONTokener(reader));
```

--------------------------------

### Override JSON serialization for objects in collections using JSONString

Source: https://github.com/stleary/json-java/wiki/Tech:-How-to-solve-specific-problems-in-your-JSON-Java-code

Use this to customize JSON serialization of objects in a collection without modifying the library. The MyPoJo class implements org.json.JSONString and overrides toJSONString() to control the output, omitting fields and formatting dates. Then, when creating a JSONArray from a collection, calling toString() triggers the custom toJSONString() for each element.

```java
public class MyPoJo implements org.json.JSONString {
        private String someField; // pretend getters and setters
        private int someOtherField; // pretend getters and setters
        private ZonedDateTime aDate; // pretend getters and setters
        
        @Override
        public String toJSONString() {
            // notice the lack of "someOtherField"
            return "{" + "\"someField\":" + JSONObject.quote(this.someField) + ",\"aDate\":" + JSONObject.quote(formatMyDate()) + "}";
        }

        private String formatMyDate() { /* some implementation that formats your date a specific way */ }
        }
```

```java
Collection<MyPoJo> cMP = getACollectionFromSomewhere();

        JSONArray ja = new JSONArray(cMP); // at this point, the items in the JSONArray are still MyPoJo, not a string or JSONObject
        // if you want you can still work with the POJO through the JSONArray

        // the following will cause the `MyPoJo.toJSONString` to be called for each MyPoJo in the list
        // the output will be as you expect with the POJO formatted as we customized.
        return ja.ToString();
```
Tokens:
Raw