David Landup

Olivera Popović

In this parent-guide - learn what you need to know about Graphs in Computer Science and focus on graph-related algorithm's theory and implementation - DFS, BFS, Dijkstra, A*, Minimum Spanning Trees, etc...

Graph Theory and Graph-Related Algorithm's Theory and Implementation

<h2 id="introduction">Introduction</h2>
Flask is one of the most popular Python web development frameworks. It's a lightweight web framework, yet it offers a variety of built-in methods that can be used for hassle-free deployment of efficient web applications.
<blockquote>
In this guide, we will get the IP address of the user who visits the web application created using Flask.
</blockquote>
We'll create a simple REST API that handles the incoming requests to the <code>/</code> endpoint, returning the IP address of the user as the response.
<h2 id="creatingabasicwebappusingflask">Creating a Basic Web App Using Flask</h2>
Create a new Flask project for this tutorial. We'll create a basic app that returns &quot;Hello World&quot; with requests to the <code>/</code> endpoint:
<pre><code class="hljs">from flask import Flask

# Creating the instance of the class Flask
app = Flask(__name__)

# Using the decorator to create the URL for the web application
@app.route(&#x27;/&#x27;)
# The function will return the information displayed on the webpage
def hello_world():
 return &#x27;&lt;h1&gt; Hello World&lt;/h1&gt;&#x27;

# Run the application
if __name__ == &#x27;__main__&#x27;:
 app.run(debug=True)
</code></pre>
Now that we have our app set up, let's collect the IP addresses associated with a user's request.
<h2 id="howtofindtheipaddressofauserinflask">How to Find the IP Address Of a User in Flask?</h2>
Whenever a client requests a page - they send an HTTP GET request, with a certain payload. Amongst other information - their distinctive IP address is included. In Flask - every route has access to the <code>request</code> variable, which represents the incoming request from the user.
From this <code>request</code>, we can extract various elements - and the IP address is denoted as the <code>remote_addr</code> property:
<pre><code class="hljs">@app.route(&#x27;/&#x27;)
def hello_world():
 ip_addr = request.remote_addr
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>
We can also get the remote address through the request context's environment. The <code>environ</code> dictionary of the <code>request</code> object holds various keys and their respective values, pertaining to the request. The <code>REMOTE_ADDR</code> is one of the server variables (keys) that is mapped to the IP address of the client or the server:
<pre><code class="hljs">@app.route(&#x27;/client&#x27;)
def client():
 ip_addr = request.environ[&#x27;REMOTE_ADDR&#x27;]
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>
But the above two options won't work if your user is making a request behind a proxy. In that case we have to check the headers of the request. In particular, we're looking for the <code>HTTP_X_FORWARDED_FOR</code> header:
<pre><code class="hljs">@app.route(&#x27;/proxy-client&#x27;)
def proxy_client():
 ip_addr = request.environ[&#x27;HTTP_X_FORWARDED_FOR&#x27;]
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>
Now, even this approach would not work if the header is not set. So a common strategy is to use the <code>get()</code> method so that if the header is not set, we can default to the remote address:
<pre><code class="hljs">@app.route(&#x27;/proxy-client&#x27;)
def proxy_client():
 ip_addr = request.environ.get(&#x27;HTTP_X_FORWARDED_FOR&#x27;, request.remote_addr)
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Trying to get a value from a non-existent key returns <code>None</code>. The <code>get()</code> method of the <code>dict</code> class allows you to set a default value to be used if <code>get()</code> fails to find a key. If <code>HTTP_X_FORWARDED_FOR</code> is <code>None</code>, the <code>request.remote_addr</code> value is used instead.

 </div>
 </div>
 </div>
 With these in mind, we can choose from any of the following three approaches to get the IP address of a user, via their incoming request:
<pre><code class="hljs">from flask import Flask, request

app = Flask(__name__)

@app.route(&#x27;/&#x27;)
def hello_world():
 ip_addr = request.remote_addr
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr


@app.route(&#x27;/client&#x27;)
def client():
 ip_addr = request.environ[&#x27;REMOTE_ADDR&#x27;]
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr


@app.route(&#x27;/client&#x27;)
def proxy_client():
 ip_addr = request.environ.get(&#x27;HTTP_X_FORWARDED_FOR&#x27;, request.remote_addr)
 return &#x27;&lt;h1&gt; Your IP address is:&#x27; + ip_addr


if __name__ == &#x27;__main__&#x27;:
 app.run(debug=True)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned three different methods to get the IP address of a user. We access the remote address directly with <code>request.remote_addr</code>, through the <code>REMOTE_ADDR</code> key from <code>request.environ</code>, and in the cases where the user is using a proxy we should check the <code>HTTP_X_FORWARDED_FOR</code> key of <code>request.environ</code>.

Marcus Sanatan

Mohammad Waseem

In this tutorial, we will take a look at how to get the IP address of the user who visits a web application created using Flask.

How To Get User's IP Address Using Flask?

Hiram Kamau

Jovana Ninkovic

In this definitive, detailed guide - learn all you need to know about Java Collectors' collectingAndThen(), whether it's efficient, and try out a hands-on data analysis project.

Guide to Java 8 Collectors: collectingAndThen()

Query Parameters are part of the Query String - a section of the URL that contains key-value pairs of parameters. Typically, parameters are sent alongside GET requests to further specify filters on the operation:
<pre><code class="hljs">www.example.com/search?name=John&amp;location=Miami
</code></pre>
The parameters are defined after the <code>?</code> character and each key-value pair is separated with a <code>&amp;</code>. Spaces are represented as <code>%20</code> and can also be represented as <code>+</code>. These map to a key-value set of:
<pre><code class="hljs">name=John
location=Miami
</code></pre>
It's easy to manipulate the URL with JavaScript - so more often than not, query parameters are added as filters to searches. Additionally, by adjusting the content on the screen based on reproducible parameters, instead of the body of a request, results are shareable between users just by sending a link with the parameters!
For instance, on AirBnB - if you're fully flexible on the location, dates and wish for an auto-suggest, a click of a button leads you to:
<pre><code class="hljs">https://www.airbnb.com/s/homes?refinement_paths%5B%5D=%2Fhomes&amp;date_picker_type=flexible_dates&amp;search_mode=flex_destinations_search&amp;search_type=AUTOSUGGEST
</code></pre>
There are a few parameters here, such as <code>refinement_paths</code>, <code>date_picker_type</code>, <code>search_mode</code>, and <code>search_type</code>, each with a value.
<blockquote>
In this short guide, we'll take a look at how to get a GET Request's Query Parameters in Flask.
</blockquote>
<h2 id="getqueryparametersinflask">Get Query Parameters in Flask</h2>
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/search&#x27;, methods=[&#x27;GET&#x27;])
def search():
 args = request.args
 return args
</code></pre>
The <code>request.args</code> field is an <code>ImmutableMultiDict</code>:
<pre><code class="hljs">print(type(args))
# &lt;class &#x27;werkzeug.datastructures.ImmutableMultiDict&#x27;&gt;
</code></pre>
It can easily be converted into a regular dictionary via:
<pre><code class="hljs">print(type(args.to_dict()))
# &lt;class &#x27;dict&#x27;&gt;
</code></pre>
Additionally, you can search for a specific key in the dictionary via the <code>get()</code> method, returning an error if the key doesn't match up to the preconceived argument list:
<pre><code class="hljs">print(args.get(&quot;name&quot;))
# John
</code></pre>
You can additionally cast the value to a different type, such as <code>int</code> or <code>str</code> while getting it. You can also set a default value if the value isn't present already. For instance, a <code>name</code> parameter will probably be a string, but the <code>price</code> parameter might be an integer:
<pre><code class="hljs">args.get(&quot;name&quot;, default=&quot;&quot;, type=str)
args.get(&quot;price&quot;, default=0, type=int)
</code></pre>
If you search for a non-existent key - a <code>None</code> is returned. This way, you can check whether a query parameter is missing, and act accordingly - assigning a default value or just not using it.
Let's send a GET request to the endpoint with a <code>name</code> and <code>location</code>:
<pre><code class="hljs">$ curl &quot;localhost:5000/search?name=John&amp;location=Miami&quot;
</code></pre>
This results in:
<pre><code class="hljs">{&quot;location&quot;:&quot;Miami&quot;,&quot;name&quot;:&quot;John&quot;}
</code></pre>
<h2 id="checkifqueryparametersarenotnone">Check if Query Parameters are Not None</h2>
When operating on parameters, you'll typically want to check if they're <code>None</code> and act accordingly. This can thankfully easily be done by getting an expected key and checking if it's present in the dictionary!
Let's create a mock database - just a dictionary of users and their locations. Then, based on the parameters passed in the URL, we'll filter this dictionary and return the matching users that fit the criteria defined by the parameters:
<pre><code class="hljs">from flask import Flask, request
# ...
db_users = {
 &quot;John&quot; : &quot;Miami&quot;,
 &quot;David&quot; : &quot;Miami&quot;,
 &quot;Jane&quot; : &quot;London&quot;,
 &quot;Gabriella&quot; : &quot;Paris&quot;,
 &quot;Tanaka&quot; : &quot;Tokyo&quot;
}

@app.route(&#x27;/search&#x27;, methods=[&#x27;GET&#x27;])
def search():
 args = request.args
 name = args.get(&#x27;name&#x27;)
 location = args.get(&#x27;location&#x27;)

 # result = db_users
 if None not in (name, location):
 result = {key: value for key, value in db_users.items() if key == name and value == location}
 elif name is not None:
 result = {key: value for key, value in db_users.items() if key == name}
 elif location is not None:
 result = {key: value for key, value in db_users.items() if value == location}

 return result
</code></pre>
Here - we extract the <code>name</code> and <code>location</code> from the parameter list. If none are present - you may wish to return all of the users, or none at all. If you'd wish to return all of them - uncomment the <code>result = db_users</code> line.
If both the <code>name</code> and <code>location</code> are present, we filter the <code>db_users</code> by both parameters. If only one is present - we filter it only using the present parameter.
Now, if we send a GET Request with both or a single parameter, we'll be greeted with:
<pre><code class="hljs">$ curl &quot;localhost:5000/search?name=John&amp;location=Miami&quot;
{&quot;John&quot;:&quot;Miami&quot;}

$ curl &quot;localhost:5000/search?name=John&quot;
{&quot;John&quot;:&quot;Miami&quot;}

$ curl &quot;localhost:5000/search?location=Miami&quot;
{&quot;David&quot;:&quot;Miami&quot;,&quot;John&quot;:&quot;Miami&quot;}
</code></pre>
Two people are located in Miami, so just using the single search parameter nets us two users. There's only one John in the dictionary, so only John is returned for the first two queries.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to get the query parameters of an HTTP GET Request in Flask.
We've also taken a look at how to check whether the parameters are <code>None</code> and how to handle the lack thereof with a mock database.

In this guide, we'll take a look at how to get the query parameters/arguments, handle missing values, set default values and cast parameters to different data types. in Flask - a lightweight Pyton framework for web development.

GET Request Query Parameters with Flask

<h2 id="introduction">Introduction</h2>
Flask is a great micro-framework for Web Development in Python, and allows you to be extremely minimal. A working REST API can be served up in seconds through a few lines of code:
<pre><code class="hljs">from flask import Flask, request
app = Flask(__name__)

@app.route(&#x27;/&#x27;)
def hello():
 return &#x27;Hello!&#x27;

if __name__ == &quot;__main__&quot;:
 app.run()
</code></pre>
The backbone of the modern web is the HTTP protocol - which sends requests and delivers responses back. To differentiate the intentions behind these requests, several &quot;verbs&quot; have been associated with tasks you're performing. <code>GET</code> verbs are used to annotate requests in which you wish to retrieve resources, <code>POST</code> verbs are used to request resources to be created, given the payload (body), <code>DELETE</code> verbs are used to request resource deletion, etc.
If you wish to create a resource on a server - you'll be sending a POST Request with a body that contains the data you're posting to the server.
<blockquote>
In this guide, we'll take a look at how to get an HTTP POST Body in Flask.
</blockquote>
In general, you'll most likely be posting JSON data to a REST API that consumes that data, or you'll be posting Form data - by having a user fill out a web form, and then sending that data to another API for processing.
When sending form data - it's typically encoded as <code>multipart/form-data</code>, while when sending JSON data - it's typically encoded as <code>application/json</code>. This information is embedded in the POST Request Header which you can, also check. For good measure - we'll be checking the request's headers before parsing the data.
When dealing with requests - the <code>request</code> module of <code>flask</code> allows you to represent incoming HTTP requests. A POST request's body can be extracted directly from the request itself and depending on the encoding - you'll access the appropriate field:
<ul>
<li><code>request.json</code> or <code>request.get_json()</code></li>
<li><code>request.form</code></li>
<li><code>request.data</code></li>
</ul>
<code>request.json</code> represents JSON sent as a request with the <code>application/json</code> content-type. Alternatively, you can use the <code>request.get_json()</code> method. Both accessing the field itself and the method returns a <code>dict</code> - with <code>key-value</code> pairs present in the incoming JSON.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The <code>json</code> field and <code>get_json()</code> methods will only work if the Content-Type of the POST request is set to <code>application/json</code>. If it's a JSON-formatted string - this approach will fail and result in a <code>None</code> value. If you can't enforce the client to send properly encoded data - you can convert the incoming string into JSON. Covered later in the guide.

 </div>
 </div>
 </div>
 <code>request.form</code> represents the <code>multipart/form-data</code> data that is acquired through web forms.
<code>request.data</code> is a string representation of the incoming data. In general - you'll use this representation to convert into JSON if you can't force the client to send the content-type you're expecting.
<h3 id="getpostjson">Get POST JSON</h3>
Let's start out with JSON - since this is the most commonly used format to transfer data between APIs. We'll create a simple route handler that receives a <code>POST</code> request, on the <code>/post_json</code> endpoint. Remember, the <code>json</code> field will only ever contain a value if the headers of the request properly annotate the body as an <code>application/json</code> payload.
Here, we'll also get the 'Content-Type' from the <code>headers</code> and check if the body indeed is <code>application/json</code> formatted. If not - we won't even try extracting JSON from the request (it will silently fail if we do) and an error message is returned:
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/post_json&#x27;, methods=[&#x27;POST&#x27;])
def process_json():
 content_type = request.headers.get(&#x27;Content-Type&#x27;)
 if (content_type == &#x27;application/json&#x27;):
 json = request.json
 return json
 else:
 return &#x27;Content-Type not supported!&#x27;
</code></pre>
If you send a POST request to your endpoint now - you'll be greeted with the JSON returned back:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Depending on the operating system and shell you're using - you might use <code>'</code> instead of <code>&quot;</code> or even skip the escape characters such as <code>\</code> altogether.

 </div>
 </div>
 </div>
 This results in:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;John&quot;,&quot;lastName&quot;:&quot;Smith&quot;}
</code></pre>
Awesome! Let's try setting the <code>-H</code> argument to another type - to check if the validation step works well:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: multipart/form-data&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
</code></pre>
This results in:
<pre><code class="hljs">Content-Type not supported!
</code></pre>
Alternatively, <code>get_json()</code> works in much the same way:
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/post_json&#x27;, methods=[&#x27;POST&#x27;])
def process_json():
 content_type = request.headers.get(&#x27;Content-Type&#x27;)
 if (content_type == &#x27;application/json&#x27;):
 json = request.get_json()
 return json
 else:
 return &#x27;Content-Type not supported!&#x27;
</code></pre>
<h3 id="getpostjsonfromstring">Get POST JSON from String</h3>
We were the ones sending the request so far - so we had the liberty of changing the content-type as we saw fit. This might not always be the case - and sometimes, you can run into a JSON-formatted request that doesn't have the correct content-type assigned to it.
In that case - <code>json</code> and <code>get_json()</code> don't parse the incoming body as JSON at all - and will end up being <code>None</code>, out of which you can't extract anything. In such cases - you can use the <code>json</code> module to load the string you've received into a dictionary (<code>key-value</code> pairs)!
Let's import the module and convert the incoming <code>request.data</code>:
<pre><code class="hljs">from flask import Flask, request, json
# ...
@app.route(&#x27;/post_json&#x27;, methods=[&#x27;POST&#x27;])
def process_json():
 data = json.loads(request.data)
 return data
</code></pre>
Now - whether you send a <code>text/plain</code>-encoded body, or an <code>application/json</code>-encoded body - the <code>json</code> module can handle the input. If we try sending either of these requests - they'd both result in the same response:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: application/json&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
$ curl -X POST -H &quot;Content-type: text/plain&quot; -d &quot;{\&quot;firstName\&quot; : \&quot;John\&quot;, \&quot;lastName\&quot; : \&quot;Smith\&quot;}&quot; &quot;localhost:5000/post_json&quot;
</code></pre>
They result in:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;John&quot;,&quot;lastName&quot;:&quot;Smith&quot;}
</code></pre>
<h3 id="getpostform">Get POST Form</h3>
When filling out forms - you have a series of inputs, and their corresponding labels. Under the hood - these are all just <code>key-value</code> pairs:
<pre><code class="hljs">username=user_input
password=user_input_2
...
</code></pre>
This is typically derived from the front-end - usually an HTML page with a <code>&lt;form&gt;</code> tag with several <code>&lt;input&gt;</code> fields within it. You can also send form data via <code>curl</code> as:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: multipart/form-data&quot; -F &quot;username=john&quot; -F &quot;password=doe&quot; &quot;localhost:5000/post_form&quot;
</code></pre>
Or, you can collapse all of the fields into a single argument:
<pre><code class="hljs">$ curl -X POST -H &quot;Content-type: multipart/form-data&quot; -F &quot;username=john&amp;password=doe&quot; &quot;localhost:5000/post_form&quot;
</code></pre>
In general - you'll be working with actual forms though, and a form we would be working with looks like:
<pre><code class="hljs">&lt;form action=&quot;/post_form&quot; enctype=&quot;multipart/form-data&quot; method=&quot;POST&quot;&gt; 
 &lt;input type=&quot;text&quot; name=&quot;username&quot;&gt;
 &lt;input type=&quot;password&quot; name=&quot;password&quot;&gt;
&lt;/form&gt;
</code></pre>
The <code>name</code> of each <code>&lt;input&gt;</code> is mapped as the <code>key</code> to a <code>value</code> input by the user. The <code>form</code> extracted from the <code>request</code> object is yet another <code>dict</code> - and you can access the fields individually easily:
<pre><code class="hljs">from flask import Flask, request
# ...
@app.route(&#x27;/post_form&#x27;, methods=[&#x27;POST&#x27;])
def process_form():
 data = request.form
 print(data[&#x27;username&#x27;])
 print(data[&#x27;password&#x27;]) 
 return data
</code></pre>
When we send a request via the console - the dictionary containing the key-value pairs is returned (which is then formatted again, as JSON):
<pre><code class="hljs">{&quot;password&quot;:&quot;doe&quot;,&quot;username&quot;:&quot;john&quot;}
</code></pre>
And on the server-end - the inputs for these two fields have been printed, right beneath the log for the incoming request
<pre><code class="hljs">127.0.0.1 - - [09/Dec/2021 00:24:32] &quot;POST /post_form HTTP/1.1&quot; 200 -
john
doe
</code></pre>
Naturally, instead of just printing the values to the console - you would validate the data, create a user, and persist them in the database. Alternatively, you can populate the fields of any class this way, before using that class for its purpose.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at how to handle incoming HTTP POST requests in Flask. We've covered incoming JSON data, as well as how to handle string-represented JSON which isn't picked up automatically.
Finally, we've covered form data.

In this guide, learn how to get, parse and handle incoming POSTed JSON and Form data in Flask with Python!

How to Get and Parse HTTP POST Body in Flask - JSON and Form Data

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
<blockquote>
In this guide, we'll take a look at how to reduce elements through a downstream collector, with the help of Collectors.reducing().
</blockquote>
Reduction operations are one of the most common and powerful operations in Functional Programming. Additionally, you can reduce elements via the <code>reduce()</code> method - however, it's typically associated with reducing a collection to a single value. <code>reducing()</code> on the other hand is associated with collecting a stream into a list of reduced values instead.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Both approaches can be used to produce lists of reduced values, as well. In general - you'll use <code>map()</code> and <code>reduce()</code> if you're reducing a stream from the get-go into a result, and you'll use <code>reducing()</code> as a downstream collector within an operation pipeline with other collectors and operations.

 </div>
 </div>
 </div>
 <blockquote>
If you'd like to read more about <code>reduce()</code> - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">Java 8 Streams: Definitive Guide to reduce()</a>!
</blockquote>
<h2 id="collectorsandstreamcollect">Collectors and Stream.collect()</h2>
Collectors represent implementations of the <code>Collector</code> interface, which implements various useful reduction operations, such as accumulating elements into collections, summarizing elements based on a specific parameter, etc.
<blockquote>
All predefined implementations can be found within the <code>Collectors</code> class.
</blockquote>
You can also very easily implement your own collector and use it instead of the predefined ones, though - you can get pretty far with the built-in collectors, as they cover the vast majority of cases in which you might want to use them.
To be able to use the class in our code we need to import it:
<pre><code class="hljs">import static java.util.stream.Collectors.*;
</code></pre>
<code>Stream.collect()</code> performs a mutable reduction operation on the elements of the stream.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 A mutable reduction operation collects input elements into a mutable container, such as a <code>Collection</code>, as it processes the elements of the stream.

 </div>
 </div>
 </div>
 <h2 id="guidetocollectorsreducing">Guide to Collectors.reducing()</h2>
Within the <code>Collectors</code> class is a vast number of methods, allowing us to collect streams in a myriad of ways. As reduction is a very common operation - it offers a reduction method that operates on all the elements of a stream - returning their reduced variants.
There are three different overloaded variants of this method. They differ from each other by the number of arguments they take in, what those arguments do, as well as the return value. We'll be discussing them all separately in detail as we go along in this guide.
The arguments are the exact ones you'd expect from a reduction operation, and exactly the same ones <code>reduce()</code> uses:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Optional&lt;T&gt;&gt; reducing(BinaryOperator&lt;T&gt; op)
 
public static &lt;T&gt; Collector&lt;T,?,T&gt; reducing(T identity, BinaryOperator&lt;T&gt; op)
 
public static &lt;T,U&gt; Collector&lt;T,?,U&gt; reducing(U identity,
 Function&lt;? super T,? extends U&gt; mapper,
 BinaryOperator&lt;U&gt; op)
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: The generic <code>T</code> in the method signatures represents the type of the input elements we're working with. The generic <code>U</code> in the third method signature represents the type of the mapped values.

 </div>
 </div>
 </div>
 In essence - you're dealing with the identity, mapper and combiner. The identity is the value that, when applied to itself, returns the same value. The mapper maps objects we're reducing to another value - commonly being one of the fields of the object. A combiner, well, combines the results into the final result returned to the user.
The <code>reducing()</code> collector is most useful when used in a multi-level reduction operation, downstream of <code>groupingBy()</code> or <code>partitioningBy()</code>. Otherwise, we could reasonably substitute it with <code>Stream.map()</code> and <code>Stream.reduce()</code> to perform a simple map-reduce on a stream instead.
<blockquote>
If you're unfamiliar with these two collectors, read our <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-groupingby/">Guide to Java 8 Collectors: groupingBy()</a> and <a target="_blank" href="https://stackabuse.com/java-8-streams-definitive-guide-to-partitioningby/">Guide to Java 8 Collectors: partitioningBy()</a>!
</blockquote>
Before we jump in and cover the different overloads of <code>reducing()</code>, let's go ahead and define a <code>Student</code> class that we'll be reducing in the upcoming examples:
<pre><code class="hljs">public class Student {
 private String name;
 private String city;
 private double avgGrade;
 private int age;
 
 // Constructor, getters, setters and toString()
}
</code></pre>
Let's also instantiate our students in a <code>List</code>:
<pre><code class="hljs">List&lt;Student&gt; students = Arrays.asList(
 new Student(&quot;John Smith&quot;, &quot;Miami&quot;, 7.38, 19),
 new Student(&quot;Mike Miles&quot;, &quot;New York&quot;, 8.4, 21),
 new Student(&quot;Michael Peterson&quot;, &quot;New York&quot;, 7.5, 20),
 new Student(&quot;James Robertson&quot;, &quot;Miami&quot;, 9.1, 20),
 new Student(&quot;Joe Murray&quot;, &quot;New York&quot;, 7.9, 19),
 new Student(&quot;Kyle Miller&quot;, &quot;Miami&quot;, 9.83, 20)
);
</code></pre>
<h2 id="collectorsreducingwithabinaryoperator">Collectors.reducing() with a BinaryOperator</h2>
The first overload of the <code>reducing()</code> method takes in only one parameter - <code>BinaryOperator&lt;T&gt; op</code>. This parameter, as the name implies, represents an operation used to reduce the input elements.
A <code>BinaryOperator</code> is a functional interface so it can be used as the assignment target for a lambda expression or a method reference. Natively, <code>BinaryOperator</code> has two methods - <code>maxBy()</code> and <code>minBy()</code> both of which take a <code>Comparator</code>. The return value of these two methods is a <code>BinaryOperator</code> that returns the greater/lesser of the two elements.
<blockquote>
In simpler terms - it accepts two inputs, and returns one output, based on some criteria.
</blockquote>
<blockquote>
If you'd like to read more about Functional Interfaces and Lambda Expressions - read our <a target="_blank" href="https://stackabuse.com/guide-to-functional-interfaces-and-lambda-expressions-in-java/">Guide to Functional Interfaces and Lambda Expressions in Java</a>!
</blockquote>
Let's assume that from within our <code>List</code> of students we want to find the student with the best and worst grades in their respective city. We'll first need to use a collector that accepts another downstream collector, such as the <code>partitioningBy()</code> or <code>groupingBy()</code> collectors, after which we'll use the <code>reducing()</code> method to perform the required reduction.
Of course, we could also reduce them from the get-go via <code>Stream.reduce()</code> without grouping them first:
<pre><code class="hljs">Map&lt;String, Optional&lt;Student&gt;&gt; reduceByCityAvgGrade = students.stream()
 .collect(Collectors
 .groupingBy(Student::getCity,
 Collectors.reducing(BinaryOperator
 .maxBy(Comparator
 .comparing(Student::getAvgGrade)))));
</code></pre>
The student <code>List</code> is transformed into a <code>Stream</code> using the <code>stream()</code> method, after which we collect the grouped elements into groups, <code>reducing()</code> the list of students in each city to a single student in each city with the highest grade. This variant of the method always returns a <code>Map&lt;T, Optional&lt;T&gt;&gt;</code>.
After running this code, we get the following output:
<pre><code class="hljs">{
New York=Optional[Student{name=&#x27;Mike Miles&#x27;, city=&#x27;New York&#x27;, avgGrade=8.4, age=21}], Miami=Optional[Student{name=&#x27;Kyle Miller&#x27;, city=&#x27;Miami&#x27;, avgGrade=9.83, age=20}]
}
</code></pre>
<h2 id="collectorsreducingwithabinaryoperatorandidentity">Collectors.reducing() with a BinaryOperator and Identity</h2>
In the previous code sample - the result is wrapped in an optional. If there is no value - an <code>Optional.empty()</code> is returned instead. This is because there is no default value that can be used instead.
To deal with this, and remove the <code>Optional</code> wrapping, we can use the second variant of the <code>reducing()</code> overload, the one that takes in two arguments - a <code>BinaryOperator</code> and an <code>Identity</code>. The <code>Identity</code> represents the value for the reduction, and also the value that is returned when there are no input elements!
This time around, we pass in a 'default' value that kicks in if a value isn't present, and is used as the identity of the result:
<pre><code class="hljs">Map&lt;String, Student&gt; reduceByCityAvgGrade = students.stream()
 .collect(Collectors
 .groupingBy(Student::getCity,
 Collectors.reducing(new Student(&quot;x&quot;, &quot;x&quot;, 0.0, 0),
 BinaryOperator.maxBy(Comparator
 .comparing(Student::getAvgGrade)))));
</code></pre>
In our case, for <code>Identity</code> we use a new <code>Student</code> object. The <code>name</code>, <code>city</code> and <code>age</code> fields have no impact on our result while using the <code>reducing()</code> method, so it doesn't really matter what we put as these three values. However, as we are reducing our input data by the <code>avgGrade</code> field, that one matters. Any value that can be logically correct here is valid.
We've put a <code>0.0</code> grade as the default one, with <code>&quot;x&quot;</code> for the name and city, denoting an empty result. The lowest grade can be <code>6.0</code> so <code>0.0</code> and the missing name signals an empty value - but we can actually expect <code>Student</code> objects instead of Optionals now:
<pre><code class="hljs">{
New York=Student{name=&#x27;Mike Miles&#x27;, city=&#x27;New York&#x27;, avgGrade=8.4, age=21},
Miami=Student{name=&#x27;Kyle Miller&#x27;, city=&#x27;Miami&#x27;, avgGrade=9.83, age=20}
}
</code></pre>
<h2 id="collectorsreducingwithabinaryoperatoridentityandmapper">Collectors.reducing() with a BinaryOperator, Identity and Mapper</h2>
The last of the three overloaded variants takes in one extra argument in addition to the previous two - a mapper. This argument represents a mapping function to apply to each element.
You don't have to group by a city to perform the <code>reducing()</code> operation:
<pre><code class="hljs">double largestAverageGrade = students.stream()
 .collect(Collectors.reducing(0.0, Student::getAvgGrade,
 BinaryOperator.maxBy(Comparator.comparingDouble(value -&gt; value))));
</code></pre>
This would return <code>9.83</code>, which in fact is the largest value assigned of all of the <code>avgGrade</code> fields assigned to all of the student objects within the <code>List</code>. However, if you're using an IDE or tool that detects code-smell, you'll quickly get recommended to change the above line into the following:
<pre><code class="hljs">double largestAverageGrade = students.stream()
 .map(Student::getAvgGrade)
 .reduce(0.0, BinaryOperator.maxBy(Comparator.comparingDouble(value -&gt; value)));
</code></pre>
<blockquote>
<code>map()</code> and <code>reduce()</code> is preferred if you're not really doing anything else. <code>reducing()</code> is preferred as a downstream collector.
</blockquote>
With a mapper - you can map the values you've reduced to something else. Commonly, you'll map objects to one of their fields. We can map <code>Student</code> objects to their names, cities or grades, for instance. In the following code snippet, we'll group students by their city, reduce each city list based on their grades to the highest-grade student, and then map this student to their grade, resulting in a single value per city:
<pre><code class="hljs">Map&lt;String, Double&gt; reduceByCityAvgGrade1 = students.stream()
 .collect(Collectors
 .groupingBy(Student::getCity,
 Collectors.reducing(6.0, Student::getAvgGrade,
 BinaryOperator.maxBy(Comparator
 .comparingDouble(i-&gt;i)))));
</code></pre>
This gives us a slightly different output than we earlier had:
<pre><code class="hljs">{New York=8.4, Miami=9.83}
</code></pre>
Considering the amount of collectors you can use instead and chain this way - you can do a lot of work using just the built-in collectors and stream operations.
<h2 id="conclusion">Conclusion</h2>
In this guide we've covered the usage of the <code>reducing()</code> method from the <code>Collectors</code> class. We covered all three of its overloads and discussed their usages through practical examples.

Branko Ilic

In this guide, we'll take a look at how to use the Collectors.reducing() method through practical examples with Identity, BinaryOperation and a Mapper and compare it to the Stream.reduce() method.

Guide to Java 8 Collectors: reducing()

Cansın Güler

In this extensive guide - we'll take a holistic view at functional programming in Java, what are Functional Interfaces and Lambda Expressions and put them to practice in testing objects functionally.

Guide to Functional Interfaces and Lambda Expressions in Java

In this extensive practical guide, learn how to partition streams and lists in Java with partitioningBy(), with downstream collectors and examples of different reduction operations.

Java 8 Streams: Definitive Guide to partitioningBy()

In this definitive guide - learn all you need to know about flatMap() with Java 8 Streams - flatten streams, duplicate streams, unwrap nested optionals, and more!