Is it possible to get next element in the Stream?

Question

I am trying to converting a for loop to functional code. I need to look ahead one value and also look behind one value. Is it possible using streams? The following code is to convert the Roman text to numeric value. Not sure if reduce method with two/three arguments can help here.

int previousCharValue = 0;
int total = 0;
    
for (int i = 0; i < input.length(); i++) {
    char current = input.charAt(i);
        
    RomanNumeral romanNum = RomanNumeral.valueOf(Character.toString(current));
        
    if (previousCharValue > 0) { 
        total += (romanNum.getNumericValue() - previousCharValue);
        previousCharValue = 0;
    } else {
        if (i < input.length() - 1) {
        
            char next = input.charAt(i + 1);
            RomanNumeral nextNum = RomanNumeral.valueOf(Character.toString(next));
            if (romanNum.getNumericValue() < nextNum.getNumericValue()) {
                previousCharValue = romanNum.getNumericValue();
            }
        }
        if (previousCharValue == 0) {
            total += romanNum.getNumericValue();
        }
            
    }
        
}

Answer 1

No, this is not possible using streams, at least not easily. The stream API abstracts away from the order in which the elements are processed: the stream might be processed in parallel, or in reverse order. So "the next element" and "previous element" do not exist in the stream abstraction.

You should use the API best suited for the job: stream are excellent if you need to apply some operation to all elements of a collection and you are not interested in the order. If you need to process the elements in a certain order, you have to use iterators or maybe access the list elements through indices.

Answer 2

I haven't see such use case with streams, so I can not say if it is possible or not. But when I need to use streams with index, I choose IntStream#range(0, table.length), and then in lambdas I get the value from this table/list.

For example

    int[] arr = {1,2,3,4};
    int result = IntStream.range(0, arr.length)
            .map(idx->idx>0 ? arr[idx] + arr[idx-1]:arr[idx])
            .sum();

Answer 3

By the nature of the stream you don't know the next element unless you read it. Therefore directly obtaining the next element is not possible when processing current element. However since you are reading current element you obiously know what was read before, so to achieve such goal as "accesing previous element" and "accessing next element", you can rely on the history of elements which were already processed.

Following two solutions are possible for your problem:

1. Get access to previously read elements. This way you know the current element and defined number of previously read elements
2. Assume that at the moment of stream processing you read next element and that current element was read in previous iteration. In other words you consider previously read element as "current" and currently processed element as next (see below).

Solution 1 - implemenation

First we need a data structure which will allow keeping track of data flowing through the stream. Good choice could be an instance of Queue because queues by their nature allows data flowing through them. We only need to bound the queue to the number of last elements we want to know (that would be 3 elements for your use case). For this we create a "bounded" queue keeping history like this:

public class StreamHistory<T> {

    private final int numberOfElementsToRemember;
    private LinkedList<T> queue = new LinkedList<T>(); // queue will store at most numberOfElementsToRemember

    public StreamHistory(int numberOfElementsToRemember) {
        this.numberOfElementsToRemember = numberOfElementsToRemember;
    }

    public StreamHistory save(T curElem) {

        if (queue.size() == numberOfElementsToRemember) {
            queue.pollLast(); // remove last to keep only requested number of elements
        }

        queue.offerFirst(curElem);

        return this;
    }


    public LinkedList<T> getLastElements() {
        return queue; // or return immutable copy or immutable view on the queue. Depends on what you want.
    }
}

The generic parameter T is the type of actual elements of the stream. Method save returns reference to instance of current StreamHistory for better integration with java Stream api (see below) and it is not really required.

Now the only thing to do is to convert the stream of elements to the stream of instances of StreamHistory (where each next element of the stream will hold last n instances of actual objects going through the stream).

public class StreamHistoryTest {
  public static void main(String[] args) {
    Stream<Character> charactersStream = IntStream.range(97, 123).mapToObj(code -> (char) code); // original stream

    StreamHistory<Character> streamHistory = new StreamHistory<>(3); // instance of StreamHistory which will store last 3 elements

    charactersStream.map(character -> streamHistory.save(character)).forEach(history -> {
      history.getLastElements().forEach(System.out::print);
      System.out.println();
    });

  }

}

In above example we first create a stream of all letters in alphabet. Than we create instance of StreamHistory which will be pushed to each iteration of map() call on original stream. Via call to map() we convert to stream containing references to our instance of StreamHistory.

Note that each time the data flows through original stream the call to streamHistory.save(character) updates the content of the streamHistory object to reflect current state of the stream.

Finally in each iteration we print last 3 saved characters. The output of this method is following:

a
ba
cba
dcb
edc
fed
gfe
hgf
ihg
jih
kji
lkj
mlk
nml
onm
pon
qpo
rqp
srq
tsr
uts
vut
wvu
xwv
yxw
zyx

Solution 2 - implementation

While solution 1 will in most cases do the job and is fairly easy to follow, there are use cases were the possibility to inspect next element and previous is really convenient. In such scenario we are only interested in three element tuples (pevious, current, next) and having only one element does not matter (for simple example consider following riddle: "given a stream of numbers return a tupple of three subsequent numbers which gives the highest sum"). To solve such use cases we might want to have more convenient api than StreamHistory class.

