<h2 id="introduction">Introduction</h2>
Lists are one of the four most commonly used data structures provided by Python. Its functionality, extensibility, and ease of use make it useful for implementing various types of functionalities.
Python lists have a few interesting characteristics:
<ol>
<li>Mutability - meaning it can change, which means it allows us to easily add and delete entries from it. This is the main difference between Python lists and tuples</li>
<li>Iterability - which means we can iterate through it (go through all elements in the list in-order)</li>
</ol>
The main attribute that will be focusing on is Iterability. An important part when dealing with an iterable object, in this case a list, is checking if there's anything to iterate through. If not handled properly, this can lead to a lot of unwanted errors.
Python provides various ways to check if our list is empty or not, some implicit and some explicit, and in this article, we'll go over how to check if a Python list is empty.
<ul>
<li><a href="#usinglenfunction">Using the <code>len()</code> Function</a></li>
<li><a href="#usinglenwithcomparisonoperator">Using <code>len()</code> With a Comparison Operator</a></li>
<li><a href="#comparisonwithemptylist">Comparison with Empty List</a></li>
<li><a href="#pep8recommendedstyle">Pep-8 Recommended Style</a> (Most Popular and Advised)</li>
<li><a href="#usingboolfunction">Using the <code>bool()</code> Function</a></li>
</ul>
<h2 id="usinglenfunction">Using <code>len()</code> Function</h2>
One of the techniques is to use the <code>len()</code> function to check if our list is empty or not:
<pre><code class="hljs">py_list = []

&quot;&quot;&quot;
Here len() returns 0, which is 
implicitly converted to false
&quot;&quot;&quot;

