In this article, we'll examine how to print a string without a newline character using Python.
In Python, the built-in <code>print</code> function is used to print content to the standard output, which is usually the console. By default, the print function adds a newline character at the end of the printed content, so the next output by the program occurs on the next line.
Try running this code to see an example:
<pre><code class="hljs">print(&#x27;Banana&#x27;)
print(&#x27;pudding.&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Banana
pudding.
</code></pre>
As expected, the output of each <code>print</code> statement is shown on its own line.
However, in some cases we may want to output multiple strings on the same line using separate <code>print</code> statements. There are a few ways to prevent Python from adding the newline character when using the <code>print</code> function, depending on whether we are using Python 2.x or Python 3.x.
For example, this kind of functionality is useful for when you're developing a REPL or any command line application that takes input from the user, and you don't want the prompt and input text to be on different lines.
For Python 2.x, we can simply add a comma after the print function call, which will terminate the printed string with a space instead of a newline character:
<pre><code class="hljs">print(&#x27;Banana&#x27;),
print(&#x27;pudding.&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Banana pudding.
</code></pre>
In Python 3.x, we can use the <code>end</code> keyword argument in the <code>print</code> method to specify the termination character for the printed string:
<pre><code class="hljs">print(&#x27;Banana&#x27;, end=&#x27; &#x27;)
print(&#x27;pudding.&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Banana pudding.
</code></pre>
So in this case, a space is used as the &quot;termination&quot; character, which results in the printed strings to be on the same line and only separated by a single space.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with a passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com/codecard">Code Card</a> - a convenient tool for developers to look up, copy, and paste common code snippets.

Jacob Stopak

Python: Print without Newline

In this article, we'll examine how to use the <code>assert</code> statement in Python.
In Python, the <code>assert</code> statement is used to validate whether or not a condition is true, using the syntax:
<pre><code class="hljs">assert &lt;condition&gt;
</code></pre>
If the condition evaluates to <code>True</code>, the program continues executing as if nothing out of the ordinary happened. However, if the condition evaluates to <code>False</code>, the program terminates with an <code>AssertionError</code>.
<pre><code class="hljs">&gt;&gt;&gt; assert True
</code></pre>
Nothing happens when the code above is executed, since the condition evaluates to <code>True</code>. Alternatively, the condition in the example below evaluates to <code>False</code>:
<pre><code class="hljs">&gt;&gt;&gt; assert False
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AssertionError
</code></pre>
For added clarity, we can add a custom error message to the assertion output as follows:
<pre><code class="hljs">&gt;&gt;&gt; assert False, &quot;This is a custom assertion message!&quot;
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AssertionError: This is a custom assertion message!
</code></pre>
The assert statement is useful when we want to check that a variable in our code assumes the correct value and terminate the program if it doesn't. This helps prevent silent failure modes, which can occur if the program continues executing with erroneous values and can be difficult to debug.
Here is an example of an assert statement with a more meaningful condition. Let's assume that we want to ensure that a flag variable input by the user has been set to one of several correct values. If not, we will terminate execution of the program. We can do that as follows:
<pre><code class="hljs">&gt;&gt;&gt; flag = input(&quot;Enter a flag (y/n): &quot;)
Enter a flag (y/n): y
&gt;&gt;&gt; assert flag == &quot;y&quot; or flag == &quot;n&quot;, &quot;Invalid flag, must be &#x27;y&#x27; or &#x27;n&#x27;&quot;
</code></pre>
In the above example, the user inputted a valid value for the flag, so no errors are thrown. However, in the example below, an assertion is thrown due to invalid user input:
<pre><code class="hljs">&gt;&gt;&gt; flag = input(&quot;Enter a flag (y/n): &quot;)
Enter a flag (y/n): b
&gt;&gt;&gt; assert flag == &quot;y&quot; or flag == &quot;n&quot;, &quot;Invalid flag, must be &#x27;y&#x27; or &#x27;n&#x27;&quot;
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AssertionError: Invalid flag, must be &#x27;y&#x27; or &#x27;n&#x27;
</code></pre>
When used in this way, your code should catch the thrown error and show the custom error message as output to the user so they can correct their response. This has a huge number of uses in Python programs, whether it be asserting inputs to an API route or checking that a downloaded resource contains the proper information.
Another important point to note is that when you're running the Python interpreter or Python script from the command line, the <code>–O</code> flag can be used to run the program without enforcing any assertions. This will ignore the assert statements by turning off the Python interpreter's debug mode. Be careful using this as it can lead to your code accepting invalid or dangerous inputs.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with a passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com/codecard">Code Card</a> - a convenient tool for developers to look up, copy, and paste common code snippets.

The Python Assert Statement

Nicholas Samuel

The Python Help System

This is the 13th article in my series of articles on Python for NLP. In the <a target="_blank" href="/python-for-nlp-creating-a-rule-based-chatbot/">previous article</a>, we saw how to create a simple rule-based chatbot that uses <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Cosine_similarity">cosine similarity</a> between the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Tf%E2%80%93idf">TF-IDF</a> vectors of the words in the corpus and the user input, to generate a response. The TF-IDF model was basically used to convert word to numbers.
In this article, we will study another very useful model that converts text to numbers i.e. the Bag of Words (BOW).
Since most of the statistical algorithms, e.g machine learning and deep learning techniques, work with numeric data, therefore we have to convert text into numbers. Several approaches exist in this regard. However, the most famous ones are Bag of Words, TF-IDF, and word2vec. Though several libraries exist, such as Scikit-Learn and NLTK, which can implement these techniques in one line of code, it is important to understand the working principle behind these word embedding techniques. The best way to do so is to implement these techniques from scratch in Python and this is what we are going to do today.
In this article, we will see how to implement the Bag of Words approach from scratch in Python. In the next article, we will see how to implement the TF-IDF approach from scratch in Python.
Before coding, let's first see the theory behind the bag of words approach.
<h2 id="theorybehindbagofwordsapproach">Theory Behind Bag of Words Approach</h2>
To understand the bag of words approach, let's first start with the help of an example.
Suppose we have a corpus with three sentences:
<ul>
<li>&quot;I like to play football&quot;</li>
<li>&quot;Did you go outside to play tennis&quot;</li>
<li>&quot;John and I play tennis&quot;</li>
</ul>
Now if we have to perform text classification, or any other task, on the above data using statistical techniques, we can not do so since statistical techniques work only with numbers. Therefore we need to convert these sentences into numbers.
<h3 id="step1tokenizethesentences">Step 1: Tokenize the Sentences</h3>
The first step in this regard is to convert the sentences in our corpus into tokens or individual words. Look at the table below:
<table class="table table-striped">
 <tr>
 <th>Sentence 1</th>
 <th>Sentence 2</th>
 <th>Sentence 3</th>
 </tr>
 <tr>
 <td>I</td>
 <td>Did</td>
 <td>John</td>
 </tr>
 <tr>
 <td>like</td>
 <td>you</td>
 <td>and</td>
 </tr>
 <tr>
 <td>to </td>
 <td>go</td>
 <td>I</td>
 </tr>
 <tr>
 <td>play</td>
 <td>outside</td>
 <td>play</td>
 </tr>
 <tr>
 <td>football</td>
 <td>to</td>
 <td>tennis</td>
 </tr>
 <tr>
 <td></td>
 <td>play</td>
 <td></td>
 </tr>
 <tr>
 <td></td>
 <td>tennis</td>
 <td></td>
 </tr>
</table>
<h3 id="step2createadictionaryofwordfrequency">Step 2: Create a Dictionary of Word Frequency</h3>
The next step is to create a dictionary that contains all the words in our corpus as keys and the frequency of the occurrence of the words as values. In other words, we need to create a histogram of the words in our corpus. Look at the following table:
<table class="table table-striped">
 <tr>
 <th>Word</th>
 <th>Frequency</th>
 </tr>
 <tr>
 <td>I</td>
 <td>2</td>
 </tr>
 <tr>
 <td>like</td>
 <td>1</td>
 </tr>
 <tr>
 <td>to</td>
 <td>2</td>
 </tr>
 <tr>
 <td>play</td>
 <td>3</td>
 </tr>
 <tr>
 <td>football</td>
 <td>1</td>
 </tr>
 <tr>
 <td>Did</td>
 <td>1</td>
 </tr>
 <tr>
 <td>you</td>
 <td>1</td>
 </tr>
 <tr>
 <td>go</td>
 <td>1</td>
 </tr>
 <tr>
 <td>outside</td>
 <td>1</td>
 </tr>
 <tr>
 <td>tennis</td>
 <td>2</td>
 </tr>
 <tr>
 <td>John</td>
 <td>1</td>
 </tr>
 <tr>
 <td>and</td>
 <td>1</td>
 </tr>
</table>
In the table above, you can see each word in our corpus along with its frequency of occurrence. For instance, you can see that since the word <code>play</code> occurs three times in the corpus (once in each sentence) its frequency is 3.
In our corpus, we only had three sentences, therefore it is easy for us to create a dictionary that contains all the words. In the real world scenarios, there will be millions of words in the dictionary. Some of the words will have a very small frequency. The words with very small frequency are not very useful, hence such words are removed. One way to remove the words with less frequency is to sort the word frequency dictionary in the decreasing order of the frequency and then filter the words having a frequency higher than a certain threshold.
Let's sort our word frequency dictionary:
<table class="table table-striped">
 <tr>
 <th>Word</th>
 <th>Frequency</th>
 </tr>
 <tr>
 <td>play</td>
 <td>3</td>
 </tr>
 <tr>
 <td>tennis</td>
 <td>2</td>
 </tr>
 <tr>
 <td>to</td>
 <td>2</td>
 </tr>
 <tr>
 <td>I</td>
 <td>2</td>
 </tr>
 <tr>
 <td>football</td>
 <td>1</td>
 </tr>
 <tr>
 <td>Did</td>
 <td>1</td>
 </tr>
 <tr>
 <td>you</td>
 <td>1</td>
 </tr>
 <tr>
 <td>go</td>
 <td>1</td>
 </tr>
 <tr>
 <td>outside</td>
 <td>1</td>
 </tr>
 <tr>
 <td>like</td>
 <td>1</td>
 </tr>
 <tr>
 <td>John</td>
 <td>1</td>
 </tr>
 <tr>
 <td>and</td>
 <td>1</td>
 </tr>
</table>
<h3 id="step3creatingthebagofwordsmodel">Step 3: Creating the Bag of Words Model</h3>
To create the bag of words model, we need to create a matrix where the columns correspond to the most frequent words in our dictionary where rows correspond to the document or sentences.
Suppose we filter the 8 most occurring words from our dictionary. Then the document frequency matrix will look like this:
<table class="table table-striped">
 <tr>
 <th></th>
 <th>Play</th>
 <th>Tennis</th>
 <th>To</th>
 <th>I</th>
 <th>Football</th>
 <th>Did </th>
 <th>You</th>
 <th>go</th>
 </tr>
 <tr>
 <td>Sentence 1</td>
 <td>1</td>
 <td>0</td>
 <td>1</td>
 <td>1</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 </tr>
 <tr>
 <td>Sentence 2</td>
 <td>1</td>
 <td>1</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>1</td>
 <td>1</td>
 </tr>
 <tr>
 <td>Sentence 3</td>
 <td>1</td>
 <td>1</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 </tr>
</table>
It is important to understand how the above matrix is created. In the above matrix, the first row corresponds to the first sentence. In the first, the word &quot;play&quot; occurs once, therefore we added 1 in the first column. The word in the second column is &quot;Tennis&quot;, it doesn't occur in the first sentence, therefore we added a 0 in the second column for sentence 1. Similarly, in the second sentence, both the words &quot;Play&quot; and &quot;Tennis&quot; occur once, therefore we added 1 in the first two columns. However, in the fifth column, we add a 0, since the word &quot;Football&quot; doesn't occur in the second sentence. In this way, all the cells in the above matrix are filled with either 0 or 1, depending upon the occurrence of the word. Final matrix corresponds to the bag of words model.
In each row, you can see the numeric representation of the corresponding sentence. For instance, the first row shows the numeric representation of Sentence 1. This numeric representation can now be used as input to the statistical models.
Enough of the theory, let's implement our very own bag of words model from scratch.
<h2 id="bagofwordsmodelinpython">Bag of Words Model in Python</h2>
The first thing we need to create our Bag of Words model is a dataset. In the previous section, we manually created a bag of words model with three sentences. However, real-world datasets are huge with millions of words. The best way to find a random corpus is Wikipedia.
In the first step, we will scrape the Wikipedia article on <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Natural_language_processing">Natural Language Processing</a>. But first, let's import the required libraries:
<pre><code class="hljs">import nltk 
import numpy as np 
import random 
import string

import bs4 as bs 
import urllib.request 
import re 
</code></pre>
As we did in the previous article, we will be using the <a rel="nofollow" target="_blank" href="https://beautiful-soup-4.readthedocs.io/en/latest/">Beautifulsoup4</a> library to parse the data from Wikipedia. Furthermore, <a target="_blank" href="/using-regex-for-text-manipulation-in-python/">Python's regex library</a>, <code>re</code>, will be used for some preprocessing tasks on the text.
Next, we need to scrape the Wikipedia article on natural language processing.
<pre><code class="hljs">raw_html = urllib.request.urlopen(&#x27;https://en.wikipedia.org/wiki/Natural_language_processing&#x27;) 
raw_html = raw_html.read()

article_html = bs.BeautifulSoup(raw_html, &#x27;lxml&#x27;)

article_paragraphs = article_html.find_all(&#x27;p&#x27;)

article_text = &#x27;&#x27;

for para in article_paragraphs: 
 article_text += para.text
</code></pre>
In the script above, we import the raw HTML for the Wikipedia article. From the raw HTML, we filter the text within the paragraph text. Finally, we create a complete corpus by concatenating all the paragraphs.
The next step is to split the corpus into individual sentences. To do so, we will use the <code>sent_tokenize</code> function from the NLTK library.
<pre><code class="hljs">corpus = nltk.sent_tokenize(article_text)
</code></pre>
Our text contains punctuations. We don't want punctuations to be the part of our word frequency dictionary. In the following script, we first convert our text into lower case and then will remove the punctuation from our text. Removing punctuation can result in multiple empty spaces. We will remove the empty spaces from the text using regex.
Look at the following script:
<pre><code class="hljs">for i in range(len(corpus )):
 corpus [i] = corpus [i].lower()
 corpus [i] = re.sub(r&#x27;\W&#x27;,&#x27; &#x27;,corpus [i])
 corpus [i] = re.sub(r&#x27;\s+&#x27;,&#x27; &#x27;,corpus [i])
</code></pre>
In the script above, we iterate through each sentence in the corpus, convert the sentence to lower case, and then remove the punctuation and empty spaces from the text.
Let's find out the number of sentences in our corpus.
<pre><code class="hljs">print(len(corpus))
</code></pre>
The output shows 49.
Let's print one sentence from our corpus:
<pre><code class="hljs">print(corpus[30])
</code></pre>
Output:
<pre><code class="hljs">in the 2010s representation learning and deep neural network style machine learning methods became widespread in natural language processing due in part to a flurry of results showing that such techniques 4 5 can achieve state of the art results in many natural language tasks for example in language modeling 6 parsing 7 8 and many others 
</code></pre>
You can see that the text doesn't contain any special character or multiple empty spaces.
Now we have our own corpus. The next step is to tokenize the sentences in the corpus and create a dictionary that contains words and their corresponding frequencies in the corpus. Look at the following script:
<pre><code class="hljs">wordfreq = {}
for sentence in corpus:
 tokens = nltk.word_tokenize(sentence)
 for token in tokens:
 if token not in wordfreq.keys():
 wordfreq[token] = 1
 else:
 wordfreq[token] += 1
</code></pre>
In the script above we created a dictionary called <code>wordfreq</code>. Next, we iterate through each sentence in the corpus. The sentence is tokenized into words. Next, we iterate through each word in the sentence. If the word doesn't exist in the <code>wordfreq</code> dictionary, we will add the word as the key and will set the value of the word as 1. Otherwise, if the word already exists in the dictionary, we will simply increment the key count by 1.
If you are executing the above in the <a rel="nofollow" target="_blank" href="https://www.spyder-ide.org/">Spyder</a> editor like me, you can go the variable explorer on the right and click <code>wordfreq</code> variable. You should see a dictionary like this:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/python-nlp-creating-bag-words-model-from-scratch-1.png">
You can see words in the &quot;Key&quot; column and their frequency of occurrences in the &quot;Value&quot; column.
As I said in the theory section, depending upon the task at hand, not all of the words are useful. In huge corpora, you can have millions of words. We can filter the most frequently occurring words. Our corpus has 535 words in total. Let us filter down to the 200 most frequently occurring words. To do so, we can make use of Python's <code>heap</code> library.
Look at the following script:
<pre><code class="hljs">import heapq
most_freq = heapq.nlargest(200, wordfreq, key=wordfreq.get)
</code></pre>
Now our <code>most_freq</code> list contains 200 most frequently occurring words along with their frequency of occurrence.
The final step is to convert the sentences in our corpus into their corresponding vector representation. The idea is straightforward, for each word in the <code>most_freq</code> dictionary if the word exists in the sentence, a 1 will be added for the word, else 0 will be added.
<pre><code class="hljs">sentence_vectors = []
for sentence in corpus:
 sentence_tokens = nltk.word_tokenize(sentence)
 sent_vec = []
 for token in most_freq:
 if token in sentence_tokens:
 sent_vec.append(1)
 else:
 sent_vec.append(0)
 sentence_vectors.append(sent_vec)
</code></pre>
In the script above we create an empty list <code>sentence_vectors</code> which will store vectors for all the sentences in the corpus. Next, we iterate through each sentence in the corpus and create an empty list <code>sent_vec</code> for the individual sentences. Similarly, we also tokenize the sentence. Next, we iterate through each word in the <code>most_freq</code> list and check if the word exists in the tokens for the sentence. If the word is a part of the sentence, 1 is appended to the individual sentence vector <code>sent_vec</code>, else 0 is appended. Finally, the sentence vector is added to the list <code>sentence_vectors</code> which contains vectors for all the sentences. Basically, this <code>sentence_vectors</code> is our bag of words model.
However, the bag of words model that we saw in the theory section was in the form of a matrix. Our model is in the form of a list of lists. We can convert our model into matrix form using this script:
<pre><code class="hljs">sentence_vectors = np.asarray(sentence_vectors)
</code></pre>
Basically, in the following script, we converted our list into a two-dimensional numpy array using <code>asarray</code> function. Now if you open the <code>sentence_vectors</code> variable in the variable explorer of the Spyder editor, you should see the following matrix:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/python-nlp-creating-bag-words-model-from-scratch-2.png">
You can see the Bag of Words model containing 0 and 1.
<h2 id="conclusion">Conclusion</h2>
Bag of Words model is one of the three most commonly used word embedding approaches with TF-IDF and Word2Vec being the other two.
In this article, we saw how to implement the Bag of Words approach from scratch in Python. The theory of the approach has been explained along with the hands-on code to implement the approach. In the <a target="_blank" href="/python-for-nlp-creating-tf-idf-model-from-scratch/">next article</a>, we will see how to implement the TF-IDF approach from scratch in Python.

Usman Malik

Python for NLP: Creating Bag of Words Model from Scratch

Daniele Paliotta

Introduction to GANs with Python and TensorFlow

Shadab Ansari

Angular Form Validation

<h2 id="introduction">Introduction</h2>
One of the most used classes in Java is the <code>String</code> class. It represents a string (array) of characters, and therefore contains textual data such as &quot;Hello World!&quot;. Besides the <code>String</code> class, there are two other classes used for similar purposes, though not nearly as often - <code>StringBuilder</code> and <code>StringBuffer</code>.
Each exists for its own reason, and unaware of the benefits of the other classes, many novice programmers only use Strings, leading to decreased performance and poor scalability.
<h2 id="string">String</h2>
Initializing a String is as easy as:
<pre><code class="hljs">String string = &quot;Hello World!&quot;;
</code></pre>
It's atypical, as in all other cases, we'd instantiate an object using the <code>new</code> keyword, whereas here we have a &quot;shortcut&quot; version.
There are several ways to instantiate Strings:
<pre><code class="hljs">// Most common, short way
String str1 = &quot;Hello World&quot;;

// Using the `new` keyword and passing text to the constructor
String str2 = new String(&quot;Hello World&quot;);

// Initializing an array of characters and assigning them to a String
char[] charArray = {&#x27;H&#x27;, &#x27;e&#x27;, &#x27;l&#x27;, &#x27;l&#x27;, &#x27;o&#x27;, &#x27; &#x27;, &#x27;W&#x27;, &#x27;o&#x27;, &#x27;r&#x27;, &#x27;l&#x27;, &#x27;d&#x27;};
String str3 = new String(charArray);
</code></pre>
Let's take a look at the source code of the class and make a few observations:
<pre><code class="hljs">public final class String
 implements java.io.Serializable, Comparable&lt;String&gt;, CharSequence {
 /** The value is used for character storage. */
 private final char value[];

 /**
 * Initializes a newly created {@code String} object so that it represents
 * an empty character sequence. Note that use of this constructor is
 * unnecessary since Strings are immutable.
 */
 public String() {
 this.value = new char[0];
 }

 /**
 * Allocates a new {@code String} so that it represents the sequence of
 * characters currently contained in the character array argument. The
 * contents of the character array are copied; subsequent modification of
 * the character array does not affect the newly created string.
 *
 * @param value
 * The initial value of the string
 */
 public String(char value[]) {
 this.value = Arrays.copyOf(value, value.length);
 }
 
 ...
}
</code></pre>
We can first observe how the text itself is saved - in a <code>char</code> array. That being said, it's logical for us to be able to form a String from an array of characters.
A really important thing to note here is the fact that <code>String</code> is defined as <code>final</code>. This means that <code>String</code> is immutable.
<blockquote>
What does this mean?
</blockquote>
<pre><code class="hljs">String str1 = &quot;Hello World!&quot;;
str1.substring(1,4).concat(&quot;abc&quot;).toLowerCase().trim().replace(&#x27;a&#x27;, &#x27;b&#x27;);
System.out.println(str1);
</code></pre>
Output:
<pre><code class="hljs">Hello World!
</code></pre>
Since <code>String</code> is final, none of these methods really changed it. They merely returned the changed state which we didn't use or assign anywhere. Each time a method on a String is called, a new String gets created, the state is changed and it's returned.
Again, taking a look at the source code:
<pre><code class="hljs">public String concat(String str) {
 int otherLen = str.length();
 if (otherLen == 0) {
 return this;
 }
 int len = value.length;
 char buf[] = Arrays.copyOf(value, len + otherLen);
 str.getChars(buf, len);
 return new String(buf, true);
}
</code></pre>
The original <code>str</code> is never changed. Its value is copied and the text we concatenate is added to it, after which a new <code>String</code> is returned.
If we did something like this:
<pre><code class="hljs">String str1 = &quot;Hello World!&quot;;
String str2 = str1.substring(1,4).concat(&quot;abc&quot;).toLowerCase().trim().replace(&#x27;a&#x27;, &#x27;b&#x27;);
System.out.println(str2);
</code></pre>
Then we'd be greeted with the output:
<pre><code class="hljs">ellbbc
</code></pre>
Now, let's take a look at these two Strings:
<pre><code class="hljs">String str1 = &quot;qwerty&quot;;
String str2 = &quot;qwerty&quot;;
</code></pre>
When we instantiate a <code>String</code> like this, the value, in this case <code>qwerty</code> is saved in the Java Heap Memory - which is used for dynamic memory allocation for all Java objects.
While we have two different reference variables in this example, they're both referring to only one memory location in Java Heap Memory. While it may seem that there are two different String objects, in reality there is only one - <code>str2</code> never gets instantiated as an object, but rather is assigned the object in memory that corresponds to <code>str1</code>.
This happens due to the way Java was optimized for Strings. Each time you wish to instantiate a String object like this, the value you want to add to the Heap Memory is compared to the previously added values. If an equal value already exists, the object isn't initialized and the value is assigned to the reference variable.
These values are saved in the so-called String Pool, which contains all literal String values. There is a way to bypass this though - by using the <code>new</code> keyword.
Let's take a look at another example:
<pre><code class="hljs">String str1 = &quot;qwerty&quot;;
String str2 = &quot;qwerty&quot;;
String str3 = new String(&quot;qwerty&quot;);

System.out.println(str1 == str2);
System.out.println(str1 == str3);
System.out.println(str1.equals(str2));
System.out.println(str1.equals(str3));
</code></pre>
Output:
<pre><code class="hljs">true
false
true
true
</code></pre>
This is logical, as <code>str1</code> and <code>str2</code> point to the same object in memory. <code>str3</code> is instantiated explicitly as <code>new</code> so a new object is created for it, even though the String literal already exists in the pool. The <code>equals()</code> method compares their values, not the objects to which they point, which is the reason it returns <code>true</code> for all of these Strings.
It's important to note that <code>substring()</code> and <code>concat()</code> methods return a new <code>String</code> object and save it in the String pool.
This is a very small piece of code, but if we consider some big projects using hundreds of <code>String</code> variables and thousands of operations like <code>substring()</code> or <code>concat()</code>, it can cause serious memory leaks and time delays. That's exactly why we want to use <code>StringBuffer</code> or <code>StringBuilder</code>.
<h2 id="stringbufferandstringbuilder">StringBuffer and StringBuilder</h2>
<h3 id="mutability">Mutability</h3>
<code>StringBuffer</code> and <code>StringBuilder</code> objects basically hold the same value as a <code>String</code> object - a sequence of characters. Both <code>StringBuffer</code> and <code>StringBuilder</code> are also mutable which means that once we assign a value to them, that value is processed as an attribute of a <code>StringBuffer</code> or <code>StringBuilder</code> object.
No matter how many times we modify their value, as a result a new <code>String</code>, <code>StringBuffer</code>, or <code>StringBuilder</code> object will not be created. This approach is much more time efficient and less resource consuming.
<h3 id="stringbuildervsstringbuffer">StringBuilder vs StringBuffer</h3>
These two classes are almost identical to one another - they use methods with the same names which return the same results. Although there are two major differences between them:
<ul>
<li>
Thread Safety: <code>StringBuffer</code> methods are <a rel="nofollow" target="_blank" href="https://stackabuse.com/synchronized-keyword-in-java/">synchronized</a>, which means that only one thread can call the methods of a <code>StringBuffer</code> instance at a time. On the other hand <code>StringBuilder</code> methods are not synchronized, therefore multiple threads can call the methods in <code>StringBuilder</code> class without being blocked.
So we have come to a conclusion that <code>StringBuffer</code> is a thread-safe class while <code>StringBuffer</code> isn't.
Is that something you should worry about? Maybe. If you are working on application which uses multiple threads it can be potentially dangerous to work with <code>StringBuilder</code>.
</li>
<li>
Speed: <code>StringBuffer</code> is actually two to three times slower than <code>StringBuilder</code>. The reason behind this is <code>StringBuffer</code> synchronization - only allowing 1 thread to execute on an object at a time results in much slower code execution.
</li>
</ul>
<h3 id="methods">Methods</h3>
Both <code>StringBuffer</code> and <code>StringBuilder</code> have the same methods (besides <code>synchronized</code> method declaration in the <code>StringBuilder</code> class). Let's go through some of the most common ones:
<ul>
<li><code>append()</code></li>
<li><code>insert()</code></li>
<li><code>replace()</code></li>
<li><code>delete()</code></li>
<li><code>reverse()</code></li>
</ul>
As you can see the each method name pretty much describes what it does. Here is a simple demonstration:
<pre><code class="hljs">StringBuffer sb1 = new StringBuffer(&quot;Buffer no 1&quot;);
System.out.println(sb1);
 
sb1.append(&quot; - and this is appended!&quot;);
System.out.println(sb1);
sb1.insert(11, &quot;, this is inserted&quot;); 
System.out.println(sb1);
sb1.replace(7, 9, &quot;Number&quot;); 
System.out.println(sb1);
sb1.delete(7, 14);
System.out.println(sb1);
sb1.reverse();
System.out.println(sb1);
</code></pre>
Output:
<pre><code class="hljs">Buffer no 1
Buffer no 1 - and this is appended!
Buffer no 1, this is inserted - and this is appended!
Buffer Number 1, this is inserted - and this is appended!
Buffer 1, this is inserted - and this is appended!
!dedneppa si siht dna - detresni si siht ,1 reffuB
</code></pre>
<h2 id="stringvsstringbuildervsstringbuffer">String vs StringBuilder vs StringBuffer</h2>
<table class="table table-striped" style="width:100%">
 <tr align="center">
 <th colspan="2"></th>
 <th>String</th>
 <th>StringBuffer</th>
 <th>StringBuilder</th>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Mutable</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Thread-Safe</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>No</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Time Efficient</td>
 <td>No</td>
 <td>No</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Memory Efficient</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
</table>
Note: As we can see from the table above, <code>String</code> is both less efficient in time and memory, but that doesn't mean we should never use it again.
In fact, <code>String</code> can be very handy to use because it can be written fast and if you ever develop an application which stores Strings that are not going to be manipulated/changed later, it's absolutely fine to use <code>String</code>.
<h2 id="codeexample">Code Example</h2>
In order to show how much efficient <code>String</code>, <code>StringBuffer</code>, and <code>StringBuilder</code> are we are going to perform a benchmark test:
<pre><code class="hljs">String concatString = &quot;concatString&quot;;
StringBuffer appendBuffer = new StringBuffer(&quot;appendBuffer&quot;);
StringBuilder appendBuilder = new StringBuilder(&quot;appendBuilder&quot;);
long timerStarted;

timerStarted = System.currentTimeMillis();
for (int i = 0; i &lt; 50000; i++) {
 concatString += &quot; another string&quot;;
}
System.out.println(&quot;Time needed for 50000 String concatenations: &quot; + (System.currentTimeMillis() - timerStarted) + &quot;ms&quot;);

timerStarted = System.currentTimeMillis();
for (int i = 0; i &lt; 50000; i++) {
 appendBuffer.append(&quot; another string&quot;);
}
System.out.println(&quot;Time needed for 50000 StringBuffer appends: &quot; + (System.currentTimeMillis() - timerStarted) + &quot;ms&quot;);
 
timerStarted = System.currentTimeMillis();
for (int i = 0; i &lt; 50000; i++) {
 appendBuilder.append(&quot; another string&quot;);
}
System.out.println(&quot;Time needed for 50000 StringBuilder appends: &quot; + (System.currentTimeMillis() - timerStarted) + &quot;ms&quot;);
</code></pre>
Output:
<pre><code class="hljs">Time needed for 50000 String concatenations: 18108ms
Time needed for 50000 StringBuffer appends: 7ms
Time needed for 50000 StringBuilder appends: 3ms
</code></pre>
This output may vary depending on your Java Virtual Machine. So from this benchmark test we can see that <code>StringBuilder</code> is the fastest in string manipulation. Next is <code>StringBuffer</code>, which is between two and three times slower than <code>StringBuilder</code>. And finally we have <code>String</code> which is by far the slowest in string manipulation.
Using <code>StringBuilder</code> resulted in a time ~6000 times faster than regular <code>String</code>'s. What it would take <code>StringBuilder</code> to concatenate in 1 second would take <code>String</code> 1.6 hours (if we could concatenate that much).
<h2 id="conclusion">Conclusion</h2>
We have seen the performance of <code>String</code>s, <code>StringBuffer</code>s, and <code>StringBuilder</code>s as well as their pros and cons. Now, the final question arises:
<blockquote>
Which one is the winner?
</blockquote>
Well the perfect answer on this question is &quot;It depends&quot;. We know that <code>String</code>s are easy to type, easy to use, and are thread-safe. On the other hand they are immutable (which means more memory consumption) and very slow when doing string manipulation.
<code>StringBuffer</code>s are mutable, memory efficient, and thread-safe. Their downfall is the speed when compared to much faster <code>StringBuilder</code>s.
As for <code>StringBuilder</code>s, they are also mutable and memory efficient, they are the fastest in string manipulation, but unfortunately they are not thread-safe.
If you take these facts into the consideration, you will always make the right choice!

Guest Contributor

String vs StringBuilder vs StringBuffer in Java

Python for NLP: Creating a Rule-Based Chatbot

<h2 id="introduction">Introduction</h2>
If you've read anything about <a rel="nofollow" target="_blank" href="https://spring.io/">Spring</a>, developed a project, or was even remotely interested in how it works, you've been introduced to the <code>@RequestMapping</code> annotation.
It's one of the basic annotations in Spring which maps HTTP requests (URLs) with methods:
<pre><code class="hljs">@RequestMapping(&quot;/&quot;)
public void helloWorld() {
 return &quot;Hello World!&quot;;
}
</code></pre>
It allows us to run methods and pieces of code each time an endpoint is hit by the end-user with an HTTP request. In this case, it's a simple root mapping that returns the String &quot;Hello World!&quot; when the root endpoint is hit.
<h2 id="therequestmappingannotation">The @RequestMapping Annotation</h2>
The <code>@RequestMapping</code> annotation itself offers more than shown in the previous example. Let's briefly cover some of the basic use cases of the annotation.
<h3 id="requestmappingscopes">@RequestMapping Scopes</h3>
The mapping can be assigned at a class level or a method level:
<pre><code class="hljs">@RequestMapping(&quot;/admin&quot;)
public class AdminController() {
 @RequestMapping(&quot;/adminPanel&quot;)
 public String adminPanel() {
 return &quot;adminPanel.html&quot;;
 }

 @RequestMapping(&quot;/statistics&quot;)
 public String statistics() {
 return &quot;statistics.html&quot;;
 }
}
</code></pre>
Here, the <code>/admin</code> mapping is assigned on the class level, whereas the <code>/adminPanel</code> and <code>/statistics</code> mappings are assigned to methods. The class-level mapping will be used as a prefix for all of these method-level mappings: <code>/admin/adminPanel</code> and <code>/admin/statistics</code>.
This way, we can segregate our application into logical parts. For an example, all administrator related logic will be behind the <code>/admin</code> wall, which only administrator users can enter. All non-administrator users will be redirected to the client side of the application.
<h3 id="multiplemappingspermethod">Multiple Mappings per Method</h3>
If need be, we can assign multiple mappings to a single method, such as:
<pre><code class="hljs">@RequestMapping({&quot;/&quot;, &quot;/index&quot;, &quot;/home&quot;})
public void helloWorld() {
 return &quot;Hello World!&quot;;
}
</code></pre>
Hitting any of these endpoints will result in the <code>helloWorld()</code> method handling our request.
<h3 id="requestmethods">Request Methods</h3>
The most common attribute used is the <code>method</code> attribute which allows us to specify and narrow down the request method that our method handles (GET, POST, DELETE, etc.) :
<pre><code class="hljs">@RequestMapping(value = &quot;/addProduct&quot;, method = RequestMethod.POST)
public String addProductPost(@ModelAttribute(&quot;product&quot;) Product product) {
 // some code
}
</code></pre>
If we don't specify a request method, the default request method is <code>GET</code>.
<h3 id="requestheaders">Request Headers</h3>
We can further specify the mapping by defining one or more headers. In this case, the <code>helloWorld()</code> method will handle the request if its <code>content-type</code> is <code>text/plain</code> or <code>text/html</code>:
<pre><code class="hljs">@RequestMapping(value = &quot;/header&quot;, headers = {&quot;content-type=text/plain&quot;, &quot;content-type=text/html&quot;})
String helloWorld() {
 return &quot;Hello World!&quot;;
}
</code></pre>
<h3 id="pathvariables">Path Variables</h3>
A lot of websites rely on path variables to showcase a specific product, page, profile, etc. to the end-user, such as <code>example.com/viewProduct/324</code>, where <code>324</code> is the product ID:
<pre><code class="hljs">@RequestMapping(&quot;/viewProduct/{productId}&quot;)
public String viewProduct(@PathVariable int productId, Model model) {
 Product product = productService.getProductById(productId);
 model.addAttribute(&quot;product&quot;, product);

 return &quot;viewProduct&quot;;
}
</code></pre>
Here, after the mapping, we encase the path variable with curly brackets (<code>{}</code>) and assign that value to our <code>productId</code>. The <code>@PathVariable</code> annotation takes care of this for us. Then, we can find the product via our <code>ProductService</code> and display it to the end-user.
Of course, the same approach can be used for other variables such as:
<pre><code class="hljs">@RequestMapping(&quot;/users/{username}&quot;)
public String viewUser(@PathVariable(&quot;username&quot;) String username) {
 Profile profile = profileService.getProfileByUsername(username);
 // rest of the code
}
</code></pre>
<h3 id="requestparameters">Request Parameters</h3>
Very similar to path variables, many applications rely on request parameters to alter the state of the page. We can use the <code>@RequestParam</code> annotation to bind a request parameter to a variable:
<pre><code class="hljs">@RequestMapping(&quot;/login&quot;)
public String login(@RequestParam(value = &quot;error&quot;, required = false) String error, @RequestParam(value = &quot;logout&quot;, required = false) String logout, Model model) {

 if (error != null) {
 model.addAttribute(&quot;error&quot;, &quot;Wrong username or password!&quot;);
 }
 if (logout != null) {
 model.addAttribute(&quot;msg&quot;, &quot;You have successfully logged out!&quot;);
 }
 return &quot;login&quot;;
}
</code></pre>
<h3 id="producibleandconsumable">Producible and Consumable</h3>
Using the <code>@RequestMapping</code> annotation, we can also produce or consume media types. To produce a media type such as &quot;JSON&quot;, you can use the <code>produces</code> attribute alongside the <code>@ResponseBody</code> annotation, whereas to consume a media type you can use the <code>consumes</code> attribute:
<pre><code class="hljs">@RequestMapping(&quot;/annotations&quot;)
public class SomeController {
 @RequestMapping(value = &quot;/produce&quot;, produces = {&quot;application/json&quot;})
 @ResponseBody
 String produces() {
 return &quot;Here&#x27;s how you use the &#x27;produces&#x27; attribute&quot;;
 }

 @RequestMapping(value = &quot;/consume&quot;, consumes = {&quot;application/JSON&quot;, &quot;application/XML&quot;})
 String consume() {
 return &quot;Here&#x27;s how you use a &#x27;consume&#x27; attribute&quot;;
 }
}
</code></pre>
<h2 id="composedrequestmappingvariants">Composed @RequestMapping Variants</h2>
A single mapping can correspond to different methods if we ensure there's no ambiguity as to which method should handle which version of the mapping.
We can have multiple methods with the same mapping if their request method is different:
<pre><code class="hljs">@RequestMapping(&quot;/hello&quot;)
public String hello() {
 return &quot;hello&quot;;
}

@RequestMapping(value = &quot;/hello&quot;, method = RequestMethod.POST)
public String helloPost() {
 return &quot;hello post&quot;;
}

@RequestMapping(value = &quot;/hello&quot;, method = RequestMethod.PUT)
public String helloGet() {
 return &quot;hello put&quot;;
}

@RequestMapping(value = &quot;/hello&quot;, method = RequestMethod.DELETE)
public String helloDelete() {
 return &quot;hello delete&quot;;
}
</code></pre>
This same method has 4 different variations:
<ul>
<li>Default (GET)</li>
<li>POST</li>
<li>PUT</li>
<li>DELETE</li>
</ul>
With more variations, the readability of code gets reduced, and this quite honestly is already verbose for a simple mapping. Request mappings in bigger applications can get very complex and convoluted, and we'd want to keep it simpler and more readable.
For this purpose, we're introduced to several new annotations, the <code>@RequestMapping</code> variants:
<ul>
<li><code>@GetMapping</code></li>
<li><code>@PostMapping</code></li>
<li><code>@DeleteMapping</code></li>
<li><code>@PutMapping</code></li>
<li><code>@PatchMapping</code></li>
</ul>
There are quite literally just shortcut versions for the mappings above where <code>@PostMapping(&quot;/hello&quot;)</code> is equal to <code>@RequestMapping(value=&quot;/hello&quot;, RequestMethod.POST)</code>.
Taking a closer look at how these annotations are defined, we can get a clear idea of what they do:
<pre><code class="hljs">@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {

 @AliasFor(annotation = RequestMapping.class)
 String name() default &quot;&quot;;

 @AliasFor(annotation = RequestMapping.class)
 String[] value() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] path() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] params() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] headers() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] produces() default {};
}
</code></pre>
That being said, we can rewrite the examples above:
<pre><code class="hljs">@GetMapping
public String hello() {
 return &quot;hello&quot;;
}

@PostMapping
public String helloPost() {
 return &quot;hello post&quot;;
}

@PutMapping
public String helloGet() {
 return &quot;hello put&quot;;
}

@DeleteMapping
public String helloDelete() {
 return &quot;hello delete&quot;;
}
</code></pre>
As this is both a simpler, more readable and newer way of writing annotations, it's generally preferred to write them like this. If need be, you can still define any other attributes such as the <code>value</code>, <code>params</code>, <code>path</code>, etc.
<h2 id="conclusion">Conclusion</h2>
<code>@RequestMapping</code> is a quintessential annotation in the Spring framework which allows us to map HTTP requests with methods we'd wish to run.
As of Spring 4.3, it's preferred and advised to use the shortcuts made for this annotation for a more readable and less verbose codebase.