Java 8 中的扩展列表<T>

lambda java java-8 default-method guava

2022-09-04 20:56:17

我经常想将一个列表映射到另一个列表。例如，如果我有一个人名单，而我想要一个他们的名字名单，我想做：

目标

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

但这显然不是那么好。事实上，我认为使用番石榴更干净：

番石榴版

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

但是，我无法弄清楚如何使用默认方法来扩展现有接口。

此外，这显然是一个微不足道的例子。通常，我希望能够扩展和接口，以便更轻松地与流 API 进行交互。List<T>Iterable<T>

答案 1

否;你不能这么做。

默认方法与扩展方法不同;它们只能在原始接口中定义。

答案 2

如果你想有一个轻量级的视图来应用和支持链接，你可以这样做：ListFunction

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风格创建映射列表，同时仍然允许将API与映射列表一起使用，懒惰地评估所有值：Stream

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]

如果要创建具有预先计算值的 a，则只需使用。Listnew ArrayList<>(mappedList)