Acquire an ObjectReader with ObjectMapper#readerFor(TypeReference) using a TypeReference describing the typed collection you want. Then use ObjectReader#readValue(JsonNode) to parse the JsonNode (presumably an ArrayNode).

For example, to get a List<String> out of a JSON array containing only JSON strings

CopyObjectMapper mapper = new ObjectMapper();
// example JsonNode
JsonNode arrayNode = mapper.createArrayNode().add("one").add("two");
// acquire reader for the right type
ObjectReader reader = mapper.readerFor(new TypeReference<List<String>>() {
});
// use it
List<String> list = reader.readValue(arrayNode);

Yes, the Jackson manual parser design is quite different from other libraries. In particular, you will notice that JsonNode has most of the functions that you would typically associate with array nodes from other APIs. As such, you do not need to cast to an ArrayNode to use. Here's an example:

JSON:

{
    "objects" : ["One", "Two", "Three"]
}

Code:

final String json = "{\"objects\" : [\"One\", \"Two\", \"Three\"]}";

final JsonNode arrNode = new ObjectMapper().readTree(json).get("objects");
if (arrNode.isArray()) {
    for (final JsonNode objNode : arrNode) {
        System.out.println(objNode);
    }
}

Output:

"One"
"Two"
"Three"

Note the use of isArray to verify that the node is actually an array before iterating. The check is not necessary if you are absolutely confident in your data structure, but it's available should you need it (and this is no different from most other JSON libraries).

You need to get the ArrayList from JsonNode. Here is your solution.

ObjectMapper objectMapper = new ObjectMapper();
JsonNode jsonNode = objectMapper.readTree(json);
String sender = jsonNode.get(0).get("sender").textValue();

ObjectMapper mapper = new ObjectMapper();
List<Employee> e = new ArrayList<Employee>();
ArrayNode array = mapper.valueToTree(e);
ObjectNode companyNode = mapper.valueToTree(company);
companyNode.putArray("Employee").addAll(array);
JsonNode result = mapper.createObjectNode().set("company", companyNode);

Moving my comment to an answer, as it got upvoted a lot.

This should do what the OP needed:

new ObjectMapper().convertValue(jsonNode, ArrayList.class)

Thanks for all the replies :)

I required the JsonNode coming via REST request containing key->value pairs to be converted into an ArrayList<OptionalHeader>, see the OptionalHeader class in question.

finally did it using following:

(getting it as JsonNode in my POJO) coming via REST request. I used below in my setter.

public void setOptHeaders(JsonNode optHeaders) throws JsonParseException, JsonMappingException, IOException {
    this.optHeaders = optHeaders;
    List<OptionalHeader> allHeaders = new ArrayList<OptionalHeader>();
    Iterator<Entry<String, JsonNode>> nodeIterator = optHeaders.fields();
    while (nodeIterator.hasNext()) {
       Map.Entry<String, JsonNode> entry = (Map.Entry<String, JsonNode>) nodeIterator.next();
       OptionalHeader header = new OptionalHeader(entry.getKey(),entry.getValue().asText());
       allHeaders.add(header);

    }
    optionalEmailHeaders.addAll(allHeaders);
}

then following in the getter to convert it back.

public JsonNode getOptHeaders() {
    final ObjectMapper mapper = new ObjectMapper();
    final Map<String, String> map = new HashMap<String, String>();
    for (final OptionalHeader data: optionalEmailHeaders)
        map.put(data.getName(), data.getValue());
    optHeaders = mapper.valueToTree(map);
    return optHeaders;
}