A common operation in many programming languages is to check if a string contains another string. While it's a simple and common task, the method names often differ between programming languages. For example, here is a small sample of the methods used to achieve this in various languages:
<ul>
<li>Java: <code>String.contains()</code>, <code>String.indexOf()</code>, etc.</li>
<li>Python: <code>in</code> operator, <code>String.index()</code>, <code>String.find()</code></li>
<li>Go: <code>strings.Contains()</code></li>
<li>Ruby: <code>string.include?</code></li>
</ul>
You get the point. There are a million ways to do this, and it seems like each language implements it differently.
Anyway, let's see a few of the ways in which you can check if a string contains a substring in JavaScript.
Note: The first two methods shown below also work on arrays, which tells you if an array contains a given value (or the index of it for <code>indexOf()</code>). Keep this in mind when reading the article as it'll likely help you for similar use-cases.
<h2 id="thestringincludesmethod">The <code>String.includes()</code> Method</h2>
This method was introduced in ES6 and is typically the preferred method for simple use-cases. If all you need to do is get a boolean value indicating if the substring is in another string, then this is what you'll want to use.
It works like this:
<pre><code class="hljs">&gt; let str = &#x27;stackabuse&#x27;;
&gt; let substr = &#x27;stack&#x27;;
&gt; str.includes(substr);
true
</code></pre>
As you can see, a boolean value is returned since the string &quot;stack&quot; is a substring of <code>stackabuse</code>.
This is a case sensitive search, so the following will not match the substring:
<pre><code class="hljs">&gt; let str = &#x27;StackAbuse&#x27;;
&gt; let substr = &#x27;stack&#x27;;
&gt; str.includes(substr);
false
</code></pre>
While this is enough for most use-cases, the <code>includes()</code> method also provides another option that may be useful to you. A second argument can be provided that tells the method at which index to start the search. So if you know that the substring isn't contained in the first 50 characters (or you just don't want it to match those characters), then you can use the method like this:
<pre><code class="hljs">str.includes(substr, 50);
</code></pre>
An offset of below 0 just starts the search from index 0, and an offset greater than <code>string.length</code> returns <code>false</code> since the search starts from <code>string.length</code>.
<h2 id="thestringindexofmethod">The <code>String.indexOf()</code> Method</h2>
The <code>String.indexOf()</code> method is much like the previous <code>includes()</code> method (and it's suitable to be used in a polyfill for <code>includes()</code> as well), but the only difference is the return value. Instead of returning a boolean value indicating the presence of the substring, it actually returns the index location of the substring, or -1 if it isn't present.
Here's an example:
<pre><code class="hljs">&gt; let str = &#x27;stackabuse&#x27;;
&gt; let substr = &#x27;abuse&#x27;;
&gt; str.indexOf(substr);
5
&gt; str.indexOf(&#x27;apple&#x27;);
-1
</code></pre>
As you can see, this method returns the 0-based index position of the substring, and a -1 when the substring wasn't found.
Just like the <code>includes()</code> method, the <code>indexOf()</code> method is case sensitive and also supports the offset parameter:
<pre><code class="hljs">&gt; let str = &#x27;StackAbuse&#x27;;
&gt; let substr = &#x27;abuse&#x27;;
&gt; str.indexOf(substr);
-1
&gt; str.indexOf(&#x27;Abu&#x27;, 3);
5
&gt; str.indexOf(&#x27;Abu&#x27;, 6);
-1
</code></pre>
This method is useful for when you need to know the exact location of the substring, however, it's not as clean when simply using it as a boolean:
<pre><code class="hljs">let str = &#x27;stackabuse&#x27;;
let substr = &#x27;stack&#x27;;

if (str.indexOf(substr) &gt; -1) {
 console.log(&#x27;Found the substring!&#x27;);
}
</code></pre>
In cases like this you should use the <code>includes()</code> method instead as it's more error-prone.
<h2 id="regex">Regex</h2>
One of the more useful and powerful ways to check for a substring is to use regular expressions, or regex. Using regex for a task like this gives you a lot more flexibility than with the previous methods where you can only check for a constant string. While regex is too big of a subject to completely cover here, we can at least take a look at some of the useful features for our use-case.
Checking for substrings in a string with regex can be achieved using the <code>RegExp.test()</code> method:
<pre><code class="hljs">&gt; let str = &#x27;stackabuse&#x27;;
&gt; /stack/.test(str);
true
</code></pre>
Unlike the previous two methods, we can now do case insensitive searches with the <code>i</code> flag:
<pre><code class="hljs">&gt; let str = &#x27;StackAbuse&#x27;;
&gt; /stack/i.test(str);
true
</code></pre>
As a more complex example, let's say you want to see if a string contains a zip code (5 digit postal codes), but you don't really care what zip code is in the string. This kind of problem can't be solved using <code>includes()</code> or <code>indexOf()</code>. But with regex, we can easily test this:
<pre><code class="hljs">&gt; let str = &#x27;My zip code is 90210&#x27;;
&gt; /\d{5}/.test(str);
true
&gt; str = &#x27;My address is 123 Fake St.&#x27;;
&gt; /\d{5}/.test(str);
false
</code></pre>
While JavaScript isn't necessarily known for its speed anyway, keep in mind that this will be slower than a simpler method like <code>includes()</code>, so you should only use it for the more complex cases that can't be solved with a simpler solution.
<h2 id="conclusion">Conclusion</h2>
Manipulating and inspecting strings is one of the most common tasks performed in many programming languages, especially with user-facing code. For many different reasons, like validating strings, you'll need to check if a string contains a substring. In this article we saw a few different methods provided by JavaScript that allows you to do exactly that.

Scott Robinson

Checking if a String contains a substring is a common operation and slightly differs between languages. JavaScript offers several ways to do this.

JavaScript: Check if String Contains a Substring

Speech recognition, as the name suggests, refers to automatic recognition of human speech. Speech recognition is one of the most important tasks in the domain of human computer interaction. If you have ever interacted with Alexa or have ever ordered Siri to complete a task, you have already experienced the power of speech recognition.
Speech recognition has various applications ranging from automatic transcription of speech data (like voice-mails) to interacting with robots via speech.
In this tutorial, you will see how we can develop a very simple speech recognition application that is capable of recognizing speech from audio files, as well as live from a microphone. So, let's begin without further ado.
Several speech recognition libraries have been developed in Python. However we will be using the <a rel="nofollow" target="_blank" href="https://pypi.org/project/SpeechRecognition/">SpeechRecognition</a> library, which is the simplest of all the libraries.
<h2 id="installingspeechrecognitionlibrary">Installing SpeechRecognition Library</h2>
Execute the following command to install the library:
<pre><code class="hljs">$ pip install SpeechRecognition
</code></pre>
<h2 id="speechrecognitionfromaudiofiles">Speech Recognition from Audio Files</h2>
In this section, you will see how we can translate speech from an audio file to text. The audio file that we will be using as input can be downloaded from <a rel="nofollow" target="_blank" href="https://www.voiptroubleshooter.com/open_speech/american/OSR_us_000_0018_8k.wav">this link</a>. Download the file to your local file system.
The first step, as always, is to import the required libraries. In this case, we only need to import the <code>speech_recognition</code> library that we just downloaded.
<pre><code class="hljs">import speech_recognition as speech_recog
</code></pre>
To convert speech to text the one and only class we need is the <code>Recognizer</code> class from the <code>speech_recognition</code> module. Depending upon the underlying API used to convert speech to text, the <code>Recognizer</code> class has following methods:
<ul>
<li><code>recognize_bing()</code>: Uses Microsoft Bing Speech API</li>
<li><code>recognize_google()</code>: Uses Google Speech API</li>
<li><code>recognize_google_cloud()</code>: Uses Google Cloud Speech API</li>
<li><code>recognize_houndify()</code>: Uses Houndify API by SoundHound</li>
<li><code>recognize_ibm()</code>: Uses IBM Speech to Text API</li>
<li><code>recognize_sphinx()</code>: Uses PocketSphinx API</li>
</ul>
Among all of the above methods, the <code>recognize_sphinx()</code> method can be used offline to translate speech to text.
To recognize speech from an audio file, we have to create an object of the <code>AudioFile</code> class of the <code>speech_recognition</code> module. The path of the audio file that you want to translate to text is passed to the constructor of the <code>AudioFile</code> class. Execute the following script:
<pre><code class="hljs">sample_audio = speech_recog.AudioFile(&#x27;E:/Datasets/my_audio.wav&#x27;)
</code></pre>
In the above code, update the path to the audio file that you want to transcribe.
We will be using the <code>recognize_google()</code> method to transcribe our audio files. However, the <code>recognize_google()</code> method requires the <code>AudioData</code> object of the <code>speech_recognition</code> module as a parameter. To convert our audio file to an <code>AudioData</code> object, we can use the <code>record()</code> method of the <code>Recognizer</code> class. We need to pass the <code>AudioFile</code> object to the <code>record()</code> method, as shown below:
<pre><code class="hljs">with sample_audio as audio_file:
 audio_content = recog.record(audio_file)
</code></pre>
Now if you check the type of the <code>audio_content</code> variable, you will see that it has the type <code>speech_recognition.AudioData</code>.
<pre><code class="hljs">type(audio_content)
</code></pre>
Output:
<pre><code class="hljs">speech_recognition.AudioData
</code></pre>
Now we can simply pass the <code>audio_content</code> object to the <code>recognize_google()</code> method of the <code>Recognizer()</code> class object and the audio file will be converted to text. Execute the following script:
<pre><code class="hljs">recog.recognize_google(audio_content)
</code></pre>
Output:
<pre><code class="hljs">'Bristol O2 left shoulder take the winding path to reach the lake no closely the size of the gas tank degrees office 30 face before you go out the race was badly strained and hung them the stray cat gave birth to kittens the young girl gave no clear response the meal was called before the bells ring what weather is in living'
</code></pre>
The above output shows the text of the audio file. You can see that the file has not been 100% correctly transcribed, yet the accuracy is pretty reasonable.
<h3 id="settingdurationandoffsetvalues">Setting Duration and Offset Values</h3>
Instead of transcribing the complete speech, you can also transcribe a particular segment of the audio file. For instance, if you want to transcribe only the first 10 seconds of the audio file, you need to pass 10 as the value for the <code>duration</code> parameter of the <code>record()</code> method. Look at the following script:
<pre><code class="hljs">sample_audio = speech_recog.AudioFile(&#x27;E:/Datasets/my_audio.wav&#x27;)
with sample_audio as audio_file:
 audio_content = recog.record(audio_file, duration=10)

recog.recognize_google(audio_content)
</code></pre>
Output:
<pre><code class="hljs">'Bristol O2 left shoulder take the winding path to reach the lake no closely the size of the gas'
</code></pre>
In the same way, you can skip some part of the audio file from the beginning using the <code>offset</code> parameter. For instance, if you do not want to transcribe the first 4 seconds of the audio, pass 4 as the value for the <code>offset</code> attribute. As an example, the following script skips the first 4 seconds of the audio file and then transcribes the audio file for 10 seconds.
<pre><code class="hljs">sample_audio = speech_recog.AudioFile(&#x27;E:/Datasets/my_audio.wav&#x27;)
with sample_audio as audio_file:
 audio_content = recog.record(audio_file, offset=4, duration=10)

recog.recognize_google(audio_content)
</code></pre>
Output:
<pre><code class="hljs">'take the winding path to reach the lake no closely the size of the gas tank web degrees office dirty face'
</code></pre>
<h3 id="handlingnoise">Handling Noise</h3>
An audio file can contain noise due to several reasons. Noise can actually affect the quality of speech to text translation. To reduce noise, the <code>Recognizer</code> class contains <code>adjust_for_ambient_noise()</code> method, which takes the <code>AudioData</code> object as a parameter. The following script shows how you can improve transcription quality by removing noise from the audio file:
<pre><code class="hljs">sample_audio = speech_recog.AudioFile(&#x27;E:/Datasets/my_audio.wav&#x27;)
with sample_audio as audio_file:
 recog.adjust_for_ambient_noise(audio_file)
 audio_content = recog.record(audio_file)

recog.recognize_google(audio_content)
</code></pre>
Output:
<pre><code class="hljs">'Bristol O2 left shoulder take the winding path to reach the lake no closely the size of the gas tank web degrees office 30 face before you go out the race was badly strained and hung them the stray cat gave birth to kittens the younger again no clear response the mail was called before the bells ring what weather is in living'
</code></pre>
The output is quite similar to what we got earlier; this is due to the fact that the audio file had very little noise already.
<h2 id="speechrecognitionfromlivemicrophone">Speech Recognition from Live Microphone</h2>
In this section you will see how you can transcribe live audio received via a microphone on your system.
There are several ways to process audio input received via microphone, and various libraries have been developed to do so. One such library is <a rel="nofollow" target="_blank" href="https://pypi.org/project/PyAudio/">PyAudio</a>. Execute the following script to install the <code>PyAudio</code> library:
<pre><code class="hljs">$ pip install PyAudio
</code></pre>
Now the source for the audio to be transcribed is a microphone. To capture the audio from a microphone, we need to first create an object of the <code>Microphone</code> class of the <code>Speach_Recogniton</code> module, as shown here:
<pre><code class="hljs">mic = speech_recog.Microphone()
</code></pre>
To see the list of all the microphones in your system, you can use the <code>list_microphone_names()</code> method:
<pre><code class="hljs">speech_recog.Microphone.list_microphone_names()
</code></pre>
Output:
<pre><code class="hljs">['Microsoft Sound Mapper - Input',
 'Microphone (Realtek High Defini',
 'Microsoft Sound Mapper - Output',
 'Speakers (Realtek High Definiti',
 'Microphone Array (Realtek HD Audio Mic input)',
 'Speakers (Realtek HD Audio output)',
 'Stereo Mix (Realtek HD Audio Stereo input)']
</code></pre>
This is a list of microphones available in my system. Keep in mind that your list will likely look different.
The next step is to capture the audio from the microphone. To do so, you need to call the <code>listen()</code> method of the <code>Recognizer()</code> class. Like the <code>record()</code> method, the <code>listen()</code> method also returns the <code>speech_recognition.AudioData</code> object, which can then be passed to the <code>recognize_google()</code> method.
The following script prompts the user to say something in the microphone and then prints whatever the user has said:
<pre><code class="hljs">with mic as audio_file:
 print(&quot;Speak Please&quot;)

 recog.adjust_for_ambient_noise(audio_file)
 audio = recog.listen(audio_file)

 print(&quot;Converting Speech to Text...&quot;)
 print(&quot;You said: &quot; + recog.recognize_google(audio))
</code></pre>
Once you execute the above script, you will see the following message:
<pre><code class="hljs">Please say something
</code></pre>
At this point of time, say whatever you want and then pause. Once you have paused, you will see the transcription of whatever you said. Here is the output I got:
<pre><code class="hljs">Converting Speech to Text...
You said: hello this is normally from stack abuse abuse this is an article on speech recognition I hope you will like it and this is just a test speech and when I will stop speaking are you in today thank you for Reading
</code></pre>
It is important to mention that if <code>recognize_google()</code> method is not able to match the words you speak with any of the words in its repository, an exception is thrown. You can test this by saying some unintelligible words. You should see the following exception:
<pre><code class="hljs">Speak Please
Converting Speech to Text...
---------------------------------------------------------------------------
UnknownValueError Traceback (most recent call last)
&lt;ipython-input-27-41218bc8a239&gt; in &lt;module&gt;
 8 print(&quot;Converting Speech to Text...&quot;)
 9
---&gt; 10 print(&quot;You said: &quot; + recog.recognize_google(audio))
 11
 12

~\Anaconda3\lib\site-packages\speech_recognition\__init__.py in recognize_google(self, audio_data, key, language, show_all)
 856 # return results
 857 if show_all: return actual_result
--&gt; 858 if not isinstance(actual_result, dict) or len(actual_result.get(&quot;alternative&quot;, [])) == 0: raise UnknownValueError()
 859
 860 if &quot;confidence&quot; in actual_result[&quot;alternative&quot;]:

UnknownValueError:
</code></pre>
A better approach is to use the <code>try</code> block when the <code>recognize_google()</code> method is called as shown below:
<pre><code class="hljs">with mic as audio_file:
 print(&quot;Speak Please&quot;)

 recog.adjust_for_ambient_noise(audio_file)
 audio = recog.listen(audio_file)

 print(&quot;Converting Speech to Text...&quot;)

 try:
 print(&quot;You said: &quot; + recog.recognize_google(audio))
 except Exception as e:
 print(&quot;Error: &quot; + str(e))
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Speech recognition has various useful applications in the domain of human computer interaction and automatic speech transcription. This article briefly explains the process of speech transcription in Python via the <code>speech_recognition</code> library and explains how to translate speech to text when the audio source is an audio file or live microphone.

Usman Malik

Speech recognition is one of the most important tasks in human-computer interaction. We'll be using the SpeechRecognition library to perform this task in Python.

Introduction to Speech Recognition with Python

<h2 id="introduction">Introduction</h2>
<a rel="nofollow" target="_blank" href="https://yaml.org/">YAML</a> files are nowadays being used extensively for defining properties of tools and applications due to the very human-readable syntax.
Besides containing configuration properties, they're also often used for data transmission/serialization, similar to how JSON is used.
Reading and writing YAML files is quickly becoming a basic developer skill, similar to how reading and writing JSON and XML files is.
<h2 id="whatisyaml">What is YAML?</h2>
YAML Ain't Markup Language (YAML) is a simple, human-readable data-serialization language, very much alike JSON. It's easier to read and comprehend and has the ability to reference other items within a YAML file, as well as embed other formats such as JSON and XML within itself.
It's not meant to be a replacement for the current solutions and is mainly used for configuration files due to the fact that it's both easy to read and edit, and supports comments, making it a lot more team-friendly.
Most YAML files can be converted to JSON, and vice-versa as YAML is a superset of JSON. Here's an example of a YAML file:
<pre><code class="hljs">--- #Employee Info
name: David
wage: 1500
position: Developer
techstack:
 - Java
 - Spring
 - Hibernate
</code></pre>
The syntax is really simple, a dictionary (our employee entity) is represented with <code>&lt;key&gt;: &lt;value&gt;</code>.
After defining a few properties such as the <code>name</code>, <code>wage</code>, and <code>position</code>, a list is included, again, indented with each list item beginning with a <code>-</code>.
Each of these items can also be a dictionary as well:
<pre><code class="hljs">---
name: David
wage: 1500
position: Developer
colleagues:
 - name: Martha
 wage: 1500
 position: Developer
 - name: Jim
 wage: 1800
 position: DevOps Engineer
</code></pre>
You can shorten dictionaries and form more complex collections, though that's out of the scope of this tutorial.
With a refresher on YAML, we're ready to write some code that reads/writes YAML files. To achieve this, we can use either of the two popular libraries: <a rel="nofollow" target="_blank" href="https://github.com/FasterXML/jackson">Jackson</a> or <a rel="nofollow" target="_blank" href="https://bitbucket.org/asomov/snakeyaml/wiki/Home">SnakeYAML</a>. In this article, we'll be focusing on Jackson.
<h2 id="readingyamlwithjackson">Reading YAML with Jackson</h2>
Jackson is an extremely popular Java-based library used for parsing and manipulating <a target="_blank" href="/reading-and-writing-json-in-java/">JSON</a> and <a target="_blank" href="/reading-and-writing-xml-in-java/">XML</a> files.
Needless to say, it also allows us to parse and manipulate YAML files in a similar fashion to how we're already used to doing with the two previously mentioned formats.
By using Jackson as our library, we're in a familiar environment and many Java applications already have Jackson for other purposes anyway.
First, let's add Jackson to our project via Maven:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt;
 &lt;artifactId&gt;jackson-dataformat-yaml&lt;/artifactId&gt;
 &lt;version&gt;{$version}&lt;/version&gt;
&lt;/dependency&gt;

&lt;dependency&gt;
 &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt;
 &lt;artifactId&gt;jackson-databind&lt;/artifactId&gt;
 &lt;version&gt;{$version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
We'll need both <code>jackson-databind</code> from which we'll extract the <code>ObjectMapper</code> class and the <code>jackson-dataformat-yaml</code> dependency from which we'll extract the <code>YAMLFactory</code> class.
Just like we did with JSON and XML, the main class we'll be using for this task will be the <code>ObjectMapper</code> class. Its <code>readValue()</code> method is used to map the source (YAML file) into the result (an object of a class).
Let's first define a simple class that we'd like to map to. With respect to the previous YAML example, let's make an <code>Employee</code> class:
<pre><code class="hljs">public class Employee {

 public Employee(String name, int wage, String position, List&lt;Employee&gt; colleagues) {
 this.name = name;
 this.wage = wage;
 this.position = position;
 this.colleagues = colleagues;
 }

 // Without a default constructor, Jackson will throw an exception
 public Employee() {}

 private String name;
 private int wage;
 private String position;
 private List&lt;Employee&gt; colleagues;

 // Getters and setters

 @Override
 public String toString() {
 return &quot;\nName: &quot; + name + &quot;\nWage: &quot; + wage + &quot;\nPosition: &quot; + position + &quot;\nColleagues: &quot; + colleagues + &quot;\n&quot;;
 }
</code></pre>
Now, we'll read a YAML file, say <code>person.yaml</code>, with the contents:
<pre><code class="hljs">---
name: David
wage: 1500
position: Developer
colleagues:
 - name: Martha
 wage: 1500
 position: Developer
 - name: Jim
 wage: 1800
 position: DevOps Engineer
</code></pre>
We'll map this file to an instance of our <code>Employee</code> class using Jackson's <code>ObjectMapper</code> class:
<pre><code class="hljs">// Loading the YAML file from the /resources folder
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
File file = new File(classLoader.getResource(&quot;person.yaml&quot;).getFile());

// Instantiating a new ObjectMapper as a YAMLFactory
ObjectMapper om = new ObjectMapper(new YAMLFactory());

// Mapping the employee from the YAML file to the Employee class
Employee employee = om.readValue(file, Employee.class);

// Printing out the information
System.out.println(&quot;Employee info &quot; + employee.toString());

// Access the first element of the list and print it as well
System.out.println(&quot;Accessing first element: &quot; + employee.getColleagues().get(0).toString());
</code></pre>
Running this piece of code will yield us:
<pre><code class="hljs">Employee info
Name: David
Wage: 1500
Position: Developer
Colleagues: [
Name: Martha
Wage: 1500
Position: Developer
Colleagues: null
,
Name: Jim
Wage: 1800
Position: DevOps Engineer
Colleagues: null
]

Accessing first element:
Name: Martha
Wage: 1500
Position: Developer
Colleagues: null
</code></pre>
Our <code>person.yaml</code> file was mapped to an instance of an object which we can then use for whatever is the intended purpose.
<h2 id="writingyamlwithjackson">Writing YAML with Jackson</h2>
With reading and mapping out of the way, let's also go ahead and write to a YAML file.
As opposed to using the <code>readValue()</code> method, we'll be using the <code>writeValue()</code> method, specifying where the resulting file will end up and the object from which we're mapping into the YAML file.
Let's instantiate an employee and assign some values:
<pre><code class="hljs">List&lt;Employee&gt; colleagues = new ArrayList&lt;Employee&gt;();

colleagues.add(new Employee(&quot;Mary&quot;, 1800, &quot;Developer&quot;, null));
colleagues.add(new Employee(&quot;Jane&quot;, 1200, &quot;Developer&quot;, null));
colleagues.add(new Employee(&quot;Tim&quot;, 1600, &quot;Developer&quot;, null));
colleagues.add(new Employee(&quot;Vladimir&quot;, 1000, &quot;Developer&quot;, null));

// We want to save this Employee in a YAML file
Employee employee = new Employee(&quot;David&quot;, 1500, &quot;Developer&quot;, colleagues);

// ObjectMapper is instantiated just like before
ObjectMapper om = new ObjectMapper(new YAMLFactory());

// We write the `employee` into `person2.yaml`
om.writeValue(new File(&quot;/src/main/resources/person2.yaml&quot;), employee);
</code></pre>
Running this piece of code will yield us a YAML file with the contents:
<pre><code class="hljs">---
name: &quot;David&quot;
wage: 1500
position: &quot;Developer&quot;
colleagues:
- name: &quot;Mary&quot;
 wage: 1800
 position: &quot;Developer&quot;
 colleagues: null
- name: &quot;Jane&quot;
 wage: 1200
 position: &quot;Developer&quot;
 colleagues: null
- name: &quot;Tim&quot;
 wage: 1600
 position: &quot;Developer&quot;
 colleagues: null
- name: &quot;Vladimir&quot;
 wage: 1000
 position: &quot;Developer&quot;
 colleagues: null
</code></pre>
As you can see, the Java <code>employee</code> object was serialized in to a YAML-formatted file by using Jackson's support of YAML.
<h2 id="conclusion">Conclusion</h2>
YAML-formatted files are becoming increasingly popular for defining properties of tools and applications due to the very human-readable syntax. Besides containing configuration properties, they're also being used more and more for data transmission, similar to how JSON is used, although their use in this area is still not as prevalent in the wild.
Jackson is an extremely popular Java-based library used for parsing and manipulating <a target="_blank" href="/reading-and-writing-json-in-java/">JSON</a> and <a target="_blank" href="/reading-and-writing-xml-in-java/">XML</a> files. In addition, it was extended to allow developers to also work with the YAML file format.

David Landup

YAML is a simple, human-readable data-serialization language, much like JSON. Using Jackson, a popular Java library present in many projects, we can easily read and write YAML.

Reading and Writing YAML Files in Java with Jackson

NPM, or the Node Package Manager, is a powerful tool that allows you to easily manage dependencies, run scripts, and organize project metadata. Its main purpose, however, is to help you download and install Node packages from its repository to your project.
Downloading and installing a package is done using NPM's <code>install</code> command:
<pre><code class="hljs">$ npm install express

+ express@4.17.1
added 50 packages from 37 contributors and audited 126 packages in 3.262s
found 0 vulnerabilities
</code></pre>
When you run the <code>install</code> command like this, by default it retrieves the latest version of the specified package, which in this case is v4.17.1 (at the time of this writing).
But what if we need a different version? Maybe this latest version breaks a feature that we need, or maybe it has a security vulnerability that the maintainer hasn't gotten around to fixing yet. In cases like this you'd probably want to install a specific version of the package that you know works, or that you know is &quot;safe&quot;.
To do this, we can specify the version using the syntax <code>npm install [package]@[version]</code>. Continuing with our example above, we would execute something like this:
<pre><code class="hljs">$ npm install express@4.16.1

+ express@4.16.1
added 48 packages from 36 contributors and audited 121 packages in 2.986s
found 0 vulnerabilities
</code></pre>
As you can see, NPM has installed the package we specified.
With NPM we also have other options for specifying the version of a package. Using either a caret (<code>^</code>) or a tilde (<code>~</code>) we can specify the latest minor or patch version, respectively. This way you can specify a compatible package version, but still get the latest.
So, for example, if you want to use Express version 4.16, but the patch version isn't important, you can use the tilde to tell NPM to retrieve the latest patch version:
<pre><code class="hljs">$ npm install express@~4.16.1

+ express@4.16.4
added 48 packages from 36 contributors and audited 121 packages in 3.02s
found 0 vulnerabilities
</code></pre>
Since we prefixed the version with <code>~</code>, NPM retrieved the latest patch version under the 4.16 minor version, which turned out to be 4.16.4.
This is good for when you don't need a very specific version, but you want to keep your dependencies up to date with the latest patches and security vulnerability fixes.
For more info, check out <a target="_blank" href="/caret-vs-tilde-in-package-json/">Caret vs Tilde in package.json</a>.

NPM is a powerful tool that allows you to easily manage dependencies, run scripts, and organize project metadata. It's main purpose is to help you download and install Node packages.

NPM: Install Specific Version of a Package

<h2 id="introduction">Introduction</h2>
In the early days of the web, data persistence was only possible with a server. Nowadays, through the use of LocalStorage, we can store data on clients like browsers and mobile apps without communicating with a back-end application.
In this article, we will discuss how developers can store data on the client with cookies and how LocalStorage improved that experience. We will then look at functions that store and retrieve data from LocalStorage. Finally, we'll discuss when it is appropriate to use LocalStorage.
<h2 id="storingdatainthebrowserwithcookies">Storing Data in the Browser With Cookies</h2>
Cookies are textual data stored in the client. They are traditionally set by the server, however, they can also be created with JavaScript code in the browser. The data in cookies are stored as key/value pairs of strings.
All cookies are sent to the server when an HTTP request is made. Cookies you make with JavaScript will also be sent to the server when an HTTP request is made. This means that the server app can inadvertently modify a cookie, causing your client app to behave unexpectedly.
With cookies, you can only store a maximum of 4KB of data on the client. For modern front-end applications, this may not be enough.
Let's see how LocalStorage allows us to create and keep data on the client-side, with much more storage space than cookies provide.
<h2 id="whatislocalstorage">What is LocalStorage?</h2>
LocalStorage is a key/value datastore that's available on a user's browser. Like cookies, LocalStorage can only store string data for its keys and values. The datastore is only accessible to JavaScript within that domain.
<blockquote>
Note: Each domain has access to its LocalStorage datastore. For example, LocalStorage used by <code>https://www.stackabuse.com</code> is separate from LocalStorage used by <code>https://www.reddit.com</code>.
Subdomains and different HTTP protocols (HTTP and HTTPS) all have independent datastores. For example, the LocalStorage used by <code>https://my.example.com</code> is completely separate from <code>https://example.com</code>. Likewise, <code>https://twitter.com</code>'s LocalStorage is separate from <code>http://twitter.com</code>.
Having LocalStorage available per domain prevents malicious JavaScript hosted on other websites from manipulating or reading our client data that's used by our domain.
</blockquote>
Each domain can store up to 5MB of data in LocalStorage. Also, our data isn't sent to the server when an HTTP request is made.
Data in LocalStorage has no expiration time. It can be removed via JavaScript or by clearing the browser's cache.
Now that we know what LocalStorage is, let's use its API to manage data in the browser.
<h2 id="howtouselocalstorage">How to Use LocalStorage</h2>
We can use following methods on the global <code>localStorage</code> object to manage client-side data:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Method</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td><code>setItem()</code></td>
 <td>Add key/value in LocalStorage</td>
 </tr>
 <tr>
 <td><code>getItem()</code></td>
 <td>Get a value from LocalStorage</td>
 </tr>
 <tr>
 <td><code>removeItem()</code></td>
 <td>Remove item by its key</td>
 </tr>
 <tr>
 <td><code>clear()</code></td>
 <td>Remove all items from LocalStorage</td>
 </tr>
 <tr>
 <td><code>key()</code></td>
 <td>Get a key of an item from LocalStorage</td>
 </tr>
 </tbody>
</table>
<h3 id="setitem">setItem()</h3>
Use the <code>setItem()</code> function to store an item in LocalStorage. This function takes a key as its first argument and a value as the second argument. As mentioned earlier, both must be strings.
In your browser's console let's add an item to our <code>localStorage</code>:
<pre><code class="hljs">localStorage.setItem(&quot;tech&quot;, &quot;JavaScript&quot;);
</code></pre>
<h3 id="getitem">getItem()</h3>
Use the <code>getItem()</code> function to retrieve data from LocalStorage. This function takes the key that was used while saving the data as an argument.
In your console, let's retrieve and print the value that was saved previously with <code>setItem()</code>:
<pre><code class="hljs">let techStack = localStorage.getItem(&quot;tech&quot;);
console.log(techStack);
</code></pre>
Your console should print &quot;JavaScript&quot;.
<h3 id="removeitem">removeItem()</h3>
Use the <code>removeItem()</code> function to remove one item from LocalStorage. You need to provide the key of the item you want to delete as an argument.
Try this in your console to delete the data saved with <code>setItem()</code>:
<pre><code class="hljs">localStorage.removeItem(&quot;tech&quot;);
</code></pre>
To confirm it was removed, try to retrieve it once more:
<pre><code class="hljs">console.log(localStorage.getItem(&quot;tech&quot;));
</code></pre>
The console would output &quot;null&quot; as <code>getItem()</code> returns <code>null</code> whenever it can't retrieve an item.
<h3 id="clear">clear()</h3>
To remove all the data stored in LocalStorage, use the <code>clear()</code> function:
<pre><code class="hljs">localStorage.clear();
</code></pre>
<h3 id="key">key()</h3>
The <code>key()</code> function allows us to retrieve the key of an item saved in LocalStorage by its index. The browser creates an integer index for each item added to LocalStorage.
As we don't generate this index, we should not use the index to retrieve keys directly. However, we can use this function to get all keys stored in LocalStorage:
<pre><code class="hljs">for (let i = 0; i &lt; localStorage.length; i++) {
 let storedValue = localStorage.key(i);
 console.log(`Item at ${i}: ${storedValue}`);
}
</code></pre>
By using the <code>length</code> property of LocalStorage, we iterate over every index created to print all the keys we have saved in LocalStorage. We can then use these keys with <code>getItem()</code> to retrieve all stored data.
Now that we have covered all the functions to manage data in the user's browser, let's look at the special case of saving complex objects instead of string data.
<h2 id="storingobjectsinlocalstorage">Storing Objects in LocalStorage</h2>
LocalStorage can only use strings for its keys and values. If we try to store any other type of data, it converts it to a string before storing it. This can bring some unexpected behavior when we want to save JavaScript objects.
Let's create a <code>person</code> object in your browser console and save it in LocalStorage:
<pre><code class="hljs">let person = {
 name: &quot;John&quot;,
 age: 22
};

localStorage.setItem(&quot;profile&quot;, person);
</code></pre>
Now, <code>setItem()</code> would have converted the <code>person</code> object to a string. When we retrieve the <code>person</code> like this:
<pre><code class="hljs">console.log(localStorage.getItem(&quot;profile&quot;));
</code></pre>
Our browser console would show this:
<img src="https://stackabuse.s3.amazonaws.com/media/storing-data-in-the-browser-with-localstorage-1.png" alt="Naively store an object in LocalStorage">
JavaScript's object to string conversion produces <code>[object Object]</code>. Admittedly, getting back a string that only indicates an object was stored is not useful.
To correctly store JavaScript objects in LocalStorage, we first need to convert our object to a JSON string.
We use the built-in <code>JSON.stringify()</code> function for this. The resulting string of that function will contain all the properties of our JSON object. We save the output of that function when we use <code>setItem()</code>.
Let's save the <code>person</code> object after stringifying it:
<pre><code class="hljs">localStorage.setItem(&quot;profile&quot;, JSON.stringify(person));
</code></pre>
To retrieve this data as an object we need to do two things. First, we need to use <code>getItem()</code> to pull it from LocalStorage. We then need to convert the JSON string into a JavaScript object.
Let's begin by taking the item from LocalStorage:
<pre><code class="hljs">let storageProfileString = localStorage.getItem(&quot;profile&quot;);
console.log(&quot;String saved in LocalStorage&quot;, storageProfileString);
</code></pre>
Now, convert the LocalStorage string into an object with <code>JSON.parse()</code> and log it to the browser's console:
<pre><code class="hljs">let savedPerson = JSON.parse(storageProfileString);
console.log(&quot;Person object:&quot;, savedPerson);
console.log(&quot;Person&#x27;s name:&quot;, savedPerson.name);
</code></pre>
Running this code will give you the following output:
<img src="https://stackabuse.s3.amazonaws.com/media/storing-data-in-the-browser-with-localstorage-2.png" alt="Correctly store an object in LocalStorage">
Note the difference in color in the console when we first logged the string to when we logged the object. We also log the <code>name</code> property of <code>person</code> to ensure that the object's properties are still accessible.
Now that we have a strategy to expand LocalStorage's uses beyond strings, let's discuss best practices when using it.
<h2 id="whentouselocalstorage">When to Use LocalStorage</h2>
LocalStorage allows for basic persistence on your website. It's commonly used to keep data that would be convenient for the user to see even if the browser was refreshed. For example, many forms save a user's input in LocalStorage until it is submitted.
Static websites commonly use LocalStorage to store user preferences, like a UI theme. Without a web server and database to save a user preference, LocalStorage allows them to continue using your website with their customizations.
However, LocalStorage should not be used for large amounts of data. Aside from the 5MB limit which may not be enough for data-intensive applications, large data brings a performance cost when using LocalStorage.
All LocalStorage functions are synchronous operations. Therefore, if you are saving or retrieving a large chunk of data, JavaScript must complete that LocalStorage operation before it can execute other code.
Be mindful that the performance cost is increased when saving large JSON objects. The <code>JSON.stringify()</code> and <code>JSON.parse()</code> functions are also synchronous. They will block JavaScript execution until they are complete.
Never store sensitive information in LocalStorage. This includes passwords, API Keys, authentication tokens like JWTs and financial information like credit card numbers, to name a few.
Remember, every JavaScript file that is loaded on your domain has access to LocalStorage. If malicious JavaScript code is added by you or your dependencies, they can retrieve user data or tokens you use to authenticate with APIs.
Always keep sensitive data on the back-end.
<h2 id="conclusion">Conclusion</h2>
LocalStorage is a datastore available in browsers. Data is stored as key/value pairs of strings, and each domain has access to its LocalStorage.
When storing JavaScript objects, be sure to correctly convert them to a string with <code>JSON.stringify()</code> before saving. As you retrieve the data, convert them to an object with <code>JSON.parse()</code>.
When using LocalStorage, avoid processing large amounts of data as it could degrade performance because its functions are synchronous. Most importantly, be sure that no sensitive user or application data is stored in LocalStorage.
Can you think of ways to improve your application with LocalStorage?!

Guest Contributor

Marcus Sanatan

LocalStorage allows us to store data without communicating with a back-end server. In this article, we'll store data with cookies and LocalStorage and retrieve it.

Storing Data in the Browser with LocalStorage

For much of JavaScript's life, it was a browser-only programming language and could not run on the server-side like it can now. Because of this, JS has a lot of built-in functions that are specific to browser-side functions, like encoding strings for use in URLs. Some of the most commonly used functions are:
<ul>
<li><code>encodeURI</code></li>
<li><code>encodeURIComponent</code></li>
<li><code>decodeURI</code></li>
<li><code>decodeURIComponent</code></li>
<li><code>escape</code></li>
<li><code>unescape</code></li>
</ul>
The function that is the focus of this article, <code>encodeURI</code>, is used to encode a Uniform Resource Identifier (URI) so that characters not meant to be used in a URI (like a space) are formatted properly. These characters are escaped using <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Percent-encoding">percent-encoding</a>, or URL encoding, to represent the non-standard URI characters.
Percent-encoding is simply a hexadecimal representation of the ASCII character prefixed with the percent (%) character. So, for example, the percent-encoding representation of the exclamation mark (!) is <code>%21</code> since 21 is the ASCII hex number for the exclamation mark.
In terms of use-cases, let's say your website has a search bar and the queries entered there are used to construct a URL like this:
<pre><code class="hljs">https://mysite.com/q=[SEARCH_QUERY]
</code></pre>
In a use-case like this, it's pretty likely that the user will enter a string containing a space (or other reserved character), which isn't allowed in URLs. So what do we do if the user enters the string &quot;web development&quot;, for example? We can't allow just any character in our URL. That's where <code>encodeURI</code> comes in:
<pre><code class="hljs">&gt; let query = &#x27;web development&#x27;;
&gt; let searchUrl = &#x27;https://mysite.com/q=&#x27; + query;
&gt; encodeURI(searchUrl)
&#x27;https://mysite.com/q=web%20development&#x27;
</code></pre>
Notice how the space has been replaced with the percent-encoding, <code>%20</code>. The <code>encodeURI</code> function is perfect for this because it doesn't escape any other reserved characters, like the colon or forward slash. This is because it expects to receive a full URL as input, unlike the <code>encodeURIComponent</code> variation of this function. The URL passed to <code>encodeURI</code> can contain any valid part of a URL scheme and not be escaped, while other reserved or disallowed characters are encoded:
<pre><code class="hljs">&gt; encodeURI(&#x27;https://scott:password@admin.example.com:443/my/file.html?stack=abuse#javascript&#x27;)
&#x27;https://scott:password@admin.example.com:443/my/file.html?stack=abuse#javascript&#x27;
&gt; encodeURI(&#x27;https://scott:password@admin.example.com:443/my/file.html?stack=&quot;abuse&quot;#javascript&#x27;)
&#x27;https://scott:password@admin.example.com:443/my/file.html?stack=%22abuse%22#javascript&#x27;
</code></pre>
Notice how there were no changes made to the URL in the first call above. This is because all characters are valid in a URL. In the second call we have a few quotation marks, which are not valid, and therefore encoded.
The following characters are not encoded by <code>encodeURI</code>, regardless of where they are located in the URL: <code>A-Za-z0-9;,/?:@&amp;=+$-_.!~*'()#</code>
This function can even handle encoding non-ASCII characters using a longer UTF-8 based encoding. For example, the euro currency symbol (€) is encoded using three percent-encoding sets:
<pre><code class="hljs">&gt; encodeURI(&#x27;€&#x27;)
&#x27;%E2%82%AC&#x27;
</code></pre>
This allows for characters from any language, or special formatting characters, to be passed via URLs.
<h2 id="conclusion">Conclusion</h2>
JavaScript's built-in <code>encodeURI</code> function is useful for properly formatting URLs, or more generically, URIs with unreserved ASCII characters or even UTF-8 characters. It should be used any time user input is used in constructing a URL to ensure that it remains properly formatted.
On the other side of things, we also have the <code>decodeURI</code> built-in function, which handles decoding the percent-encoded values, which we'll take a look at in another article.!

For much of its life, JavaScript was a browser-only language. Naturally, it has a lot of built-in functions specific to browsers - like encoding Strings using the encodeURI function.

JavaScript's encodeURI Function

<h2 id="introduction">Introduction</h2>
The Java Collections Framework is a fundamental and essential framework that any strong Java developer should know like the back of their hand.
A Collection in Java is defined as a group or collection of individual objects that act as a single object.
There are many collection classes in Java and all of them extend the <code>java.util.Collection</code> and <code>java.util.Map</code> interfaces. These classes mostly offer different ways to formulate a collection of objects within a single object.
Java Collections is a framework that provides numerous operations over a collection - searching, sorting, insertion, manipulation, deletion etc.
This is the third part of a series of Java Collections articles:
<ul>
<li><a target="_blank" href="/java-collections-the-list-interface/">The List Interface</a></li>
<li><a target="_blank" href="/java-collections-the-set-interface/">The Set Interface</a></li>
<li>The Map Interface (you are here)</li>
<li><a target="_blank" href="/java-collections-queue-and-deque-interfaces/">The Queue and Deque Interfaces</a></li>
</ul>
<h2 id="listsandsetslimitations">Lists and Sets Limitations</h2>
First of all, let's discuss the limitations of <code>List</code> and <code>Set</code>. They provide many features to add, remove, and check for the presence of items, as well as iteration mechanisms. But when it comes to retrieve specific items, they are not very handy.
The <code>Set</code> interface doesn't provide any mean to retrieve a specific object, as it's unordered. And the <code>List</code> interface merely provides the possibility to retrieve items by their index.
Unfortunately, indices are not always very self-speaking and thus have little meaning.
<h2 id="maps">Maps</h2>
That's where the <code>java.util.Map</code> interface shows up. A <code>Map</code> associates items to keys, allowing us to retrieve items by those keys. Such associations carry much more sense than associating an index to an item.
<code>Map</code> is a generic interface with two types, one for the keys and one for the values. Therefore, if we wanted to declare a <code>Map</code> storing words count in a text, we would write:
<pre><code class="hljs">Map&lt;String, Integer&gt; wordsCount;
</code></pre>
Such a <code>Map</code> uses a <code>String</code> as its key and an <code>Integer</code> as its value.
<h3 id="addingelements">Adding Elements</h3>
Let's now dive into the <code>Map</code> operations, starting with the addition of elements. There are a few ways to add elements to a <code>Map</code>, the most common one being the <code>put()</code> method:
<pre><code class="hljs">Map&lt;String, Integer&gt; wordsCount = new HashMap&lt;&gt;();
wordsCount.put(&quot;the&quot;, 153);
</code></pre>
Note: In addition to associating a value to a key, the <code>put()</code> method also returns the previously associated value, if any, and <code>null</code> otherwise.
But, what if we only want to add an element only if nothing is associated to its key? Then we have a few possibilities, the first being to test for the key presence with the <code>containsKey()</code> method:
<pre><code class="hljs">if (!wordsCount.containsKey(&quot;the&quot;)) {
 wordsCount.put(&quot;the&quot;, 150);
}
</code></pre>
Thanks to the <code>containsKey()</code> method, we can check if an element is already associated to the key <code>the</code> and only add a value if not.
However, that's a bit verbose, especially considering there are two other options. First of all, let's see the most ancient one, the <code>putIfAbsent()</code> method:
<pre><code class="hljs">wordsCount.putIfAbsent(&quot;the&quot;, 150);
</code></pre>
This method call achieves the same result as the previous one, but using only one line.
Now, let's see the second option. Since Java 8, another method, similar to <code>putIfAbsent()</code>, exists - <code>computeIfAbsent()</code>.
It works roughly the same way as the former, but takes a <a target="_blank" href="/lambda-expressions-in-java">Lambda Function</a> instead of a direct value, giving us the possibility to instantiate the value only if nothing is attached to the key yet.
The function argument is the key, in case the value instantiation depends on it. So, to achieve the same result as with the precedent methods, we would have to do:
<pre><code class="hljs">wordsCount.computeIfAbsent(&quot;the&quot;, key -&gt; 3 + 150);
</code></pre>
It will provide the same result as before, only it will not compute the value 153 if another value is already associated to the key <code>the</code>.
Note: This method is particularly useful when the value is heavy to instantiate or if the method is called often and we want to avoid creating too many objects.
<h3 id="retrievingelements">Retrieving Elements</h3>
Until now, we learned how to put elements into a <code>Map</code>, but how about retrieving them?
To achieve that, we use the <code>get()</code> method:
<pre><code class="hljs">wordsCount.get(&quot;the&quot;);
</code></pre>
That code will return the words count of the word <code>the</code>.
If no value matches the given key, then <code>get()</code> returns <code>null</code>. We can avoid that, though, by using the <code>getOrDefault()</code> method:
<pre><code class="hljs">wordsCount.getOrDefault(&quot;duck&quot;, 0);
</code></pre>
Note: Here, if nothing is associated to the key, we'll get <code>0</code> back instead of <code>null</code>.
Now, that's for retrieving one element at a time using its key. Let's see how to retrieve all the elements. The <code>Map</code> interface offers three methods to achieve this:
<ul>
<li><code>entrySet()</code>: Returns a <code>Set</code> of <code>Entry&lt;K, V&gt;</code> which are key/value pairs representing the elements of the map</li>
<li><code>keySet()</code>: Returns a <code>Set</code> of keys of the map</li>
<li><code>values()</code>: Returns a <code>Set</code> of values of the map</li>
</ul>
<h3 id="removingelements">Removing Elements</h3>
Now that we know how to put and retrieve elements from a map, let's see how to remove some!
First, let's see how to remove an element by its key. To this end, we'll use the <code>remove()</code> method, which takes a key as its parameter:
<pre><code class="hljs">wordsCount.remove(&quot;the&quot;);
</code></pre>
The method will remove the element and return the associated value if any, otherwise it does nothing and returns <code>null</code>.
The <code>remove()</code> method has an overloaded version taking also a value. Its goal is to remove an entry only if it has the same key and value as those specified in the parameters:
<pre><code class="hljs">wordsCount.remove(&quot;the&quot;, 153);
</code></pre>
This call will remove the entry associated to the word <code>the</code> only if the corresponding value is <code>153</code>, otherwise it doesn't do anything.
This method doesn't return an <code>Object</code>, but rather returns a <code>boolean</code> telling if an element has been removed or not.
<h3 id="iteratingoverelements">Iterating over Elements</h3>
We can't talk about a Java collection without explaining how to iterate over it. We'll see two ways to iterate over the elements of a <code>Map</code>.
The first one is the <code>for-each</code> loop, that we can use on the <code>entrySet()</code> method:
<pre><code class="hljs">for (Entry&lt;String, Integer&gt; wordCount: wordsCount.entrySet()) {
 System.out.println(wordCount.getKey() + &quot; appears &quot; + wordCount.getValue() + &quot; times&quot;);
}
</code></pre>
Before Java 8, this was the standard way of iterating through a <code>Map</code>. Fortunately for us, a less verbose way has been introduced in Java 8: the <code>forEach()</code> method which takes a <code>BiConsumer&lt;K, V&gt;</code>:
<pre><code class="hljs">wordsCount.forEach((word, count) -&gt; System.out.println(word + &quot; appears &quot; + count + &quot; times&quot;));
</code></pre>
Since some may not be familiar with the functional interface, <code>BiConsumer</code> - it accepts two arguments and doesn't return any value. In our case, we pass a <code>word</code> and its <code>count</code>, which are then printed out via a Lambda Expression.
This code is very concise and easier to read than the previous one.
<h3 id="checkingforanelementpresence">Checking for an Element Presence</h3>
Although we already had an overview of how to check for an element presence in a <code>Map</code>, let's talk about the possible ways of achieving that.
First of all, there is the <code>containsKey()</code> method, which we already used and that returns a <code>boolean</code> value telling us if an element matches the given key or not. But, there is also the <code>containsValue()</code> method which checks for the presence of a certain value.
Let's imagine a <code>Map</code> representing players scores for a game and the first to hit 150 wins, then we could use the <code>containsValue()</code> method to tell if a player wins the game or not:
<pre><code class="hljs">Map&lt;String, Integer&gt; playersScores = new HashMap&lt;&gt;();
playersScores.put(&quot;James&quot;, 0);
playersScores.put(&quot;John&quot;, 0);

while (!playersScores.containsValue(150)) {
 // Game taking place
}

System.out.println(&quot;We have a winner!&quot;);
</code></pre>
<h3 id="retrievingsizeandcheckingforemptiness">Retrieving Size and Checking for Emptiness</h3>
Now, as for <code>List</code> and <code>Set</code>, there are operations for counting the number of elements.
Those operations are <code>size()</code>, which returns the number of elements of the <code>Map</code>, and <code>isEmpty()</code>, which returns a <code>boolean</code> telling if the <code>Map</code> does or doesn't contain any element:
<pre><code class="hljs">Map&lt;String, Integer&gt; map = new HashMap&lt;&gt;();
map.put(&quot;One&quot;, 1);
map.put(&quot;Two&quot;, 2);

System.out.println(map.size());
System.out.println(map.isEmpty());
</code></pre>
The output is:
<pre><code class="hljs">2
false
</code></pre>
<h3 id="sortedmap">SortedMap</h3>
We've now covered the main operations we can realize on <code>Map</code> via the <code>HashMap</code> implementation. But there are other map interfaces that inherit from it that offer new features and make the contracts more strict.
The first one we'll learn about is the <code>SortedMap</code> interface, which ensures that entries of the map will maintain a certain order based on its keys.
In addition, this interface offers features taking advantage of the maintained ordering, such as the <code>firstKey()</code> and <code>lastKey()</code> methods.
Let's reuse our first example, but using a <code>SortedMap</code> this time:
<pre><code class="hljs">SortedMap&lt;String, Integer&gt; wordsCount = new TreeMap&lt;&gt;();
wordsCount.put(&quot;the&quot;, 150);
wordsCount.put(&quot;ball&quot;, 2);
wordsCount.put(&quot;duck&quot;, 4);

System.out.println(wordsCount.firstKey());
System.out.println(wordsCount.lastKey());
</code></pre>
Because the default ordering is the natural one, this will produce the following output:
<pre><code class="hljs">ball
the
</code></pre>
If you'd like to customize the order criteria, you can define a custom <code>Comparator</code> in the <code>TreeMap</code> constructor.
By defining a <code>Comparator</code>, we can compare keys (not full map entries) and sort them based on them, instead of values:
<pre><code class="hljs">SortedMap&lt;String, Integer&gt; wordsCount =
 new TreeMap&lt;String, Integer&gt;(new Comparator&lt;String&gt;() {
 @Override
 public int compare(String e1, String e2) {
 return e2.compareTo(e1);
 }
 });

wordsCount.put(&quot;the&quot;, 150);
wordsCount.put(&quot;ball&quot;, 2);
wordsCount.put(&quot;duck&quot;, 4);

System.out.println(wordsCount.firstKey());
System.out.println(wordsCount.lastKey());
</code></pre>
As the order is reversed, the output is now:
<pre><code class="hljs">the
ball
</code></pre>
<h3 id="navigablemap">NavigableMap</h3>
The <code>NavigableMap</code> interface is an extension of the <code>SortedMap</code> interface and it adds methods allowing to navigate the map more easily by finding the entries lower or higher than a certain key.
For example, the <code>lowerEntry()</code> method returns the entry with the greatest key that is strictly less than the given key:
Taking the map from the previous example:
<pre><code class="hljs">SortedMap&lt;String, Integer&gt; wordsCount = new TreeMap&lt;&gt;();
wordsCount.put(&quot;the&quot;, 150);
wordsCount.put(&quot;ball&quot;, 2);
wordsCount.put(&quot;duck&quot;, 4);

System.out.println(wordsCount.lowerEntry(&quot;duck&quot;));
</code></pre>
The output would be:
<pre><code class="hljs">ball
</code></pre>
<h3 id="concurrentmap">ConcurrentMap</h3>
Finally, the last <code>Map</code> extension we'll cover is the <code>ConcurrentMap</code>, which make the contract of the <code>Map</code> interface more strict by ensuring it to be thread-safe, that is usable in a multi-threading context without fearing the content of the map to be inconsistent.
This is achieved by making the updating operations, like <code>put()</code> and <code>remove()</code>, <a target="_blank'" href="/synchronized-keyword-in-java/">synchronized</a>.
<h3 id="implementations">Implementations</h3>
Now, let's take a look at the implementations of the different <code>Map</code> interfaces. We'll not cover all of them, just the main ones:
<ul>
<li><code>HashMap</code>: This is the implementation we used the most since the beginning, and is the most straightforward as it offers simple key/value mapping, even with <code>null</code> keys and values. It is a direct implementation of <code>Map</code> and therefore ensure neither order of the elements nor thread-safety.</li>
<li><code>EnumMap</code>: An implementation which takes <code>enum</code> constants as the keys of the map. Therefore, the number of elements in the <code>Map</code> are bound by the number of constants of the <code>enum</code>. Plus, the implementation is optimized for handling the generally rather small number of elements such a <code>Map</code> will contain.</li>
<li><code>TreeMap</code>: As an implementation of the <code>SortedMap</code> and <code>NavigableMap</code> interfaces, <code>TreeMap</code> ensures that elements added to it will observe a certain order (based on the key). This order will either be the natural order of the keys, or the one enforced by a <code>Comparator</code> we can give to the <code>TreeMap</code> constructor.</li>
<li><code>ConcurrentHashMap</code>: This last implementation is most likely the same as <code>HashMap</code>, expect that it ensures thread-safety for updating operations, as guaranteed by the <code>ConcurrentMap</code> interface.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Java Collections framework is a fundamental framework that every Java developer should know how to use.
In this article, we've talked about the <code>Map</code> interface. We covered the main operations through a <code>HashMap</code> as well as a few interesting extensions such as <code>SortedMap</code> or <code>ConcurrentMap</code>.

François Dupire

The Java Collections Framework is a fundamental and essential framework. The Map interface is a high-level interface from which many collections extend functionality.

Java Collections: The Map Interface

<h3 id="introduction">Introduction</h3>
Heap Sort is another example of an efficient sorting algorithm. Its main advantage is that it has a great worst-case runtime of $O(nlogn)$ regardless of the input data.
As the name suggests, Heap Sort relies heavily on the heap data structure - a common implementation of a Priority Queue.
Without a doubt, Heap Sort is one of the simplest sorting algorithms to implement, and coupled with the fact that it's a fairly efficient algorithm compared to other simple implementations, it's a common one to encounter.
<h3 id="theideabehindtheheapsort">The Idea Behind the Heap Sort</h3>
Heap Sort works by &quot;removing&quot; elements from the heap part of the array one by one and adding them to the sorted part of the array. Before we get further into the explanation and revisit the heap data structure, we should mention a few attributes of the Heap Sort itself.
It is an in-place algorithm, meaning that it requires a constant amount of additional memory, i.e. the memory needed doesn't depend on the size of the initial array itself, other than the memory needed to store that array.
For example, no copies of the original array are necessary, and there is no recursion and recursive call stacks. The simplest implementation of Heap Sort usually uses a second array to store the sorted values. We will be using this approach since it's a lot more intuitive and easy to follow in code, but it can be implemented completely in place.
Heap Sort is unstable, meaning that it does not maintain the relative order of elements with equal values. This isn't an issue with primitive types (like integers and characters...) but it can be a problem when we sort complex types, like objects.
For example, imagine we have a custom class <code>Person</code> with the <code>age</code> and <code>name</code> fields, and several objects of that class in an array, including a person called &quot;Mike&quot; aged 19, and &quot;David&quot;, also aged 19 - appearing in that order.
If we decided to sort that array of people by age, there would be no guarantee that &quot;Mike&quot; would appear before &quot;David&quot; in the sorted array, even though they appeared in that order in the initial array. It can happen, but it's not guaranteed.

 <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">
 Fun fact: Heap Sort is the sorting algorithm of choice in the <a rel="nofollow" target="_blank" href="https://github.com/torvalds/linux/blob/master/lib/sort.c">Linux Kernel</a>.

 </div>
 </div>
 </div>
 <h3 id="theheapdatastructure">The Heap Data Structure</h3>
Heaps are one of the most popular and heavily used data structures in computer science - not to mention very popular during Software Engineering interviews.
We'll talk of heaps keeping track of the smallest element (min-heap), but they can just as easily be implemented to keep track of the largest element (max-heap).
Simply put, a min-heap is a tree-based data structure in which every node is smaller than all of its children. Most often a binary tree is used. Heaps have three supported operations - <code>delete_minimum()</code>, <code>get_minimum()</code>, and <code>add()</code>.
You can only delete the first element in the heap, after which it's &quot;re-sorted&quot;. Heaps &quot;re-sort&quot; themselves after an element is added or removed so that the smallest element is always in the first position.

 <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 in no way means that heaps are sorted arrays. The fact that every node is smaller than its children isn't enough to guarantee that the whole heap is in ascending order.

 </div>
 </div>
 </div>
 Let's look at an example of a heap:
<img src="https://i.postimg.cc/54kvXxFL/heap-sort-in-python-01.png" alt="heap-sort-in-python-01.png">
As we can see, the above example does fit the description of a heap but is not sorted. We won't go into details of the heap implementation since that is not the focus of this article. The crucial advantage of the heap data structure we leverage when using it in Heap Sort is that the next smallest element is always the first element in the heap.

 <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: Thanks to the way heaps sort elements after an element is removed, the complexity of the next smallest element moving to the first position, while keeping the array a heap still, takes $O(logn)$ time, which is a highly efficient operation.

 </div>
 </div>
 </div>
 <h3 id="howtoimplementheapsortinpython">How to Implement Heap Sort in Python</h3>
<h4 id="sortingarrays">Sorting Arrays</h4>
Python provides methods for creating and using heaps so we don't have to implement them ourselves:
<ul>
<li><code>heappush(list, item)</code> - Adds an element to the heap, and re-sorts it afterward so that it remains a heap. Can be used on an empty list.</li>
<li><code>heappop(list)</code> - Pops (removes) the first (smallest) element and returns that element. The heap remains a heap after this operation, so we don't have to call <code>heapify()</code>.</li>
<li><code>heapify(list)</code> - Turns the given list into a heap. It is worth noting that this method exists even though we won't be using this since we don't want to change our original array.</li>
</ul>
Now that we know this, the implementation for Heap Sort is fairly straightforward:
<pre><code class="hljs">from heapq import heappop, heappush

def heap_sort(array):
 heap = []
 for element in array:
 heappush(heap, element)

 ordered = []

 # While we have elements left in the heap
 while heap:
 ordered.append(heappop(heap))

 return ordered

array = [13, 21, 15, 5, 26, 4, 17, 18, 24, 2]
print(heap_sort(array))
</code></pre>
Output:
<pre><code class="hljs">[2, 4, 5, 13, 15, 17, 18, 21, 24, 26]
</code></pre>
As we can see, the heavy lifting is done with the heap data structure, all we have to do is add all the elements we need and remove them one by one. It's almost like a coin-counting machine that sorts the inputted coins by their value and we can take them out afterward.
<h4 id="sortingcustomobjects">Sorting Custom Objects</h4>
Things get a little more complicated when using custom classes. Usually, we advise against overriding comparison operators in classes for the purpose of using our sorting algorithms for them and instead suggest rewriting the algorithm so that it takes a <a target="_blank" href="/lambda-functions-in-python/">lambda function</a> comparator instead.
However, since our implementation relies on the built-in heap methods, we can't do that here.
Python does provide the following methods:
<ul>
<li><code>heapq.nlargest(*n*, *iterable*, *key=None*)</code> - Returns a list with the n largest elements from the dataset defined by <code>iterable</code>.</li>
<li><code>heapq.nsmallest(*n*, *iterable*, *key=None*)</code> - Returns a list with the n smallest elements from the dataset defined by <code>iterable</code>.</li>
</ul>
We could use it to simply get <code>n = len(array)</code> largest/smallest elements but the methods themselves do not use Heap Sort and are essentially equivalent to just calling the <code>sorted()</code> method.
The only solution we have left for custom classes is to actually override the comparison operators. This sadly limits us to only one type of comparison per class. In our example, it limits us to sorting <code>Movie</code> objects by year.
However, it does let us demonstrate using Heap Sort on custom classes. Let's go ahead and define the <code>Movie</code> class:
<pre><code class="hljs">from heapq import heappop, heappush

class Movie:
 def __init__(self, title, year):
 self.title = title
 self.year = year

 def __str__(self):
 return str.format(&quot;Title: {}, Year: {}&quot;, self.title, self.year)

 def __lt__(self, other):
 return self.year &lt; other.year

 def __gt__(self, other):
 return other.__lt__(self)

 def __eq__(self, other):
 return self.year == other.year

 def __ne__(self, other):
 return not self.__eq__(other)
</code></pre>
And now, let's slightly modify our <code>heap_sort()</code> function:
<pre><code class="hljs">def heap_sort(array):
 heap = []
 for element in array:
 heappush(heap, element)

 ordered = []

 while heap:
 ordered.append(heappop(heap))

 return ordered
</code></pre>
And finally, let's instantiate a few movies, put them in an array, and then sort them:
<pre><code class="hljs">movie1 = Movie(&quot;Citizen Kane&quot;, 1941)
movie2 = Movie(&quot;Back to the Future&quot;, 1985)
movie3 = Movie(&quot;Forrest Gump&quot;, 1994)
movie4 = Movie(&quot;The Silence of the Lambs&quot;, 1991);
movie5 = Movie(&quot;Gia&quot;, 1998)

array = [movie1, movie2, movie3, movie4, movie5]

for movie in heap_sort(array):
 print(movie)
</code></pre>
Output:
<pre><code class="hljs">Title: Citizen Kane, Year: 1941
Title: Back to the Future, Year: 1985
Title: The Silence of the Lambs, Year: 1991
Title: Forrest Gump, Year: 1994
Title: Gia, Year: 1998
</code></pre>
<h3 id="comparisontoothersortingalgorithms">Comparison to Other Sorting Algorithms</h3>
One of the main reasons Heap Sort is still used fairly often, even though it's often outperformed by a well-implemented <a target="_blank" href="/quicksort-in-python/">Quick Sort</a>, is its reliability.
Heap Sort's main advantage here is the $O(nlogn)$ upper bound as far as time complexity is concerned, and security concerns. Linux kernel developers give the following reasoning for using Heap Sort over Quick Sort:
<blockquote>
The sorting time of Heap Sort is $O(nlogn)$ both on average and worst-case. While qsort is about 20% faster on average, it suffers from an exploitable $O(n^2)$ worst-case behavior and extra memory requirements that make it less suitable for kernel use.
</blockquote>
Furthermore, Quick Sort behaves poorly in predictable situations, and given enough knowledge of the internal implementation, it could create a security risk (mainly DDoS attacks) since the bad $O(n^2)$ behavior could easily be triggered.
Another algorithm that Heap Sort is often compared to is <a target="_blank" href="/merge-sort-in-python/">Merge Sort</a>, which has the same time complexity.
Merge Sort has the advantage of being stable and intuitively parallelizable, while Heap Sort is neither.
Another note is that Heap Sort is slower than Merge Sort in most cases, even though they have the same complexity since Heap Sort has larger constant factors.
Heap Sort can, however, be implemented much more easily in place than Merge Sort can, so it's preferred when memory is a more important factor than speed.
<h3 id="conclusion">Conclusion</h3>
As we saw, Heap Sort isn't as popular as other efficient, general-purpose algorithms but its predictable behavior (other than being unstable) makes it a great algorithm to use where memory and security are more important than slightly faster run-time.
It's really intuitive to implement and leverage the built-in functionality provided with Python, all we essentially have to do is put the items in a heap and take them out - similar to a coin counter.

Olivera Popović

Dimitrije Stamenic

Heap Sort is one of the few efficient sorting algorithms in widespread use. With a constant runtime of O(n*logn) and relying on the heap data structure, Heap Sort has found its way in many projects.

Heap Sort in Python

Hiram Kamau

PostgreSQL is a great pairing for Java due to its object-relational nature. With the extended support for custom data types and large data sets, it's an extremely popular choice for many Java developers.