<h2 id="introduction">Introduction</h2>
Whether you are creating a registration form for your website or you just need to delete all invalid email addresses from your mailing list, you can't help but perform the process of email validation.
<blockquote>
You need to validate if an email address is real by checking whether it meets the required form and can receive email messages. That must be performed efficiently and safely.
</blockquote>
That is where <code>email-validator</code> comes in. It is an easy to use, yet robust, Python library used to validate email addresses.
In this guide, we'll go over the basics of this library, discover when and why you could use it, as well as when not to. We'll go over these with practical examples that will help you understand how to use <code>email-validator</code>.
<h2 id="whatisemailvalidator">What is email-validator?</h2>
As we've previously stated, <code>email-validator</code> is a robust Python library that validates email addresses. It performs two types of validation - syntax validation and deliverability validation. That is important because the email address must meet the required form and have a resolvable domain name at the same time to be considered valid.

 <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">
 Syntax validation ensures that a string representation of an email address is of the form , such as <code>example@stackabuse.com</code>. 
Deliverability validation ensures that the syntactically correct email address has the domain name (the string after the <code>@</code> sign - <code>stackabuse.com</code>) that can be resolved.

 </div>
 </div>
 </div>
 In simple terms, it ensures that the validated email address can send and receive email messages.
On top of that, <code>email-validator</code> has a small bonus for us, if the email address is valid, <code>email-validator</code> can return its normalized form, so that we can store it in a database in a proper way. On the other hand, if an email address is invalid, <code>email-validator</code> will give us a clear and human-readable error message to help us understand why the passed email address is not valid.

 <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">
 In its simplest form, the normalization of an email address implies lowercasing the domain of an email address (the sequence after the <code>@</code> sign), because it is case-insensitive.

 </div>
 </div>
 </div>
 In more complex cases of normalization, where the domain part includes some Unicode characters, normalization covers a variety of conversions between Unicode and ASCII characters. The problem lies in the fact that different Unicode strings can look and mean the same to the end-user, so the normalization should ensure that those strings will be recorded in the same way because they actually represent the same domain.
It is important to mention that this library is not designed to work with an email address that doesn't meet the form of <code>example@domainname.com</code>.
<blockquote>
For example, it won't properly validate the <code>To:</code> line in an email message (for example, <code>To: Example Name &lt;example@domainname.com&gt;</code>).
</blockquote>
<h2 id="emailvalidatorvsregexforemailvalidation">email-validator vs RegEx for Email Validation</h2>
We usually use some kind of Regular Expression (RegEx) to validate the correct form of email addresses and it is a great choice if you only need to make sure that some email address meets the required form. It is a well-known technique, easy to write and maintain, and doesn't consume too much computing power to execute.
<blockquote>
If you'd like to read more about validating email addresses with RegEx - read our <a target="_blank" href="https://stackabuse.com/python-validate-email-address-with-regular-expressions-regex/">Python: Validate Email Address with Regular Expressions</a>!
</blockquote>
On the other hand, email address validation sometimes can be a lot more complex. A string containing an email address may meet the specified form of an email address, but still cannot be considered a proper email address, because the domain doesn't resolve.
<blockquote>
For instance, <code>example@ssstackabuse.com</code> meets the specified form of an email address, but isn't valid because the domain name (<code>ssstackabuse.com</code>) doesn't exist, therefore doesn't resolve and the example email address can't send and receive email messages.
</blockquote>
On the other hand, <code>example@stackabuse.com</code>, meets both requirements for a valid email address. It meets the desired form and the domain name resolves. Therefore, it can be considered a valid email address.
In that case, the <code>email-validator</code> provides a superior solution - it performs both syntax and deliverability validation with one simple function call, so there is no need to bother with making sure that the email address can actually send and receive emails. It would be impossible to code both of those verifications using just Regular Expressions.

 <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: It's factually impossible to guarantee whether an email will be received, or not, without sending an email and observing the result. You can, however, check if it could receive an email as a categorical possibility.

 </div>
 </div>
 </div>
 Those two things make a strong case in favor of <code>email-validator</code> against Regular Expressions. It is easier to use and still can perform more tasks more efficiently.
<h2 id="howtoinstallemailvalidator">How to Install email-validator?</h2>
The <code>email-validator</code> library is available on PyPI, so the installation is pretty straightforward via <code>pip</code> or <code>pip3</code>:
<pre><code class="hljs">$ pip install email-validator
$ pip3 install email-validator
</code></pre>
And now you have the <code>email-validator</code> ready to use in a Python script.
<h2 id="validateemailaddresswithemailvalidator">Validate Email Address with email-validator?</h2>
The core of the <code>email-validator</code> library is its <code>validate_email()</code> method. It takes a string representation of an email address as the argument and performs validation on that address. If the passed email address is valid, the <code>validate_email()</code> method will return an object containing a normalized form of the passed email address, but in the case of an invalid email address, it will raise the <code>EmailNotValidError</code> with a clear and human-readable error message that will help us understand why the passed email address is not valid.
<code>EmailNotValidError</code> is actually just an abstract class, which is used to detect that an error in a validation process occurred, hence, it is not used to represent and describe actual errors.
For that purpose, <code>EmailNotValidError</code> class has two subclasses describing actual errors that occurred. The first one is <code>EmailSynaxError</code> which is raised when a syntax validation fails, meaning that the passed email doesn't meet the required form of an email address. The second one is <code>EmailUndeliverableError</code> which is raised when a deliverability validation fails, meaning that the domain name of the passed email address doesn't exist.
Now we can finally take a look at how to use the <code>validate_email()</code> method. Of course, the first step is to import it to our script, and then we are ready to use it:
<pre><code class="hljs">from email_validator import validate_email

testEmail = &quot;example@stackabuse.com&quot;

emailObject = validate_email(testEmail)
print(emailObject.email)
</code></pre>
Since the passed <code>testEmail</code> is a valid email address, the previous code will output the normalized form of the email address stored in <code>testEmail</code> variable:
<pre><code class="hljs">example@stackabuse.com
</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: In the previous example, the output is the same as the original address from the <code>testEmail</code> because it was originally normalized. If you pass the unnormalized form of an email to the <code>validate_email()</code> method, the returned email address will be normalized, as expected.

 </div>
 </div>
 </div>
 If we change the original <code>testEmail</code> to <code>&quot;example@STACKabuse.com&quot;</code>, the previous code will still have the same output, because it's normalized:
