If the array is defined in the file but is empty, like:

...
"kl":[]
...

Then getJSONArray("kl") will return an empty array, but the object is not null. Then, if you do this:

kl = c.getJSONArray("kl");
if(kl != null){
   klassenID[i] = kl.getJSONObject(0).getString("id");
}

kl is not null and kl.getJSONObject(0) will throw an exception - there is no first element in the array.

Instead you can check the length(), e.g.:

kl = c.getJSONArray("kl");
if(kl != null && kl.length() > 0 ){
   klassenID[i] = kl.getJSONObject(0).getString("id");
}

 JSONArray jarr = new JSONArray();
 jo1.put("filters",jarr);

or all on one line:

jo1.put("filters", new JSONArray());

Your code is wrong. Try this code to test the JSON array:

String jsonString = "[ {"
            + "\"TimeStamp\": \"20:10\","
            + "\"PipeTemp\": \"31.5\","
            + "\"ChocolateMixingTemp\": \"25\","
            + "\"WaterCoolingTemp\": \"5\","
            + "\"WaterMixingTemp\": \"0\","
            + "\"WaterHeatingTemp\": \"0\",},"
            + "{"
            + "\"TimeStamp\": \"20:00\","
            + "\"PipeTemp\": \"35.5\","
            + "\"ChocolateMixingTemp\": \"28\","
            + "\"WaterCoolingTemp\": \"3\","
            + "\"WaterMixingTemp\": \"15\","
            + "\"WaterHeatingTemp\": \"0\","
            + "}]";

JSONArray jsonArray = new JSONArray(jsonString);

System.out.println(jsonArray);

for (int n = 0; n < jsonArray.length(); n++) {
    JSONObject jsonObject = jsonArray.getJSONObject(n);
    System.out.println((String) jsonObject.get("TimeStamp"));
}

From your JSON data, it seem skills is an array of objects.

"skills": [],
 "skills": [
   "skill_1": {},
   "skill_2": {}
 ]

But your Java code defines it as Map:

public Map<String, Skill> skills;

That's why you got an exception when trying to convert the array to a map directly. If you can't change the POJO's Profile, you should have an intermediate step to convert the list to a Map.

public class SkillsMapDeserializer extends JsonDeserializer<Map<String, Skill>> {
    @Override
    public Map<String, Skill> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        final List<Map<String,Skill>> skills = jsonParser.readValueAs(new TypeReference<List<Map<String,Skill>>>>() {
        });
        return functionConvertListToMapWithParam(skills);
    }
}

You can use method from is* family:

Gson gson = new GsonBuilder().create();

String[] jsons = {"[]", "[ ]", "[\r\n]", "{}", "{\"error\":\"Internal error\"}"};
for (String json : jsons) {
    JsonElement root = gson.fromJson(json, JsonElement.class);
    if (root.isJsonObject()) {
        JsonElement error = root.getAsJsonObject().get("error");
        System.out.println(error);
    }
}

prints:

null
"Internal error"

There is no point to check "[]" string because between brackets could be many different white characters. JsonElement is a root type for all JSON objects and is safe to use.

You can get the desired behaviour with this configuration:

mapper.enable(JsonParser.Feature.ALLOW_MISSING_VALUES);

According to Jackson docs:

ALLOW_MISSING_VALUES
Feature allows the support for "missing" values in a JSON array: missing value meaning sequence of two commas, without value in-between but only optional white space

The missing values appear as null inside JsonNode

You're already using the appropriate method. It's the JsonReader.hasNext() method as described in the JsonReader class docs:

Within array handling methods, first call beginArray() to consume the array's opening bracket. Then create a while loop that accumulates values, terminating when hasNext() is false. Finally, read the array's closing bracket by calling endArray().

You just need to switch from a do/while to a while loop. Your current code requires there to always be at least one object in the array because a do/while doesn't check the condition until the end of the loop.

The example you provided probably doesn't match the provided output, as mentioned in the comment. Anyway, what you are describing can be done by simply initializing the properties in construction phase.

I am not sure of the object that contains the properties, but those should be tore1 and tore2. Before iterating the json and try to set those, just initialize them to be empty strings ("") in this way when you don't find a valid value in the json, you will use the empty string as required.

Something like this should work:

DBObject one = cur.next();  

if (one.get("photos") == null)
  one.put("photos", new Object[0]);

return JSON.serialize(one);

assuming:

String jsonString = "pac_selected": [{
    "pack_selected_id": "7"
}, {}, {
    "pack_selected_id": 45
}]

I would do the following, based on this answer:

JSONArray list = new JSONArray();     
JSONArray jsonArray = new JSONArray(jsonstring); 
int len = jsonArray.length();

if (jsonArray != null) { 
   for (int i=0;i<len;i++)
   { 
       String element = jsonArray.get(i);

       if (!element.isEmpty()) 
       {
          list.put(element);
       }
   } 
}

Then just use list instead of jsonArray.