For this scenario we introduce a new variation of StreamHistory class (which we call StreamNeighbours). The class will allow to inspect the previous and the next element directly. Processing will be done in time "T-1" (that is: the currently processed original element is considered as next element, and previously processed original element is considered to be current element). This way we, in some sense, inspect one element ahead.

The modified class is following:

public class StreamNeighbours<T> {
    private LinkedList<T> queue = new LinkedList(); // queue will store one element before current and one after
    private boolean threeElementsRead; // at least three items were added - only if we have three items we can inspect "next" and "previous" element

    /**
     * Allows to handle situation when only one element was read, so technically this instance of StreamNeighbours is not
     * yet ready to return next element
     */
    public boolean isFirst() {
        return queue.size() == 1;
    }

    /**
     * Allows to read first element in case less than tree elements were read, so technically this instance of StreamNeighbours is
     * not yet ready to return both next and previous element
     * @return
     */
    public T getFirst() {
        if (isFirst()) {
            return queue.getFirst();
        } else if (isSecond()) {
            return queue.get(1);
        } else {
            throw new IllegalStateException("Call to getFirst() only possible when one or two elements were added. Call to getCurrent() instead. To inspect the number of elements call to isFirst() or isSecond().");
        }
    }

    /**
     * Allows to handle situation when only two element were read, so technically this instance of StreamNeighbours is not
     * yet ready to return next element (because we always need 3 elements to have previos and next element)
     */
    public boolean isSecond() {
        return queue.size() == 2;
    }

    public T getSecond() {
        if (!isSecond()) {
            throw new IllegalStateException("Call to getSecond() only possible when one two elements were added. Call to getFirst() or getCurrent() instead.");
        }
        return queue.getFirst();
    }


    /**
     * Allows to check that this instance of StreamNeighbours is ready to return both next and previous element.
     * @return
     */
    public boolean areThreeElementsRead() {
        return threeElementsRead;
    }


    public StreamNeighbours<T> addNext(T nextElem) {

        if (queue.size() == 3) {
            queue.pollLast(); // remove last to keep only three
        }

        queue.offerFirst(nextElem);

        if (!areThreeElementsRead() && queue.size() == 3) {
            threeElementsRead = true;
        }

        return this;
    }


    public T getCurrent() {
        ensureReadyForReading();
        return queue.get(1); // current element is always in the middle when three elements were read

    }

    public T getPrevious() {
        if (!isFirst()) {
            return queue.getLast();
        } else {
            throw new IllegalStateException("Unable to read previous element of first element. Call to isFirst() to know if it first element or not.");
        }
    }

    public T getNext() {
        ensureReadyForReading();
        return queue.getFirst();
    }

    private void ensureReadyForReading() {
        if (!areThreeElementsRead()) { 
            throw new IllegalStateException("Queue is not threeElementsRead for reading (less than two elements were added). Call to areThreeElementsRead() to know if it's ok to call to getCurrent()");
        }
    }

}

Now, assuming that three elements were already read, we can directly access current element (which is the element going through the stream at time T-1), we can access next element (which is the element going at the moment through the stream) and previous (which is the element going through the stream at time T-2):

public class StreamTest {
  public static void main(String[] args) {
    Stream<Character> charactersStream = IntStream.range(97, 123).mapToObj(code -> (char) code);

    StreamNeighbours<Character> streamNeighbours = new StreamNeighbours<Character>();


    charactersStream.map(character -> streamNeighbours.addNext(character)).forEach(neighbours -> {
      //  NOTE: if you want to have access the values before instance of StreamNeighbours is ready to serve three elements
      //  you can use belows methods like isFirst() -> getFirst(), isSecond() -> getSecond()
      //
      //            if (curNeighbours.isFirst()) {
      //                Character currentChar = curNeighbours.getFirst();
      //                System.out.println("???" + " " + currentChar + " " + "???");
      //            } else if (curNeighbours.isSecond()) {
      //                Character currentChar = curNeighbours.getSecond();
      //                System.out.println(String.valueOf(curNeighbours.getFirst()) + " " + currentChar + " " + "???");
      //
      //            }
      //
      //   OTHERWISE: you are only interested in tupples consisting of three elements, so three elements needed to be read

      if (neighbours.areThreeElementsRead()) {
        System.out.println(neighbours.getPrevious() + " " + neighbours.getCurrent() + " " + neighbours.getNext());
      }
    });

  }

}

The output of this is following:

a b c
b c d
c d e
d e f
e f g
f g h
g h i
h i j
i j k
j k l
k l m
l m n
m n o
n o p
o p q
p q r
q r s
r s t
s t u
t u v
u v w
v w x
w x y
x y z

By StreamNeighbours class it is easier to track the previous/next element (because we have method with appropriate names), while in StreamHistory class this is more cumbersome since we need to manually "reverse" the order of the queue to achieve this.