For any one who looks for answer yet:

1.Add jackson-databind library to your build tools like Gradle or Maven

2.in your Code:

ObjectMapper mapper = new ObjectMapper();

List<Student> studentList = new ArrayList<>();

studentList = Arrays.asList(mapper.readValue(jsonStringArray, Student[].class));

As ryzhman said, you are able to cast it to a List, but only of the object (JSONArray in ryzhman's case) extends the ArrayList class. You don't need an entire method for this. You can simply:

List<String> listOfStrings = new JSONArray(data);

Or if you are using IBM's JSONArray (com.ibm.json.java.JSONArray):

List<String> listOfStrings = (JSONArray) jsonObject.get("key");

This works for me, use it for different types, hope this will help

public class RestMapper
{

    private ObjectMapper objectMapper;

    public <T> List<T> stringJsonToObject( String json, Class<T> objectType )
    {
        List<T> resultList = new LinkedList<T>();
        ListOfObjects<T> arrObject;
        try
        {
            arrObject = objectMapper.readValue( json, ListOfObjects.class );
            for ( int i = 0; i < arrObject.getBody().size(); i++ )
            {
                T singleObject = objectMapper.convertValue( arrObject.getBody().get( i ), objectType );
                resultList.add( singleObject );
            }
        }
        catch ( IOException e )
        {
            e.printStackTrace();
        }
        return resultList;
    }


    static class ListOfObjects<T>
    {
        private List<T> body;

        public ListOfObjects()
        {

        }

        public void setBody( List<T> body )
        {
            this.body = body;
        }

        public List<T> getBody()
        {
            return body;
        }
    }

Use gson with specified type to convert to list of maps:

Gson gson = new Gson();
Type resultType = new TypeToken<List<Map<String, Object>>>(){}.getType();
List<Map<String, Object>> result = gson.fromJson(json, resultType);

You can use Jackson's TypeReference to achieve this, e.g.:

ObjectMapper objectMapper = new ObjectMapper();
TypeReference<List<Token>> typeReference = new TypeReference<List<Token>>() {};
List<Token> tokens = objectMapper.readValue("<json_stribg>", typeReference);

You can read more about TypeReference here.

Your JSON structure is a Map, if you want an array or list use [ { } , {} ] it is the structure in JSON for array or list

The org.json based classes included in Android don't have any features related to converting Java POJOs to/from JSON.

If you have a list of some class (List<GroupItem>) and you absolutely need to convert that to a org.json.JSONArray you have two choices:

A) Use Gson or Jackson to convert to JSON, then parse that JSON into a JSONArray:

List<GroupItem> list = ...
String json = new Gson().toJson(list);
JSONArray array = new JSONArray(json);

B) Write code to create the JSONArray and the JSONObjects it will contain from your Java objects:

JSONArray array = new JSONArray();
for (GroupItem gi : list)
{
    JSONObject obj = new JSONObject();
    obj.put("fieldName", gi.fieldName);
    obj.put("fieldName2", gi.fieldName2);
    array.put(obj);
}

You have to directly construct JSONArray from JSON string in this case.

JSONArray arr = new JSONArray(jstring);

If you just want to parse your string quickly using Gson, you can simply create the builder and use the "default" List and Map instances used to represent your JSON in Java. If you want to be more type-safe, or you want to use the parsed instances in a "larger" project, I'd suggest to create a POJO as described in the other answers.

final GsonBuilder gsonBuilder = new GsonBuilder();

// you may want to configure the builder

final Gson gson = gsonBuilder.create();

/*
 * The following only works if you are sure that your JSON looks
 * as described, otherwise List<Object> may be better and a validation,
 * within the iteration.
 */
@SuppressWarnings("unchecked") 
final List<Map<String, String>> list = gson.fromJson("[{ ... }]", List.class);

final List<String> stringList = list.stream()
            .map(m -> m.get("rowId"))
            .collect(Collectors.toList());

System.out.println(stringList);