Create a list of values from getters of a List of objects

You could use Guava's Lists.transform:

Function<Baby, String> getBabyNameFunction = new Function<Baby, String>() {
    @Override
    public String apply(Baby baby) {
        return baby.getName();
    }
};

List<String> babyNames = Lists.transform(babies, getBabyNameFunction);

The key difference here being that babyNames is a view of the original list on which the transformations are lazily performed. From the documentation:

The function is applied lazily, invoked when needed. This is necessary for the returned list to be a view, but it means that the function will be applied many times for bulk operations like List.contains(java.lang.Object) and List.hashCode(). For this to perform well, function should be fast. To avoid lazy evaluation when the returned list doesn't need to be a view, copy the returned list into a new list of your choosing.

Obviously the syntax for implementing the Function is rather verbose - that's Java for you until lambdas. I typically keep commonly used functions as constants to avoid clutter and re-instantiation at the call site:

public class Baby {

    ...

    public static class Functions {

        private static final Function<Baby, String> GET_NAME =
                new Function<Baby, String>() {
                    @Override
                    public String apply(Baby baby) {
                        return baby.getName();
                    }
                };

        private Functions() { }

        public static Function<Baby, String> getName() {
            return GET_NAME;
        }
    }
}

Yes, it's even more code but it's hidden away and more maintainable. Then at the call site:

List<String> babyNames = Lists.transform(babies, Baby.Functions.getName());

With GS Collections you have a couple ways to do this. You can use the drop-in replacement for ArrayList called FastList.

MutableList<Baby> babies = FastList.newList();
/* some code adding a bunch of babies to the fastlist */

MutableList<String> names = babies.collect(new Function<Baby, String>() {
    public String valueOf(Baby baby) {
        return baby.getName();
    }
});

Or you can use the ArrayList with the ListIterate utility class.

ArrayList<Baby> babies = new ArrayList<Baby>();
/* some code adding a bunch of babies to the arraylist */

List<String> names = ListIterate.collect(babies, new Function<Baby, String>() {
    public String valueOf(Baby baby) {
        return baby.getName();
    }
});

If you don't care about result order, but want to allow duplicates you could use a Bag instead.

MutableList<Baby> babies = FastList.newList();
/* some code adding a bunch of babies to the fastlist */

MutableBag<String> names = babies.collect(new Function<Baby, String>() {
    public String valueOf(Baby baby) {
        return baby.getName();
    }
}, HashBag.<String>newBag());

int numberOfBabiesNamedXYZ = names.occurrencesOf("XYZ");

If you are using this function over and over, you might want to put it as a constant on the Baby class.

Note: I am a developer on GS Collections.

Well... simply put, no.

That's assuming you're looking for something like

ArrayList<String> names = babies.getName();

There's nothing like that in Java.

However, you could make a new class to do it for you:

public class BabyNameifier {

    public BabyNameifier(){}

    public ArrayList<String> Nameify(ArrayList<Baby> babies) {
        ArrayList<String> names = new ArrayList<String>();
        for (Baby b : babies) {
            names.add(b.getName());
        }
        return names;
    }
}

That way, you can later say:

ArrayList<Baby> babies = new ArrayList<Baby>();
/* some code adding a bunch of babies to the arraylist */

BabyNameifier babyNameifier = new BabyNameifier();
ArrayList<String> names = babyNameifier.Nameify(babies);

Which would create just about the coolest way to systematically retrieve Baby names that the world has ever known.

You want cooler way to do it? If you know Spring framework, you are in luck!

In applicationContext.xml, write something like this:

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<bean id="babyList" class="com.babies.BabyList">

    <property name="babyLists">
        <list>
            <bean class="com.babies.Baby">
                <property name="name" value="alice" />
            </bean>
            <bean class="com.babies.Baby">
                <property name="name" value="bob" />
            </bean>
            <bean class="com.babies.Baby">
                <property name="name" value="trudy" />
            </bean>
        </list>
    </property>
</bean>

 </beans>

Here is the code in normal Java

package com.babies;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

  public class Main  {
      public static void main( String[] args ) {
          ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

          BabyList babyList = (BabyList)context.getBean("babyList");
          System.out.println(babyList);

    }
  }

Now you can edit the list in the applicationContext.xml whenever you want to add/delete any name from the list. No need to hard code everything.

You can refer more about Spring framework collection from this link: http://www.mkyong.com/spring/spring-collections-list-set-map-and-properties-example/

Or if you simply want to learn more about Spring, here is a good starting point: http://www.mkyong.com/tutorials/spring-tutorials/

The cooler way after the release of Java 8 back in March 2014 introducing Stream API with .map and .collect operations is like this:

ArrayList<Baby> babies = new ArrayList<Baby>();
/* some code adding a bunch of babies to the arraylist */

List<String> names = babies
    .stream() // Stream<Baby>
    .map(Baby::getName) // Stream<String>; use reference to the getter method
    .collect(Collectors.toList()); // build resulting list of names