programacion - listmodel java
Cómo transformar List<X> a otra lista<Y> (6)
¿Qué tal esto?
import java.util.ArrayList;
import java.util.List;
import com.google.common.base.Function;
import com.google.common.collect.Lists;
public class GuavaTransform {
public static void main(String[] args) {
List<X> xList = new ArrayList<X>();
xList.add(new X("a", "b", "v", "w", "m", "n"));
xList.add(new X("a1", "b1", "v1", "w1", "m1", "n1"));
for(X elem: xList) {
System.out.println("An instance of X:"+ elem);
}
System.out.println();
List<Y> yList = Lists.transform(xList, new TransformXY());
for(Y elem: yList) {
System.out.println("The corresponding instance of Y: /n"+elem);
}
}
}
class TransformXY implements Function<X, Y> {
@Override
public Y apply(X x) {
List<B> bList = new ArrayList<B>();
bList.add(new B(x.m, x.n));
List<A> aList = new ArrayList<A>();
aList.add(new A(x.v, x.w, bList));
return new Y(x.a, x.b, aList);
}
}
class X {
String a;
String b;
String v;
String w;
String m;
String n;
X(String a, String b, String v, String w, String m, String n) {
super();
this.a = a;
this.b = b;
this.v = v;
this.w = w;
this.m = m;
this.n = n;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("(");
sb.append(a+",");
sb.append(b+",");
sb.append(v+",");
sb.append(w+",");
sb.append(m+",");
sb.append(n);
sb.append(")");
return sb.toString();
}
}
class Y {
String a;
String b;
List<A> aList;
Y(String a, String b, List<A> aList) {
super();
this.a = a;
this.b = b;
this.aList = aList;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(a+"/n");
sb.append(b+"/n");
for(A elem: aList) {
sb.append(elem+"/n");
}
return sb.toString();
}
}
class A {
String v;
String w;
List<B> bList;
A(String v, String w, List<B> bList) {
super();
this.v = v;
this.w = w;
this.bList = bList;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("--------"+v+"/n");
sb.append("--------"+w+"/n");
for(B elem: bList) {
sb.append(elem+"/n");
}
return sb.toString();
}
}
class B {
String m;
String n;
B(String m, String n) {
super();
this.m = m;
this.n = n;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("----------------"+m+"/n");
sb.append("----------------"+n+"/n");
return sb.toString();
}
}
Salida de la consola:
An instance of X:(a,b,v,w,m,n)
An instance of X:(a1,b1,v1,w1,m1,n1)
The corresponding instance of Y:
a
b
--------v
--------w
----------------m
----------------n
The corresponding instance of Y:
a1
b1
--------v1
--------w1
----------------m1
----------------n1
Tengo dos listas de objetos; List<X> y List<Y> . X e Y son objetos que parecen:
public class X {
String a;
String b;
String v;
String w;
String m;
String n;
}
public class Y {
String a;
String b;
List<A> aList;
}
public class A {
String v;
String w;
List<B> bList;
}
public class B {
String m;
String n;
}
Cómo transformar List<X> en List<Y> según una regla:
Los valores de algunos campos deben ser iguales.
Por ejemplo:
En la List<Y> , para un objeto Y, el valor del campo a debe ser igual.
En la List<A> campo de Y List<A> , para un objeto A, el valor del campo w debe ser igual.
En el campo A de la List<B> , para un objeto B, el valor del campo m debe ser igual y así sucesivamente.
La guayaba tiene este método, Lists#transform , pero no sé cómo transformar.
O de otra manera?
Con java lambda:
public static <K,V,Q extends K> List<V> transform( final List<Q> input, final java.util.function.Function<K,V> tfunc ) {
if( null == input ) {
return null;
}
return input.stream().map(tfunc).collect( Collectors.toList() );
}
Solo necesita implementar: java.util.function.Function
Estilo Java 8, IntelliJ IDEA me ayudó:
List<X> xList = new ArrayList<>();
List<Y> yList = xList
.stream()
.map(X::getY)
.collect(Collectors.toList());
Igual que @Isaace pero con la sintaxis lambda (lo obtuve de este ejemplo ):
List<X> xList = new ArrayList<>();
List<Y> yList = xList
.stream()
.map(n -> someTransformFunc(n))
.collect(Collectors.toList());
asumir que tiene dos objetos puede interconversión, Coach y EntityBase
1.clarar el método genérico
public static <TSourse, TResult> void ToList(List<TSourse> list, List<TResult> results) {
if (list.size() > 0) {
for (TSourse obj : list) {
TResult tResult = (TResult) obj;
if (tResult == null) {
throw new AppException("error....");
}
results.add(tResult);
}
}
}
2. llama este método
List<EntityBase> entityBaseList = new ArrayList<>();
Coach coach = new Coach();
coach.setId("123");
entityBaseList.add(coach);
List<Coach> coachList = new ArrayList<>();
ToList(entityBaseList, coachList);
//will complete List<AObj> to another List<BObj>
public static <F,T> List<T> transform(List<F> fromList,
Function<? super F,? extends T> function
Es posible que desee leer los documentos API para Lists.transform() y Function , pero básicamente la persona que llama de la transformación proporciona un objeto Function que convierte una F en una T
Por ejemplo, si tiene una List<Integer> intList y desea crear una List<String> modo que cada elemento de este último contenga la representación en inglés de ese número (1 se convierta en "uno", etc.) y tenga acceso a un clase como IntToEnglish entonces
Function<Integer, String> intToEnglish =
new Function<Integer,String>() {
public String apply(Integer i) { return new IntToEnglish().english_number(i); }
};
List<String> wordsList = Lists.transform(intList, intToEnglish);
¿Esa conversión?
Puede aplicar el mismo patrón para transformar su List<X> en List<Y>