[英]Converting lists of one element type to a list of another type
I'm writing an adapter framework where I need to convert a list of objects from one class to another.我正在编写一个适配器框架,我需要将对象列表从一个类转换为另一个类。 I can iterate through the source list to do this as in
我可以遍历源列表来做到这一点
Java: Best way of converting List<Integer> to List<String> Java:将 List<Integer> 转换为 List<String> 的最佳方式
However, I'm wondering if there is a way to do this on the fly when the target list is being iterated, so I don't have to iterate through the list twice.但是,我想知道是否有办法在迭代目标列表时即时执行此操作,因此我不必遍历列表两次。
Java 8 way: Java 8 方式:
List<String> original = ...;
List<Wrapper> converted = original.stream().map(Wrapper::new).collect(Collectors.toList());
assuming Wrapper
class has a constructor accepting a String
.假设
Wrapper
类有一个接受String
的构造函数。
My answer to that question applies to your case:我回答这个问题适用于您的情况:
import com.google.common.collect.Lists;
import com.google.common.base.Functions
List<Integer> integers = Arrays.asList(1, 2, 3, 4);
List<String> strings = Lists.transform(integers, Functions.toStringFunction());
The transformed list is a view on the original collection, so the transformation happens when the destination List
is accessed.转换后的列表是原始集合的视图,因此在访问目标
List
时会发生转换。
As an alternative to the iterator pattern, you can use a abstract generic mapper class, and only override the transform method:作为迭代器模式的替代方案,您可以使用抽象的通用映射器类,并且只覆盖转换方法:
the implementation:实施:
// Generic class to transform collections
public abstract class CollectionTransformer<E, F> {
abstract F transform(E e);
public List<F> transform(List<E> list) {
List<F> newList = new ArrayList<F>();
for (E e : list) {
newList.add(transform(e));
}
return newList;
}
}
// Method that transform Integer to String
// this override the transform method to specify the transformation
public static List<String> mapIntegerToStringCollection(List<Integer> list) {
CollectionTransformer transformer = new CollectionTransformer<Integer, String>() {
@Override
String transform(Integer e) {
return e.toString();
}
};
return transformer.transform(list);
}
// Example Usage
List<Integer> integers = Arrays.asList(1,2);
List<String> strings = mapIntegerToStringCollection(integers);
This would be useful is you have to use transformations every time, encapsulating the process.这将很有用,因为您必须每次都使用转换,封装过程。 So you can make a library of collection mappers very easy.
因此,您可以非常轻松地制作集合映射器库。
You can write a mapping iterator that decorates an existing iterator and applies a function on it.您可以编写一个映射迭代器来修饰现有的迭代器并在其上应用一个函数。 In this case, the function transforms the objects from one type to another "on-the-fly".
在这种情况下,该函数将对象从一种类型“即时”转换为另一种类型。
Something like this:像这样的东西:
import java.util.*;
abstract class Transformer<T, U> implements Iterable<U>, Iterator<U> {
public abstract U apply(T object);
final Iterator<T> source;
Transformer(Iterable<T> source) { this.source = source.iterator(); }
@Override public boolean hasNext() { return source.hasNext(); }
@Override public U next() { return apply(source.next()); }
@Override public void remove() { source.remove(); }
public Iterator<U> iterator() { return this; }
}
public class TransformingIterator {
public static void main(String args[]) {
List<String> list = Arrays.asList("1", "2", "3");
Iterable<Integer> it = new Transformer<String, Integer>(list) {
@Override public Integer apply(String s) {
return Integer.parseInt(s);
}
};
for (int i : it) {
System.out.println(i);
}
}
}
Lambdaj allows to do that in a very simple and readable way. Lambdaj允许以一种非常简单易读的方式做到这一点。 For example, supposing you have a list of Integer and you want to convert them in the corresponding String representation you could write something like that;
例如,假设您有一个 Integer 列表,并且您想将它们转换为相应的 String 表示形式,您可以编写类似的内容;
List<Integer> ints = asList(1, 2, 3, 4);
Iterator<String> stringIterator = convertIterator(ints, new Converter<Integer, String> {
public String convert(Integer i) { return Integer.toString(i); }
});
Lambdaj applies the conversion function only while you're iterating on the result. Lambdaj 仅在您迭代结果时应用转换函数。 There is also a more concise way to use the same feature.
还有一种更简洁的方法来使用相同的功能。 The next example works supposing that you have a list of persons with a name property and you want to convert that list in an iterator of person's names.
下一个示例假设您有一个具有 name 属性的人员列表,并且您希望在人员姓名的迭代器中转换该列表。
Iterator<String> namesIterator = convertIterator(persons, on(Person.class).getName());
Pretty easy.挺容易。 Isn't it?
不是吗?
This Could be a solutions --> by using map这可能是一个解决方案 --> 通过使用地图
List<Employee> employee = Arrays.asList(new Emp(1, 100), new Emp(2, 200), new Emp(3, 300));
List<Employee> employeS = employee.stream()
.map(emp -> new Emp(emp.getId(), emp.getSalary * 100))
.collect(Collectors.toList());
employeS .stream() .forEach(s -> System.out.println("Id :" + s.getId() + " Salary :" + s.getSalary()));
如果您尝试获取列表中的元素列表,请使用以下代码。这里的对象列表包含属性名称,下面为您提供该列表中的名称列表
inputList.stream().map(p -> p.getName()).collect(Collectors.toList());
That question does not iterate through the list twice.这个问题不会遍历列表两次。 It just iterates once and by far is the only known method.
它只迭代一次,到目前为止是唯一已知的方法。
Also you could use some transformer classes in commons-collections of google-collections but they all do the same thing under the hood :) the following being one way您也可以在 google-collections 的 commons-collections 中使用一些转换器类,但它们在幕后都做同样的事情:) 以下是一种方法
CollectionUtils.collect(collectionOfIntegers, new org.apache.commons.collections.functors.StringValueTransformer());
Well, you could create your own iterator wrapper class to do this.好吧,您可以创建自己的迭代器包装类来执行此操作。 But I doubt that you would save much by doing this.
但我怀疑你这样做会节省多少。
Here's a simple example that wraps any iterator to a String iterator, using Object.toString() to do the mapping.这是一个简单的示例,它使用 Object.toString() 进行映射,将任何迭代器包装为 String 迭代器。
public MyIterator implements Iterator<String> {
private Iterator<? extends Object> it;
public MyIterator(Iterator<? extends Object> it) {
this.it = it;
}
public boolean hasNext() {
return it.hasNext();
}
public String next() {
return it.next().toString();
}
public void remove() {
it.remove();
}
}
I think you would either have to create a custom List (implementing the List interface) or a custom Iterator.我认为您必须创建一个自定义 List(实现 List 接口)或一个自定义迭代器。 For example:
例如:
ArrayList<String> targetList = new ArrayList<String>();
ConvertingIterator<String> iterator = new ConvertingIterator<String>(targetList);
// and here you would have to use a custom List implementation as a source List
// using the Iterator created above
But I doubt that this approach would save you much.但我怀疑这种方法是否能为您节省很多。
Here's an on-the-fly approach.这是一种即时方法。 (There must be something already like this in the jdk; I just can't find it.)
(jdk中肯定已经有这样的东西了;我就是找不到。)
package com.gnahraf.util;
import java.util.AbstractList;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
/**
*
*/
public class Lists {
private Lists() { }
public static <U,V> List<V> transform(List<U> source, Function<U, V> mapper) {
return new ListView<U, V>(source, mapper);
}
protected static class ListView<U, V> extends AbstractList<V> {
private final List<U> source;
private final Function<U, V> mapper;
protected ListView(List<U> source, Function<U, V> mapper) {
this.source = Objects.requireNonNull(source, "source");
this.mapper = Objects.requireNonNull(mapper, "mapper");
}
@Override
public V get(int index) {
return mapper.apply(source.get(index));
}
@Override
public int size() {
return source.size();
}
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.