相当于Java7中的map（来自haskell）

在Haskell中有一个名为

map

的函数，它获取

a

类型的列表和

f

函数，将

a

类型的值映射到

B

类型的值。它返回类型为

B

的列表，这样结果列表的每个元素都源自对输入列表中某个值的

f

调用

例如，给定

• a列表

  m=['a'，'b'，'c']

• 函数f={'a'->1，'b'->2，'c'->3}
• 然后

  map（m，f）=[1,2,3]

是否有一个可以与Java7一起使用的库，它提供类似于

map

函数的功能？我已经查看并发现了和之类的内容，但它们不允许重新调整完全不同类型的集合。出于同样的原因，谷歌搜索其他库失败了

明确地说：我知道如何自己解决这个问题，但我强烈地感觉到，必须已经存在一个好的库来更广泛地执行这个任务

---

还有一个问题：在Java7中是否有一些等价于Haskell函子（即从集合移动到iterables）的东西可用？进一步解释：是否有一个map函数，它接受一个

Iterable

而不是

Collection

，并返回一个

Iterable

而不是

Collection

（由一个拟合函数

f

提供）？

我不知道这样的库，但是使用普通java有什么问题，比如：

List<String> m;
Map<Key,String> map = new HashMap<Key,String>();
int c=1;
for (String i : m) map.put(i,c++);

列表m；
Map Map=newhashmap（）；
int c=1；
for（stringi:m）map.put（i，c++）；

您要求的是Java 7（使用Java 8更容易）：

你可以使用和那里特别

final List strings=Arrays.asList（“a”、“b”、“c”）；
最终列表整数=FluentIterable
.来自（字符串）
.transform（新函数（）{
@可空
@凌驾
公共整数应用（@Nullable String input）{
返回input.equals（“a”）？1:input.equals（“b”）？2:input.equals（“c”）？3:-1；
}
})
.toList（）；

---

额外的问题：集合是一个iterable:-）

您需要使用来自Java8的流APi。使用官方API，您不能在Java 7中使用流API，而是使用：

,

,

，或

你可以。更多信息请参阅和文档retrolambda、Totalylazy、gradle retrolambda或轻量级流API。但如果您可以使用Java8，那么它比使用非官方API容易得多

或者你可以使用

---

在Java 7中使用函数式编程，但流式API更为正式和通用。

您可以自己编写一个

迭代器

，它接受执行转换的

映射

对象

static class Transformer<F, T> implements Iterator<T> {

    final Iterator<F> source;
    final Map<F, T> map;

    public Transformer(Iterator<F> source, Map<F, T> map) {
        this.source = source;
        this.map = map;
    }

    @Override
    public boolean hasNext() {
        return source.hasNext();
    }

    @Override
    public T next() {
        return map.map(source.next());
    }

    public interface Map<F, T> {

        public T map(F f);
    }
}

private static final String[] numbers = {"Zero", "One", "Two", "Three", "Four", "Five"};

public void test() {
    List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5);
    Transformer t = new Transformer<>(ints.iterator(), new Transformer.Map<Integer, String>() {
        @Override
        public String map(Integer f) {
            return numbers[f];
        }

    });
    while (t.hasNext()) {
        System.out.println(t.next());
    }
}

静态类转换器实现迭代器{
最终迭代器源；
最终地图；
公共转换器（迭代器源、映射）{
this.source=源；
this.map=map；
}
@凌驾
公共布尔hasNext（）{
返回source.hasNext（）；
}
@凌驾
公共交通工具{
返回map.map（source.next（））；
}
公共接口图{
公共T图（F）；
}
}
私有静态最终字符串[]数字={“零”、“一”、“二”、“三”、“四”、“五”}；
公开无效测试（）{
List ints=Arrays.asList（1,2,3,4,5）；
Transformer t=new Transformer（ints.iterator（），new Transformer.Map（））{
@凌驾
公共字符串映射（整数f）{
返回编号[f]；
}
});
while（t.hasNext（））{
System.out.println（t.next（））；
}
}

功能转换已添加到Java 8中，但它们不适用于Java 7。例如，将字符串转换为整数的映射函数如下所示

List<String> list = Arrays.asList("1","2","3");
List<Integer> nums = list.stream().map(Integer::parseInt).collect(Collectors.toList());

---

但是正如您所知，由于Java7中缺少lambda表达式，它看起来并不简洁，听起来您确实想要Java8。Java 7不再受到公开支持。在我的项目中使用Java 7有一个限制。实际上，Java 7中没有任何功能与Haskell相当。java中有一个java.util.Map，可以处理键和值。你可以用同样的方法把一个对象转换成值，等等…那就是。。。实际上比foreach循环要流畅得多。

List<String> list = Arrays.asList("1","2","3");
List<Integer> nums = list.stream().map(Integer::parseInt).collect(Collectors.toList());

Collection<Integer> ints = Collections2.transform(list, new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return Integer.parseInt(s);
        }
    });