This does NOT require custom serializers but simple annotation:

@JsonFormat(shape=JsonFormat.Shape.ARRAY)
public class UserModel {
    // ...
}

I got it working by adding a custom serializer:

class Foo {
    @JsonSerialize(using = MySerializer.class)
    private List<String> fooElements;
}

public class MySerializer extends JsonSerializer<Object> {

    @Override
    public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
            throws IOException, JsonProcessingException {
        List<String> fooList = (List<String>) value;

        if (fooList.isEmpty()) {
            return;
        }

        String fooValue = fooList.get(0);
        String[] fooElements = fooValue.split(",");

        jgen.writeStartArray();
        for (String fooValue : fooElements) {
            jgen.writeString(fooValue);
        }
        jgen.writeEndArray();
    }
}

First create a mapper :

import com.fasterxml.jackson.databind.ObjectMapper;// in play 2.3
ObjectMapper mapper = new ObjectMapper();

As Array:

MyClass[] myObjects = mapper.readValue(json, MyClass[].class);

As List:

List<MyClass> myObjects = mapper.readValue(jsonInput, new TypeReference<List<MyClass>>(){});

Another way to specify the List type:

List<MyClass> myObjects = mapper.readValue(jsonInput, mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class));

You hql query does not return instances of type Solution. Instead it returns int, String pairs. So the Jackson cannot map them to the correct form.

You should either return complete objects Solution from the database, or you map the results of the query to Solution object before you pass it to Jackson.

Currently your Solution object is very small, so you don't have to worry about the performance. Just modify the hql query like this:

String hql = "SELECT solution FROM Solution solution"; 

If you only want to serialize Date instances, then the best idea would be to write a custom serializer for Date type only, but I suspect this is not an option.

What is more - Object[] is quite a broad specification and it may possibly conflict with other data that is to be serialized in your system. Maybe creating a wrapper class like that:

class MyWrapper {
   Object[] objects;
}

And writing a specialized serializer for this particular wrapper class would be better idea.

What is even more (and this is solution for your problem) - if you are serializing Array then it is on you to keep its syntax proper (the output from your serializer does not contain array-start [ and array-end ] tags). To fix that you should add writeStartArray() and writeEndArray() method calls:

@Override
public void serialize(Object[] array,
                      JsonGenerator gen,
                      SerializerProvider provider)
        throws IOException, JsonProcessingException {
    gen.writeStartArray();
    // processing array
    gen.writeEndArray();
}

And the last thing :) If you don't want to serialize other types in a custom way - you can just write:

@Override
public void serialize(Object[] array,
                      JsonGenerator gen,
                      SerializerProvider provider)
        throws IOException, JsonProcessingException {
    gen.writeStartArray();
    for(Object tempObject : array) {
        if(tempObject instanceof Date) {
            gen.writeString(tempObject.toString());
        } else {
            gen.writeObject(tempObject);
        }
    }
    gen.writeEndArray();
}

PS. It would be also a good idea to use some specialized date formatting utility like SimpleDateFormat instead of relying on Date#toString method unless you really want to have this format

You should use the @JsonSerialize annotation. It will allow you to specify a Typing value as either dynamic or static. In your case you want to use the static type rather than waiting til runtime for it to see the specific subclass.