My Code:
List<Integer> ints = Stream.of(1,2,4,3,5).collect(Collectors.toList());
ints.forEach((i)-> System.out.print(ints.get(i-1)+ " "));
out put:
1 2 3 4 5
my question is why i must be i-1 inside the get method? does i-1 prevent the out of boundary issue?
Does below code acts like the for loop iteration?
(i)-> System.out.print(ints.get(i-1))
so is above code equal to this
for(Ineger i:ints)
System.out.print(ints.get(i));
The lambda parameter i takes the value of the items in the collection, not the indexes. You are subtracting 1 because the values happen to be one greater than their index.
If you tried with
List<Integer> ints = Stream.of(10,20,40,30,50).collect(Collectors.toList());
ints.forEach((i)-> System.out.print(ints.get(i-1)+ " "));
You would find the code does not work so well.
You should be able to simply do (not needing to do a get call)
ints.forEach((i)-> System.out.print(i + " "));
Your lambda and your proposed for loop are not equivalent.
ints.forEach((i)-> System.out.print(ints.get(i-1)))
Would be equivalent to
for(Integer i:ints)
System.out.print(ints.get(i-1));
Note the preservation of the minus 1.
In response to the comment:
Lambdas are not loops, they are functions (effectively anyway). In your first example the forEach method is what provides the looping functionality. The argument lambda is what it should do on each iteration. This is equivalent to the body of your for loop
In the example in the comment, max is the function that provides the loop like behavior. It will iterate (do a loop) of the items to find the maximum value). The lambda you provide i -> i would be an identity function. It takes one parameter and returns that object unmodified.
Suppose you had a more complex object and you wanted to compare them on a particular member such as GetHighScore(). Then you could use i -> i.GetHighScore() to get the object with the highest score.
max function. I see while I was writing it comment was removed. Not sure if the content is helpful to you or not.
min/max, exactly; implicit iteration. I am not sure whether there are exception to that rule for certain types. For example in .NET you can do Min against certain types and it will be converted to a SQL query rather than a loop. Not sure if Java has equivalents (yet). For something like a List then yes it would always be a full iteration for min/max
min and max do an internal iteration for unsorted streams, or multiple partial iterations for parallel streams, however, for streams that are already sorted in respect to the same order it may simply return the first resp. last element of the stream.List indexes in Java are 0-based.
Therefore:
ints.get(0) == 1;
ints.get(1) == 2;
ints.get(2) == 3;
//etc...
You're calling ints.get(i-1) for each "i" where "i" is equal to the value of each element in the list "ints".
If you were to call ints.get(i) you'd be fetching elements with indices equal to 1,2,3,4 and 5 and 5 wouldn't be a valid index into a list with 5 elements.
This code:
ints.forEach((i)-> System.out.print(ints.get(i-1)+ " "));
is equivalent to:
for(int i : ints ) {
System.out.print(ints.get(i-1) + " ");
}
Your examples aren't equivalent.
This is a wish, rather than a solution! Other language like NodeJS/JavaScript have a similar loop that passes two arguments to the lambda. Parameter i is the index and parameter j is the item from the container (regarless of container type).
ints.forEach((i,j)-> System.out.print("Index is ${i} and item is ${j}", i, j));
ints.get(i-1)to get that to work as well.