I'll elaborate a bit more on ChrisR awesome answer and bring images from his awesome reference.

A valid JSON always starts with either curly braces { or square brackets [, nothing else.

{ will start an object:

{ "key": value, "another key": value }

Hint: although javascript accepts single quotes ', JSON only takes double ones ".

[ will start an array:

[value, value]

Hint: spaces among elements are always ignored by any JSON parser.

And value is an object, array, string, number, bool or null:

So yeah, ["a", "b"] is a perfectly valid JSON, like you could try on the link Manish pointed.

Here are a few extra valid JSON examples, one per block:

{}

[0]

{"__comment": "json doesn't accept comments and you should not be commenting even in this way", "avoid!": "also, never add more than one key per line, like this"}

[{   "why":null} ]

{
  "not true": [0, false],
  "true": true,
  "not null": [0, 1, false, true, {
    "obj": null
  }, "a string"]
}

Straight-up serialization won't work, since the items are not equivalent. If you truly want what you're asking for, then you need an array which contains arrays, then serialize that array:

You can do that by first converting your collection, then simple JSON serialization:

string[][] newKeys = keys.Select(x => new string[]{x}).ToArray();

string json = JsonConvert.SerializeObject(newKeys);

In the situation where your incoming JSON uses different names for the String and List<String> varieties, you don't need to do much of anything at all.

Simply including both the String type and List<String> types variables in your PackageInformation class, and using JSON.deserialize(<JSON here>, PackageInformation.class) will work because the regular deserialize() method doesn't care about extra data, nor missing data.

If you need to use JSON.deserializeStrict(), or if your incoming JSON uses a single name (like "type") for both a List<String> and a String value, then there isn't much you can do to avoid requiring two different deserialization classes.

You'd also need to be able to determine which deserialization class you'd need to use.

Using exceptions for this (i.e. try one class, catch the JSON exception if one occurs, then try the other class) is not recommended. This is known as the "exceptions as flow control" antipattern.

Instead, I think the best option available to us at this time is to first use deserializeUntyped() and test whether your target variable is an instance of List<Object> or not.

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>>(){});

You can use json2apex to build a parser for you.

That said, here's the code you'd want to use:

public class Location {
    public String locName;
}

Later, when you want to parse your JSON:

List<Location> locations = (List<Location>)JSON.deserialize(myJsonString, List<Location>.class);

You'll get similar output from json2apex, but I just wrote this by hand.

If you want just the strings, you then just need to iterate:

String[] locationNames = new String[0];
for(Location item: locations) {
    locationNames.add(item.locName);
}