<pre><code class="hljs">example@stackabuse.com
</code></pre>
On the other hand, if we pass the invalid email address to the <code>validate_email()</code> method, the previous code will prompt us with the corresponding error message. The following example of <code>testEmail</code> will pass the syntax validation, but fail the deliverability validation because the domain <code>ssstackabuse.com</code> doesn't exist:
<pre><code class="hljs">testEmail = &quot;example@ssstackabuse.com&quot;
</code></pre>
In this case, the previous code will prompt a long error amongst which is:
<pre><code class="hljs">&gt;&gt; ...
&gt;&gt; raise EmailUndeliverableError(&quot;The domain name %s does not exist.&quot; % domain_i18n)
email_validator.EmailUndeliverableError: The domain name ssstackabuse.com does not exist.
</code></pre>
Based on this prompt, we can conclude that the passed email is invalid because its domain name does not exist. The corresponding messages will also be prompted in the case of syntactically invalid emails so that we can easily conclude that the passed email address doesn't meet the required form of an email address.
You could extract a more user-friendly and human-readable error message from this as well, automatically. To extract just the error message from the previous prompt, we need to rewrite the previous code as follows:
<pre><code class="hljs">from email_validator import validate_email, EmailNotValidError

testEmail = &quot;examplestackabuse.com&quot;

try:
 # Validating the `testEmail`
 emailObject = validate_email(testEmail)

 # If the `testEmail` is valid
 # it is updated with its normalized form
 testEmail = emailObject.email
 print(testEmail)
except EmailNotValidError as errorMsg:
 # If `testEmail` is not valid
 # we print a human readable error message
 print(str(errorMsg))
</code></pre>
This code will output just a simple error message extracted from the previous prompt:
<pre><code class="hljs">The domain name ssstackabuse.com does not exist.
</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: We've taken advantage of the <code>EmailNotValidError</code> class. We've tried to execute the email validation in the <code>try</code> block and ensured that the error will be caught in the <code>except</code> block in case of failing the validation. There is no need to catch <code>EmailSyntaxError</code> or <code>EmailUndeliverableError</code> individually, because both of them are subclasses of the caught <code>EmailNotValidError</code> class, and the type of error can be easily determined by the printed error message.

 </div>
 </div>
 </div>
 <h3 id="validate_emailoptionalarguments">validate_email() - Optional Arguments</h3>
By default, the <code>validate_email()</code> method accepts only one argument - the string representation of the email address that needs to be validated, but can accept a few other keyword arguments:
<ul>
<li>allow_smtputf8 - the default value is <code>True</code>, if set to <code>False</code> the <code>validate_email()</code> won't validate internationalized email addresses, just ones that have a domain name consisting of ASCII characters only (no UTF-8 characters are allowed in a domain name in that case).</li>
<li>check_deliverability - the default value is <code>True</code>, if set to <code>False</code>, no deliverability validation is performed .</li>
<li>allow_empty_local - the default value is <code>False</code>, if set to <code>True</code>, the empty local part of an email address will be allowed (i.e. <code>@stackabuse.com</code> will be considered as the valid email address).</li>
</ul>
<h3 id="thevalidatedemailobject">The ValidatedEmail Object</h3>
You've probably noticed that we've been accessing the normalized form of an email address by <code>emailObject.email</code>. That is because the <code>validate_email()</code> method returns the <code>ValidatedEmail</code> object (in previous examples, it was stored in the <code>emailObject</code> variable) when a valid email address is passed as the argument.
The <code>ValidatedEmail</code> object contains multiple attributes which describe different parts of the normalized email address. The <code>email</code> attribute contains the normalized form of the validated email address, therefore, we need to access it using the <code>.</code> notation - <code>emailObject.email</code>.
<blockquote>
Generally, we can access any attribute of the <code>ValidatedEmail</code> object by using <code>variableName.attributeName</code> (where <code>variableName</code> is the variable used to store the <code>ValidatedEmail</code> object).
</blockquote>
For example, let's say that we've validated the <code>example@sTaCkABUSE.cOm</code> with the <code>validate_email()</code> method. The resulting <code>ValidatedEmail</code> object will contain some interesting and useful attributes as described in the following table:
<table class='table table-striped'>
<thead>
<tr>
<th align="center">Attribute Name</th>
<th>Example Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td align="center">email</td>
<td>example@stackabuse.com</td>
<td>Normalized form of an email address.</td>
</tr>
<tr>
<td align="center">ascii_email</td>
<td>example@stackabuse.com</td>
<td>ASCII only form of <code>email</code> attribute. If the <code>local_part</code> contains any kind of internationalized characters, this attribute will be set to <code>None</code>.</td>
</tr>
<tr>
<td align="center">local_part</td>
<td>example</td>
<td>The string before the <code>@</code> sign in the normalized form of the email address.</td>
</tr>
<tr>
<td align="center">ascii_local_part</td>
<td>example</td>
<td>If there are no internationalized characters, this attribute is set to ASCII only form of <code>local_part</code> attribute. Otherwise, it is set to <code>None</code>.</td>
</tr>
<tr>
<td align="center">domain</td>
<td>stackabuse.com</td>
<td>The string after the <code>@</code> sign in the normalized form of the email address. If it contains non-ASCII characters, the <code>smptutf8</code> attribute must be <code>True</code>.</td>
</tr>
<tr>
<td align="center">ascii_domain</td>
<td>stackabuse.com</td>
<td>ASCII only form of <code>domain</code> attribute.</td>
</tr>
<tr>
<td align="center">smtputf8</td>
<td>True</td>
<td>A boolean value. If the <code>allow_smtputf8=False</code> argument is passed to the <code>validate_email()</code> method, this argument is <code>False</code> and <code>True</code> otherwise.</td>
</tr>
</tbody>
</table>

 <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: ASCII variants of mentioned attributes are generated using the Punycode encoding syntax. It is an encoding syntax used to transform a Unicode string into an ASCII string for use with Internationalized Domain Names in Applications (IDNA).

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
All in all, the <code>email-validator</code> is a great tool for validating email addresses in Python.
In this guide, we've covered all the important aspects of using this library, so that you have a comprehensive view of it. You should be able to understand when and how to use the <code>email-validator</code>, as well as when to pick some alternative tool.

David Landup

Dimitrije Stamenic

In this guide, learn how to validate email addresses in Python with email-validator - checking their syntax and deliverability in one method, as well as how to handle errors and extract meaningful messages through practical examples.

Validate Email Addresses in Python with email-validator

