There is not.

You can use built-in Nashorn engine to evaluate Javascript in Java 8

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Map;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class JSONParsingTest {

    private ScriptEngine engine;

    @Before
    public void initEngine() {
        ScriptEngineManager sem = new ScriptEngineManager();
        this.engine = sem.getEngineByName("javascript");
    }

    @Test
    public void parseJson() throws IOException, ScriptException {
        String json = new String(Files.readAllBytes(/*path*/);
        String script = "Java.asJSONCompatible(" + json + ")";
        Object result = this.engine.eval(script);
        assertThat(result, instanceOf(Map.class));
        Map contents = (Map) result;
        contents.forEach((t, u) -> {
        //key-value pairs
        });
    }
}

source : Converting JSON To Map With Java 8 Without Dependencies

Update : Nashorn has been removed from Java 15

Right, there is a difference between Java EE and Java SE. JSON parsing is needed with enterprise applications nowadays. Oracle has a dependency you can download:

https://javaee.github.io/jsonp/

If you are using maven, you can just include this in your POM:

<!-- https://mvnrepository.com/artifact/javax.json/javax.json-api -->
<dependency>
    <groupId>javax.json</groupId>
    <artifactId>javax.json-api</artifactId>
    <version>1.1.4</version>
</dependency>

BUT, this has been superseded by the Jakarta EE package (ee4j):

(GitHub download) https://github.com/eclipse-ee4j/jsonp

(Maven download)

<!-- https://mvnrepository.com/artifact/jakarta.json/jakarta.json-api -->
<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>1.1.6</version>
</dependency>

If you look at EE4J, you can see there are so many APIs you can download. Java SE would be so bloated with them by default. For a while, Oracle was just distributing these 'reference implementations' of Java EE packages as well along with various servers like Glassfish. There are so many ways to handle these protocols and formats like JSON, and on the job these may be mission-critical.

The org.json library is easy to use.

Just remember (while casting or using methods like getJSONObject and getJSONArray) that in JSON notation

• [ … ] represents an array, so library will parse it to JSONArray
• { … } represents an object, so library will parse it to JSONObject

Example code below:

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts"); // notice that `"posts": [...]`
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

You may find more examples from: Parse JSON in Java

Downloadable jar: http://mvnrepository.com/artifact/org.json/json

The two most popular and fully-featured Java JSON libraries according to Maven Repository are:

• GSON (2.4)
• Jackson (2.6)

and jars for both are accessible via Maven:

• Gson requires gson-2.4.jar (group id com.google.code.gson, artifact id gson
• Jackson requires jackson-databind-2.6.2.jar (group id com.fasterxml.jackson.core, artifact jackson-databind), as well as 2 supporting jars (jackson-core for streaming parser, jackson-annotations for annotation suport)

Jars that you listed are for other lesser commonly used packages (one for json-lib, http://json-lib.sourceforge.net/ is pretty old; other I don't even know what it is), so I would not recommend you use them.