You are asking Jackson to parse a StudentList. Tell it to parse a List (of students) instead. Since List is generic you will typically use a TypeReference

List<Student> participantJsonList = mapper.readValue(jsonString, new TypeReference<List<Student>>(){});

Your input string should be as follows to qualify for a list of SomeObject

{
    [{
            "k1": 1,
            "k2": "v2",
            "k3": "v3"
        }, {
            "k1": 2,
            "k2": "v2",
            "k3": "v3"
        }
    ]
}

Below code should work ..

JSONObject jsonObject = new JSONObject(jsonString);
SomeObject[] objectsList = gson.fromJson(jsonObject.toString(), SomeObject[].class);

For given JSON String here you can handle this way (add toString() to SomeObject for displaying it)...

import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class TestClass {

    public static void main(String[] args) {
        List<SomeObject> list = new LinkedList<SomeObject>();
        String jsonString = "{\"obj_1\":{\"k1\":1,\"k2\":\"v2\",\"k3\":\"v3\"},\"obj_2\":{\"k1\":2,\"k2\":\"v2\",\"k3\":\"v3\"}}";
        Gson gson = new Gson();
        JsonObject jsonObject = new JsonParser().parse(jsonString).getAsJsonObject();
        for (Entry<String, JsonElement> entry : jsonObject.entrySet()) {
            // note entry.getKey() will be obj_1, obj_2, etc.
            SomeObject item = gson.fromJson(entry.getValue().getAsJsonObject(), SomeObject.class);
            list.add(item);
        }
        System.out.println(list);
    }
}

Sample Run

[SomeObject [k1=1, k2=v2, k3=v3], SomeObject [k1=2, k2=v2, k3=v3]]

NOTE: the value of k1 must be a number and without quotes as k1 is declared as int in SomeObject

Using gson it is much simpler. Use following code snippet:

 // create a new Gson instance
 Gson gson = new Gson();
 // convert your list to json
 String jsonCartList = gson.toJson(cartList);
 // print your generated json
 System.out.println("jsonCartList: " + jsonCartList);

Converting back from JSON string to your Java object

 // Converts JSON string into a List of Product object
 Type type = new TypeToken<List<Product>>(){}.getType();
 List<Product> prodList = gson.fromJson(jsonCartList, type);

 // print your List<Product>
 System.out.println("prodList: " + prodList);

With Jackson you would do something like:

String jsonStr = "...";
ObjectReader reader = new ObjectMapper().reader();
List<Map<String, Object>> objs = reader.readValue(jsonStr);

Map<String, Object> myFirstObj = objs.get(0);
myFirstObj.get("data");
myFirstObj.get("what");
// and so on

Or even better you can create a pojo and do:

String jsonStr = "...";
ObjectMapper mapper = new ObjectMapper();
List<MyPojo> myObjs = mapper.readValue(jsonStr, new TypeReference<List<MyPojo>>() {});
MyPojo myPojo = myObjs.get(0);
myPojo.getData();
myPojo.getWhat();
// and so on

Use Jackson or GSON to read the JSON as List or array of expected type. With Jackson:

ObjectMapper mapper = new ObjectMapper(); // reuse if multiple calls MyPOJO[] pojos = mapper.readValue(jsonSource, MyPojo[].class); // with `List`, need to use `TypeReference` // or, if you do not have matching MyPOJO type: List<Object> pojosAsMaps = mapper.readValue(jsonSource, List.class);

There are many other ways you could do it, like reading as JSON tree (JsonNode). It all depends on whether you can easily model structure as Java class (if so, most convenient) or not.