<h2 id="introduction">Introduction</h2>
Reversing a string isn't uncommon in development, and fairly popular for entry-level interview questions. With JavaScript, we have many ways to reverse a string, which is somewhat similar to <a target="_blank" href="https://stackabuse.com/reverse-an-array-or-list-in-javascript/">reversing an array</a>. We can use a combination of string's <code>split()</code> method as well as array's <code>reverse()</code> and <code>join()</code> methods (since strings are ultimately arrays of characters).
We can also reverse a string with our own iterative (loop) or recursive functions.
<blockquote>
In this guide, we'll take a look at several ways to reverse a string in JavaScript.
</blockquote>
<h2 id="usingbuiltinmethodstoreversethestringsplitreverseandjoin">Using Built-in Methods to Reverse the String - split(), reverse() and join()</h2>
The simplest way to reverse a string in JavaScript is to split a string into an array, <code>reverse()</code> it and <code>join()</code> it back into a string. With ES6, this can be shortened and simplified down to:
<pre><code class="hljs">let string = &quot;!onaiP&quot;
string = [...string].reverse().join(&quot;&quot;);

console.log(string); // &quot;Piano!&quot;
</code></pre>
Here, the <a target="_blank" href="https://stackabuse.com/spread-operator-in-javascript/">Spread Syntax</a> is used to split the string into an array and is functionally equivalent to the <code>split()</code> method, which you could also use instead.
To understand why they all work together, let's overview what each function does.
<h3 id="split">split()</h3>
The <code>split()</code> method returns a new array of strings after splitting a string with the provided separator:
<pre><code class="hljs">string.split(separator, limit)
</code></pre>
The <code>separator</code> defines where the string splits into an element in the resulting array. We can define the number of the array element with the <code>limit</code> parameter. When we use the <code>split()</code> method with an empty string, <code>''</code>, the string will be split on every character. It will come in handy when we convert our string into an array of individual characters.
Again, you can use the spread operator to achieve the same result. The spread operator is a JavaScript operator that works on the iterables like an array, string, and objects. We can copy and concatenate objects and arrays using the spread operator:
<pre><code class="hljs">[...myVar, 4, 5, 6] // combines myVar array with the given elements
myFunc(...myVar) // Use the myVar&#x27;s elements as argument to the function
</code></pre>
When the spread operator is used with a string, the string is converted into a sequence of characters:
<pre><code class="hljs">let str = &#x27;hello&#x27;;
console.log([...str]); // [&quot;h&quot;,&quot;e&quot;,&quot;l&quot;,&quot;l&quot;,&quot;o&quot;]
console.log(str.split(&#x27;&#x27;)); // [&quot;h&quot;,&quot;e&quot;,&quot;l&quot;,&quot;l&quot;,&quot;o&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: While splitting UTF-16 characters, use the spread operator instead of the <code>split()</code> method.

 </div>
 </div>
 </div>
 <h3 id="reverse">reverse()</h3>
The <code>reverse()</code> returns a reversed array, in-place. That's to say - the original array is reversed instead of a copy that's returned as the result:
<pre><code class="hljs">let str = [&#x27;a&#x27;,&#x27;b&#x27;,&#x27;c&#x27;,&#x27;d&#x27;];
let reversedStr = str.reverse();
console.log(str); // [&quot;d&quot;,&quot;c&quot;,&quot;b&quot;,&quot;a&quot;]
console.log(reversedStr); // [&quot;d&quot;,&quot;c&quot;,&quot;b&quot;,&quot;a&quot;]
</code></pre>
You don't need to assign the result to a new variable, though, we commonly do in order to change the variable name to a more indicative one.
<h3 id="join">join()</h3>
The <code>join()</code> method concatenates the elements of an array and returns a string. We can also specify a <code>separator</code>, which is optional, to join the elements. When we use the default separator, the elements will be separated by a comma in the string. Using an empty string as the separator will concatenate the array elements and return as a string as usual:
<pre><code class="hljs">let str = [&#x27;a&#x27;,&#x27;b&#x27;,&#x27;c&#x27;,&#x27;d&#x27;];
console.log(str.join(&#x27;&#x27;)); // &quot;abcd&quot;
console.log(str.join()); // &quot;a,b,c,d&quot;
console.log(str.join(&#x27; - &#x27;)); // &quot;a - b - c - d&quot;
</code></pre>
<h3 id="combiningthebuiltinmethodstoreversethestring">Combining the Built-in Methods to Reverse the String</h3>
With all of that in mind - the way these work together becomes intuitive:
<pre><code class="hljs">let str = &#x27;guitar&#x27;;
console.log(&#x27;The original string is: &#x27; + str);
let splitStr = str.split(&#x27;&#x27;); // [&quot;g&quot;,&quot;u&quot;,&quot;i&quot;,&quot;t&quot;,&quot;a&quot;,&quot;r&quot;]
let reversedArr = splitStr.reverse();
let reversedStr = reversedArr.join(&#x27;&#x27;);
console.log(&quot;The reversed string is: &quot; + reversedStr);
</code></pre>
Or, you can shorten it down to:
<pre><code class="hljs">let reversedStr = [...str].reverse().join(&#x27;&#x27;);
// Or
let reversedStr = str.split(&#x27;&#x27;).reverse().join(&#x27;&#x27;);
</code></pre>
The code above results in:
<pre><code class="hljs">The original string is: guitar
The reversed string is: ratiug
</code></pre>
<h2 id="usingaforlooptoreversethestring">Using a for Loop to Reverse the String</h2>
With a for loop, we can iterate over each character from the string. Starting from the end of the string to the beginning of the string - we can continuously append the characters to a new string and thus form a reversed string:
<pre><code class="hljs">const str = &#x27;guitar&#x27;;
console.log(&#x27;The original string is: &#x27; + str);
let reversedStr = &#x27;&#x27;;

for (let i = str.length - 1; i &gt;= 0; i--) {
 reversedStr += str[i];
}

console.log(&#x27;The reversed string is: &#x27; + reversedStr);
</code></pre>
Here, we created an empty string, <code>reversedStr</code>, to hold the reversed string. String indices are like array indices, they start at 0. Therefore, we started the loop from one less than the length of the string (picking up the letter <code>r</code>) and loop till our counter goes to 0 (with the letter <code>g</code>).
The <code>reversedStr</code> variable concatenates the elements of the string.
Running the code gives us this output:
<pre><code class="hljs">The original string is: guitar
The reversed string is: ratiug
</code></pre>
<h2 id="usingrecursiontoreversethestring">Using Recursion to Reverse the String</h2>
Recursion is a process where a function calls itself. However, a function that calls itself may end up calling itself infinitely, and the process will never end without an exit condition. Therefore, we provide a condition, namely the base condition, to end the recursive behavior of the function.

 <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">
 We can use recursion to solve problems by writing very few lines of code without the hassle of iterating. However, this process can be slow if the recursion depth is high.

 </div>
 </div>
 </div>
 The syntax of a generic recursive function looks like this:
<pre><code class="hljs">function recursion(){
 .......
 base condition
 recursion()
 .......
}

recursion()
</code></pre>
When the <code>recursion()</code> function is called, it first checks some condition, and if evaluated to <code>true</code> - the function calls itself. This process is then repeated, again, and again. When the condition fails, the recursion is stopped, and the function returns a value.
<blockquote>
We can use recursion to reverse a string in JavaScript using some string methods like <code>substring()</code> and <code>charAt()</code>.
</blockquote>
The <code>substring()</code> method extracts a part of the string. We can pass the start and end indices in the method as the parameters. If only the start index is supplied to the method - it will extract the string from that index until the last one.
But, when we supply both the start and the end index, it will extract the string from the start index but does not include the end index:
<pre><code class="hljs">let str = &#x27;hello&#x27;
console.log(str.substring(1)) //&quot;ello&quot;
console.log(str.substring(1,3)) //&quot;el&quot;
</code></pre>
The <code>charAt()</code> method extracts the indexed character from a string. It returns a new string consisting of the character. An example of the method is shown below.
<pre><code class="hljs">let str = &#x27;hello&#x27;
console.log(str.charAt(2)) // &quot;l&quot;
</code></pre>
For our recursive function - we first check whether the string is empty as the base condition. After a series of recursive calls, the string will become empty, and the recursion will end. Inside the <code>reverse()</code> function, the recursive <code>reverse()</code> function is given <code>substring(1)</code> as its parameter.
The <code>charAt()</code> method is concatenated with the <code>reverse()</code> function in the return statement:
<pre><code class="hljs">function reverse(str) {
 if (str === &#x27;&#x27;)
 return &#x27;&#x27;;
 else
 return reverse(str.substring(1)) + str.charAt(0);
}

let str = &#x27;guitar&#x27;
console.log(&#x27;The original string is: &#x27; + str);
const output = reverse(str);
console.log(&#x27;The reversed string is: &#x27; + output);
</code></pre>
In the first recursive call, <code>reverse(&quot;guitar&quot;)</code> will result <code>reverse(&quot;uitar&quot;) + &quot;g&quot;</code>. In the second call, <code>reverse(&quot;uitar&quot;)</code> will result <code>reverse(&quot;itar&quot;) + &quot;u&quot;</code>. Likewise, the final recursive call, <code>reverse(&quot;o&quot;)</code> will return an <code>reverse(&quot;&quot;)+ &quot;r&quot;</code>.
Now the execution of the <code>else</code> part is terminated, and the recursion will travel back its depth. At the final call, the string <code>r</code> is added to <code>reverse('')</code>, which results in the string <code>r</code>.
Next, the function call moves one step above where the string <code>a</code> is added to <code>reverse(&quot;r&quot;)</code>. It makes the string <code>ra</code>. Likewise, <code>t</code> is added with <code>ra</code>, and it becomes <code>rat</code>. Similarly, the recursion depth is traversed upwards, and it finally returns the string <code>ratiug</code>:
<pre><code class="hljs">The original string is: guitar
The reversed string is: ratiug
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article we discussed how to reverse a string. We used the built-in <code>split()</code>, <code>reverse()</code> and <code>join()</code> methods, the spread operator, created a <code>for</code> loops that creates a new reversed string, and a recursive function using <code>substring()</code> and <code>charAt()</code> which all produced the same results.

Guest Contributor

Marcus Sanatan

In this article we reverse strings using the spread operator, built-in split(), reverse() and join() methods, creating for loops that creates a new reversed string, and a recursive function using substring() and charAt().

How to Reverse a String in JavaScript

Branko Ilic

In this tutorial, we'll take a look at how to convert and collect a stream into a map in Java 8 with a pair of mapper functions, a merge function and a supplier function, with practical examples and tips.

Guide to Java 8 Collectors: toMap()

<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 collect a stream into an unmodifiable collections.
</blockquote>
<h2 id="collectstreamintounmodifiablecollections">Collect Stream into Unmodifiable Collections</h2>
It's worth noting that there's a difference between an immutable and unmodifiable collection.
<blockquote>
You can't change the contents of an unmodifiable collection. But, if the source collection changes, the unmodifiable collection changes too. An immutable collection is one that is a result of copying a source collection to create a new one. This new one should be unmodifiable too.
</blockquote>
In the proceeding sections, we'll take a look at how you can collect a stream into an unmodifiable list, set or map. For this purpose, the regular <code>collect()</code> and <code>collectingAndThen()</code> methods do the trick. The former allows you to directly convert a stream into a collection, while the latter allows us to collect a stream into a regular collection, and then convert it into its unmodifiable counterpart through a separate function.
Instead, you could introduce other functions or chain the <code>collectingAndThen()</code> method to introduce new changes in the pipeline before collecting into an unmodifiable collection.
<blockquote>
If you'd like to read more about the regular <code>collect()</code> and advanced <code>collectingAndThen()</code>, read our <a target="_blank" href="https://stackabuse.com/java-8-streams-convert-a-stream-to-list/">Java 8 Streams: Convert a Stream to List</a> and <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-collectingandthen/">Guide to Java 8 Collectors: collectingAndThen()</a>!
</blockquote>
<h3 id="collectstreamintounmodifiablelist">Collect Stream into Unmodifiable List</h3>
Let's start out with a list. We'll use the standard <code>Collectors.toList()</code> collector, followed by a call to <code>unmodifiableList()</code> of the <code>Collections</code> class. Alternatively, you can supply a <code>toUnmodifiableList()</code> collector to the <code>collect()</code> method:
<pre><code class="hljs">Stream&lt;Integer&gt; intStream = Stream.of(1, 2, 3);

List&lt;Integer&gt; unmodifiableIntegerList1 = intStream.collect(Collectors.toUnmodifiableList());

List&lt;Integer&gt; unmodifiableIntegerList2 = intStream.collect(
 Collectors.collectingAndThen(
 Collectors.toList(),
 Collections::unmodifiableList
 )
);
</code></pre>
If we try to modify these lists, an <code>UnsupportedOperationException</code> should be thrown. Their <code>simpleName</code> should be <code>UnmodifiableRandomAccessList</code> and they should contain the exact same elements as seen in the stream:
<pre><code class="hljs">@Test
public void listShouldBeImmutable() {
 // Should contain elements 1, 2, and 3
 assertEquals(
 &quot;[1, 2, 3]&quot;,
 unmodifiableIntegerList1 .toString()
 );
 // Should be of type UnmodifiableList
 assertEquals(
 &quot;UnmodifiableRandomAccessList&quot;,
 unmodifiableIntegerList1 .getClass().getSimpleName()
 );
 // Should throw an exception when you attempt to modify it
 assertThrows(
 UnsupportedOperationException.class,
 () -&gt; unmodifiableIntegerList1 .add(4)
 );
}
</code></pre>
<h3 id="collectstreamintounmodifiableset">Collect Stream into Unmodifiable Set</h3>
If a stream you're dealing with has duplicates, and you'd like to get rid of them - the easiest way isn't to filter the list or keep track of the encountered elements in another list. The easiest solution to remove duplicates from a list is to box the list into a set, which doesn't allow for duplicates!
Again, the <code>collectingAndThen()</code> collector works wonders here, as you can collect the stream into a <code>Set</code> and convert it into an unmodifiable set in the downstream function:
<pre><code class="hljs">Stream&lt;Integer&gt; intStream = Stream.of(1, 1, 3, 2, 3);

Set&lt;Integer&gt; integerSet1 = intStream.collect(Collectors.toUnmodifiableSet());

Set&lt;Integer&gt; integerSet2 = intStream.collect(
 Collectors.collectingAndThen(
 Collectors.toSet(),
 Collections::unmodifiableSet
 )
);
</code></pre>
Then, the <code>Set</code> should be unmodifiable. Any change attempt should throw an <code>UnsupportedOperationException</code>:
<pre><code class="hljs">@Test
public void setShouldBeImmutable() {
 // Set shouldn&#x27;t contain duplicates
 assertEquals(
 &quot;[1, 2, 3]&quot;,
 integerSet1.toString()
 );
 // Set should be of type UnmodifiableSet
 assertEquals(
 &quot;UnmodifiableSet&quot;,
 integerSet1.getClass().getSimpleName()
 );
 // Set should not be modifiable
 assertThrows(
 UnsupportedOperationException.class,
 () -&gt; integerSet1.add(3)
 );
}
</code></pre>
<h3 id="collectstreamintounmodifiablemap">Collect Stream into Unmodifiable Map</h3>
Collecting to an unmodifiable map works in much the same way as the previous two, so let's try to spice it up a bit. Say you have a case where you want to store numbers and their square-value equivalents:
<table class="table table-striped">
 <tr>
 <td>Key</td>
 <td>Value</td>
 </tr>
 <tr>
 <td>2</td>
 <td>4</td>
 </tr>
 <tr>
 <td>3</td>
 <td>9</td>
 </tr>
 <tr>
 <td>4</td>
 <td>16</td>
 </tr>
</table>
But, when you receive duplicate keys, you don't want to repeat entries:
<table class="table table-striped">
 <tr>
 <td>Key</td>
 <td>Value</td>
 <td>Passes?</td>
 </tr>
 <tr>
 <td>2</td>
 <td>4</td>
 <td>YES</td>
 </tr>
 <tr>
 <td>3</td>
 <td>9</td>
 <td>YES</td>
 </tr>
 <tr>
 <td>4</td>
 <td>16</td>
 <td>YES</td>
 </tr>
 <tr>
 <td>4</td>
 <td>16</td>
 <td>NO</td>
 </tr>
</table>
Yet, the method, when converting into a map using the same approach we used before, there's no place to check for duplicate entries:
<pre><code class="hljs">Stream&lt;Integer&gt; stream = Stream.of(1, 2, 3, 4, 4);

Map&lt;Integer, Integer&gt; map1 = stream.collect(
 Collectors.toUnmodifiableMap(
 Function.identity(), 
 i -&gt; (int)Math.pow(i, 2)
 )
);

Map&lt;Integer, Integer&gt; map2 = stream.collect(
 Collectors.collectingAndThen(
 Collectors.toMap(
 // Key
 Function.identity(),
 // Value
 i -&gt; (int) Math.pow(i, 2)
 ),
 Collections::unmodifiableMap
 )
);
</code></pre>
Note the use of <code>Function.identity()</code> in the key mapper of the <code>Collectors.toMap()</code> method. The method <code>identity()</code> makes the mapper use the <code>Integer</code> element itself as the key of the map entry.
Thus, when you call it with duplicate entries, it always throws an <code>IllegalStateException</code>:
<pre><code class="hljs">Exception in thread &quot;main&quot; java.lang.IllegalStateException: 
Duplicate key 4 (attempted merging values 16 and 16)
</code></pre>
It's easy to remedy this problem with stream operations themselves, so the client doesn't have to worry about providing a clean list! Just by adding an intermediate <code>distinct()</code> operation to the stream, we can filter out duplicate values before collecting:
<pre><code class="hljs">Map&lt;Integer, Integer&gt; map1 = stream.distinct().collect(
 Collectors.toUnmodifiableMap(
 Function.identity(), 
 i -&gt; (int)Math.pow(i, 2)
 )
);

Map&lt;Integer, Integer&gt; map2 = stream.distinct().collect(
 Collectors.collectingAndThen(
 Collectors.toMap(
 // Key
 Function.identity(),
 // Value
 i -&gt; (int) Math.pow(i, 2)
 ),
 Collections::unmodifiableMap
 )
);
</code></pre>
Let's test the result:
<pre><code class="hljs">@Test
public void mapShouldBeImmutable() { 
 assertEquals(
 &quot;{1=1, 2=4, 3=9, 4=16}&quot;,
 map1.toString()
 );
 assertEquals(
 &quot;UnmodifiableMap&quot;,
 map1.getClass().getSimpleName()
 );
 assertThrows(
 UnsupportedOperationException.class,
 () -&gt; map1.put(5, 25)
 );
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to collect streams into unmodifiable collections - a list, set and map!
We've also taken a quick look at how to handle duplicate values, which can in some data structures, raise exceptions, and in others, cause silent failure.

Hiram Kamau

In this guide, learn how to convert/collect a Java 8 Stream into a Collection such as a List, Map or Set, with practical code examples!

Java 8 - Collect Stream into Unmodifiable List, Set or Map

Checkboxes are one of the several types of input fields we use very commonly to allow users to interact with web pages and typically POST data to a backend, by checking any box that applies to a given situation.
As opposed to Radio Buttons (which belong to Radio Groups) - checkboxes belonging to a single group aren't mutually exclusive so a user can select multiple boxes that apply. You should keep this in mind when checking whether any options are selected.
<blockquote>
In this guide, we'll take a look at how to check if a checkbox is checked in jQuery - a popular library for JavaScript, and Vanilla JavaScript.
</blockquote>
<h2 id="elementchecked">element.checked</h2>
Let's start out with a simple Checkbox setup:
<pre><code class="hljs">&lt;h1&gt;Check if Checkbox is Checked&lt;/h1&gt;
&lt;p&gt;Have you taken this test before?&lt;/p&gt;
&lt;input type=&quot;checkbox&quot; id=&quot;takenBefore&quot; placeholder=&quot;Yes&quot;&gt;
&lt;label for=&quot;takenBefore&quot;&gt;Yes&lt;/label&gt;

&lt;button id=&quot;button&quot;&gt; Check Checkbox &lt;/button&gt;
</code></pre>
In pure JavaScript - checking if a Checkbox is checked is as easy as accessing the <code>checked</code> field, represented by a boolean:
<pre><code class="hljs">// Get relevant element
checkBox = document.getElementById(&#x27;takenBefore&#x27;);
// Check if the element is selected/checked
if(checkBox.checked) {
 // Respond to the result
 alert(&quot;Checkbox checked!&quot;);
}
</code></pre>
However, this code will only ever run if you specifically run it. For instance, you could run it when the user submits a form or wishes to proceed to the next page as a validation step. Validation isn't commonly done this way, and typically delegated to libraries that are more robust. More commonly, you want to react to the checkbox to change something on the page - such as providing other input options.
In these cases, you'll want to add an event listener to the button, and let it listen to events, such as being clicked. When such an event occurs - you can decide to respond to the event:
<pre><code class="hljs">checkBox = document.getElementById(&#x27;takenBefore&#x27;).addEventListener(&#x27;click&#x27;, event =&gt; {
 if(event.target.checked) {
 alert(&quot;Checkbox checked!&quot;);
 }
});
</code></pre>
In this setup - the code is constantly waiting and listening to events on the element! Now as soon as someone clicks the Checkbox, your <code>alert()</code> method will execute. This time, however, to obtain the <code>checkBox</code> element, we procure it from the <code>event</code> instance, as the <code>target</code> of that event.
When you open the page up in a browser, and click the button, you'll be greeted with:
<img src="https://s3.stackabuse.com/media/articles/how-to-check-if-checkbox-is-checked-in-jquery-and-javascript-1.gif" alt="check if checkbox is checked with javascript">
<h2 id="element0checked">$('#element')[0].checked</h2>

 <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: jQuery is a popular JavaScript library, present in many projects around the world. Due to its light weight and features that expand the scope of JavaScript's built-in capabilities - it's become a staple. Not surprisingly - it can be used to check whether a Checkbox is selected or not.

 </div>
 </div>
 </div>
 We can use jQuery's selector syntax instead of pure JavaScript's to simplify both the selection of the element and the event listener attached to it.
<blockquote>
You can import jQuery in your page via a Content Delivery Network (CDN). You can use jQuery's own CDN for importing the library as well.
</blockquote>
<pre><code class="hljs">&lt;script src=&quot;https://code.jquery.com/jquery-3.6.0.min.js&quot;
 integrity=&quot;sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=&quot; 
 crossorigin=&quot;anonymous&quot;&gt;
&lt;/script&gt;
</code></pre>
To check whether a Checkbox has been checked, in jQuery, you can simply select the element, get its underlying object, instead of the jQuery object (<code>[0]</code>) and use the built-in <code>checked</code> property:
<pre><code class="hljs">let isChecked = $(&#x27;#takenBefore&#x27;)[0].checked
console.log(isChecked);
</code></pre>
Here, we'd be testing if the <code>takenBefore</code> checkbox is checked, by accessing it via jQuery's selector, and using the innate <code>checked</code> field as before.
Alternatively, you can define a listener that detects a change:
<pre><code class="hljs">$(&#x27;#takenBefore&#x27;).change(function() {
 alert(&#x27;Checkbox checked!&#x27;);
});
</code></pre>
This code is much simpler, but performs in much the same way as the pure JS solution! Clicking the checkbox will trigger an alert as before:
<img src="https://s3.stackabuse.com/media/articles/how-to-check-if-checkbox-is-checked-in-jquery-and-javascript-2.gif" alt="check if checkbox is checked with jquery">
<h2 id="elementischecked">$('#element').is(':checked'))</h2>
Instead of checking via the built-in <code>checked</code> property - we can offload the logic to the <code>is()</code> method. The <code>is()</code> method is a general method that can be used for many purposes - and returns a <code>true</code>/<code>false</code> based on the comparison criteria. The <code>:checked</code> selector was specifically made for checking whether a radio button or checkbox element had been selected or not.
So, if you combine these together, it's easy to check whether a checkbox <code>is(':checked')</code>:
<pre><code class="hljs">let isChecked = $(&#x27;#takenBefore&#x27;).is(&#x27;:checked&#x27;);
console.log(isChecked); // true (if checked at the time)
</code></pre>
<h2 id="elementpropchecked">$('#element').prop(&quot;checked&quot;)</h2>
In earlier versions of jQuery - <code>attr()</code> was used to access and manipulate fields of elements. In newer versions, the method was replaced with <code>prop()</code>. It can work as a getter/setter for properties of elements, and in our case - as a wrapper for getting the <code>checked</code> property of an element.
<pre><code class="hljs">let isChecked = $(&#x27;#takenBefore&#x27;).prop(&#x27;checked&#x27;);
console.log(isChecked); // true (if checked at the time)
</code></pre>
<h2 id="isvsprop">is() vs prop()?</h2>
<blockquote>
So, what's the difference between <code>is()</code> and <code>prop()</code> in this context?
</blockquote>
Both methods appear to work in much the same way from our perspective. So, what's the difference?
<code>is()</code> has a bit more overhead processing and parsing than <code>prop()</code>. Even considering the fact that <code>prop()</code> doesn't just access the property and does some validation, it's more performant when it comes to processing a large number of inputs, say, in a loop.
On the other hand - <code>is()</code> always returns a <code>boolean</code> value, whereas <code>prop()</code> just returns the underlying property's type. You can't guarantee that something else sneaked in, and your code may fail at runtime if you don't use <code>prop()</code> properly. <code>is()</code> also semantically indicates the return value - a <code>boolean</code>, which makes it a more readable option.
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to check whether a checkbox is checked with JavaScript and jQuery.
We've used the <code>checked</code> property - directly and indirectly, followed by the <code>is()</code> and <code>prop()</code> methods, as well as taken a quick look as to which you could prefer.

In this short guide, learn how to check if a checkbox has been checked in JavaScript with jQuery - using the checked property, is() and prop() methods!

How to Check if Checkbox is Checked in jQuery and JavaScript

<h2 id="introduction">Introduction</h2>
The <code>or</code> operator is one of the three existing logical operators in Python (<code>and</code>, <code>or</code>, <code>not</code>), which perform a logical evaluation of the passed operands.
In simple terms, when two operands are passed, it will decide whether the final value of the created logical expression is <code>True</code> or <code>False</code>. The mechanism used to evaluate the value of the final expression is based on the set of rules known as Boolean algebra.
<blockquote>
In this guide, we'll cover the <code>or</code> operator in Python as well as its most common use cases.
</blockquote>
<h2 id="oroperatorbasics">or Operator Basics</h2>
Python's <code>or</code> operator just performs logical disjunction on the two provided operands. Assuming that the operands are simply two Boolean values, the rule on how to use the <code>or</code> operator is pretty straight-forward:
<blockquote>
If either one of two operands has the value <code>True</code>, the whole expression has the value <code>True</code>. In all other cases, the whole expression has the value <code>False</code>.
</blockquote>
Now let's take a look at the truth table of the <code>or</code> operator:
<table class="table table-striped">
 <tr>
 <td>Operand 1</td>
 <td>Operand 2</td>
 <td>OR Expression Value</td>
 </tr>
 <tr>
 <td>True</td>
 <td>True</td>
 <td>True</td>
 </tr>
 <tr>
 <td>True</td>
 <td>False</td>
 <td>True</td>
 </tr>
 <tr>
 <td>False</td>
 <td>True</td>
 <td>True</td>
 </tr>
 <tr>
 <td>False</td>
 <td>False</td>
 <td>False</td>
 </tr>
</table>
This table describes the law of logical disjunction. By looking at this table, we can see that the <code>or</code> operator produces <code>False</code> as the result only if both of the operands are <code>False</code> as well.
All of this leads us to the concept of lazy evaluation. A mechanism used to optimize calculations of mathematical operations. In this particular case, it is used to speed up the process of evaluating Boolean expressions with the <code>or</code> operator.
We already know that an <code>or</code> expression results in a <code>True</code> value if either of its two operands is <code>True</code>. Therefore, in a Boolean expression consisting of multiple operands, it is completely unnecessary to evaluate each one of them individually.
It's enough just to read the values of operands one after the other. When we come across a <code>True</code> for the first time, we can safely just ignore all of the other operands and just evaluate the whole expression as <code>True</code>.
On the other hand, if there is no operand with the value <code>True</code>, we must evaluate the whole expression with the value <code>False</code>. That is the basic principle of lazy evaluation - don't evaluate if you don't have to.
<h2 id="usingoronbooleanvariables">Using or on Boolean Variables</h2>
The <code>or</code> operator in Python is used to evaluate two of its operands. In this section, we'll focus on the case where both of the operands have Boolean values. In some cases, the <code>or</code> operator can be used with non-Boolean values, which we'll discuss in the following sections.
Let's take a look at how to use the <code>or</code> operator with two Boolean values:
<pre><code class="hljs"># Two Boolean values
result1 = True or False # Expected to be `True`
result2 = False or False # Expected to be `False`

print(&#x27;R1:&#x27;, result1)
print(&#x27;R2:&#x27;, result2)
</code></pre>
In this example, we can see how the <code>or</code> operator evaluates expressions consisting only of simple Boolean values. As described in the previous sections, this piece of code will have the following output:
<pre><code class="hljs">R1: True
R2: False
</code></pre>
In the previous example, we've named Boolean expressions <code>result1</code> and <code>result2</code>. That way, we've created two Boolean variables with values <code>True</code> and <code>False</code>, respectively.
Those two variables can be used as the operands of another Boolean expression and, therefore, could be considered as subexpressions of the more complex Boolean expression. That's the general principle used to build more complex Boolean expressions layer by layer:
<pre><code class="hljs">result3 = result1 or result2 # `True` or `False` &lt;=&gt; `True`
result4 = result3 or True # `True` or `True` &lt;=&gt; `True`

print(&#x27;R3:&#x27;, result3)
print(&#x27;R4:&#x27;, result4)
</code></pre>
As expected, this will output:
<pre><code class="hljs">R3: True
R4: True
</code></pre>
<code>result4</code> is a complex Boolean expression consisting of multiple subexpressions and Boolean values. Let's take a look at the process of unfolding it:
<pre><code class="hljs">1. result4 = result3 or True
2. result4 = (result1 or result2) or True
3. result4 = ((True or False) or (False or False)) or True
</code></pre>
Based on the associative law for the <code>or</code> operator, we know that the order in which we apply the operator doesn't have an impact on the value of the Boolean expression, so there is no need for brackets. Therefore, we can transform <code>result4</code> one step further by deleting all of the brackets:
<pre><code class="hljs"> result4 = True or False or False or False or True
</code></pre>
<h2 id="usingoronnonbooleanvariables">Using or on Non-Boolean Variables</h2>
The <code>or</code> operator in Python can also be used with variables other than Boolean. You can even mix and match Boolean variables with non-Boolean variables. In this section, we'll go over some examples that illustrate the usage of the <code>or</code> operator with variables of different data types.
Generally speaking, any object or a variable in Python is considered to be <code>True</code> unless its class has a predefined <code>__bool__()</code> method that returns <code>False</code> or a <code>__len__()</code> method that returns <code>0</code>.
In simple terms that means that only objects considered to be <code>False</code> are those which are predefined to be <code>False</code> or those which are empty - empty lists, tuples, strings, dictionaries... <a target="_blank" rel="nofollow noopener noreferrer" href="https://docs.python.org/3/library/stdtypes.html">The Official Python documentation</a> gives us the list of some of the most common built-in objects considered to be <code>False</code>:
<ul>
<li>Constants defined to be false: <code>None</code> and <code>False</code>.</li>
<li>Zero of any numeric type: <code>0</code>, <code>0.0</code>, <code>0j</code>, <code>Decimal(0)</code>, <code>Fraction(0, 1)</code></li>
<li>Empty sequences and collections: <code>''</code>, <code>()</code>, <code>[]</code>, <code>{}</code>, <code>set()</code>, <code>range(0)</code></li>
</ul>

 <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: These are also known as Falsy Values - the ones you'd intuitively be able to reduce to a <code>False</code> boolean value. The opposite values are Truthy Values.

 </div>
 </div>
 </div>
 <blockquote>
Another very important fact is that the <code>or</code> operator in this case returns the actual object, not the <code>True/False</code> value of the object.
</blockquote>
Let's take a look at the example that illustrates mentioned behavior:
<pre><code class="hljs">exp = {} or &#x27;This is a string&#x27;
</code></pre>
As stated before, the first operand - <code>{}</code> (empty dictionary) is considered to be <code>False</code> and the second operand - <code>'This is a string'</code> (not an empty string) is considered to be <code>True</code>. This means that the previous expression is implicitly transformed to:
<pre><code class="hljs"># exp = False or True
</code></pre>
Here, <code>exp</code> is evaluated to <code>True</code>. But, when we try to print the original <code>exp</code> value, instead of <code>True</code>, the output will be:
<pre><code class="hljs">&#x27;This is a string&#x27;
</code></pre>
This example illustrates the case when the <code>or</code> operator returns the object itself instead of its <code>True/False</code> value. To sum this behavior up, we can illustrate it with the altered (truth) table of the <code>or</code> operator:
<table class='table table-striped'>
 <tr>
 <td>object1 (value)</td>
 <td>object2 (value)</td>
 <td>object1 `or` object2 (return value)</td>
 </tr>
 <tr>
 <td>True</td>
 <td>True</td>
 <td>object1</td>
 </tr>
 <tr>
 <td>True</td>
 <td>False</td>
 <td>object1</td>
 </tr>
 <tr>
 <td>False</td>
 <td>True</td>
 <td>object2</td>
 </tr>
 <tr>
 <td>False</td>
 <td>False</td>
 <td>object2</td>
 </tr>
</table>
This also applies when we combine usual Boolean values and objects in Boolean expressions.
If the expression contains at least one value that is considered to be <code>True</code>, the value of the expression is <code>True</code>, but the return value can vary based on the first <code>True</code> element in it.
If the first <code>True</code> operand to be found in the expression is a simple Boolean value, the return value will be <code>True</code>, but if the first <code>True</code> element is some sort of an object, the return value will be that object itself. For example, the following expression will return <code>True</code>:
<pre><code class="hljs">0 or True 
</code></pre>
And the following expression will return <code>[1, 2, 3]</code>, which is the first <code>True</code> operand found:
<pre><code class="hljs">False or [1, 2, 3]
</code></pre>
On the other hand, if a Boolean expression is <code>False</code>, meaning that no <code>True</code> operand was found, its return value will be its last operand, either object or <code>False</code>:
<pre><code class="hljs">{} or 0.0 or [] or False or ()
# Output &gt;&gt; ()
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we've explained the usage of the <code>or</code> operator in Python. We've introduced the syntax in Python and described how the <code>or</code> operator evaluates Boolean expressions and how it determine the proper return value based on the operands.
Besides its primary usage for evaluating Boolean expressions, the <code>or</code> operator can also be pretty useful in some other use cases.
Its features make it a good choice when you need to set default values for some variables or a default return value of a function and much more, but those special use cases are far beyond the scope of this article, so we'll let you explore all the use cases that the <code>or</code> operator can be utilized in.

Vladimir Batoćanin

In this guide, we'll take a look at how to use the Python or operator, how Boolean algebra works, what truthy and falsy values are in Python, as well as how to use the or operator both with boolean and non-boolean values.

Guide to the Python or Operator

Reham Muzzamil

In this guide, learn what the difference is between Java 8's map() and flatMap() methods are, in the context of Optionals and the Stream API, with practical code examples and use cases.

Java 8 - Difference Between map() and flatMap()

<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 collect and reverse a list in Java.
</blockquote>
<h2 id="collectandreversealistinjava">Collect and Reverse a List in Java</h2>
The first approach would be to <code>collect()</code> the stream into a list - and then use the <code>Collections.reverse()</code> method on the list, which reverses it in-place.

 <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: If you also want to sort the collection while reversing it, you can use the <code>sorted(Comparator.reverseOrder())</code> method in the chain. However, this will impose a completely new relative order of elements.

 </div>
 </div>
 </div>
 Let's define a stream with some elements, collect it into a list, reverse the list and print it:
<pre><code class="hljs">Stream&lt;?&gt; s = Stream.of(1, 2, 3, 4, 5);

List&lt;?&gt; list = s.collect(Collectors.toList());
Collections.reverse(list);
System.out.println(list);
</code></pre>
This results in:
<pre><code class="hljs">[5, 4, 3, 2, 1]
</code></pre>
This works well, but there's a simpler way to do this - all in one method. The <code>collectingAndThen()</code> method allows us to chuck in an additional finishing transformation <code>Function</code> besides the <code>collect()</code> method. This way, we can collect the stream and perform the <code>Collections.reverse()</code> call in the same <code>collect()</code> call!
<h2 id="collectandreversealistwithcollectingandthen">Collect and Reverse a List with collectingAndThen()</h2>
<blockquote>
If you'd like to read more about <code>collectingAndThen()</code> - read our detailed, definitive <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-collectingandthen/">Guide to Java 8 Collectors: collectingAndThen()</a>!
</blockquote>
Let's take a look at how we can use <code>collectingAndThen()</code> to bundle the transformations into a single call:
<pre><code class="hljs">Stream&lt;?&gt; s = Stream.of(1, 2, 3, 4, 5);

List&lt;?&gt; list = s.collect(
 Collectors.collectingAndThen(
 Collectors.toList(),
 l -&gt; {Collections.reverse(l); return l; }
 )
);

System.out.println(list);
</code></pre>
Here, we've supplied an adapter <code>Collector</code> to the <code>collect()</code> method. The adapted collector runs <code>Collectors.toList()</code>, and a Lambda function to reverse and return the reversed list. Finally - the returned value is assigned to the <code>list</code> reference variable!
<blockquote>
If you'd like to read more about Functional Interfaces and Lambda Expressions in Java - 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>
This results in:
<pre><code class="hljs">[5, 4, 3, 2, 1]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how you can collect and reverse a stream/list in Java 8, using <code>collect()</code> and <code>Collections.reverse()</code> - individually, and together through the <code>collectingAndThen()</code> method.

In this tutorial, learn how to collect and reverse a stream into a list in Java 8 with Collectors.toList() and Collections.reverse(), as well as Collectors.collectingAndThen()!

Java 8 Streams - Collect and Reverse Stream into List

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...