Java8 - how to determine if each element in a sorted list is one less that previous? [closed] - list

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed yesterday.
Improve this question
I have a list of ints that is sorted in order of highest > lowest:
I want to determine if each list element is one less than the previous, how can I do so, ideally using streams?
This would pass:
10
9
8
7
This would fail:
10
8
7
6

Answer 1

You can use IntStream to process the list sequentially and compare the previous index value if it is one more than the current one
public static void main(String[] args) {
List<Integer> sequentList = Arrays.asList(10, 9, 8, 7);
List<Integer> nonSequentList = Arrays.asList(10, 8, 7, 6);
System.out.println(isInSequence(sequentList));
System.out.println(isInSequence(nonSequentList));
}
private static boolean isInSequence(List<Integer> sequentList) {
return IntStream.range(1, sequentList.size())
.allMatch(i -> (sequentList.get(i - 1) - sequentList.get(i)) == 1);
}

Answer 2

There are multiple solutions to solve the problem, streams are hardly the ideal one in this case, both in terms of efficiency or readability:
Using streams:
One example could be:
private boolean isContiguousListWithStreams(List<Integer> sortedDescInput) {
return IntStream.range(1, sortedDescInput.size())
.noneMatch(i -> sortedDescInput.get(i - 1) - sortedDescInput.get(i) != 1);
}
Using For loop:
In this simple scenario, streams might just answer it as readable and efficient, but just to point out that in many complex scenarios, a simple for loop can be just what's needed and it can be as efficient and readable (if not more).
private boolean isContiguousListWithLoop(List<Integer> sortedDescInput) {
for (int i = 1; i < sortedDescInput.size(); i++) {
if (sortedDescInput.get(i - 1) - sortedDescInput.get(i) != 1) {
return false;
}
}
return true;
}
Using neither:
Since it was established that the input list is sorted in descending order, neither streams nor for loops are actually needed, a simple first - last + 1 == length formula will do:
private boolean isContiguousList(List<Integer> sortedDescInput) {
return sortedDescInput.size() < 2
|| sortedDescInput.get(0) - sortedDescInput.get(sortedDescInput.size() - 1) + 1 == sortedDescInput.size();
}
Please note that the efficiency of any of these solutions will depend on the underlying implementation of the list (e.g. Array lists are efficient to access based on an index, unlike linked lists).