是否有一种简洁的方法来迭代流，同时可以访问流中的索引？
String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList;
Stream<Integer> indices = intRange(1, names.length).boxed();
nameList = zip(indices, stream(names), SimpleEntry::new)
.filter(e -> e.getValue().length() <= e.getKey())
.map(Entry::getValue)
.collect(toList());
与那里给出的LINQ示例相比，这似乎相当令人失望
string[] names = { "Sam", "Pamela", "Dave", "Pascal", "Erik" };
var nameList = names.Where((c, index) => c.Length <= index + 1).ToList();
有更简洁的方法吗？
此外，拉链似乎已移动或被移除......
答案 0 :(得分：375)
最简洁的方法是从一系列指数开始：
String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
IntStream.range(0, names.length)
.filter(i -> names[i].length() <= i)
.mapToObj(i -> names[i])
.collect(Collectors.toList());
结果列表仅包含“Erik”。
当您习惯于循环时，一种看起来更熟悉的替代方法是使用可变对象维护一个临时计数器，例如AtomicInteger：
String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
AtomicInteger index = new AtomicInteger();
List<String> list = Arrays.stream(names)
.filter(n -> n.length() <= index.incrementAndGet())
.collect(Collectors.toList());
请注意，在并行流上使用后一种方法的 可能会中断，因为这些项目不会“按顺序” 进行处理。
答案 1 :(得分：65)
Java 8流API缺少获取流元素索引的功能以及将流压缩在一起的功能。这是不幸的，因为它使某些应用程序（如LINQ挑战）比其他应用程序更难。
然而，通常有解决方法。通常，这可以通过用整数范围“驱动”流来完成，并利用原始元素通常在数组中或在索引可访问的集合中的事实。例如，挑战2问题可以通过这种方式解决：
String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList =
IntStream.range(0, names.length)
.filter(i -> names[i].length() <= i)
.mapToObj(i -> names[i])
.collect(toList());
正如我上面提到的，这利用了数据源（名称数组）可直接索引的事实。如果不是，这种技术将不起作用。
我承认这不符合挑战2的意图。尽管如此，它确实能够合理有效地解决问题。
修改
我之前的代码示例使用flatMap来融合过滤器和映射操作，但这很麻烦并且没有任何优势。我根据Holger的评论更新了这个例子。
答案 2 :(得分：31)
自番石榴21以来，您可以使用
Streams.mapWithIndex()
示例（来自official doc）：
Streams.mapWithIndex(
Stream.of("a", "b", "c"),
(str, index) -> str + ":" + index)
) // will return Stream.of("a:0", "b:1", "c:2")
答案 3 :(得分：23)
我在我的项目中使用了以下解决方案。我认为它比使用可变对象或整数范围更好。
import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Collector.Characteristics;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import static java.util.Objects.requireNonNull;
public class CollectionUtils {
private CollectionUtils() { }
/**
* Converts an {@link java.util.Iterator} to {@link java.util.stream.Stream}.
*/
public static <T> Stream<T> iterate(Iterator<? extends T> iterator) {
int characteristics = Spliterator.ORDERED | Spliterator.IMMUTABLE;
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, characteristics), false);
}
/**
* Zips the specified stream with its indices.
*/
public static <T> Stream<Map.Entry<Integer, T>> zipWithIndex(Stream<? extends T> stream) {
return iterate(new Iterator<Map.Entry<Integer, T>>() {
private final Iterator<? extends T> streamIterator = stream.iterator();
private int index = 0;
@Override
public boolean hasNext() {
return streamIterator.hasNext();
}
@Override
public Map.Entry<Integer, T> next() {
return new AbstractMap.SimpleImmutableEntry<>(index++, streamIterator.next());
}
});
}
/**
* Returns a stream consisting of the results of applying the given two-arguments function to the elements of this stream.
* The first argument of the function is the element index and the second one - the element value.
*/
public static <T, R> Stream<R> mapWithIndex(Stream<? extends T> stream, BiFunction<Integer, ? super T, ? extends R> mapper) {
return zipWithIndex(stream).map(entry -> mapper.apply(entry.getKey(), entry.getValue()));
}
public static void main(String[] args) {
String[] names = {"Sam", "Pamela", "Dave", "Pascal", "Erik"};
System.out.println("Test zipWithIndex");
zipWithIndex(Arrays.stream(names)).forEach(entry -> System.out.println(entry));
System.out.println();
System.out.println("Test mapWithIndex");
mapWithIndex(Arrays.stream(names), (Integer index, String name) -> index+"="+name).forEach((String s) -> System.out.println(s));
}
}
答案 4 :(得分：13)
除了protonpack之外，jOOλ's Seq提供了这个功能（并且通过像cyclops-react那样构建在它上面的扩展库，我是这个库的作者。）
Seq.seq(Stream.of(names)).zipWithIndex()
.filter( namesWithIndex -> namesWithIndex.v1.length() <= namesWithIndex.v2 + 1)
.toList();
Seq也只支持Seq.of（名称），并将构建一个JDK Stream。
简单反应的等价物看起来像
LazyFutureStream.of(names)
.zipWithIndex()
.filter( namesWithIndex -> namesWithIndex.v1.length() <= namesWithIndex.v2 + 1)
.toList();
简单反应版本更适合异步/并发处理。
答案 5 :(得分：12)
为了完整性，这里涉及我的StreamEx库的解决方案：
var Hello = React.createClass(new (function(){
var name;
this.getInitialState = function() {
name = "Sir " + this.props.name;
return null;
};
this.render = function() {
return <div>Hello {name}</div>;
};
})());
React.render(<Hello name="World" />, document.getElementById('container'));
在这里，我们创建了一个EntryStream<Integer, String>，其扩展了String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
EntryStream.of(names)
.filterKeyValue((idx, str) -> str.length() <= idx+1)
.values().toList();
并添加了一些特定的操作，例如filterKeyValue或values。还使用toList()快捷方式。
答案 6 :(得分：5)
我在列表或数组创建Stream时找到了解决方案（并且您知道大小）。但是如果Stream的大小未知呢？在这种情况下，请尝试以下变体：
public class WithIndex<T> {
private int index;
private T value;
WithIndex(int index, T value) {
this.index = index;
this.value = value;
}
public int index() {
return index;
}
public T value() {
return value;
}
@Override
public String toString() {
return value + "(" + index + ")";
}
public static <T> Function<T, WithIndex<T>> indexed() {
return new Function<T, WithIndex<T>>() {
int index = 0;
@Override
public WithIndex<T> apply(T t) {
return new WithIndex<>(index++, t);
}
};
}
}
用法：
public static void main(String[] args) {
Stream<String> stream = Stream.of("a", "b", "c", "d", "e");
stream.map(WithIndex.indexed()).forEachOrdered(e -> {
System.out.println(e.index() + " -> " + e.value());
});
}
答案 7 :(得分：4)
使用列表，您可以尝试
List<String> strings = new ArrayList<>(Arrays.asList("First", "Second", "Third", "Fourth", "Fifth")); // An example list of Strings
strings.stream() // Turn the list into a Stream
.collect(HashMap::new, (h, o) -> h.put(h.size(), o), (h, o) -> {}) // Create a map of the index to the object
.forEach((i, o) -> { // Now we can use a BiConsumer forEach!
System.out.println(String.format("%d => %s", i, o));
});
输出：
0 => First
1 => Second
2 => Third
3 => Fourth
4 => Fifth
答案 8 :(得分：3)
https://github.com/poetix/protonpack 你可以做那个拉链：
String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList;
Stream<Integer> indices = IntStream.range(0, names.length).boxed();
nameList = StreamUtils.zip(indices, stream(names),SimpleEntry::new)
.filter(e -> e.getValue().length() <= e.getKey()).map(Entry::getValue).collect(toList());
System.out.println(nameList);
答案 9 :(得分：3)
如果您不介意使用第三方库，Eclipse Collections zipWithIndex和forEachWithIndex可用于多种类型。这是针对使用zipWithIndex的JDK类型和Eclipse集合类型的挑战的一组解决方案。
String[] names = { "Sam", "Pamela", "Dave", "Pascal", "Erik" };
ImmutableList<String> expected = Lists.immutable.with("Erik");
Predicate<Pair<String, Integer>> predicate =
pair -> pair.getOne().length() <= pair.getTwo() + 1;
// JDK Types
List<String> strings1 = ArrayIterate.zipWithIndex(names)
.collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings1);
List<String> list = Arrays.asList(names);
List<String> strings2 = ListAdapter.adapt(list)
.zipWithIndex()
.collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings2);
// Eclipse Collections types
MutableList<String> mutableNames = Lists.mutable.with(names);
MutableList<String> strings3 = mutableNames.zipWithIndex()
.collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings3);
ImmutableList<String> immutableNames = Lists.immutable.with(names);
ImmutableList<String> strings4 = immutableNames.zipWithIndex()
.collectIf(predicate, Pair::getOne);
Assert.assertEquals(expected, strings4);
MutableList<String> strings5 = mutableNames.asLazy()
.zipWithIndex()
.collectIf(predicate, Pair::getOne, Lists.mutable.empty());
Assert.assertEquals(expected, strings5);
以下是使用forEachWithIndex的解决方案。
MutableList<String> mutableNames =
Lists.mutable.with("Sam", "Pamela", "Dave", "Pascal", "Erik");
ImmutableList<String> expected = Lists.immutable.with("Erik");
List<String> actual = Lists.mutable.empty();
mutableNames.forEachWithIndex((name, index) -> {
if (name.length() <= index + 1)
actual.add(name);
});
Assert.assertEquals(expected, actual);
如果将lambdas更改为上面的匿名内部类，那么所有这些代码示例也将在Java 5 - 7中运行。
注意：我是Eclipse Collections的提交者
答案 10 :(得分：3)
由于Stream与任何Stream不同，因此无法在访问索引时迭代Collection。 Stream仅仅是用于将数据从一个地方传送到另一个地方的管道，如documentation中所述：
没有存储空间。流不是存储元素的数据结构;相反，它们通过计算操作管道从源（可以是数据结构，生成器，IO通道等）传输值。
当然，正如您在问题中暗示的那样，您可以随时将Stream<V>转换为Collection<V>，例如List<V>，您可以在其中访问到索引。
答案 11 :(得分：2)
如果您碰巧使用Vavr（以前称为Javaslang），您可以使用专用方法：
Stream.of("A", "B", "C")
.zipWithIndex();
如果我们打印出内容，我们会看到一些有趣的内容：
Stream((A, 0), ?)
这是因为Streams是懒惰的，我们对流中的下一个项目一无所知。
答案 12 :(得分：1)
以下是AbacusUtil
的代码Stream.of(names).indexed()
.filter(e -> e.value().length() <= e.index())
.map(Indexed::value).toList();
披露：我是AbacusUtil的开发者。
答案 13 :(得分：0)
如果您需要forEach中的索引，那么这提供了一种方法。
public class IndexedValue {
private final int index;
private final Object value;
public IndexedValue(final int index, final Object value) {
this.index = index;
this.value = value;
}
public int getIndex() {
return index;
}
public Object getValue() {
return value;
}
}
然后按以下方式使用它。
@Test
public void withIndex() {
final List<String> list = Arrays.asList("a", "b");
IntStream.range(0, list.size())
.mapToObj(index -> new IndexedValue(index, list.get(index)))
.forEach(indexValue -> {
System.out.println(String.format("%d, %s",
indexValue.getIndex(),
indexValue.getValue().toString()));
});
}
答案 14 :(得分：0)
正如jean-baptiste-yunès所说，如果您的流是基于Java List的，则使用AtomicInteger，它的增量和获取方法可以很好地解决此问题，并且返回的整数确实对应于原始List中的索引只要不使用并行流。
答案 15 :(得分：0)
您不需要 map
那是最接近LINQ示例的lambda：
int[] idx = new int[] { 0 };
Stream.of( names ).filter( name -> name.length() <= idx[0]++ ).collect( Collectors.toList() );
答案 16 :(得分：0)
String[] namesArray = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
String completeString
= IntStream.range(0,namesArray.length)
.mapToObj(i -> namesArray[i]) // Converting each array element into Object
.map(String::valueOf) // Converting object to String again
.collect(Collectors.joining(",")); // getting a Concat String of all values
System.out.println(completeString);
输出：Sam，Pamela，Dave，Pascal，Erik
String[] namesArray = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
IntStream.range(0,namesArray.length)
.mapToObj(i -> namesArray[i]) // Converting each array element into Object
.map(String::valueOf) // Converting object to String again
.forEach(s -> {
//You can do various operation on each element here
System.out.println(s);
}); // getting a Concat String of all
要在列表中收集：
String[] namesArray = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> namesList
= IntStream.range(0,namesArray.length)
.mapToObj(i -> namesArray[i]) // Converting each array element into Object
.map(String::valueOf) // Converting object to String again
.collect(Collectors.toList()); // collecting elements in List
System.out.println(listWithIndex);
答案 17 :(得分：0)
您可以使用IntStream.iterate()来获取索引：
String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList = IntStream.iterate(0, i -> i < names.length, i -> i + 1)
.filter(i -> names[i].length() <= i)
.mapToObj(i -> names[i])
.collect(Collectors.toList());
这仅适用于Java 8或更高版本的Java 9，您可以使用以下方法：
String[] names = {"Sam","Pamela", "Dave", "Pascal", "Erik"};
List<String> nameList = IntStream.iterate(0, i -> i + 1)
.limit(names.length)
.filter(i -> names[i].length() <= i)
.mapToObj(i -> names[i])
.collect(Collectors.toList());
答案 18 :(得分：0)
如果您尝试根据谓词获取索引，请尝试以下操作：
如果您只关心第一个索引：
OptionalInt index = IntStream.range(0, list.size())
.filter(i -> list.get(i) == 3)
.findFirst();
或者如果你想找到多个索引：
IntStream.range(0, list.size())
.filter(i -> list.get(i) == 3)
.collect(Collectors.toList());
添加.orElse(-1);，以防您想要返回值，如果找不到它。
答案 19 :(得分：0)
这个问题（Stream Way to get index of first element matching boolean）已将当前问题标记为重复，因此我无法在那里回答;我在这里回答。
以下是获取不需要外部库的匹配索引的通用解决方案。
如果你有一个清单。
public static <T> int indexOf(List<T> items, Predicate<T> matches) {
return IntStream.range(0, items.size())
.filter(index -> matches.test(items.get(index)))
.findFirst().orElse(-1);
}
并称之为：
int index = indexOf(myList, item->item.getId()==100);
如果使用集合，请试试这个。
public static <T> int indexOf(Collection<T> items, Predicate<T> matches) {
int index = -1;
Iterator<T> it = items.iterator();
while (it.hasNext()) {
index++;
if (matches.test(it.next())) {
return index;
}
}
return -1;
}
答案 20 :(得分：0)
您可以创建一个静态内部类来封装索引器，如下所示：
static class Indexer {
int i = 0;
}
public static String getRegex() {
EnumSet<MeasureUnit> range = EnumSet.allOf(MeasureUnit.class);
StringBuilder sb = new StringBuilder();
Indexer indexer = new Indexer();
range.stream().forEach(
measureUnit -> {
sb.append(measureUnit.acronym);
if (indexer.i < range.size() - 1)
sb.append("|");
indexer.i++;
}
);
return sb.toString();
}
答案 21 :(得分：-1)
一种可能的方法是索引流上的每个元素：
AtomicInteger index = new AtomicInteger();
Stream.of(names)
.map(e->new Object() { String n=e; public i=index.getAndIncrement(); })
.filter(o->o.n.length()<=o.i) // or do whatever you want with pairs...
.forEach(o->System.out.println("idx:"+o.i+" nam:"+o.n));
在非常有用的情况下，沿着流使用匿名类并不常用。