If you are using maven, you can add the following dependency

<dependency>
   <groupId>javax</groupId>
   <artifactId>javaee-api</artifactId>
   <version>7.0</version>
</dependency>

you can also download the artefact manually here

http://central.maven.org/maven2/javax/javaee-api/7.0/javaee-api-7.0.jar

For Gradle, use

compile group: 'javax', name: 'javaee-api', version: '7.0'

The site https://mvnrepository.com shows you the different dependencies for different build systems.

Please note that this is only one possible dependency. You can certainly find smaller dependencies, which only contain the classes you want. Simply search for it on google or mavencentral.

I was facing same issue in my Spring Integration project. I added below JSON dependencies in pom.xml file. It works for me.

<dependency>
  <groupId>org.json</groupId>
  <artifactId>json</artifactId>
  <version>20090211</version>
</dependency>

A list of versions can be found here: https://mvnrepository.com/artifact/org.json/json

Adding this to my build.gradle file works:

implementation 'com.googlecode.json-simple:json-simple:1.1.1'

org.json library has very simple API which does not have JSONParser but has JSONTokener. We can construct JSONObject or JSONArray directly from String:

import org.json.JSONArray;
import org.json.JSONObject;

public class JsonApp {

    public static void main(String[] args) {
        // JSON Object
        String object = "{\"p1\":\"v1\", \"p2\":2}";
        JSONObject jsonObject = new JSONObject(object);
        System.out.println(jsonObject);

        // JSON Array
        String array = "[{\"p1\":\"v1\", \"p2\":2}]";
        JSONArray jsonArray = new JSONArray(array);
        System.out.println(jsonArray);
    }
}

Above code prints:

{"p1":"v1", "p2":2}
[{"p1":"v1","p2":2}]

You need to notice that it depends from JSON payload which class to use: if JSON starts from { use JSONObject, if from [ - use JSONArray. In other case JSON payload is invalid.

As it mentioned in other answers, if you can you should definitely use Jackson or Gson

For the sake of the example lets assume you have a class Person with just a name.

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

Jackson (Maven)

My personal favourite and probably the most widely used.

ObjectMapper mapper = new ObjectMapper();

// De-serialize to an object
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);
System.out.println(user.name); //John

// Read a single attribute
JsonNode nameNode = mapper.readTree("{\"name\": \"John\"}");
System.out.println(nameNode.get("name").asText());

Google GSON (Maven)

Gson g = new Gson();

// De-serialize to an object
Person person = g.fromJson("{\"name\": \"John\"}", Person.class);
System.out.println(person.name); //John

// Read a single attribute
JsonObject jsonObject = new JsonParser().parseString("{\"name\": \"John\"}").getAsJsonObject();
System.out.println(jsonObject.get("name").getAsString()); //John

Org.JSON (Maven)

This suggestion is listed here simply because it appears to be quite popular due to stackoverflow reference to it. I would not recommend using it as it is more a proof-of-concept project than an actual library.

JSONObject obj = new JSONObject("{\"name\": \"John\"}");

System.out.println(obj.getString("name")); //John