@Beta
  public static <R> Stream<R> mapWithIndex(IntStream stream, IntFunctionWithIndex<R> function) {
    """
	Returns a stream consisting of the results of applying the given function to the elements of
	{@code stream} and their indexes in the stream. For example,
	
	<pre>{@code
	mapWithIndex(
	IntStream.of(0, 1, 2),
	(i, index) -> i + ":" + index)
	}</pre>
	
	<p>...would return {@code Stream.of("0:0", "1:1", "2:2")}.
	
	<p>The resulting stream is <a
	href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>
	if and only if {@code stream} was efficiently splittable and its underlying spliterator
	reported {@link Spliterator#SUBSIZED}. This is generally the case if the underlying stream
	comes from a data structure supporting efficient indexed random access, typically an array or
	list.
	
	<p>The order of the resulting stream is defined if and only if the order of the original stream
	was defined.
    """
    checkNotNull(stream);
    checkNotNull(function);
    boolean isParallel = stream.isParallel();
    Spliterator.OfInt fromSpliterator = stream.spliterator();

    if (!fromSpliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
      PrimitiveIterator.OfInt fromIterator = Spliterators.iterator(fromSpliterator);
      return StreamSupport.stream(
              new AbstractSpliterator<R>(
                  fromSpliterator.estimateSize(),
                  fromSpliterator.characteristics() & (Spliterator.ORDERED | Spliterator.SIZED)) {
                long index = 0;

                @Override
                public boolean tryAdvance(Consumer<? super R> action) {
                  if (fromIterator.hasNext()) {
                    action.accept(function.apply(fromIterator.nextInt(), index++));
                    return true;
                  }
                  return false;
                }
              },
              isParallel)
          .onClose(stream::close);
    }
    class Splitr extends MapWithIndexSpliterator<Spliterator.OfInt, R, Splitr>
        implements IntConsumer, Spliterator<R> {
      int holder;

      Splitr(Spliterator.OfInt splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(int t) {
        this.holder = t;
      }

      @Override
      public boolean tryAdvance(Consumer<? super R> action) {
        if (fromSpliterator.tryAdvance(this)) {
          action.accept(function.apply(holder, index++));
          return true;
        }
        return false;
      }

      @Override
      Splitr createSplit(Spliterator.OfInt from, long i) {
        return new Splitr(from, i);
      }
    }
    return StreamSupport.stream(new Splitr(fromSpliterator, 0), isParallel).onClose(stream::close);
  }
@Beta
  public static <R> Stream<R> mapWithIndex(IntStream stream, IntFunctionWithIndex<R> function) {
    checkNotNull(stream);
    checkNotNull(function);
    boolean isParallel = stream.isParallel();
    Spliterator.OfInt fromSpliterator = stream.spliterator();

    if (!fromSpliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
      PrimitiveIterator.OfInt fromIterator = Spliterators.iterator(fromSpliterator);
      return StreamSupport.stream(
              new AbstractSpliterator<R>(
                  fromSpliterator.estimateSize(),
                  fromSpliterator.characteristics() & (Spliterator.ORDERED | Spliterator.SIZED)) {
                long index = 0;

                @Override
                public boolean tryAdvance(Consumer<? super R> action) {
                  if (fromIterator.hasNext()) {
                    action.accept(function.apply(fromIterator.nextInt(), index++));
                    return true;
                  }
                  return false;
                }
              },
              isParallel)
          .onClose(stream::close);
    }
    class Splitr extends MapWithIndexSpliterator<Spliterator.OfInt, R, Splitr>
        implements IntConsumer, Spliterator<R> {
      int holder;

      Splitr(Spliterator.OfInt splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(int t) {
        this.holder = t;
      }

      @Override
      public boolean tryAdvance(Consumer<? super R> action) {
        if (fromSpliterator.tryAdvance(this)) {
          action.accept(function.apply(holder, index++));
          return true;
        }
        return false;
      }

      @Override
      Splitr createSplit(Spliterator.OfInt from, long i) {
        return new Splitr(from, i);
      }
    }
    return StreamSupport.stream(new Splitr(fromSpliterator, 0), isParallel).onClose(stream::close);
  }
@ Beta public static < R > Stream < R > mapWithIndex ( IntStream stream , IntFunctionWithIndex < R > function ) { checkNotNull ( stream ) ; checkNotNull ( function ) ; boolean isParallel = stream . isParallel ( ) ; Spliterator . OfInt fromSpliterator = stream . spliterator ( ) ; if ( ! fromSpliterator . hasCharacteristics ( Spliterator . SUBSIZED ) ) { PrimitiveIterator . OfInt fromIterator = Spliterators . iterator ( fromSpliterator ) ; return StreamSupport . stream ( new AbstractSpliterator < R > ( fromSpliterator . estimateSize ( ) , fromSpliterator . characteristics ( ) & ( Spliterator . ORDERED | Spliterator . SIZED ) ) { long index = 0 ; @ Override public boolean tryAdvance ( Consumer < ? super R > action ) { if ( fromIterator . hasNext ( ) ) { action . accept ( function . apply ( fromIterator . nextInt ( ) , index ++ ) ) ; return true ; } return false ; } } , isParallel ) . onClose ( stream :: close ) ; } class Splitr extends MapWithIndexSpliterator < Spliterator . OfInt , R , Splitr > implements IntConsumer , Spliterator < R > { int holder ; Splitr ( Spliterator . OfInt splitr , long index ) { super ( splitr , index ) ; } @ Override public void accept ( int t ) { this . holder = t ; } @ Override public boolean tryAdvance ( Consumer < ? super R > action ) { if ( fromSpliterator . tryAdvance ( this ) ) { action . accept ( function . apply ( holder , index ++ ) ) ; return true ; } return false ; } @ Override Splitr createSplit ( Spliterator . OfInt from , long i ) { return new Splitr ( from , i ) ; } } return StreamSupport . stream ( new Splitr ( fromSpliterator , 0 ) , isParallel ) . onClose ( stream :: close ) ; }
Returns a stream consisting of the results of applying the given function to the elements of
{@code stream} and their indexes in the stream. For example,

<pre>{@code
mapWithIndex(
IntStream.of(0, 1, 2),
(i, index) -> i + ":" + index)
}</pre>

<p>...would return {@code Stream.of("0:0", "1:1", "2:2")}.

<p>The resulting stream is <a
href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>
if and only if {@code stream} was efficiently splittable and its underlying spliterator
reported {@link Spliterator#SUBSIZED}. This is generally the case if the underlying stream
comes from a data structure supporting efficient indexed random access, typically an array or
list.

<p>The order of the resulting stream is defined if and only if the order of the original stream
was defined.
Returns a stream consisting of the results of applying the given function to the elements of { @code stream } and their indexes in the stream . For example