if len(py_list):
 print(&#x27;The list is not empty&#x27;)
else:
 print(&#x27;T list is empty&#x27;)
</code></pre>
Output
<pre><code class="hljs">List is empty
</code></pre>
When <code>len(py_list)</code> executes it produces zero, which is then implicitly cast to the boolean value of <code>False</code>. Thus in case of an empty list the program will be redirected to the else block.
Although this method looks simple, it's not that intuitive for beginners.
<h2 id="usinglenwithcomparisonoperator">Using len() With Comparison Operator</h2>
This technique is similar to the one above but it is more explicit and easy to understand. That's why those who are new to python or coding itself usually consider it more intuitive:
<pre><code class="hljs">if len(py_list) == 0:
 print(&#x27;List is empty&#x27;)
else:
 print(&#x27;List not empty&#x27;)
</code></pre>
In the code above, <code>len(py_list) == 0</code> will be true if the list is empty and will will be redirected to the else block. This also allows you to set other values as well, rather than relying on <code>0</code> being converted as <code>False</code>. All other positive values are converted to <code>True</code>.
<h2 id="comparisonwithemptylist">Comparison With Empty List</h2>
This method is also very simple and works well for beginners as it involves comparing with an empty list:
<pre><code class="hljs">if py_list == []:
 print(&#x27;List is empty&#x27;)
else:
 print(&#x27;List is not empty&#x27;)
</code></pre>
Here again, we are using the comparison operation to compare one list with another - an empty one, and if both are empty the <code>if</code> block will execute.
<h2 id="pep8recommendedstyle">Pep-8 Recommended Style</h2>
<pre><code class="hljs">#PEP-8 recommended style

if py_list:
 print(&#x27;List is not empty&#x27;)
if not py_list:
 print(&#x27;List empty&#x27;)
</code></pre>
For this, let's take a look at <a rel="nofollow noopener" target="_blank" href="https://docs.python.org/3/library/stdtypes.html#truth-value-testing">Truth Value Testing</a>. The official docs state that:
<blockquote>
Here are most of the built-in objects considered false:
<ul>
<li>constants defined to be false: None and False.</li>
<li>zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)</li>
<li>empty sequences and collections: '', (), [], {}, set(), range(0)</li>
</ul>
</blockquote>
As an empty list is in fact just an empty collection, it will be converted to a boolean value of <code>False</code>. Therefore, if <code>py_list</code> is empty, it will be converted to <code>False</code>.
The second statement is pretty similar, except <code>not</code> will invert a false condition to a true one. This approach is very similar to the <code>if(len(list))</code> approach.
This is the preferred approach as it's the cleanest and shortest solution there is.
<h2 id="usingboolfunction">Using bool() Function</h2>
We can also use the <code>bool()</code> function to verify a list is empty:
<pre><code class="hljs">#As truth value testing says [] braces denotes false

if bool(py_list):
 print(&#x27;List is not empty&#x27;)
else:
 print(&#x27;List is empty&#x27;)
</code></pre>
This is basically a manually implemented truth value test. So if the list is not empty the function will return <code>True</code> and if block will be executed.
This approach is less common as we can achieve the desired results even without using <code>bool()</code>, but it's not a bad thing to know how Python works under the hood.
<h2 id="conclusion">Conclusion</h2>
This article was all about ways to check if our python list is empty or not. We started by exploring different techniques and finally looking into some parameters that we can use to make our judgment regarding which technique may work for us.
I can't say that this is the end as new Python updates may give rise to new and more improved coding styles. So it's better to keep exploring and keep learning.

Guest Contributor

In this tutorial, we'll go over examples on How to Check if List is Empty in Python. We'll be using the len() function, Pep-8 Recommended Style, as well as the bool() function.

How to Check if List is Empty in Python

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to change the marker size in a Matplotlib scatter plot.
<h2 id="importdata">Import Data</h2>
We'll use the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/unsdsn/world-happiness">World Happiness</a> dataset, and compare the Happiness Score against varying features to see what influences perceived happiness in the world:
<pre><code class="hljs">import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2019.csv&#x27;)
</code></pre>
Then, we can easily manipulate the size of the markers used to represent entries in this dataset.
<h2 id="changemarkersizeinmatplotlibscatterplot">Change Marker Size in Matplotlib Scatter Plot</h2>
Let's start off by plotting the generosity score against the GDP per capita:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2019.csv&#x27;)

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;])
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-1.png" alt="matplotlib scatter plot">
Now, let's say we'd like to increase the size of each marker, based on the perceived happiness of the inhabitants of that country. The happiness score is a list, coming straight from the <code>df</code>, so this can work with other lists as well.
To change the size of the markers, we use the <code>s</code> argument, for the <code>scatter()</code> function. This will be the <code>markersize</code> argument for the <code>plot()</code> function:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2019.csv&#x27;)

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;], s = df[&#x27;Score&#x27;]*25)
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
We've also multiplied the value of each element in the list by an arbitrary number of 25, because they're ranked from <code>0..1</code>. This will produce really small markers if we use them in their original values.
This now results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-2.png" alt="matplotlib change scatter plot marker size">
Or better yet, instead of crudely multiplying everything by 25, since the values are similar anyway, we can do something like this:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2019.csv&#x27;)

size = df[&#x27;Score&#x27;].to_numpy()
s = [3*s**2 for s in size]

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;], s = s)
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
It's important to have the <code>s</code> list the same length as <code>x</code> and <code>y</code>, as each value from <code>s</code> now gets applied to them. If the list is shorter or longer, the code will break.
Here, we've extracted the values from the <code>Score</code> column, scaled them and applied the size back to the scatter plot:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-4.png" alt="scaled marker size scatter plot matplotlib">
<h2 id="setglobalmarkersizeinmatplotlibscatterplot">Set Global Marker Size in Matplotlib Scatter Plot</h2>
If you'd like to detach the marker size from some variable, and would just like to set a standard, global size of markers in the scatter plot, you can simply pass in a single value for <code>s</code>:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv(&#x27;worldHappiness2019.csv&#x27;)

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(x = df[&#x27;GDP per capita&#x27;], y = df[&#x27;Generosity&#x27;], s = 100)
plt.xlabel(&quot;GDP per Capita&quot;)
plt.ylabel(&quot;Generosity Score&quot;)

plt.show()
</code></pre>
This now results in:
<img src="https://stackabuse.s3.amazonaws.com/media/matplotlib-change-scatter-plot-marker-size-3.png" alt="global marker size matplotlib scatter plot">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over how to change the marker size in a Matplotlib Scatter Plot.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with theses libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth, guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, cover core plotting libraries like Matplotlib and Seaborn, and show you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

David Landup

In this tutorial, we'll go over examples of how to change the marker size of an individual, as well as all markers in a Matplotlib Scatter Plot using Python.

Matplotlib: Change Scatter Plot Marker Size

Rayven Yor Esplanada

In this tutorial, we'll build a demo Spring Boot REST API application, with CRUD functionality. We'll cover database setup, the domain model, persistence layer as well as the business layer.

Build a Spring Boot REST API with Java - Full Guide

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its hierarchy of objects.
In this tutorial, we'll take a look at how to rotate tick text/labels in a Matplotlib plot.
<h2 id="creatingaplot">Creating a Plot</h2>
Let's create a simple plot first:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/%7Frotate-axis-labels-in-matplotlib-1.png" alt="simple matplotlib plot">
<h2 id="rotatexaxisticklabelsinmatplotlib">Rotate X-Axis Tick Labels in Matplotlib</h2>
Now, let's take a look at how we can rotate the X-Axis tick labels here. There are two ways to go about it - change it on the Figure-level using <code>plt.xticks()</code> or change it on an Axes-level by using <code>tick.set_rotation()</code> individually, or even by using <code>ax.set_xticklabels()</code> and <code>ax.xtick_params()</code>.
Let's start off with the first option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.xticks(rotation = 45) # Rotates X-Axis Ticks by 45-degrees
plt.show()
</code></pre>
Here, we've set the <code>rotation</code> of <code>xticks</code> to 45, signifying a 45-degree tilt, counterclockwise:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-2.png" alt="rotate x-axis label with xticks">

 <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: This function, like all others here, should be called after <code>plt.plot()</code>, lest the ticks end up being potentially cropped or misplaced.

 </div>
 </div>
 </div>
 Another option would be to get the current <code>Axes</code> object and call <code>ax.set_xticklabels()</code> on it. Here we can set the labels, as well as their rotation:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

ax.set_xticklabels(ax.get_xticks(), rotation = 45)

plt.show()
</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: For this approach to work, you'll need to call <code>plt.draw()</code> before accessing or setting the X tick labels. This is because the labels are populated after the plot is drawn, otherwise, they'll return empty text values.

 </div>
 </div>
 </div>
 <img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-3.png" alt="rotate x axis labels with xticklabels">
Alternatively, we could've iterated over the <code>tick</code>s in the <code>ax.get_xticklabels()</code> list. Then, we can call <code>tick.set_rotation()</code> on each of them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

for tick in ax.get_xticklabels():
 tick.set_rotation(45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-4.png" alt="rotate x axis labels with set_rotation">
And finally, you can use the <code>ax.tick_params()</code> function and set the label rotation there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
ax.tick_params(axis=&#x27;x&#x27;, labelrotation = 45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-4.png" alt="rotate x axis labels with tick_params">
<h2 id="rotateyaxisticklabelsinmatplotlib">Rotate Y-Axis Tick Labels in Matplotlib</h2>
The exact same steps can be applied for the Y-Axis tick labels.
Firstly, you can change it on the Figure-level with <code>plt.yticks()</code>, or on the Axes-level by using <code>tick.set_rotation()</code> or by manipulating the <code>ax.set_yticklabels()</code> and <code>ax.tick_params()</code>.
Let's start off with the first option:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)
plt.yticks(rotation = 45)
plt.show()
</code></pre>
Same as last time, this sets the <code>rotation</code> of <code>yticks</code> by 45-degrees:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-5.png" alt="rotate y axis labels yticks">
Now, let's work directly with the <code>Axes</code> object:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

ax.set_yticklabels(ax.get_yticks(), rotation = 45)

plt.show()
</code></pre>
The same note applies here, you have to call <code>plt.draw()</code> before this call to make it work correctly.
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-6.png" alt="rotate y axis labels with yticklabels">
Now, let's iterate over the list of <code>tick</code>s and <code>set_rotation()</code> on each of them:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
plt.draw()

for tick in ax.get_yticklabels():
 tick.set_rotation(45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-7.png" alt="rotate y axis labels with set_rotation">
And finally, you can use the <code>ax.tick_params()</code> function and set the label rotation there:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 10, 0.1)
y = np.sin(x)

plt.plot(x, y)

ax = plt.gca()
ax.tick_params(axis=&#x27;y&#x27;, labelrotation = 45)
plt.show()
</code></pre>
This also results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-7.png" alt="rotate y axis labels with tick_params">
<h2 id="rotatedatestofitinmatplotlib">Rotate Dates to Fit in Matplotlib</h2>
Most often, the reason people rotate ticks in their plots is because they contain dates. Dates can get long, and even with a small dataset, they'll start overlapping and will quickly become unreadable.
Of course, you can rotate them like we did before, usually, a 45-degree tilt will solve most of the problems, while a 90-degree tilt will free up even more.
Though, there's another option for rotating and fixing dates in Matplotlib, which is even easier than the previous methods - <code>fig.autofmt__date()</code>.
This function can be used either as <code>fig.autofmt_xdate()</code> or <code>fig.autofmt_ydate()</code> for the two different axes.
Let's take a look at how we can use it on the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rtatman/did-it-rain-in-seattle-19482017">Seattle Weather Dataset</a>:
<pre><code class="hljs">import pandas as pd
import matplotlib.pyplot as plt

weather_data = pd.read_csv(&quot;seattleWeather.csv&quot;)

fig = plt.figure()
plt.plot(weather_data[&#x27;DATE&#x27;], weather_data[&#x27;PRCP&#x27;])
fig.autofmt_xdate()
plt.show()
</code></pre>
This results in:
<img src="https://stackabuse.s3.amazonaws.com/media/rotate-axis-labels-in-matplotlib-8.png" alt="auto format dates to fit in matplotlib">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to rotate Axis text/labels in a Matplotlib plot, including a specific way to format and fit dates .
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

In this tutorial, we'll go over examples on how to rotate the axis text or labels in a Matplotlib plot. We'll work on a figure-level and an axes-level, with several methods.

Rotate Axis Labels in Matplotlib

<h2 id="introduction">Introduction</h2>
Key-value stores are essential and often used, especially in operations that require fast and frequent lookups. They allow an object - the key - to be mapped to another object, the value. This way, the values can easily be retrieved, by looking up the key.
In Java, the most popular <code>Map</code> implementation is the <code>HashMap</code> class. Aside from key-value mapping, it's used in code that requires frequest insertions, updates and lookups. The insert and lookup time is a constant O(1).
In this tutorial, we'll go over how to get the Keys and Values of a map in Java.
<h2 id="getkeysandvaluesentriesfromjavamap">Get Keys and Values (Entries) from Java Map</h2>
Most of the time, you're storing key-value pairs because both pieces of info are important. Thus, in most cases, you'll want to get the key-value pair together.
The <code>entrySet()</code> method returns a set of <code>Map.Entry&lt;K, V&gt;</code> objects that reside in the map. You can easily iterate over this set to get the keys and their associated values from a map.
Let's populate a <code>HashMap</code> with some values:
<pre><code class="hljs">Map&lt;String, Integer&gt; map = new HashMap&lt;&gt;();
 
map.put(&quot;David&quot;, 24);
map.put(&quot;John&quot;, 35);
map.put(&quot;Jane&quot;, 19);
map.put(&quot;Billy&quot;, 21);
</code></pre>
Now, let's iterate over this map, by going over each <code>Map.Entry&lt;K,V&gt;</code> in the <code>entrySet()</code>, and extracing the key and value from each of those entries:
<pre><code class="hljs">for (Map.Entry&lt;String, Integer&gt; pair : map.entrySet()) {
 System.out.println(String.format(&quot;Key (name) is: %s, Value (age) is : %s&quot;, pair.getKey(), pair.getValue())); 
}
</code></pre>
This results in:
<pre><code class="hljs">Key (name) is: Billy, Value (age) is: 21
Key (name) is: David, Value (age) is: 24
Key (name) is: John, Value (age) is: 35
Key (name) is: Jane, Value (age) is: 19
</code></pre>
<h2 id="getkeysandvaluesentriesfromjavamapwithforeach">Get Keys and Values (Entries) from Java Map with forEach()</h2>
Java 8 introduces us to the <code>forEach()</code> method for collections. It accepts a <code>BiConsumer&lt;? super K, ? super V&gt; action</code>. The <code>forEach()</code> method performs the given <code>BiConsumer</code> action on each entry of the <code>HashMap</code>.
Let's use the same map from before, but this time, add a year to each of the entries' ages:
<pre><code class="hljs">map.forEach((key, value) -&gt; System.out.println(key + &quot; : &quot; + value));
</code></pre>
This prints out:
<pre><code class="hljs">Billy : 21
David : 24
John : 35
Jane : 19
</code></pre>
Or, instead of consuming each <code>key</code> and <code>value</code> from the map, you can use a regular <code>Consumer</code> and just consume entire entries from the <code>entrySet()</code>:
<pre><code class="hljs">map.entrySet()
 .forEach((entry) -&gt; System.out.println(entry.getKey() + &quot; : &quot; + entry.getValue()));
</code></pre>
This also results in:
<pre><code class="hljs">Billy : 21
David : 24
John : 35
Jane : 19
</code></pre>
<h2 id="getkeysfromajavamap">Get Keys from a Java Map</h2>
To retrieve just keys, if you don't really need any information from the values, instead of the entry set, you can get the key set:
<pre><code class="hljs">for(String key: map.keySet()){
 System.out.println(key);
}
</code></pre>
Output:
<pre><code class="hljs">Billy
David
John
Jane
</code></pre>
<h2 id="getvaluesfromajavamap">Get Values from a Java Map</h2>
Similarly, one may desire to retrieve and iterate through the values only, without the keys. For this, we can use <code>values()</code>:
<pre><code class="hljs">for(String value: map.values()){
 System.out.println(value);
}
</code></pre>
Output:
<pre><code class="hljs">21
54
35
19
</code></pre>
<h2 id="checkifmapcontainsakey">Check if Map Contains a Key</h2>
The <code>HashMap</code> class has a <code>containsKey()</code> method, which checks if the passed key exists in the <code>HashMap</code>, and returns a boolean value signifying the presence of the element or lack thereof.
Let's check if a key, <code>5</code> exists:
<pre><code class="hljs">boolean result = map.containsKey(5);
System.out.println(result);
</code></pre>
This prints out:
<pre><code class="hljs">false
</code></pre>
And for an existing key:
<pre><code class="hljs">boolean result = map.containsKey(&quot;John&quot;);
System.out.println(result);
</code></pre>
This prints out:
<pre><code class="hljs">true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few ways to get keys and values (entries) of a Map in Java. We've covered using an iterator and going through each <code>Map.Entry&lt;K, V&gt;</code>, as well as using a <code>forEach()</code> method both on the map itself, as well as its entry set.
Finally, we've gone over how to get the key set and values separately, and check if a map contains a given key.

In this tutorial, we'll go over examples on how to get the keys and values (entries) of a map in Java. We'll use forEach as well as iterators.

Java: How to Get Keys and Values from a Map

<h2 id="introduction">Introduction</h2>
Matplotlib is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this tutorial, we'll take a look at how to change the background of a plot in Matplotlib.
<h2 id="importingdataandlibraries">Importing Data and Libraries</h2>
Let's import the required libraries first. We'll obviously need Matplotlib, and we'll use Pandas to read the data:
<pre><code class="hljs">import matplotlib.pyplot as plt
import pandas as pd
</code></pre>
Specifically, we'll be using the <a rel="nofollow noopener" target="_blank" href="https://www.kaggle.com/rtatman/did-it-rain-in-seattle-19482017">Seattle Weather Dataset</a>:
<pre><code class="hljs">weather_data = pd.read_csv(&quot;seattleWeather.csv&quot;)
print(weather_data.head())
</code></pre>
<pre><code class="hljs"> DATE PRCP TMAX TMIN RAIN
0 1948-01-01 0.47 51 42 True
1 1948-01-02 0.59 45 36 True
2 1948-01-03 0.42 45 35 True
3 1948-01-04 0.31 45 34 True
4 1948-01-05 0.17 45 32 True
</code></pre>
<h2 id="creatingaplot">Creating a Plot</h2>
Now, let's create a simple <a target="_blank" href="/matplotlib-scatterplot-tutorial-and-examples/">Matplotlib Scatter Plot</a>, with a few different variables we want to visualize:
<pre><code class="hljs">PRCP = weather_data[&#x27;PRCP&#x27;]
TMAX = weather_data[&#x27;TMAX&#x27;]
TMIN = weather_data[&#x27;TMIN&#x27;]
</code></pre>
Now, we'll construct a scatter plot between the minimum temperature and precipitation and <code>show()</code> it using Matplotlib's PyPlot:
<pre><code class="hljs">plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-1.png" alt="matplotlib scatter plot">
The graph that we have produced is interpretable, but it is looking a little plain. Let's try customizing it. We want to customize the background of our plot using a couple of different methods.
<h2 id="changeplotbackgroundinmatplotlib">Change Plot Background in Matplotlib</h2>
Now, let's go ahead and change the background of this plot. We can do this with two different approaches. We can change the color of the face, which is currently set to <code>white</code>. Or, we can input a picture using <code>imshow()</code>.
<h3 id="changeaxesbackgroundinmatplotlib">Change Axes Background in Matplotlib</h3>
Let's first change the color of the face. This can either be done with the <code>set()</code> function, passing in the <code>face</code> argument and its new value, or via the dedicated <code>set_facecolor()</code> function:
<pre><code class="hljs">ax = plt.axes()
ax.set_facecolor(&quot;orange&quot;)
# OR
ax.set(facecolor = &quot;orange&quot;)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-2.png" alt="change axes background color matplotlib">
Either of these approaches produces the same result, as they both call on the same function under the hood.
<h3 id="changefigurebackgroundinmatplotlib">Change Figure Background in Matplotlib</h3>
If you would like to set the background for the figure and need the axes to be transparent, this can be done with the <code>set_alpha()</code> argument when you create the figure. Let's create a figure and an axes object. Of course, you can also use the <code>set()</code> function, and pass the <code>alpha</code> attribute instead.
The color of the entire figure will be blue and we will initially set the <code>alpha</code> of the axes object to <code>1.0</code>, meaning fully opaque. We color the axes object orange, giving us an orange background within the blue figure:
<pre><code class="hljs">fig = plt.figure()
fig.patch.set_facecolor(&#x27;blue&#x27;)
fig.patch.set_alpha(0.6)

ax = fig.add_subplot(111)
ax.patch.set_facecolor(&#x27;orange&#x27;)
ax.patch.set_alpha(1.0)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-3.png" alt="change figure background matplotlib">
Now let's see what happens when we adjust the alpha of the axes subplot down to <code>0.0</code>:
<pre><code class="hljs">fig = plt.figure()
fig.patch.set_facecolor(&#x27;blue&#x27;)
fig.patch.set_alpha(0.6)

ax = fig.add_subplot(111)
ax.patch.set_facecolor(&#x27;orange&#x27;)
ax.patch.set_alpha(0.0)

plt.scatter(TMIN, PRCP)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-4.png" alt="change axes background matplotlib within figure">
Notice that the background of the plot itself is transparent now.
<h3 id="addimagetoplotbackgroundinmatplotlib">Add Image to Plot Background in Matplotlib</h3>
If you would like to use an image as the background for a plot, this can be done by using PyPlot's <code>imread()</code> function. This function loads an image into Matplotlib, which can be displayed with the function <code>imshow()</code>.
In order to plot on top of the image, the extent of the image has to be specified. By default, Matplotlib uses the upper left corner of the image as the image's origin. We can give a list of points to the <code>imshow()</code> function, specifying what region of the image should be displayed. When combined with subplots, another plot can be inserted on top of the image.
Let's use an image of rain as the background for our plot:
<pre><code class="hljs">img = plt.imread(&quot;rain.jpg&quot;)
fig, ax = plt.subplots()
ax.imshow(img, extent=[-5, 80, -5, 30])
ax.scatter(TMIN, PRCP, color=&quot;#ebb734&quot;)
plt.show()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-change-plot-background-in-matplotlib-5.png" alt="adding image to background matplotlib">
The <code>extent</code> argument takes in additional arguments in this order: <code>horizontal_min</code>, <code>horizontal_max</code>, <code>vertical_min</code>, <code>vertical_max</code>).
Here, we've read the image, cropped it and showed it on the axes using <code>imshow()</code>. Then, we plotted the scatter plot with a different color and showed the plot.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've gone over several ways to change the background of a plot using Python and Matplotlib.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on <a class="ebook-link" href="https://gum.co/data-visualization-in-python-book-bundle">Data Visualization in Python</a>:
<div style="border: 1px solid #ebebeb;padding: 15px;">
 <a class="ebook-link" rel="nofollow" target="_blank" href="https://gum.co/data-visualization-in-python-book-bundle" style="text-decoration: none;color: inherit;">
 <h4 style="margin-top: 10px;">Data Visualization in Python</h4>
 <div class="row">
 <div class="col-md-4 col-xs-12">
 <img class="img-responsive center-block" src="https://s3.stackabuse.com/media/ebooks/data-visualization-in-python/dvp-mpl-bundle-1-small.jpg">
 </div>
 <div class="col-md-8 col-xs-12 my-auto">
 Become dangerous with Data Visualization
 ✅ 30-day no-question money-back guarantee 
 ✅ Beginner to Advanced 
 ✅ Updated regularly for free (latest update in April 2021) 
 ✅ Updated with bonus resources and guides 
 </div>
 </div>
 </a>
</div>
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
<blockquote>
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
</blockquote>
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
<blockquote>
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.
</blockquote>

Dan Nelson

In this tutorial, we'll go over several examples of how to change the background of a plot (figure background and axes background) in Matplotlib using Python.

How to Change Plot Background in Matplotlib

<h2 id="introduction">Introduction</h2>
Sorting data is a frequent problem in computer science. Given a collection of elements, the goal is to rearrange them in some order. Common examples are sorting an array alphabetically or from smallest to largest.
Sorted data is a lot easier to manipulate. Finding the largest or smallest element of an array can be done in constant time if the array is sorted. Searching for an element is a lot faster using algorithms such as <a rel="nofollow" target="_blank" href="/binary-search-in-java/">Binary Search</a> which rely on the assumption that the array is already sorted.
One of the simplest algorithms for sorting data is Selection Sort. It's usually taught in beginner programming classes and tutorials to explain the concept of sorting, so we'll keep this article very beginner-friendly.
<h2 id="selectionsort">Selection Sort</h2>
Selection sort is an in-place comparison sorting algorithm that uses brute force to sort an array.
<blockquote>
In-place means that the algorithm uses a small constant amount of space for extra storage.
</blockquote>
It's called a &quot;brute force&quot; algorithm because it uses the simplest and most ineffective way of calculating the solution. However, it does make up for it with its straightforward implementation.
The algorithm divides the array into two subarrays:
<ul>
<li>A sorted subarray</li>
<li>An unsorted subarray</li>
</ul>
The sorted subarray is empty in the beginning. In every iteration, the smallest element of the unsorted array will be appended to the end of the sorted array by swapping. This way, the sorted array will eventually contain all the elements of the original array.
An example array we want to sort in ascending order:
<table>
 <tr>
 <td>Sorted array</td>
 <td>Unsorted array</td>
 <td>Minimal element of the unsorted array</td>
 </tr>
 <tr>
 <td>[]</td>
 <td>[16, 5, 30, 6, 2, 7]</td>
 <td>2</td>
 </tr>
 <tr>
 <td>[2]</td>
 <td>[16, 5, 20, 6, 7]</td>
 <td>5</td>
 </tr>
 <tr>
 <td>[2, 5]</td>
 <td>[16, 20, 6, 7]</td>
 <td>6</td>
 </tr>
 <tr>
 <td>[2, 5, 6]</td>
 <td>[16, 7, 20]</td>
 <td>7</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7]</td>
 <td>[16, 20]</td>
 <td>16</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7, 16]</td>
 <td>[20]</td>
 <td>20</td>
 </tr>
 <tr>
 <td>[2, 5, 6, 7, 16, 20]</td>
 <td>[]</td>
 <td></td>
 </tr>
</table>
<h2 id="implementation">Implementation</h2>
The <code>selectionSort()</code> method takes just one argument, the array that needs to be sorted. We'll iterate through the unsorted array, which will be between indexes <code>i</code> and <code>j</code>, find its minimum and place it into the sorted array by swapping:
<pre><code class="hljs">public static void selectionSort(int[] nums) {
 for (int i = 0; i &lt; nums.length; i++) {
 // min is the index of the smallest element with an index greater or equal to i
 int min = i;
 for (int j = i + 1; j &lt; nums.length; j++) {
 if (nums[j] &lt; nums[min]) {
 min = j;
 }
 }
 // Swapping i-th and min-th elements
 int swap = nums[i];
 nums[i] = nums[min];
 nums[min] = swap;
 }
}
</code></pre>
Let's test out the code:
<pre><code class="hljs">int[] array = new int[]{16, 5, 30, 6, 7, 2};
selectionSort(array);
System.out.println(Arrays.toString(array));
</code></pre>
This will print out:
<pre><code class="hljs">[2, 5, 6, 7, 16, 30]
</code></pre>
<h2 id="selectionsorttimecomplexity">Selection Sort Time Complexity</h2>
Time complexity is a way to describe how much time an algorithm needs to finish executing relative to the size of the input. Analyzing the time it takes for an algorithm to give output is of crucial importance. Imagine a telephone book application that would take a day to sort all the numbers after a new number was added. That would be way less useful than the same app that would do it almost instantly.
Performance depends on the hardware as well as software, but the same program can be run on many different types of hardware. The Big-O notation makes it easier to approximate the time needed for a program to execute, regardless of software.
The average and worst-case time complexity of Selection Sort is O(n2). This makes Selection Sort a lot slower than many other comparison sorting algorithms like <a target="_blank" href="/merge-sort-in-java/">Merge Sort</a> or <a target="_blank" href="/merge-sort-in-java/">Insertion Sort</a> which have the worst-case time complexity (O(nlogn)). Interestingly, O(nlogn) is the best that can be achieved by any comparison sorting algorithm.
<h2 id="timecomplexityanalysis">Time Complexity Analysis</h2>
Showing that Selection Sort has quadratic time complexity comes down to calculating the number of times the inner loop will be iterated. We can see this if we go through the code line by line and try to approximate the time it takes to execute each line of code:
<pre><code class="hljs">for (int i = 0; i &lt; nums.length; i++) {
</code></pre>
Everything in the inner block of the loop will be executed <code>n</code> times, where <code>n</code> is the length of a given array:
<pre><code class="hljs">int min = i;
</code></pre>
<code>min</code> will be initialized to <code>i</code> exactly <code>n</code> times. Now comes the tricky part:
<pre><code class="hljs">for (int j = i + 1; j &lt; nums.length; j++)
</code></pre>
Since this loop is nested, it takes a bit of math to calculate the number of times the block of code inside it will execute. Let's work it out.
When <code>i</code> is equal to 0, <code>j</code> will go from 1 to <code>n</code>, meaning every instruction in the inner block will execute <code>n</code> times. When <code>i</code> increases to 1, <code>j</code> will stay between 2 and <code>n</code>, which implies the inner block will execute <code>n-2</code> times. Summing this up:
<pre><code class="hljs">(n - 1) + (n - 2) + ... + 1
</code></pre>
The sum of a sequence of natural numbers is calculated using something called Gauss's trick, and it results in (n2 - n)/2. Simplifying this, results in O(n2) time complexity.
<blockquote>
Put simply, when calculating the complexity of an algorithm O(f(n)), we need to look for the highest power of n in the function f(n) and isolate it. This is because any part of the equation that has a lower power will not affect the result in any significant way.
For example, we have the function f(x) = x2+13x+23
O(f(x)) would be the highest power of x in the equation, which in this case is x2.
</blockquote>
Here's how it performed after sorting an array containing 10,000 integers in random order:
<pre><code class="hljs">public static void main(String[] args) {
 int[] array = new int[10000];
 for (int i = 0; i &lt; array.length; i++) {
 array[i] = i;
 }

 // Shuffle array
 Collections.shuffle(Arrays.asList(array));

 // Print shuffled collection
 System.out.println(Arrays.toString(array));
 
 long startTime = System.nanoTime();
 selectionSort(array);
 long endTime = System.nanoTime();
 
 // Print sorted collection
 System.out.println(Arrays.toString(array));

 // Print runtime in seconds
 System.out.println(&quot;Selection Sort runtime: &quot; + (endTime - startTime)/1000000000);
}
</code></pre>
Running it 10 times, this code produced the following results:
<table class="table table-striped">
 <tr>
 <td>Time(s)</td>
 <td>Selection Sort</td>
 </tr>
 <tr>
 <td>First Run</td>
 <td>0.024</td>
 </tr>
 <tr>
 <td>Second Run</td>
 <td>0.020</td>
 </tr>
 <tr>
 <td>Third Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Fourth Run</td>
 <td>0.020</td>
 </tr>
 <tr>
 <td>Fifth Run</td>
 <td>0.025</td>
 </tr>
 <tr>
 <td>Sixth Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Seventh Run</td>
 <td>0.021</td>
 </tr>
 <tr>
 <td>Eight Run</td>
 <td>0.031</td>
 </tr>
 <tr>
 <td>Ninth Run</td>
 <td>0.022</td>
 </tr>
 <tr>
 <td>Tenth Run</td>
 <td>0.029</td>
 </tr>
</table>
The average run time was 0.0236 seconds, though, this will majorly depend on your machine as well.
<h2 id="selectionsortspacecomplexity">Selection Sort Space Complexity</h2>
Space Complexity is also a big factor in algorithm design. Our programs are bound, not only by the time that they need to execute but also by memory usage. There is a limited amount of memory on any computer, so a programmer should keep an eye on that too.
The space complexity of Selection Sort is constant(O(1)) because it is in-place, which is great. Worst case complexity of Selection Sort is, unfortunately, O(n2) as well, which means that even if the algorithm gets an already sorted array as input, it will still take a lot of time to return the unchanged array.
This algorithm has decent performance if the collection doesn't have a lot of elements. If the array has ~10 elements, the difference in performance between different sorting algorithms shouldn't be that noticeable, and Selection Sort might even outperform other divide-and-conquer algorithms.
Where Selection Sort shines, is when the number of swaps needs to be minimal. In the worst case, there will only be <code>n-1</code> swaps, which is the minimal possible number of swaps that need to be performed. This is quite intuitive if we consider that every element will be placed in its right spot in the sorted array right away.
<h2 id="conclusion">Conclusion</h2>
Selection Sort is a brute force in-place comparison sort which continuously finds the minimum of an unsorted subarray and places it in the correct position in the sorted subarray. Due to its simplicity, it's often one of the first algorithms that are taught in computer science courses all around the world.
Even if more efficient algorithms come built-it, it's still important to understand the underlying logic and complexity analysis to avoid common issues and to make sure that the tool being used is the one that's best suited for the job at hand.

Kristina Popovic

In this tutorial, we'll go over the theory and implementation of Selection Sort in Java. We'll also explore its time and space complexity with examples.

Selection Sort in Java

Marcus Sanatan

Ruslan Hasanov

WTForms is a popular Python library that validates form data. This tutorial shows you how to use WTForms with Flask to create and verify forms in your app.

Flask Form Validation with WTForms

Flask Form Validation with Flask-WTF

<h2 id="introduction">Introduction</h2>
Whether in Java, or any other programming language, it is a common occurrence to check if an array contains a value. This is one of the things that most beginners tend to learn, and it is a useful thing to know in general.
In this article, we'll take a look at how to check if an array contains a value or element in Java.
<ul>
<li><a href="#arraysaslistcontains">Arrays.asList().contains()</a></li>
<li><a href="#usingaforloop">Using a for-loop</a></li>
<li><a href="#collectionsbinarysearch">Collections.binarySearch()</a></li>
<li><a href="#java8streamapi">Java 8 Stream API</a></li>
<li><a href="#apachecommonsarrayutils">Apache Commons - ArrayUtils</a></li>
</ul>
<h2 id="arraysaslistcontains">Arrays.asList().contains()</h2>
This is perhaps the most common way of solving this problem, just because it performs really well and is easy to implement.
First, we convert the array to an <code>ArrayList</code>. There are various ways to <a target="_blank"
href="/how-to-convert-a-java-array-to-arraylist/">convert a Java array to an ArrayList</a>, though, we'll be using the most widely used approach.
Then, we can use the <code>contains()</code> method on the resulting <code>ArrayList</code>, which returns a boolean signifying if the list contains the element we've passed to it or not.
Array of an <code>Integer</code> type:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

List&lt;Integer&gt; intList = new ArrayList&lt;&gt;(Arrays.asList(intArray));
List&lt;String&gt; nameList = new ArrayList&lt;&gt;(Arrays.asList(nameArray));

System.out.println(intList.contains(12));
System.out.println(nameList.contains(&quot;John&quot;));
</code></pre>
Running this code results in:
<pre><code class="hljs">false
true
</code></pre>
<h2 id="usingaforloop">Using a for-loop</h2>
A more basic and manual approach to solving the problem is by using a <code>for</code> loop. In worst case, it'll iterate the entire array once, checking if the element is present.
Let's start out with primitive integers first:
<pre><code class="hljs">int[] intArray = new int[]{1, 2, 3, 4, 5};
boolean found = false;
int searchedValue = 2;

for(int x : intArray){
 if(x == searchedValue){
 found = true;
 break;
 }
}

System.out.println(found);
</code></pre>
The <code>found</code> variable is initially set to <code>false</code> because the only way to return <code>true</code> would be to find the element and explicitly assign a new value to the boolean. Here, we simply compare each element of the array to the value we're searching for, and return <code>true</code> if they match:
<pre><code class="hljs">true
</code></pre>
For Strings, and custom Objects you might have in your code, you'd be using a different comparison operator. Assuming you've validly ovverriden the <code>equals()</code> method, you can use it to check if an object is equal to another, returning <code>true</code> if they are:
<pre><code class="hljs">String[] stringArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};
boolean found = false;
String searchedValue = &quot;Michael&quot;;

for(String x : stringArray){
 if(x.equals(searchedValue)){
 found = true;
 break;
 }
}

System.out.println(found);
</code></pre>
Running this code will result in:
<pre><code class="hljs">false
</code></pre>
<h2 id="collectionsbinarysearch">Collections.binarySearch()</h2>
Additionally, we can find a specific value using a built-in method <code>binarySearch()</code> from the <code>Collections</code> class. The problem with binary search is that it requires our array be sorted. If our array is sorted though, <code>binarySearch()</code> outperforms both the <code>Arrays.asList().contains()</code> and the for-loop approaches.
If it's not sorted, the added time required to sort the array might make this approach less favorable, depending on the size of the array and the sorting algorithm used to sort it.
<code>binarySearch()</code> has many overloaded variants depending on the types used and our own requirements, but the most general one is:
<pre><code class="hljs">public static int binarySearch(Object[] a, Object[] key)
</code></pre>
Where <code>a</code> represents the array, and <code>key</code> the specified value we're looking for.
Now, the return value might be a bit confusing, so it's best to take Oracle's official documentation in mind:
<blockquote>
The return value of this method is the index of the searched key, if it is contained in the array; otherwise (-(insertion point) - 1), where insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or <code>a.length</code> if all elements in the array are less than the specified key.
</blockquote>
Let's try this out:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;Bill&quot;, &quot;Connor&quot;, &quot;Joe&quot;, &quot;John&quot;, &quot;Mark&quot;}; // Array is already sorted lexicographically

List&lt;Integer&gt; intList = new ArrayList&lt;&gt;(Arrays.asList(intArray));
List&lt;String&gt; nameList = new ArrayList&lt;&gt;(Arrays.asList(nameArray));
System.out.println(Collections.binarySearch(intList, 2));
System.out.println(Collections.binarySearch(nameList, &quot;Robin&quot;));
</code></pre>
This will output:
<pre><code class="hljs">1
-6
</code></pre>
The first element is found, at position <code>1</code>. The second element isn't found, and would be inserted at position <code>5</code> - at the end of the array. The return value is <code>-(insertion point)-1</code>, so the return value ends up being <code>-6</code>.
If the value is above equal to, or above <code>0</code>, the array contains the element, and it doesn't contain it otherwise.
<h2 id="java8streamapi">Java 8 Stream API</h2>
The Java 8 Stream API is very versatile and offers for concise solutions to various tasks related to processing collections of objects. Using Streams for this type of task is natural and intuitive for most.
Let's take a look at how we can use the Stream API to check if an array contains an integer:
<pre><code class="hljs">Integer[] arr = new Integer[]{1, 2, 3, 4, 5};

System.out.println(Arrays.stream(arr).anyMatch(x -&gt; x == 3));
</code></pre>
This will output:
<pre><code class="hljs">true
</code></pre>
And to do this with Strings or custom objects:
<pre><code class="hljs">String[] arr = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

String searchString = &quot;Michael&quot;;

boolean doesContain = Arrays.stream(arr)
 .anyMatch(x -&gt; x.equals(searchString));

System.out.println(doesContain);
</code></pre>
Or, you can make this shorter by using a method reference:
<pre><code class="hljs">boolean doesContain = Arrays.stream(arr)
 .anyMatch(searchString::equals);
 
System.out.println(doesContain);
</code></pre>
Both of these would output:
<pre><code class="hljs">false
</code></pre>
<h2 id="apachecommonsarrayutils">Apache Commons - ArrayUtils</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library provides many new interfaces, implementations and classes that expand on the core Java Framework, and is present in many projects.
The <code>ArrayUtils</code> class introduces many methods for manipulating arrays, including the <code>contains()</code> method:
<pre><code class="hljs">Integer[] intArray = new Integer[]{1, 2, 3, 4, 5};
String[] nameArray = new String[]{&quot;John&quot;, &quot;Mark&quot;, &quot;Joe&quot;, &quot;Bill&quot;, &quot;Connor&quot;};

System.out.println(ArrayUtils.contains(intArray, 3));
System.out.println(ArrayUtils.contains(nameArray, &quot;John&quot;));
</code></pre>
This would result in:
<pre><code class="hljs">true
true
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over several ways to check whether an array in Java contains a certain element or value. We've gone over converting the array to a list and calling the <code>contains()</code> method, using a for-loop, the Java 8 Stream API, as well as Apache Commons.

Branko Ilic

In this tutorial, we'll go over examples of how to check if a Java array contains a certain element or value. We'll be using a List, the Stream API as well as Apache Commons.