<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 one.
Java Collections is a framework that provides numerous operations over a collection - searching, sorting, insertion, manipulation, deletion, etc.
This is the fourth and final part of a series of articles on Java Collections:
<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><a target="_blank" href="/java-collections-the-map-interface/">The Map Interface</a></li>
<li>Queues, Deques, Stacks (you are here)</li>
</ul>
<h2 id="queue">Queue</h2>
Let's start this final article of the series with the <code>java.util.Queue</code> interface.
<h3 id="principle">Principle</h3>
First of all, what's it good for? The <code>Queue</code> is designed to <a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Queue.html">hold elements prior to their processing</a>. Some can be of a fixed capacity, meaning they can contain only up to a certain number of elements.
So, the idea is to push some elements into a <code>Queue</code>, and then retrieve them afterwards. Generally, queues are returning elements respecting the First-In First-Out (FIFO) pattern, meaning the oldest element of the queue is returned first, then the oldest after that, etc.
<blockquote>
You can think of FIFO as a line in front of a store. The first one to stand in the line is the first one to enter.
</blockquote>
But there can be other implementations which respect the Last-In First-Out (LIFO) pattern, or even answer to some kind of priority system (e.g. using <code>Comparator</code>).
<blockquote>
You can think of LIFO as a stack of coins. The last one to be put on the top of the stack is the first one to be taken off.
</blockquote>
Let's now explore the features of the <code>Queue</code> interface!
<h3 id="addinganelement">Adding an Element</h3>
We'll begin by adding an element to a <code>Queue</code>. First, let's instantiate one using the <code>ArrayDeque</code> implementation, which also implements the <code>Deque</code> interface we'll cover later:
<pre><code class="hljs">Queue&lt;Integer&gt; queue = new ArrayDeque&lt;&gt;();
</code></pre>
In order to add an element in this <code>Queue</code>, we have two possibilities: the <code>add()</code> method or the <code>offer()</code> method.
Let's start with the former:
<pre><code class="hljs">queue.add(3);
</code></pre>
And with the latter:
<pre><code class="hljs">queue.offer(4);
</code></pre>
Both return a <code>boolean</code> value indicating if the element was added to the <code>Queue</code> or not, according to its capacity (if it applies). What's the difference between both methods then?
Well, the first will in fact never return <code>false</code>, rather throwing an <code>Exception</code> when adding an element to a full <code>Queue</code>. On the other hand, the second one will return <code>false</code> in such cases.
Instead of <code>ArrayDeque</code>, which is unbounded, let's use the <code>LinkedBlockingQueue</code> which can be assigned a capacity:
<pre><code class="hljs">Queue&lt;Integer&gt; queue = new LinkedBlockingQueue&lt;&gt;(1);
</code></pre>
Here, we've instantiated a queue which can hold a maximum of one element at a time. Therefore, we can't use the <code>add()</code> method two times consecutively without having an exception:
<pre><code class="hljs">queue.add(3);
queue.add(4);
</code></pre>
Trying to add these two elements will result in:
<pre><code class="hljs">java.lang.IllegalStateException: Queue full
 at java.base/java.util.AbstractQueue.add(AbstractQueue.java:98)
</code></pre>
On the other hand, using the <code>offer()</code> method instead will do nothing and return <code>false</code> as a result.
<h3 id="retrievinganelement">Retrieving an Element</h3>
As stated earlier, a <code>Queue</code> generally respects FIFO, which means that it'll return the first entered element first, if we're retrieving one.
The interface offers a few methods to retrieve elements. Two of them, <code>remove()</code> and <code>poll()</code>, remove the element before returning it. The two others, <code>element()</code> and <code>peek()</code> just return it but don't remove it.
The <code>remove()</code> and <code>element()</code> methods will throw an exception when called on an empty <code>Queue</code>:
<pre><code class="hljs">Queue&lt;Integer&gt; queue = new ArrayDeque&lt;&gt;();
queue.offer(3);
queue.offer(4);

queue.poll();
queue.peek();
</code></pre>
Here, our we'll gather the elements <code>3</code> and <code>4</code>, but the first time the element will be removed (via <code>poll()</code>), and the second time not (via <code>peek()</code>), leaving our queue with element <code>4</code> in it.
Using <code>remove()</code> and <code>element()</code> instead of <code>poll()</code> and <code>peek()</code>, respectively, would've had the same results, as the queue is never empty in our case.
<h3 id="iteratingoverelements">Iterating over Elements</h3>
Besides indexed <code>while</code> and <code>for</code> loops, the <code>Queue</code> interface implements <code>Iterable</code> and provides an <code>Iterator</code>, therefore making it eligible for the <code>for-each</code> loop:
<pre><code class="hljs">for (Integer element: queue) {
 System.out.println(element);
}
</code></pre>
That loop would print each element of the queue to the console.
Since Java 8, of course, there's the possibility to call the <code>forEach()</code> method, passing a <a target="_blank" href="/method-references-in-java-8">Method Reference</a>:
<pre><code class="hljs">queue.forEach(System.out::println);
</code></pre>
This achieves the same result as the previous loop.
If you'd like to read more about the <a target="_blank" href="/java-iterable-interface-iterator-listiterator-and-spliterator/">Iterable Interface in Java</a>, we've got you covered!
<h3 id="implementations">Implementations</h3>
Now, what are the classes that implements the <code>Queue</code> interface? There are several implementations of the interface, though these are really the most relevant ones:
<ul>
<li><code>LinkedList</code>: Although mainly known to be a <code>List</code> implementation, this class also implements the <code>Queue</code> interface. This implementation works by linking its elements together and going through that chain when iterating or searching for elements.</li>
<li><code>ArrayDeque</code>: An implementation of both <code>Queue</code> and <code>Deque</code>. Its backed up by an array, which can be increased when the number of elements increase over its current capacity.</li>
<li><code>DelayQueue</code>: Can only contain elements which implement the <code>Delayed</code> interface - elements that become active after a certain time. The <code>DelayQueue</code> will only deliver elements whose delays have expired.</li>
<li><code>PriorityQueue</code>: Orders its elements according to their natural order or a <code>Comparator</code> (if provided). This means it doesn't work using the FIFO principle, but rather returns the element with the highest priority (defined by how they compare to each other).</li>
</ul>
Let's imagine an anomaly system, with an <code>enum</code> defining their severity:
<pre><code class="hljs">public class Anomaly implements Comparable&lt;Anomaly&gt; {
 private String log;
 private Severity severity;

 public Anomaly(String log, Severity severity) {
 this.log = log;
 this.severity = severity;
 }

 @Override
 public int compareTo(Anomaly o) {
 return severity.compareTo(o.severity);
 }

 private enum Severity {
 HIGH,
 MEDIUM,
 LOW
 }
}
</code></pre>
Here, anomalies are naturally ordered by their severities (as <code>enum</code> are naturally ordered by their declaration order).
So, if we were to add two anomalies to a <code>PriorityQueue</code> without a <code>Comparator</code>, one <code>LOW</code> and one <code>HIGH</code>, then the <code>poll()</code> method would return the second anomaly first rather and the first one:
<pre><code class="hljs">Queue&lt;Anomaly&gt; anomalies = new PriorityQueue&lt;&gt;();

