Получение списка элементов из ArrayList

Гуава имеет _ 1_, которая может преобразовывать List<F> в List<T>, используя предоставленный _ 4_ (точнее, Function<? super F,? extends T>).

Из документации:

public static <F,T>
   List<T> transform(
               List<F> fromList,
               Function<? super F,? extends T> function
           )

Возвращает список, который применяет function к каждому элементу fromList. Возвращенный список представляет собой преобразованный вид fromList; изменения в fromList будут отражены в возвращаемом списке и наоборот.

function применяется лениво, вызывается при необходимости.

Аналогичные преобразования просмотра в реальном времени также предоставляются следующим образом:

• _ 12_ (с Iterable<F> по Iterable<T>)
• _ 15_ (с Iterator<F> по Iterator<T>)
• _ 18_ (с Collection<F> по Collection<T>)
• _ 21_ (с Map<K,V1> по Map<K,V2>)

Похоже, вы ищете Java-эквивалент функции Perl map в Perl. Подобные вещи могут быть добавлены в библиотеку коллекций после того, как (если) Java получит закрытие. А пока я думаю, что это лучшее, что вы можете сделать:

List<String> list = new ArrayList<String>(customers.size());
for ( Customer c : customers ) {
    list.add(c.getName());
}

Вы также можете написать map функцию, которая использует простой интерфейс для предоставления функции сопоставления. Что-то вроде этого:

public interface Transform<I, O> {
    O transform(I in);
}
public <I, O> List<O> map(Collection<I> coll, Transform<? super I, ? extends O> xfrm) {
    List<O> list = new ArrayList<O>(coll.size());
    for ( I in : coll ) {
        list.add(xfrm.transform(in));
    }
    return list;
}

можно было бы использовать что-то вроде этого: http://code.google.com/p/lambdaj/

Я думаю, что это то, что вам придется закодировать самостоятельно, в цикле.

Вы можете использовать LambdaJ Converter и иметь следующую строку:

List<String> customerNames = convert(customerList, new Converter<Customer,String>() {
  public String convert(Customer customer) {
    return customer.getName();
  }
});

Вам нужно использовать цикл, но функция, которую вы ищете, в функциональных языках называется map. В Java можно реализовать map, хотя это, как правило, довольно неэлегантно; вот версия, которую я реализовал много лет назад в моей библиотеке «вещи, которые должны быть в Java, но по какой-то причине нет»:

public interface MapFunction<T, U> {
    public U map(T source);
}

public static <T, U> U[] map(T[] objects, MapFunction<T, U> f) {
    if(objects.length == 0) {throw new IllegalArgumentException("Can't map onto an empty array");}
    @SuppressWarnings("unchecked") U[] rtn = (U[])Array.newInstance(f.map(objects[0]).getClass(), objects.length);
    for(int i = 0; i < objects.length; i++)
        rtn[i] = f.map(objects[i]);
    return rtn;
}

Используя это, вы могли:

List<Customer> list = yourFunction();
List<String> names = Arrays.asList(map(list.toArray(new Customer[0]), new MapFunction<Customer, String>() {
    public String map(Customer c) {
        return c.getName();
    }
}));

Вы можете естественным образом изменить карту, чтобы она принимала коллекции вместо массивов, что устранит необходимость в Arrays.asList и List.toArray

Используя Guava, вы можете использовать Функция вместе с Iterables.transform, Collections2.transform или Lists.transform для создания Iterable, Collection или List соответственно.

Iterable<String> names = Iterables.transform(customers, 
    new Function<Customer, String>() {
      public String apply(Customer from) {
        return from.getName();
      }
    });

Возвращенный Iterable является ленивым и применяет функцию к базовому списку, когда вы его просматриваете. Для List<String>, содержащего имена, вы можете использовать:

List<String> names = Lists.transform(...);

or

ImmutableList<String> names = ImmutableList.copyOf(Iterables.transform(...));

Конечно, записывать реализацию анонимного внутреннего класса Function каждый раз, когда вы хотите это сделать, некрасиво и многословно, поэтому вы можете сделать Function константой, доступной из класса Customer, например, с именем Customer.NAME.

Тогда преобразование выглядит намного лучше (особенно со статическим импортом):

for (String name : transform(customers, Customer.NAME)) { ... }

Я также писал об использовании интерфейсов для определенных свойств объектов (например, name здесь), чтобы помочь с объединением таких функций в моем блоге здесь.

.... есть короткий путь или более эффективный способ

Итак, вы ищете более эффективный способ сделать это:

 List<String> names = new ArrayList<String>();
 for( Customer customer : yourCustomerList ) {
     names.add( customer.getName() );
 }

?!!!!

Или просто другой способ?

Все предыдущие ответы на самом деле не более эффективны с точки зрения времени выполнения или кодирования. Однако они, без сомнения, более гибкие.

Другой альтернативой было бы включить Scala Groovy в ваш Java-код и использовать это:

list.map( _.name )

list.collect { it.name }

В случае компиляции классы Groovy можно использовать из Java, или вы можете подключить их как сценарий.

Вот пример для данного класса Customer, использующего Groovy в качестве скрипта.

    List<Customer> customers = Arrays.asList( new Customer[]{
       new Customer("A","123",1),
       new Customer("B","456",2),
       new Customer("C","789",3),
       new Customer("D","012",4)
    });

    setVariable(customers, "list");
    evaluate("names = list.collect { it.name } ");
    List<String> names = (List<String>) getVariable("names");
    System.out.println("names = " + names);

Вывод:

names = [A, B, C, D]

_{примечание: я извлек метод для удобства чтения, но вы можете увидеть их ниже}

Но, опять же, это просто другое, не более эффективное, чем обычный цикл for.

Вот полный исходный код. Для его запуска вам просто нужны Java1.6 и Groovy в пути к классам.