[英]Extending List<T> in Java 8
我經常想將一個列表映射到另一個列表。 例如,如果我有一個人員列表,我想要一個他們的名字列表,我想這樣做:
目標
List<Person> people = ... ;
List<String> names = people.map(x -> x.getName());
使用Java 8可以實現這樣的功能:
JAVA 8版
List<String> names = people.stream()
.map(x -> x.getName())
.collect(Collectors.toList());
但這顯然不是那么好。 事實上,我認為使用番石榴更清潔:
GUAVA版本
List<String> names = Lists.transform(people, x -> x.getName());
但是,我喜歡鏈接。 那么,我的目標是否可行?
我聽說有人說Java 8默認方法類似於C#擴展方法。 使用C#擴展方法,我可以輕松地向IEnumerable<T>
添加一個輔助方法:
public static IEnumerable<TRet> Map<T, TRet>(this IEnumerable<T> list, Func<T, TRet> selector)
{
return list.Select(selector);
}
但是,我無法弄清楚如何使用默認方法來擴展現有接口 。
此外,這顯然是一個微不足道的例子。 通常,我希望能夠擴展List<T>
和Iterable<T>
接口,以便更容易地與流api進行交互。
沒有; 你不能這樣做。
默認方法與擴展方法不同; 它們只能在原始界面中定義。
如果您希望為應用Function
和支持鏈接的List
提供輕量級視圖,您可以這樣做:
import java.util.*;
import java.util.function.Function;
import java.util.stream.Stream;
public class MappingList<E> extends AbstractList<E> {
// using this helper class we avoid carrying <S> with the public API
static final class Source<E,S> {
final List<S> list;
final Function<? super S, ? extends E> mapper;
Source(List<S> l, Function<? super S, ? extends E> m) {
list=l;
mapper=m;
}
E get(int index) { return mapper.apply(list.get(index)); }
<T> Source map(Function<? super E, ? extends T> f) {
Objects.requireNonNull(f);
return new Source<>(list, mapper.andThen(f));
}
Stream<E> stream() { return list.stream().map(mapper); }
Stream<E> parallelStream() { return list.parallelStream().map(mapper); }
}
final Source<E,?> source;
private MappingList(Source<E,?> s) {
Objects.requireNonNull(s);
source=s;
}
@Override
public E get(int index) {
return source.get(index);
}
@Override
public int size() {
return source.list.size();
}
@Override
public Stream<E> stream() {
return source.stream();
}
@Override
public Stream<E> parallelStream() {
return source.parallelStream();
}
public <T> MappingList<T> map(Function<? super E, ? extends T> f) {
return new MappingList<>(source.map(f));
}
public static <S,T> MappingList<T> map(
List<S> l, Function<? super S, ? extends T> f) {
Objects.requireNonNull(l);
if(l instanceof MappingList)
return ((MappingList<S>)l).map(f);
return new MappingList<>(new Source<>(l, f));
}
}
它支持GUAVA樣式創建映射列表,同時仍然允許使用Stream
API和映射列表懶惰地評估所有值:
public static void main(String[] arg) {
List<String> strings=Arrays.asList("a", "simple", "list");
List<Integer> ints=MappingList.map(strings, s->compute(s));
List<Integer> results=MappingList.map(ints, i->compute(i));
for(int result:results) {
System.out.println("first result: "+result);
System.out.println("Not computing any more values");
break;
}
System.out.println();
System.out.println(" interacting with stream API:");
System.out.println(results.stream().filter(i-> i>500).findFirst());
}
public static int compute(String s) {
System.out.println("doing computation for "+s);
return Integer.parseInt(s, 36);
}
public static int compute(int i) {
System.out.println("doing computation for "+i);
return i*i;
}
doing computation for a doing computation for 10 first result: 100 Not computing any more values interacting with stream API: doing computation for a doing computation for 10 doing computation for simple doing computation for 1724345618 Optional[410277188]
如果要創建一個包含預先計算值的List
,可以使用new ArrayList<>(mappedList)
。
吃我自己的狗的食物並實施我在評論中建議的內容(未測試,但它應該有效 - 注意你應該在適當的地方使用super
,這不是我的強項):
public final class ListTransformer<T>
{
private final List<T> inputList;
public static <X> ListTransformer<X> transform(final List<X> inputList)
{
return new ListTransformer<X>(inputList);
}
private ListTransformer(final List<T> inputList)
{
this.inputList = inputList;
}
public <U> List<U> using(final Function<T, U> f)
{
return inputList.stream().map(f).collect(Collectors.toList());
}
}
用法:
import static wherever.is.ListTransformer.transform;
//
final List<String> names = transform(personList).using(x -> x.getName());
C#擴展方法非常棒,並且提供了使用自己的方法擴展C#集合的簡單機制。
但現在java中有流。 基於@fge響應,我附帶了這個片段來在流上編寫自己的擴展方法:
public final class StreamExtender<T>
{
private final Stream<T> _inputStream;
public static <T> StreamExtender<T> extend(final Stream<T> inputStream)
{
return new StreamExtender<>(inputStream);
}
private StreamExtender(final Stream<T> inputStream)
{
this._inputStream = inputStream;
}
public <U> List<U> extensionMethod(final Function<T, U> f)
{
// your own code.
return _inputStream.map(f).collect(Collectors.toList());
}
}
並看到它在行動:
Integer[] array = { 1, 2, 3};
List<String> result = StreamExtender.extend(stream(array)).extensionMethod(Object::toString);
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.