Obtener una lista de elementos de un ArrayList

Question

Digamos que tengo un frijol como el siguiente.

class Customer{ 
    private String code; 
    private String name; 
    private Integer value; 
    //getters setters omitted for brevity 
} 

Luego, de un método me sale un List<Customer> hacia atrás. Ahora digamos que quiero obtener una lista de todos los miembros de "nombre" de la lista. Obviamente puedo atravesar y construir un List<String> del elemento "nombre" yo mismo.

Sin embargo, me preguntaba si hay un atajo o una forma más eficiente de esta técnica que cualquiera sepa. Por ejemplo, si quiero obtener una lista de todas las claves en un objeto Map, obtengo do map.keySet(). Algo en esa línea es lo que trato de descubrir.

Answer 1

guayaba tiene Lists.transform que puede transformar un List<F> a un List<T>, utilizando un Function<F,T> proporcionado (o más bien, Function<? super F,? extends T>).

De la documentación:

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

Devuelve una lista que se aplica a cada elemento function de fromList. La lista devuelta es una vista transformada de fromList; los cambios a fromList se reflejarán en la lista devuelta y viceversa.

El function se aplica de forma diferida, se invoca cuando es necesario.

vivo-vista similar transforma también se proporcionan los siguientes:

• Iterables.transform (Iterable<F> a Iterable<T>)
• Iterators.transform (Iterator<F> a Iterator<T>)
• Collections2.transform (Collection<F> a Collection<T>)
• Maps.transformValues (Map<K,V1> a Map<K,V2>)

Answer 2

Creo que esto es algo que tendría que codificar usted mismo, en un bucle.

Answer 3

Parece que está buscando el equivalente en Java de la función map de Perl. Este tipo de cosas podrían agregarse a la biblioteca de colecciones una vez que Java reciba cierres. Hasta entonces, creo que esto es lo mejor que puede hacer:

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

También podría escribir una función map que utiliza una interfaz sencilla para proporcionar la función de mapeo. Algo como esto:

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; 
} 

Answer 4

podría utilizar algo como esto: http://code.google.com/p/lambdaj/

Answer 5

Puede utilizar LambdaJ 's Converter interfaz y tiene la siguiente línea:

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

Answer 6

Es necesario utilizar un bucle, pero la función que está buscando se llama en map lenguajes funcionales. Es posible implementar map en Java, aunque tiende a ser bastante poco elegante; Aquí está la versión I implementado hace años en mi "cosas de Java debe tener, pero por alguna razón no" biblioteca:

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; 
} 

Usando eso, usted podría hacer:

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

Se podría, naturalmente, cambiar mapa tomar colecciones en lugar de matrices, lo que eliminaría la necesidad de Arrays.asList y List.toArray

Answer 7

Usando Guava, se puede utilizar un Function junto con Iterables.transform, o Collections2.transformLists.transform para crear un Iterable, Collection o List respectivamente.

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

El regresaron Iterable es perezoso y se aplica la función a la lista subyacente como iterar a través de él. Para una List<String> que contiene los nombres, se puede utilizar:

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

o

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

Por supuesto, escribir a cabo la clase interna anónima Function aplicación cada vez que desee hacer esto es feo y detallado, por lo Es posible que desee hacer que el Function sea una constante disponible de la clase Customer, llamada Customer.NAME por ejemplo.

A continuación, la transformación se verá mejor (con importaciones estáticas especialmente):

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

También he escrito sobre el uso de las interfaces para las propiedades particulares de los objetos (como name aquí) para ayudar con la consolidación de estas funciones en mi blog here.

Answer 8

....¿hay un atajo o una manera más eficiente

Entonces, ¿estás buscando una manera más eficiente de hacer esto:

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

!!!!?

¿O solo un diferente manera?

Todas las respuestas anteriores no son realmente más eficientes en términos de tiempo de ejecución ni codificación. Sin embargo, son más flexibles sin lugar a dudas.

Otra alternativa sería incluir Scala maravilloso en el código Java y utilizar esto:

list.map(_.name)

list.collect { it.name } 

Si es compilado, clases Groovy se puede utilizar desde Java, o puede enchúfalos como un script.

Aquí hay un ejemplo de la clase dada Customer usando Groovy como secuencia de comandos.

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); 

Salida:

names = [A, B, C, D] 

_{nota: extraje método para facilitar la lectura, pero se pueden ver a continuación}

Pero, una vez más que es simplemente diferente, no es realmente más eficaz que la normal en bucle.

Aquí está el complete source code. Para ejecutarlo solo necesitas Java1.6 y Groovy en el classpath.