Anomaly optionalInformationNotRetrievedAnomaly = new Anomaly(&quot;Couldn&#x27;t retrieve optional information&quot;, Anomaly.Severity.LOW);
anomalies.offer(optionalInformationNotRetrievedAnomaly);

Anomaly databaseNotReachableAnomaly = new Anomaly(&quot;Couldn&#x27;t contact database&quot;, Anomaly.Severity.HIGH);
anomalies.offer(databaseNotReachableAnomaly);

anomalies.poll(); // This would return &#x27;databaseNotReachableAnomaly&#x27;
</code></pre>
Now, if we pass a <code>Comparator</code> to the <code>PriorityQueue</code> constructor, let's say one that reverses the natural order:
<pre><code class="hljs">Queue&lt;Anomaly&gt; anomalies = new PriorityQueue&lt;&gt;(Comparator.reverseOrder());
</code></pre>
Then in the same scenario as before, the <code>poll()</code> method would return the first anomaly - that is <code>optionalInformationNotRetrievedAnomaly</code>.
<h2 id="deque">Deque</h2>
Now that the <code>Queue</code> interface has been covered, let's jump to <code>Deque</code>.
<h3 id="principle">Principle</h3>
Deque stands for <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Double-ended_queue">Double Ended Queue</a>, which means this is a queue that can be accessed by both ends, and therefore can be used with both FIFO and LIFO styles. By default, it organizes its element LIFO style, meaning that getting the first in the <code>Deque</code> would return the last that had been added.
<h3 id="addinganelement">Adding an Element</h3>
Let's jump to <code>Deque</code> usages with element insertion. There are multiple possibilities to achieve that:
<ul>
<li>Some methods add the element at the top, some at the bottom</li>
<li>Some methods throw an exception if the <code>Deque</code> is full, some don't</li>
</ul>
Let's summarize them in a table:
<table class="table table-striped" style="white-space:nowrap;">
 <tr>
 <th></th>
 <th>Top</th>
 <th>Bottom</th>
 </tr>
 <tr>
 <td>No Exception</td>
 <td><code>offerFirst()</code></td>
 <td><code>offer()</code>, <code>offerLast()</code></td>
 </tr>
 <tr>
 <td>Exception</td>
 <td><code>addFirst()</code>, <code>push()</code></td>
 <td><code>add()</code>, <code>addLast()</code></td>
 </tr>
</table>
Let's say we have a <code>Deque</code> of <code>Integer</code> and we call <code>addFirst()</code> with integers <code>3</code> and <code>4</code>:
<pre><code class="hljs">Deque&lt;Integer&gt; deque = new ArrayDeque&lt;&gt;();
deque.addFirst(3);
deque.addFirst(4);
</code></pre>
Then, the deque will contain <code>4</code> and <code>3</code>, in this order.
If we had used <code>addLast()</code>, then it would've contained <code>3</code> and <code>4</code>, in this order. The same would've happened with <code>offerFirst()</code> and <code>offerLast()</code>, respectively.
<h3 id="retrievingandremovinganelement">Retrieving and Removing an Element</h3>
Now, let's see how to retrieve elements from a <code>Deque</code>. Again, there are multiple possibilities:
<ul>
<li>Some methods return the first element, some return the last</li>
<li>Some methods remove the element when returned, some don't</li>
<li>Some methods throw an exception if the <code>Deque</code> is empty, some don't</li>
</ul>
To make it a bit easier, we're going to summarize that in a table as well:
<table class="table table-striped" style="white-space:nowrap; overflow-x:auto;">
 <tr>
 <th></th>
 <th>First (top) element, no removal</th>
 <th>First (top) element, removal</th>
 </tr>
 <tr>
 <td>No Exception</td>
 <td><code>peek()</code>, <code>peekFirst()</code></td>
 <td><code>poll()</code>, <code>pollFirst()</code></td>
 </tr>
 <tr>
 <td>Exception</td>
 <td><code>getFirst()</code>, <code>element()</code></td>
 <td><code>remove()</code>, <code>removeFirst()</code>, <code>pop()</code></td>
 </tr>
</table>
<table class="table table-striped" style="white-space:nowrap;overflow-x:auto;">
 <tr>
 <th></th>
 <th>Last (bottom) element, no removal</th>
 <th>Last (bottom) element, removal</th>
 </tr>
 <tr>
 <td>No Exception</td>
 <td><code>peekLast()</code></td>
 <td><code>pollLast()</code></td>
 </tr>
 <tr>
 <td>Exception</td>
 <td><code>getLast()</code></td>
 <td><code>removeLast()</code></td>
 </tr>
</table>
Let's say we have a <code>Deque</code> of <code>Integer</code> with elements <code>4</code> and <code>3</code>, top to bottom. And we call <code>peekFirst()</code>:
<pre><code class="hljs">Deque&lt;Integer&gt; deque = new ArrayDeque&lt;&gt;();
deque.push(3);
deque.push(4);

deque.peekFirst();
</code></pre>
Then, this would return <code>4</code>, without removing the element. If we had used <code>peekLast()</code>, then it would've returned <code>3</code>.
Now, if we were to use <code>removeFirst()</code> or <code>pop()</code>, we would got <code>4</code> but the <code>Deque</code> would only contain <code>3</code> in the end.
<h3 id="iteratingoverelements">Iterating over Elements</h3>
As for the <code>Queue</code>, we can iterate using the standard mechanisms and the <code>forEach()</code> method. We just have to remember that, by default, the <code>Deque</code> organizes its elements LIFO style and therefore will iterate on them, top to bottom:
<pre><code class="hljs">Deque&lt;Integer&gt; deque = new ArrayDeque&lt;&gt;();
deque.push(3);
deque.push(4);

deque.forEach(System.out::println);
</code></pre>
This would print:
<pre><code class="hljs">4
3
</code></pre>
You could also use an <code>Iterator</code>:
<pre><code class="hljs">Deque&lt;Integer&gt; deque = new ArrayDeque&lt;&gt;();
deque.push(3);
deque.push(4);

for (Iterator&lt;Integer&gt; iterator = deque.iterator(); iterator.hasNext();) {
 System.out.println(iterator.next());
}
</code></pre>
This would also print:
<pre><code class="hljs">4
3
</code></pre>
<h3 id="implementations">Implementations</h3>
<ul>
<li><code>ArrayDeque</code>: This is the one we used for <code>Queue</code> and which is backed up by an <code>array</code>. Implements both <code>Queue</code> and <code>Deque</code>.</li>
<li><code>LinkedList</code>: Implements both <code>Queue</code>, <code>Deque</code> and <code>List</code>. We also see this one earlier.</li>
<li><code>LinkedBlockingDeque</code>: This one works a bit like the <code>LinkedList</code>, but can be bounded. Thus the insertion operations we saw earlier would throw an exception if this <code>Deque</code> was full.</li>
</ul>
<h2 id="stack">Stack?</h2>
It's worth noting that a <code>Stack</code> exists as well. It was introduced in the beginning of Java and was to be used as a LIFO collection, with <code>push()</code> and <code>pop()</code> methods.
<blockquote>
Why not use it then?
</blockquote>
Because the documentation advise us to use the <code>Deque</code> interface which offers a more consistent API. Plus, <code>Stack</code> is subclass of <code>Vector</code> and thus is tightly bound to it, making it a <code>List</code> above all things, which is conceptually different from a stack.
<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>Queue</code> and <code>Deque</code> interfaces and covered their main operations. The full code for this article can be found over on <a rel="nofollow noopener" target="_blank" href="https://github.com/dupirefr/stackabuse-code">GitHub</a>.

François Dupire

The Java Collections Framework is a fundamental and essential framework. The Queues and Deques are designed to hold elements prior to processing in FIFO or LIFO styles.

Java Collections: Queue and Deque Interfaces

Guest Contributor

AWS SNS is a publisher/subscriber messaging system and a popular choice for many developers. In this tutorial, we'll be making a Spring Cloud app with SMS and Email messaging support.

Spring Cloud: AWS SNS

Usman Malik

BERT is a text representation technique similar to Word Embeddings. In this article, we'll be using BERT and TensorFlow 2.0 for text classification.

Text Classification with BERT Tokenizer and TF 2.0 in Python

Unless you have been hiding under a rock, you have probably used <a rel="nofollow noopener" target="_blank" href="https://translate.google.com/">Google Translate</a> on many occasions in your life. Whenever you try to translate a word or a sentence from a certain language to another, it is the Google Translate API which brings you the desired results in the background. Though you can translate anything by simply going to the Google Translate web page, you can also integrate <a rel="nofollow noopener" target="_blank" href="https://pypi.org/project/googletrans/">Google Translate API</a> into your web applications or desktop programs. The best thing about the API is that it is extremely easy to set up and use.
You can actually do a lot of things with the help of the Google Translate API ranging from detecting languages to simple text translation, setting source and destination languages, and translating entire lists of text phrases. In this article, you will see how to work with the Google Translate API in the Python programming language.
<h2 id="googletranslateapiinstallation">Google Translate API Installation</h2>
Before you can work with the Google Translate API in Python, you will have to install it. There are two different methods of installing the API. The first method is straight forward. Simply go to terminal and use the <code>pip</code> installer to install the API, as you would for any other Python library. To do this, type the following command in your terminal:
<pre><code class="hljs">$ pip install googletrans
</code></pre>
Press <kbd>Enter</kbd> and the Python module for Google Translate API will be installed on your system.
If you have installed an Anaconda distribution of Python, you can install the API using the Anaconda Prompt. In this particular method, you will replace <code>pip</code> in the above command with <code>conda</code>, as shown in the following code snippet:
<pre><code class="hljs">$ conda install googletrans
</code></pre>
Now that you have installed the API, we will see it in action with the help of some examples.
<h2 id="listingsupportedlanguages">Listing Supported Languages</h2>
The Google Translate API supports a variety of languages. To list all the supported languages, run the following script:
<pre><code class="hljs">import googletrans

print(googletrans.LANGUAGES)
</code></pre>
In the above example, you use the keyword <code>import</code> to import the <code>googletrans</code> module. Subsequently, you can list all the language names by printing the <code>LANGUAGES</code> attribute of the <code>googletrans</code> module.
When executed, the above piece of code will list all the supported languages names along with their shorthand notation. Here is how the output will look:
<pre><code class="hljs">{&#x27;af&#x27;: &#x27;afrikaans&#x27;, &#x27;sq&#x27;: &#x27;albanian&#x27;, &#x27;am&#x27;: &#x27;amharic&#x27;, &#x27;ar&#x27;: &#x27;arabic&#x27;, &#x27;hy&#x27;: &#x27;armenian&#x27;, &#x27;az&#x27;: &#x27;azerbaijani&#x27;, &#x27;eu&#x27;: &#x27;basque&#x27;, &#x27;be&#x27;: &#x27;belarusian&#x27;, &#x27;bn&#x27;: &#x27;bengali&#x27;, &#x27;bs&#x27;: &#x27;bosnian&#x27;, &#x27;bg&#x27;: &#x27;bulgarian&#x27;, &#x27;ca&#x27;: &#x27;catalan&#x27;, &#x27;ceb&#x27;: &#x27;cebuano&#x27;, &#x27;ny&#x27;: &#x27;chichewa&#x27;, &#x27;zh-cn&#x27;: &#x27;chinese (simplified)&#x27;, &#x27;zh-tw&#x27;: &#x27;chinese (traditional)&#x27;, &#x27;co&#x27;: &#x27;corsican&#x27;, &#x27;hr&#x27;: &#x27;croatian&#x27;, &#x27;cs&#x27;: &#x27;czech&#x27;, &#x27;da&#x27;: &#x27;danish&#x27;, &#x27;nl&#x27;: &#x27;dutch&#x27;, &#x27;en&#x27;: &#x27;english&#x27;, &#x27;eo&#x27;: &#x27;esperanto&#x27;, &#x27;et&#x27;: &#x27;estonian&#x27;, &#x27;tl&#x27;: &#x27;filipino&#x27;, &#x27;fi&#x27;: &#x27;finnish&#x27;, &#x27;fr&#x27;: &#x27;french&#x27;, &#x27;fy&#x27;: &#x27;frisian&#x27;, &#x27;gl&#x27;: &#x27;galician&#x27;, &#x27;ka&#x27;: &#x27;georgian&#x27;, &#x27;de&#x27;: &#x27;german&#x27;, &#x27;el&#x27;: &#x27;greek&#x27;, &#x27;gu&#x27;: &#x27;gujarati&#x27;, &#x27;ht&#x27;: &#x27;haitian creole&#x27;, &#x27;ha&#x27;: &#x27;hausa&#x27;, &#x27;haw&#x27;: &#x27;hawaiian&#x27;, &#x27;iw&#x27;: &#x27;hebrew&#x27;, &#x27;hi&#x27;: &#x27;hindi&#x27;, &#x27;hmn&#x27;: &#x27;hmong&#x27;, &#x27;hu&#x27;: &#x27;hungarian&#x27;, &#x27;is&#x27;: &#x27;icelandic&#x27;, &#x27;ig&#x27;: &#x27;igbo&#x27;, &#x27;id&#x27;: &#x27;indonesian&#x27;, &#x27;ga&#x27;: &#x27;irish&#x27;, &#x27;it&#x27;: &#x27;italian&#x27;, &#x27;ja&#x27;: &#x27;japanese&#x27;, &#x27;jw&#x27;: &#x27;javanese&#x27;, &#x27;kn&#x27;: &#x27;kannada&#x27;, &#x27;kk&#x27;: &#x27;kazakh&#x27;, &#x27;km&#x27;: &#x27;khmer&#x27;, &#x27;ko&#x27;: &#x27;korean&#x27;, &#x27;ku&#x27;: &#x27;kurdish (kurmanji)&#x27;, &#x27;ky&#x27;: &#x27;kyrgyz&#x27;, &#x27;lo&#x27;: &#x27;lao&#x27;, &#x27;la&#x27;: &#x27;latin&#x27;, &#x27;lv&#x27;: &#x27;latvian&#x27;, &#x27;lt&#x27;: &#x27;lithuanian&#x27;, &#x27;lb&#x27;: &#x27;luxembourgish&#x27;, &#x27;mk&#x27;: &#x27;macedonian&#x27;, &#x27;mg&#x27;: &#x27;malagasy&#x27;, &#x27;ms&#x27;: &#x27;malay&#x27;, &#x27;ml&#x27;: &#x27;malayalam&#x27;, &#x27;mt&#x27;: &#x27;maltese&#x27;, &#x27;mi&#x27;: &#x27;maori&#x27;, &#x27;mr&#x27;: &#x27;marathi&#x27;, &#x27;mn&#x27;: &#x27;mongolian&#x27;, &#x27;my&#x27;: &#x27;myanmar (burmese)&#x27;, &#x27;ne&#x27;: &#x27;nepali&#x27;, &#x27;no&#x27;: &#x27;norwegian&#x27;, &#x27;ps&#x27;: &#x27;pashto&#x27;, &#x27;fa&#x27;: &#x27;persian&#x27;, &#x27;pl&#x27;: &#x27;polish&#x27;, &#x27;pt&#x27;: &#x27;portuguese&#x27;, &#x27;pa&#x27;: &#x27;punjabi&#x27;, &#x27;ro&#x27;: &#x27;romanian&#x27;, &#x27;ru&#x27;: &#x27;russian&#x27;, &#x27;sm&#x27;: &#x27;samoan&#x27;, &#x27;gd&#x27;: &#x27;scots gaelic&#x27;, &#x27;sr&#x27;: &#x27;serbian&#x27;, &#x27;st&#x27;: &#x27;sesotho&#x27;, &#x27;sn&#x27;: &#x27;shona&#x27;, &#x27;sd&#x27;: &#x27;sindhi&#x27;, &#x27;si&#x27;: &#x27;sinhala&#x27;, &#x27;sk&#x27;: &#x27;slovak&#x27;, &#x27;sl&#x27;: &#x27;slovenian&#x27;, &#x27;so&#x27;: &#x27;somali&#x27;, &#x27;es&#x27;: &#x27;spanish&#x27;, &#x27;su&#x27;: &#x27;sundanese&#x27;, &#x27;sw&#x27;: &#x27;swahili&#x27;, &#x27;sv&#x27;: &#x27;swedish&#x27;, &#x27;tg&#x27;: &#x27;tajik&#x27;, &#x27;ta&#x27;: &#x27;tamil&#x27;, &#x27;te&#x27;: &#x27;telugu&#x27;, &#x27;th&#x27;: &#x27;thai&#x27;, &#x27;tr&#x27;: &#x27;turkish&#x27;, &#x27;uk&#x27;: &#x27;ukrainian&#x27;, &#x27;ur&#x27;: &#x27;urdu&#x27;, &#x27;uz&#x27;: &#x27;uzbek&#x27;, &#x27;vi&#x27;: &#x27;vietnamese&#x27;, &#x27;cy&#x27;: &#x27;welsh&#x27;, &#x27;xh&#x27;: &#x27;xhosa&#x27;, &#x27;yi&#x27;: &#x27;yiddish&#x27;, &#x27;yo&#x27;: &#x27;yoruba&#x27;, &#x27;zu&#x27;: &#x27;zulu&#x27;, &#x27;fil&#x27;: &#x27;Filipino&#x27;, &#x27;he&#x27;: &#x27;Hebrew&#x27;}
</code></pre>
<h2 id="basicuse">Basic Use</h2>
The most basic use of the Google Translate API is, of course, translating words or sentences from one language into another. To do so, we have to import the <code>Translator</code> class from <code>googletrans</code> module.
<pre><code class="hljs">from googletrans import Translator
</code></pre>
Next, you have to create an object of the <code>Translator</code> class.
<pre><code class="hljs">translator = Translator()
</code></pre>
Once the Translator class object is created, you will pass the text in source language as a parameter to the <code>translate()</code> method of the <code>Translator()</code> class object, as shown below:
<pre><code class="hljs">result = translator.translate(&#x27;Mitä sinä teet&#x27;)
</code></pre>
In the script above, we pass Finnish text to the <code>translate()</code> method.
The <code>translate()</code> method returns an object that contains information about the translated text, the source and destination languages and the pronunciation of the text. By default, the <code>translate()</code> method returns the English translation of the text passed to it. In our case, the object returned by the <code>translate()</code> method is stored in the <code>result</code> variable.
The object returned by the <code>translate()</code> method has the following attributes:
<ul>
<li><code>src</code>: The source language</li>
<li><code>dest</code>: Destination language, which is set to English (en)</li>
<li><code>origin</code>: Original text, that is 'Mitä sinä teet' in our example</li>
<li><code>text</code>: Translated text, that will be 'what are you doing?' in our case</li>
<li><code>pronunciation</code>: Pronunciation of the translated text</li>
</ul>
Let's print all the above attributes and see what output we get:
<pre><code class="hljs">print(result.src)
print(result.dest)
print(result.origin)
print(result.text)
print(result.pronunciation)
</code></pre>
Output:
<pre><code class="hljs">fi
en
Mitä sinä teet
What are you doing
What are you doing
</code></pre>
The output shows that the source language is Finnish (fi) and the destination language is English (en). The translated sentence can be printed via the <code>text</code> attribute.
In the above example, we did not specify the source language. Therefore, Google Translate API tries to detect source language itself. Similarly, we did not specify any destination language as well and thus, the API translated the source language into the default language that is English. But, what if you want to specify both the source and destination languages?
<h2 id="specifyingsourceanddestinationlanguages">Specifying Source and Destination Languages</h2>
It is in fact, very easy to specify both the destination and source languages in the Google Translate API. Here is the code you'll use to pass only the source language:
<pre><code class="hljs">result = translator.translate(&#x27;Mikä on nimesi&#x27;, src=&#x27;fi&#x27;)
</code></pre>
For adding destination language only, you have to add <code>dest</code> attribute, followed by the language code:
<pre><code class="hljs">result = translator.translate(&#x27;Mikä on nimesi&#x27;, dest=&#x27;fr&#x27;)
</code></pre>
You can also pass the source and destination languages at the same time:
<pre><code class="hljs">result = translator.translate(&#x27;Mikä on nimesi&#x27;, src=&#x27;fi&#x27;, dest=&#x27;fr&#x27;)
</code></pre>
Let's now translate a Finnish sentence into French and then print the source and destination languages, as well as the translated text. This time we will specify the source and destination languages.
<pre><code class="hljs">from googletrans import Translator

translator = Translator()
result = translator.translate(&#x27;Mikä on nimesi&#x27;, src=&#x27;fi&#x27;, dest=&#x27;fr&#x27;)

print(result.src)
print(result.dest)
print(result.text)
</code></pre>
The above piece of code will produce the following result.
<pre><code class="hljs">fi
fr
Quel est votre nom
</code></pre>
<h2 id="translatinglistofphrases">Translating List of Phrases</h2>
It is also possible to translate a list of textual phrases with the help of the Google Translate API. The basic process is the same as discussed above. You just have to pass the list containing the phrases as a parameter to the <code>translate()</code> method. This is useful for having a batch of phrases translated separately, but all in one API call.
Let's create a list of strings containing some phrases from the French language.
<pre><code class="hljs">sentences = [&#x27;Bienvenu&#x27;, &#x27;Comment allez-vous&#x27;, &#x27;je vais bien&#x27;]
</code></pre>
Now it is time to call the <code>translate()</code> method and pass the list, the source language, and the destination language as parameters.
<pre><code class="hljs">result = translator.translate(sentences, src=&#x27;fr&#x27;, dest=&#x27;sw&#x27;)
</code></pre>
In the above script, the source language is French and the destination language is Swahili.
The <code>translate()</code> method returns a list of objects if you pass a list of phrases to it. Each object in the list returned by <code>translate()</code> method corresponds to each phrase in the input list that has to be translated. The best way to find the translation of each input phrase in the list is to iterate over the list of output objects. You can then use the <code>text</code>, <code>origin</code>, <code>src</code>, and other attributes of the individual objects to see the translation of individual phrases in the input list.
In the script below, we iterate over the list of objects returned by the <code>translate()</code> method and then print the origin and translated text:
<pre><code class="hljs">for trans in result:
 print(f&#x27;{trans.origin} -&gt; {trans.text}&#x27;)
</code></pre>
The following will be the result displayed on the screen.
<pre><code class="hljs">Bienvenu -&gt; karibu
Comment allez-vous -&gt; Vipi wewe
je vais bien -&gt; Niko sawa
</code></pre>
<h2 id="translatingtextdocuments">Translating Text Documents</h2>
You can also translate text documents via Google Translate API. All you have to do is to read the text file in Python using the <code>open</code> method, read the text and pass it to the <code>translate()</code> method.
The first step is to open the file in the &quot;read&quot; mode:
<pre><code class="hljs">f = open(&#x27;C:\\Users\\Khurram\\Desktop\\test.txt&#x27;, &#x27;r&#x27;)
</code></pre>
You can also check whether or not the file is in &quot;read&quot; mode using the <code>mode</code> property:
<pre><code class="hljs">if f.mode == &#x27;r&#x27;:
</code></pre>
Next, you can use the <code>f.read()</code> method to read the contents of the file. The contents of the file can be stored in any variable. In our case, the name of the variable will be <code>contents.</code>
We will also print the <code>contents</code> variable to check whether or not Python is properly reading the text file:
<pre><code class="hljs">contents = f.read()
print(contents)
</code></pre>
Here is the output of the file contents:
<pre><code class="hljs">We are going to translate this text file using Python.
Subsequently, we will also translate it into French.
</code></pre>
Make sure you have the above content in your text file if you want to follow along with our example.
We have ascertained that Python is accessing and reading the text file. Now, we will translate the result by importing the same old <code>Translate</code> class from before.
<pre><code class="hljs">from googletrans import Translator

file_translate = Translator()
</code></pre>
The next step is to pass the <code>contents</code> variable containing the input text to the <code>translate()</code> function. Finally, print the <code>text</code> attribute of the object returned by the <code>translate()</code> method and you will get the translated string.
<pre><code class="hljs">result = translator.translate(contents, dest=&#x27;fr&#x27;)
print(result.text)
</code></pre>
The output should look like the following:
<pre><code class="hljs">Nous allons traduire ce fichier texte en Python.
Par la suite, nous le traduirons également en français.
</code></pre>
To write the translated text to the same file, or a different text file, you will simply open the file in the write mode (&quot;w&quot;). Next, you need to call the <code>write()</code> method and pass it your translated text, as shown below:
<pre><code class="hljs">with open(&#x27;C:\\Users\\Khurram\\Desktop\\test_2.txt&#x27;, &#x27;w&#x27;) as f:
 f.write(result.text)
</code></pre>
In the above example, we have used the <a target="_blank'" href="/python-context-managers/">context manager</a> <code>with</code> to automatically open and close the write stream. Secondly, we have opened the file in the write mode. Lastly, we have used the <code>write()</code> method to write the translated string to a new file.
<h2 id="conclusion">Conclusion</h2>
Google Translate is a tool with an API that helps you perform a lot of different translation-related functions. We have only scratched the surface with the above examples. You are encouraged to practice the API, as well as learn and understand how to use it in real-life applications.

You could translate anything by simply going to the Google Translate web page, though you can also integrate the Google Translate API in your own application.

Text Translation with Google Translate API in Python

Robley Gori

Nowadays, Object-Relational Mappers like SQLAlchemy are used as a bridge between applications and SQL databases and make it easy to work with them programmatically.

Using SQLAlchemy with Flask and PostgreSQL

<h2 id="introduction">Introduction</h2>
Python 3.6 introduced a new way to format strings: f-Strings. It is faster than other string formatting methods in Python, and they allow us to evaluate Python expressions inside a string.
In this post, we'll look at the various ways we can format strings in Python. Then we'll have a deeper look at f-Strings, looking at how we can use it when displaying different data.
<h2 id="traditionalstringformattinginpython">Traditional String Formatting in Python</h2>
Before we get into f-Strings, let's have a look at the more &quot;traditional&quot; <a rel="nofollow noopener" target="_blank" href="https://stackabuse.com/formatting-strings-with-python/">string formatting</a> options available in Python. If you just want to skip to learning about f-Strings, check out the section <a href="#stringformattingwithfstrings">String Formatting with f-Strings</a> in this article.
<h3 id="stringconcatenation">String Concatenation</h3>
String concatenation means that we are combining two strings to make a new one. In Python, we typically concatenate strings with the <code>+</code> operator.
In your Python interpreter, let's use concatenation to include a variable in a string:
<pre><code class="hljs">name = &quot;Python&quot;
print(&quot;I like &quot; + name + &quot; very much!&quot;)
</code></pre>
You would see the following output:
<pre><code class="hljs">I like Python very much!
</code></pre>
String concatenation works only on strings. If you want non-string data to be included, you have to convert it manually.
Let's see by concatenating a number with a string:
<pre><code class="hljs">age = (10 + 5) * 2
print(&quot;You wouldn&#x27;t believe me, but I am only &quot; + age + &quot; years old&quot;)
</code></pre>
Running the above you'll see this error:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
TypeError: can only concatenate str (not &quot;int&quot;) to str
</code></pre>
Now, let's convert <code>age</code> to a string:
<pre><code class="hljs">age = (10 + 5) * 2
print(&quot;You wouldn&#x27;t believe me, but I am only &quot; + str(age) + &quot; years old&quot;)
</code></pre>
The interpreter would correctly show:
<pre><code class="hljs">You wouldn&#x27;t believe me, but I am only 30 years old
</code></pre>
This method is not always the quickest for Python to evaluate, nor is it easy for humans to manage with many variables. It's better to use Python's dedicated string formatting methods.
<h3 id="cstylestringformatting">C-Style String Formatting</h3>
C-style string formatting, also referred to as the printf style, uses strings as templates that are marked with <code>%</code> so that variables can be substituted.
For example, <code>%d</code> tells Python that we are substituting a number, whereas <code>%s</code> tells Python that we are substituting a string.
There are a few controlling mechanisms available too, for example <code>%02d</code> ensures that the number is at least 2 digits, and if it is not, the rest will be filled by zeros. We can use a marker like <code>%.4f</code> to substitute a decimal with exactly 4 floating points in the string.
In your Python interpreter, type the following code so we can see C-style string formatting in action:
<pre><code class="hljs">print(&#x27;Here is an integer %02d&#x27; % 4)
print(&#x27;And a float: %.2f&#x27; % 3.141592)
print(&quot;And a %s with %d replacements&quot; % (&quot;mess&quot;, 2))
</code></pre>
Your output should be:
<pre><code class="hljs">Here is an integer 04
And a float: 3.14
And a mess with 2 replacements
</code></pre>
As you could see, with more and more arguments it gets pretty convoluted and hard to follow. So Python takes this one step further and allows you to use dictionaries in <code>%</code> formatting.
Although it isn't much of an improvement in its overall aesthetics, it could help a little bit on the readability front.
Try formatting a C-style string with a dictionary:
<pre><code class="hljs">print(&#x27;Using %(dictionary)s format in C-style string formatting, here is %(num)d number to make it more interesting!&#x27; % {&#x27;dictionary&#x27;: &quot;named&quot;, &quot;num&quot;: 1})
</code></pre>
As you can see, we can specify the name within parenthesis between the <code>%</code> and the rest of the identifier.
Your interpreter should display:
<pre><code class="hljs">Using named format in C-style string formatting, here is 1 number to make it more interesting!
</code></pre>
If you haven't spent the last 42 years developing in C, the above syntax might not be to your liking. As such, Python gives us another option using the <code>format()</code> method on strings.
<h3 id="pythonformatfunction">Python format() Function</h3>
The <code>format()</code> function behaves similarly to the C-style formatting, but it is much more readable. It works by invoking the <code>format()</code> method on your string while providing the replacements in the template within curly brackets - <code>{}</code>.
Using your Python interpreter, we'll use the <code>format()</code> method to format a string. Let's start by substituting one string:
<pre><code class="hljs">print(&quot;This is a first {}&quot;.format(&quot;attempt!&quot;))
</code></pre>
The output will be:
<pre><code class="hljs">This is a first attempt!
</code></pre>
We can use curly brackets multiple times, substituting the variables in order:
<pre><code class="hljs">print(&quot;And {} can add {} string too.&quot;.format(&quot;we&quot;, &quot;more&quot;))
</code></pre>
Output:
<pre><code class="hljs">And we can add more string too.
</code></pre>
We can also name the variables we are formatting:
<pre><code class="hljs">print(&quot;String format also supports {dictionary} arguments.&quot;.format(dictionary=&quot;named&quot;))
</code></pre>
The above code should print:
<pre><code class="hljs">String format also supports named arguments.
</code></pre>
While this method is very readable, Python is more efficient with f-Strings, while also being readable. Let's have a look at f-Strings more closely.
<h2 id="stringformattingwithfstrings">String Formatting with f-Strings</h2>
F-Strings, or formatted string literals, are prefixed with an <code>f</code> and contain the replacement fields with curly braces. They are evaluated at run-time, which makes them the fastest string formatting option in Python (at least in the standard CPython implementation).
First, verify that you have a Python version that's 3.6 or higher:
<pre><code class="hljs">$ python3 --version
Python 3.6.0
</code></pre>
If your Python version is less than 3.6, you need to upgrade to use this feature.
F-String literals start with an <code>f</code>, followed by any type of strings (i.e. single quotation, double quotation, triple quotation), then you can include your Python expression inside the string, in between curly brackets.
Let's string to use an f-String in your Python shell:
<pre><code class="hljs">name = &quot;f-String&quot;
print(f&quot;hello {name}!&quot;)
</code></pre>
And now run it to see the magic:
<pre><code class="hljs">hello f-String!
</code></pre>
It's very similar to using the <code>format()</code> function. However, it comes with a lot of features that are not available with other formatting methods.
Let's have a look at those features, starting with multi-line strings.
<h3 id="multilinefstrings">Multi-line f-Strings</h3>
F-Strings allows for multi-line strings, all you have to do is wrap them in parentheses:
<pre><code class="hljs">name = &quot;World&quot;
message = (
 f&quot;Hello {name}. &quot;
 &quot;This is from a multi-lined f-string. &quot;
 f&quot;Have a good day, {name}&quot;
)
print(message)
</code></pre>
You will see this on printed out:
<pre><code class="hljs">Hello World. This is from a multi-lined f-string. Have a good day, World
</code></pre>
Don't forget to put the <code>f</code> literal in front of lines that have replacements. The substitutions won't work otherwise.
<h3 id="evaluatingpythonexpressionsinfstrings">Evaluating Python Expressions in f-Strings</h3>
Python's f-Strings allow you to do expressions right in the string itself. The following string is valid:
<pre><code class="hljs">number = 10
print(f&quot;{number} + 1 = {number+1}&quot;)
</code></pre>
And outputs:
<pre><code class="hljs">10 + 1 = 11
</code></pre>
You can include any valid expression you want, as long as it doesn't have special characters. For example, we can have function calls:
<pre><code class="hljs">def func():
 return 42

print(f&quot;func() = {func()}&quot;)
</code></pre>
This returns:
<pre><code class="hljs">func() = 42
</code></pre>
<h3 id="formattingclasseswithfstrings">Formatting Classes with f-Strings</h3>
You can include objects created from classes in an f-String. Every class has two different methods that allow an object to be converted to a string:
<ul>
<li>The <code>__str__()</code> method of an object should return a string that is both displayable to the user, and understandable by them. That means it should not have any secret information that should be kept hidden from the user, and it should not have any debug messages.</li>
<li>The <code>__repr__()</code> method of an object should return a more detailed string, possibly containing debug information.</li>
</ul>
f-Strings automatically call the <code>__str__()</code> for the object you provide them.
Let's try our f-Strings with a class to see for ourselves. We will create a <code>User</code> class that stores our name and associated database ID that our imaginary system uses.
Create a new file called <code>fstring_classes.py</code> and add the following:
<pre><code class="hljs"># fstring_classes.py

class User:
 def __init__(self, name, db_id):
 self.name = name
 self.db_id = db_id

 def __str__(self):
 return f&quot;User with name: {self.name}&quot;

my_user = User(&quot;Sajjad&quot;, 12)
print(f&quot;{my_user}&quot;)
</code></pre>
In your Terminal, run the file with Python:
<pre><code class="hljs">$ python fstring_classes.py
</code></pre>
This program will show:
<pre><code class="hljs">User with name: Sajjad
</code></pre>
If we wanted to use an f-String with the <code>__repr_()</code> method of an object, you can put an <code>!r</code> in front of your object being substituted.
Edit the <code>fstring_classes.py</code> file and change the last line:
<pre><code class="hljs">print(f&quot;{my_user}&quot;)
</code></pre>
Into the following, which includes the <code>!r</code> suffix:
<pre><code class="hljs">print(f&quot;{my_user!r}&quot;)
</code></pre>
Now we can run this program again:
<pre><code class="hljs">$ python fstring_classes.py
</code></pre>
And our output will be:
<pre><code class="hljs">User with name: Sajjad with id 12
</code></pre>
<h3 id="handlingspecialcharactersinfstrings">Handling Special Characters in f-Strings</h3>
F-Strings, like any other Python string, support the use of backslashes to escape characters. All the following are valid Python f-Strings:
<pre><code class="hljs">print(f&#x27;escaping with \\ is also possible, like: \&#x27;&#x27;)
</code></pre>
Running this will print:
<pre><code class="hljs">escaping with \ is also possible, like: &#x27;
</code></pre>
However, there is one limitation, we cannot use backslashes within the curly braces (the expression part of the f-String). If you try the following in your Python interpreter:
<pre><code class="hljs">print(f&#x27;{ord(&quot;\n&quot;)}&#x27;)
</code></pre>
You'll get the following error:
<pre><code class="hljs"> File &quot;&lt;stdin&gt;&quot;, line 1
SyntaxError: f-string expression part cannot include a backslash
</code></pre>
The same limitation is true for same-type quotation marks. The code below:
<pre><code class="hljs">a = {&quot;key&quot;: &quot;value&quot;}
print(f&quot;the value is {a[&quot;key&quot;]}&quot;)
</code></pre>
Gives us this syntax error:
<pre><code class="hljs"> File &quot;&lt;stdin&gt;&quot;, line 1
 print(f&quot;the value is {a[&quot;key&quot;]}&quot;)
 ^
SyntaxError: invalid syntax
</code></pre>
To avoid these problems, we can either calculate them outside of the f-String:
<pre><code class="hljs">ord_newline = ord(&quot;\n&quot;)
print(f&#x27;{ord_newline}&#x27;)
</code></pre>
Which prints:
<pre><code class="hljs">10
</code></pre>
Or we can use different quotation types:
<pre><code class="hljs">a = {&quot;key&quot;: &quot;val&quot;}
print(f&quot;The value is {a[&#x27;key&#x27;]}&quot;)
</code></pre>
Which displays:
<pre><code class="hljs">The value is val
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this post, we looked at different methods of string formatting in Python, with a focus on the f-String method. In Python, we are spoiled for options as we can concatenate strings, use C-Style formatting with <code>%</code>, or the <code>format()</code> method on strings.
However, with f-Strings, we get a readable solution that Python has optimized for. Aside from its speed benefits, we've seen how well f-Strings work with evaluating expressions and objects from classes.

Marcus Sanatan

Sajjad Heydari

F-Strings, are prefixed with an f and contain the replacement fields with curly braces. They allow us to format strings and evaluate expressions faster in Python.

String Formatting with Python 3's f-Strings

Dan Nelson

Ensemble classification models can be powerful machine learning tools capable of achieving excellent performance and generalizing well to new, unseen datasets.

Ensemble/Voting Classification in Python with Scikit-Learn

Tom Kadwill

Heroku is a widespread solution for quick, free hosting online. There are numerous add-ons that make it even more functional. We'll be adding a Postgre database to a Node.js application.

Adding a PostgreSQL Database to a Node.js App on Heroku

<h2 id="introduction">Introduction</h2>
When developing a web application, the natural progression is to take it online and make it available for end users. To make this task possible, and easier, there are numerous cloud platforms available to choose from to host your application - <a rel="nofollow" target="_blank" href="https://www.heroku.com/">Heroku</a> is one of them.
Heroku provides a platform as a service for deploying applications of various technology stacks like Node, Java, Python, etc. It takes care of all the complicated aspects for deployment, infrastructure, scaling, upgrading, security, etc. and allows us to focus on the application's logic and delivering more value to our end users, rather than deployment.
In this article, we will build a really simple Spring Boot REST API application that will expose an endpoint, and we'll look into various ways of deploying the application to Heroku.
<h2 id="creatingaspringbootapplication">Creating a Spring Boot Application</h2>
<h3 id="initializingthespringbootapp">Initializing the Spring Boot App</h3>
As always, the easiest way to start off with a skeleton Spring Boot project is to use the <a rel="nofollow" target="_blank" href="https://start.spring.io/">Spring Initializer</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-1.png" alt="spring_boot_initializr">
Choose your preferred build tool, we'll be using Maven. The only dependency we'll need is the Spring Web dependency.
Alternatively, we can create the application using the <a rel="nofollow" target="_blank" href="https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-cli.html">Spring Boot CLI</a>:
<pre><code class="hljs">$ spring init --dependencies=web heroku-demo
</code></pre>
<h3 id="createarestendpoint">Create a REST Endpoint</h3>
With our skeleton done, let's add a simple REST endpoint:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/api/v1.0&quot;)
public class TimeController {

 @GetMapping(&quot;/time&quot;)
 @ResponseStatus(HttpStatus.OK)
 public String getCurrentTime() {

 return Instant.now().toString();
 }
}
</code></pre>
In case you're not already familiar with the <code>@RestController</code> annotation, it's a convenience annotation made as a combination of the <code>@Controller</code> and <code>@ResponseBody</code> annotations.
This endpoint will simply return the current server time upon request. Let's run the application on our local machine and test if it's working:
<pre><code class="hljs">$ mvn spring-boot:run
</code></pre>
Or, using your IDE, simply run the application and navigate to your browser's <code>localhost:8080/api/v1.0/time</code> URL address:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-2.png" alt="spring_boot_app_homepage">
Alternatively, you can use a tool such as <code>curl</code> to hit the endpoint:
<pre><code class="hljs">$ curl -X GET &#x27;http://localhost:8080/api/v1.0/time&#x27;
2020-01-04T13:19:30.980Z
</code></pre>
<h2 id="deploymenttoheroku">Deployment to Heroku</h2>
With our application primed and ready, let's explore the different ways we can deploy it to Heroku.
<h3 id="usingtheherokucliwithgit">Using the Heroku CLI with Git</h3>
Heroku offers its own CLI, which we can use to deploy an application. In order to do this we need to install <a rel="nofollow" target="_blank" href="https://devcenter.heroku.com/articles/heroku-cli#download-and-install">Heroku CLI</a> and <a rel="nofollow" target="_blank" href="https://git-scm.com/">Git</a>.
Before we try to deploy it, Heroku needs the application to be in a Git repository, so let's <a target="_blank" href="/git-create-a-new-repository/">create a repository</a> in our project directory:
<pre><code class="hljs">$ git init
</code></pre>
Once the repository is created, let's add and commit the files:
<pre><code class="hljs">$ git add src/ pom.xml
$ git commit -m &quot;first commit with project base&quot;
</code></pre>
The next step is to log in to Heroku using the Heroku CLI and create a Heroku app:
<pre><code class="hljs">$ heroku login
</code></pre>
It will prompt for email and password for your Heroku account:
<pre><code class="hljs">Enter your Heroku credentials:
Email: ***********@gmail.com
Password: ***********
Logged in as **********@gmail.com
</code></pre>
Once we are logged in, let's create the app:
<pre><code class="hljs">$ heroku create
</code></pre>
Relatively quickly, we'll be strapped with an application:
<pre><code class="hljs">Creating app... done, ⬢ arcane-journey-46830
https://arcane-journey-46830.herokuapp.com/ | https://git.heroku.com/arcane-journey-46830.git
</code></pre>
The <code>create</code> command will <a target="_blank" href="/git-add-new-remote-to-a-repo/">add a Git remote</a> named <code>heroku</code> to our local Git repository and also add a random name to it - in our case it's <code>arcane-journey-46830</code>.
Finally, we can deploy our code:
<pre><code class="hljs">$ git push heroku master
</code></pre>
Heroku will detect that this is a Java/Maven application by the presence of the <code>pom.xml</code> file in the repository. After pushing, if you take a look at the logs, you'll be able to notice:
<pre><code class="hljs">Enumerating objects: 26, done.
Counting objects: 100% (26/26), done.
Delta compression using up to 4 threads
Compressing objects: 100% (21/21), done.
Writing objects: 100% (26/26), 2.96 KiB | 504.00 KiB/s, done.
Total 26 (delta 5), reused 0 (delta 0)
remote: Compressing source files... done.
remote: Building source:
remote:
remote: -----&gt; Java app detected
remote: -----&gt; Installing JDK 1.8... done
remote: -----&gt; Installing Maven 3.6.2... done
remote: -----&gt; Executing Maven
...
</code></pre>
And finally, the deployment is finished and we're prompted with a URL leading to our app:
<pre><code class="hljs">...
remote: -----&gt; Compressing...
remote: Done: 65.7M
remote: -----&gt; Launching...
remote: Released v3
remote: **https://arcane-journey-46830.herokuapp.com/** deployed to Heroku
remote:
remote: Verifying deploy... done.
To https://git.heroku.com/arcane-journey-46830.git
 * [new branch] master -&gt; master
</code></pre>
Let's test the application again using <code>curl</code>:
<pre><code class="hljs">$ curl -X GET &#x27;https://arcane-journey-46830.herokuapp.com/api/v1.0/time&#x27;
2020-01-04T13:51:31.559Z
</code></pre>
Or by navigating our browser to its URL:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-3.png" alt="spring_boot_app_deployed_on_heroku">
<h3 id="herokudeployplugin">Heroku Deploy Plugin</h3>
If we want to deploy our application directly without using a Git repository, we can do it using the <code>heroku-cli-deploy</code> plugin. Let's begin by installing it:
<pre><code class="hljs">$ heroku plugins:install heroku-cli-deploy
</code></pre>
Similar to the previous section, we ask Heroku to create the application, but this time we include a <code>--no-remote</code> argument to avoid being asked for the Git repository:
<pre><code class="hljs">$ heroku creare heroku-demo-stackabuse --no-remote
</code></pre>
Notice, that we have mentioned an application name this time around - <code>heroku-demo-stackabuse</code>. This will create the application with a given name, and not generate a random name like in the earlier section.
We also need to mention the port at which Heroku will bind the application in the <code>application.properties</code> file:
<pre><code class="hljs">server.port=${PORT:8080}
</code></pre>
Note: This is required as Heroku binds the application to a port passed as the <code>PORT</code> environment variable and Spring Boot by default exposes the <code>8080</code> port. Here, we ask Spring to use <code>PORT</code> and fallback to <code>8080</code> in case the environment variable isn't present, i.e. we're running locally.
Finally, we build our application with Maven to create the <code>jar</code> file and deploy it:
<pre><code class="hljs">$ mvn clean package
</code></pre>
<pre><code class="hljs">$ heroku deploy:jar target/heroku-demo.0.0.1-SNAPSHOT.jar --app heroku-demo-stackabuse
</code></pre>
<h3 id="mavenplugin">Maven Plugin</h3>
There could be scenarios where we would like to make the deployment as part of our Maven build. This is possible using the <a rel="nofollow" target="_blank" href="https://mvnrepository.com/artifact/com.heroku.sdk/heroku-maven-plugin">Heroku Maven Plugin</a>. Let's put the plugin configuration in our <code>pom.xml</code>:
<pre><code class="hljs">...
&lt;build&gt;
 &lt;plugins&gt;
 &lt;plugin&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-maven-plugin&lt;/artifactId&gt;
 &lt;/plugin&gt;
 &lt;plugin&gt;
 &lt;groupId&gt;com.heroku.sdk&lt;/groupId&gt;
 &lt;artifactId&gt;heroku-maven-plugin&lt;/artifactId&gt;
 &lt;version&gt;{version}&lt;/version&gt;
 &lt;configuration&gt;
 &lt;appName&gt;heroku-demo-stackabuse&lt;/appName&gt;
 &lt;includeTarget&gt;false&lt;/includeTarget&gt;
 &lt;includes&gt;
 &lt;include&gt;${project.build.directory}/${project.build.finalName}.jar&lt;/include&gt;
 &lt;/includes&gt;
 &lt;jdkVersion&gt;1.8&lt;/jdkVersion&gt;
 &lt;processTypes&gt;
 &lt;web&gt;java $JAVA_OPTS -jar
 ${project.build.directory}/${project.build.finalName}.jar&lt;/web&gt;
 &lt;/processTypes&gt;
 &lt;/configuration&gt;
 &lt;/plugin&gt;
 &lt;/plugins&gt;
 &lt;/build&gt;
...
</code></pre>
Always, check for the latest version of the plugin <a rel="nofollow" target="_blank" href="https://search.maven.org/classic/#search|ga|1|heroku-maven-plugin">here</a>.
As a final step, we need to set an environment variable - <code>HEROKU_API_KEY</code>. This step required only if you do not have Heroku CLI logged in for authorization. The API key can be found in your Heroku dashboard <a rel="nofollow" target="_blank" href="https://dashboard.heroku.com/account">account</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-5.png" alt="heroku_api_key">
And now we can use the <code>heroku:deploy</code> goal to deploy the application:
<pre><code class="hljs">$ mvn clean heroku:deploy
</code></pre>
<h3 id="herokudashboardwithgithub">Heroku Dashboard with GitHub</h3>
With the programmatic/CLI approaches out of the way, there's also a really user-friendly GUI approach too. We can create an application in the <a rel="nofollow" target="_blank" href="https://dashboard.heroku.com/new-app">Heroku Dashboard</a>, link it up with a GitHub account and deploy from there.
Navigate to the &quot;new app&quot; option:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-6.png" alt="heroku_dashboard_new_app">
Next, connect your GitHub account, and search for your repository to connect:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-7.png" alt="github_app_connect_to_heroku">
Once connected, you can deploy your application choosing a branch to deploy or directly choosing the master branch. Also, you may chose to enable automatic deployments based on commits on a particular branch:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-8.png" alt="github_app_deploy_to_heroku">
<h2 id="checkinglogsofdeployedapplications">Checking Logs of Deployed Applications</h2>
Checking the logs of the deployed application can be useful for many purposes. Thankfully, it's really easy to access them.
Using the CLI, it's just a single command:
<pre><code class="hljs">$ heroku logs --tail
</code></pre>
This would allow to see the logs running:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-9.png" alt="heroku_logs">
Alternatively, the Heroku Dashboard allows us to access them via the right-hand side More &gt; View Logs:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-10.png" alt="heroku_dashboard_logs">
<h2 id="herokuprocfile">Heroku Procfile</h2>
The Procfile could be used to configure or override default application settings and commands. For example, while deploying the application using the Heroku deploy plugin, we have added port information in the <code>application.properties</code>.
This could also be added into the Procfile. We would add commands to run the application such as:
<pre><code class="hljs">web: java $JAVA_OPTS -jar target/heroku-demo-0.0.1-SNAPSHOT.jar -Dserver.port=$PORT
</code></pre>
Here, we've added a command to run the application with Java and added a JVM argument to override the Spring Boot default port binding.
<h2 id="removingtheappfromheroku">Removing the App from Heroku</h2>
At some point, you may want to remove your app from Heroku, for whatever reason. This is done via a simple command:
<pre><code class="hljs">$ heroku apps:destroy --confirm arcane-journey-46830
</code></pre>
We may run the command without the <code>--confirm</code> flag, but in that case, it will prompt to enter the app name.
Alternatively, we can remove the application from the Heroku Dashboard settings:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-spring-boot-applications-to-heroku-11.png" alt="heroku_delete_app_dashboard">
<h2 id="conclusion">Conclusion</h2>
With the increased popularity of cloud computing, it is important to know how we could deploy and manage our application in a cloud platform.
Heroku is a platform as a service to deploy, manage and scale applications. It also provides free of cost deployments with free dyno's. This free deployments could be used for any demo or evaluation purposes but definitely not suitable for production live applications.
In this article, we've covered several ways of deploying Spring Boot applications to Heroku - using the Heroku CLI, the Heroku deploy plugin, the Maven Plugin and finally the GUI approach via a GitHub repository.
All deployments done here, are deployed into the free dyno. Please note that these free dynos will stop when we are not using the application for a certain amount of time. They will spin up again when we have hit the application. So we may face some delays when we try to reach our application after a long time.

Dhrubajyoti Bhattacharjee

Heroku is a widespread solution for quick, free online hosting. We'll be covering several ways to get your own Spring Boot app up and running on the web.