This lesson introduces a new programming paradigm that is particular useful for working with data: streams.
We’ll manipulated linear collections of data using good old
But we can do better.
Let’s see how!
Many of the code and algorithms we’ve written together have operated on sequential data, stored in either arrays or
And we’ve seen and identified common patterns for working with this kind of data.
Such as counting:
And while these are fine building blocks for creating larger programs, there is something a bit repetitive and dull about them.
Every one has the same overall structure: the same
loop, the same return structure.
Shouldn’t there be a better, more compact way of expressing these kind of patterns?
Yes. There is. And in Java these are called streams.
Streams allow us to work with sequential data by composing powerful programming primitives to great effect. First, let’s examine the Javadoc together.
Next, let’s examine how to utilize common stream operations to replace the repetitive loop-based code we wrote above.
First, let’s look at how to set up a stream and one of the most basic stream operations—
We can also filter streams using…
And count them using…
Let’s see how:
And, we can even reduce a
Stream until a single value with
reduce, a surprisingly powerful primitive.
Streams may seem alien to you at first.
That’s not surprising.
A famous silicon valley tech thought leader has pointed out that powerful programming ideas usually feel strange and even bizarre at first.
But, as you come to appreciate them, not only do they become more natural, but the older less-powerful ways of doing things start to see even more limited.
for-loop based patterns we’ve listed above have been factored out, leaving only the decision-making logic that changes depending on the application
Streams allow various kinds of operations (like
map, for example) to be done in parallel, increasing the speed with which large collections can be processed
To wrap up, let’s have some fun with
Streams working with one of our favorite data sets:
Let's get some more practice with algorithms by escaping from a maze!
Implement a public class
MazeEscape that provides a single public class method named
escape accepts a single parameter, a
Maze object with methods explained below.
Your goal is to manipulate the maze until you reach the exit, and then return it when you are finished.
If the passed
null, throw an
To navigate the maze, using the following
truewhen you have reached the exit of the maze
turnRight()rotates your character 90 degrees to the right
turnLeft()rotates your character 90 degrees to the left
trueif you can move one cell forward,
falseotherwise. Your path may be blocked by a wall!
move()moves your character one cell forward and increases the step counter
Maze object represents a simply-connected or perfect maze: one that contains no loops. As a result,
we suggest that you pursue a classic maze escape algorithm: wall following. Simply put, in a maze that contains no
loops, as long as you continue following a wall you will eventually reach the exit. In a corn maze, you might
implement this by simply maintaining contact with a wall (right or left) until you complete the maze. However,
you'll need to think a bit about how to implement this algorithm to finish this problem.
Need more practice? Head over to the practice page.