When using reflection, you do not need to necessarily invoke the getters in the objects (if the getters only return the value and don't contain any special logic), even if the fields are private (See setAccessible).

As for performance, we are doing something similar in our current project and haven't had any problems yet (at worst, the handler checking the annotated fields on object and building JSON-data from them via reflection is traversing deeply nested object-trees (collections within collections) of up to hundreds of objects, each of which can contain from a handful to several dozen fields).

Well you can use reflection to do that in a loop if you don;t want to use the commons library, although using tried and tested code seem to be the wiser choice if you don't have a problem with adding the library to your existing application.

Edit:

This should be enough for you

http://java.sun.com/developer/technicalArticles/ALT/Reflection/

Although I don't know about the performance of this solution vs ApacheCommons I don't think there will be a huge difference.

You can't easily - and you shouldn't.

You see, your POJO class offers some setters. All of them have a distinct meaning. Your first mistake is that all of these fields are strings in your model:

• gender is not a string. It would rather be an enum.
• "number" is not a string. It should rather be int/long/double (whatever the idea behind that property is)

In other words: you premise that "input" data is represented as array/list is already flawed.

The code you have written provides almost no helpful abstractions. So - instead of worrying how to call these setter methods in some loop context - you should rather step back and improve your model.

And hint: if this is really about populating POJO objects from string input - then get your string into JSON format, and use tools such as gson or jackson to do that (reflection based) mapping for you.

I strongly recommend to use an existing library and to avoid reflection in this case! Use JPA or Hibernate for database uses, use JAXB or similar for JSON/XML/other serialization, etc.

However, if you want to see what an example code would look like you can have a look at this:

package myOwnPackage;
import java.lang.reflect.Field;


class Address {
    private String addr1;
    private String addr2;
    private String city;
    private Zip zip;
}
class Contact {
    private String phone;
    private String email;
}
class Employee {
    private String id;
    private String name;
    private int age;
    private Address addr;
    private Contact cont;

    public void setAddr(Address addr) {
        this.addr = addr;
    }
}

class Zip {
    private String zipCd;
    private String zipExt;
}

public class Main {

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {

        Employee employee = new Employee();
        employee.setAddr(new Address());

        printFields("", employee);
    }

    private static void printFields(String prefix, Object container) throws IllegalAccessException {

        Class<? extends Object> class1 = null; 
        Package package1 = null;

        if (container != null)
            class1 = container.getClass();

        if (class1 != null)
            package1 = class1.getPackage();

        if (package1 == null || !"myOwnPackage".equals(package1.getName())) {
            System.out.println(container);
            return;
        }

        for (Field field : class1.getDeclaredFields()) {
            System.out.print(prefix+field.getName()+": ");

            // make private fields accessible
            field.setAccessible(true);

            Object value = field.get(container);
            printFields(prefix+"  ", value);
        }
    }
}

Downsides of my code:

• This code uses reflection, so you are limited at the depth of fields
• Inherited fields are not printed

Yes, with reflection.

Use the Class object to access Field objects with the getFields() method.

Field[] fields = ClassWithStuff.class.getFields();

Then loop over the fields. This works because all fields you have declared are public. If they aren't, then use getDeclaredFields(), which accesses all Fields that are directly declared on the class, public or not.

You can use:

• Map.entrySet() (as mentioned by org.life.java) or,
• Map.keySet() as in this example (based on your sampled code)

Example:

Map<String, Person> personMap = ..... //assuming it's not null
Iterator<String> strIter = personMap.keySet().iterator();
synchronized (strIter) {
    while (strIter.hasNext()) {
        String key = strIter.next();
        Person person = personMap.get(key);

        String a = key;
        String b = person.getName();
        String c = person.getAge().toString();
        System.out.println(String.format("Key : %s Name : %s Age : %s", a, b, c));

    }
}

Use Jackson:

https://github.com/FasterXML/jackson-dataformat-xml

Serialization is done very similar to JSON serialization: all that needs to change is ObjectMapper instance to use:

// Important: create XmlMapper; it will use proper factories, workarounds
ObjectMapper xmlMapper = new XmlMapper();
String xml = xmlMapper.writeValue(new Simple());

and with POJO like:

public class Simple {
    public int x = 1;
    public int y = 2;
}

you would get something like:

<Simple>
  <x>1</x>
  <y>2</y>
</Simple>

(except that by default output is not indented: you can enabled indentation using standard Jackson mechanisms)

Deserializing POJOs from XML Similar to serialization, deserialization is not very different from JSON deserialization:

ObjectMapper xmlMapper = new XmlMapper();
Simple value = xmlMapper
   .readValue("<Simple><x>1</x><y>2</y></Simple>", Simple.class);

P.S. You can also use reflection for that and iterate via all declared fields using Class.getDeclaredFields(). But from my experience one rarely has to do that. There is a lot of 3rd party open-source libraries for different purposes and usually it's a better solution just to use them (e.g. Jackson in this particular case)

Accessing the fields directly is not really good style in java. I would suggest creating getter and setter methods for the fields of your bean and then using then Introspector and BeanInfo classes from the java.beans package.

MyBean bean = new MyBean();
BeanInfo beanInfo = Introspector.getBeanInfo(MyBean.class);
for (PropertyDescriptor propertyDesc : beanInfo.getPropertyDescriptors()) {
    String propertyName = propertyDesc.getName();
    Object value = propertyDesc.getReadMethod().invoke(bean);
}