The Name() class has what I would call a half-assed constructor: it creates an object in a not-quite-initialized state, making it temporarily useless until the setters are called. If you had a Name(String name, String attrib) constructor, then the code would be a lot less cumbersome.

You can also avoid using indexed loops.

for (String city : list1) {
    namesList.add(new Name(city, "City"));
}
for (String country : list2) {
    namesList.add(new Name(country, "Country"));
}

You don't need the 2 intermediate lists. Plus you could set the name and attrib directly at the construction of a Name.

public final List<Name> retrieveCitiesAndCountries() {
    List<Name> namesList = new ArrayList<Names>();

    for(String city : retrieveListOfCities()) {
        namesList.add(new Name(city, "City"));
    }

    for(String country : retrieveListOfCountries()) {
        namesList.add(new Name(country, "Country"));
    }

    return namesList;
}

class final Name {
    final String name;
    final String attrib;

    public Name(String name, String attrib) {
        this.name = name;
        this.attrib = attrib;
    }

    ...
}

Again in your JSON service, you can directly return:

@RequestMapping(value = "/names")
public @ResponseBody List<Name> retrieveCitiesAndCountries() {
    return retrievalServ.retrieveCitiesAndCountries();
}

Expressive instantiation

Adding to @200_success's answer, why not consider static methods too, that makes the instantiation a little more expressive?

public class Name {
    // ...

    public static Name ofCity(String cityName) {
        return new Name(cityName, "City");
    }

    public static Name ofCountry(String countryName) {
        return new Name(countryName, "Country");
    }
}

I know you are on Java 7, so you'll still have to rely on the explicit for-loop constructs, but here's a sneak peak at how this can be done much more conveniently in Java 8 (when you get the chance to upgrade):

public List<Name> retrieveCitiesAndCountries() {
    return Stream.concat(retrieveListOfCities().stream().map(Name::ofCity),
                            retrieveListOfCountries().stream().map(Name::ofCountry))
                    .collect(Collectors.toList());
}

Here, we use the method references Name::ofCity and Name::ofCountry to convert each String value we have to a Stream of the required type. Finally, we concat() both and collect() all the results using toList().

What's in a "City" or "Country"?

Is it meant to be used generically (in layman terms) to represent either city or country names? How about landmarks? Other geographical features? - myself

The reason why I made that comment is that usually, String values are a poor substitute for representing enumerated values:

• Prone to human errors ("city" vs "City", and that's "goodbye sleep!").
• Can't reliably rely on == for comparison (only if you take extreme care to intern() everywhere that's required).
• Can't be used in a switch pre-Java 7.
• No efficient Collection classes' implementations.
• May not be easy to validate for correct values (depending on use cases).

This is where you may want to consider using an enum for such representations, as they are feasible solutions to the points listed above.