<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be diving into String Comparison in Java.
String comparison is a common operation in all languages. The ability to check if one String is equal to another allows us to perform fundamental checks and alter the code flow.
<h2 id="theoperator">The <code>==</code> Operator</h2>
The <code>==</code> operator is one of the first operators learned when diving into a new language, typically for comparing primitive data types like <code>int</code>s.
Let's take a look at how we can compare two <code>String</code> objects with the <code>==</code> operator:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = &quot;Hello&quot;;
String s3 = &quot;World&quot;;

System.out.println(s1 == s2);
System.out.println(s2 == s3);
</code></pre>
This would return:
<pre><code class="hljs">true
false
</code></pre>
This is expected - <code>s1 == s2</code> and <code>s2 != s3</code>. However, let's rewrite this a bit into:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = new String(&quot;Hello&quot;);

System.out.println(s1 == s2);
</code></pre>
This returns:
<pre><code class="hljs">false
</code></pre>
<blockquote>
This is because the <code>==</code> operator doesn't check for equality. It checks for identity.
</blockquote>
In other words, it doesn't compare the <code>String</code>s value - it compares object references.
The <code>s1</code> is a reference variable to the same object in memory that <code>s2</code> references. This is because the String Pool doesn't create new objects if we try instantiating a String with an already existing value.
However, when we instantiate <code>s2</code> with the <code>new</code> keyword, we explicitly tell the JVM that we want a new object. Then, even though they have the same String value - the <code>s1</code> and <code>s2</code> reference variables refer to different objects, and thus the <code>==</code> operator returns <code>false</code>.
<h2 id="theequalsmethod">The <code>equals()</code> Method</h2>
The <code>equals()</code> method is typically the way to go when comparing the contents of Strings. It's case sensitive and compares each character of the String to each character of the other String:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = new String(&quot;Hello&quot;);

System.out.println(s1.equals(s2));
</code></pre>
This will always return:
<pre><code class="hljs">true
</code></pre>
Whether we wrote <code>s1.equals(s2)</code> or <code>s2.equals(s1)</code>, the result would be the same.
<code>equals()</code> is null-safe, which means it checks for <code>null</code> values for you. If we compare a non-<code>null</code> value to a <code>null</code> value, logically, the result is <code>false</code>:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = null;

System.out.println(s1.equals(s2));
</code></pre>
<pre><code class="hljs">false
</code></pre>
<h2 id="theequalsignorecasemethod">The <code>equalsIgnoreCase()</code> Method</h2>
Since <code>equals()</code> is case-sensitive, in cases like <code>Hello</code> and <code>hello</code>, it'll return <code>false</code>. These truly aren't equal if case is important. However, in some situations, the case really isn't important. You'd just like to check if the characters themselves are the same, regardless of case.
For that, we use the <code>equalsIgnoreCase()</code> method:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = &quot;hello&quot;;

System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
</code></pre>
This results in:
<pre><code class="hljs">false
true
</code></pre>
<h2 id="thecomparetomethod">The <code>compareTo()</code> Method</h2>
The <code>compareTo()</code> method works in a different fashion from the <code>equals()</code> method. The <code>compareTo()</code> method checks for the String's lexicographical value.
If we compare <code>s1</code> to <code>s2</code> - if <code>s1</code>'s lexicographical value is higher than <code>s2</code>'s, the method will return a positive value. If it's lower, the method will return a negative value. If they're the same, the method will return <code>0</code>.
This method is very useful if you'd want to sort words in a lexicographical order:
<pre><code class="hljs">String s1 = &quot;a&quot;;
String s2 = &quot;b&quot;;

System.out.println(s1.compareTo(s2));
</code></pre>
This returns:
<pre><code class="hljs">-1
</code></pre>
Since the difference in Unicode values for <code>a</code> and <code>b</code> is just 1. Let's take a look at another example:
<pre><code class="hljs">String s1 = &quot;Hello World&quot;;
String s2 = &quot;hello world&quot;;

System.out.println(s1.compareTo(s2));
</code></pre>
This results in:
<pre><code class="hljs">-32
</code></pre>
<h2 id="thecomparetoignorecasemethod">The <code>compareToIgnoreCase()</code> Method</h2>
Similarly, there's a version of this method that doesn't care about the case of the characters. For example, the previous two Strings:
<pre><code class="hljs">String s1 = &quot;Hello World&quot;;
String s2 = &quot;hello world&quot;;

System.out.println(s1.compareToIgnoreCase(s2));
</code></pre>
Would now return:
<pre><code class="hljs">0
</code></pre>
<h2 id="thecontentequalsmethod">The <code>contentEquals()</code> Method</h2>
The <code>contentEquals()</code> is a relatively rarely used method, since it looks like it's the same as the <code>equals()</code> method.
Namely, the <code>equals()</code> method compares objects for equality. The String class overrides the default behavior to make it compare the contents.
The <code>contentEquals()</code> method compares <code>CharSequence</code>s and <code>StringBuffer</code>s. With it, you don't have to convert a <code>StringBuffer</code> into a <code>String</code> for comparison - the method will deal with that itself:
<pre><code class="hljs">String s1 = &quot;aaaa&quot;;
StringBuffer s2 = new StringBuffer(&quot;&quot;);

for (int i = 0; i &lt; 4; i++) {
 s2.append(&#x27;a&#x27;);
}

System.out.println(s1.contentEquals(s2));
</code></pre>
With the method from before, you can't compare a <code>String</code> to a <code>StringBuffer</code>. This way, you can.
This code returns:
<pre><code class="hljs">true
</code></pre>
<h2 id="stringutilsapachecommons">StringUtils - Apache Commons</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library is a robust library filled with countless convenience methods and classes.
<code>StringUtils</code> is a helper class with a bunch of String-related operations, including the ones for checking equality.
<h3 id="stringutilsequals">StringUtils.equals()</h3>
The <code>equals()</code> method of the <code>StringUtils</code> class works in the same way we'd expect it to based on our familiarity with the <code>Object.equals()</code> method:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = new String(&quot;Hello&quot;);

System.out.println(StringUtils.equals(s1, s2));
System.out.println(StringUtils.equals(s1, null));
System.out.println(StringUtils.equals(null, null));
</code></pre>
This would return:
<pre><code class="hljs">true
false
true
</code></pre>
It also features null-safety and checks for <code>null</code> values. Comparing two <code>null</code> values will return <code>true</code>.
<h3 id="stringutilsequalsignorecase">StringUtils.equalsIgnoreCase()</h3>
The <code>equalsIgnoreCase()</code> method works in the same fashion:
<pre><code class="hljs">String s1 = &quot;Hello&quot;;
String s2 = new String(&quot;hello&quot;);

System.out.println(StringUtils.equalsIgnoreCase(s1, s2));
System.out.println(StringUtils.equalsIgnoreCase(s1, null));
System.out.println(StringUtils.equalsIgnoreCase(null, null));
</code></pre>
This returns:
<pre><code class="hljs">true
false
true
</code></pre>
<h3 id="stringutilsequalsany">StringUtils.equalsAny()</h3>
The <code>equalsAny()</code> is the first method that does something completely new. It accepts a <code>String</code> and a <code>CharSequence</code> vararg. If any of the varargs can be found in the <code>String</code>, it returns true:
<pre><code class="hljs">System.out.println(StringUtils.equalsAny(&quot;Hello World&quot;, &quot;Hello&quot;, &quot;World&quot;));
System.out.println(StringUtils.equalsAny(&quot;Java is great!&quot;, &quot;Java&quot;, &quot;great!&quot;));
</code></pre>
This would return:
<pre><code class="hljs">true
true
</code></pre>
Note: The method is case-sensitive.
<h3 id="stringutilsequalsanyignorecase">StringUtils.equalsAnyIgnoreCase()</h3>
Of course, we also have a case-insensitive variant of the method:
<pre><code class="hljs">System.out.println(StringUtils.equalsAnyIgnoreCase(&quot;Hello World&quot;, &quot;HELLO&quot;, &quot;world&quot;));
System.out.println(StringUtils.equalsAnyIgnoreCase(&quot;Java is great!&quot;, &quot;JavA&quot;, &quot;GrEat!&quot;));
</code></pre>
These would also return:
<pre><code class="hljs">true
true
</code></pre>
<h3 id="stringutilscompare">StringUtils.compare()</h3>
The <code>compare()</code> method of the <code>StringUtils</code> class works in the same way as the <code>compareTo()</code> method of the <code>String</code> class. However, this convenience method is null-safe unlike the official implementation.
It follows the idea of a <code>null</code> value being lexicographically smaller than a non-<code>null</code> value, which makes a lot of sense.
<pre><code class="hljs">String s1 = &quot;a&quot;;
String s2 = &quot;b&quot;;

System.out.println(StringUtils.compare(s1, s2));
</code></pre>
This returns:
<pre><code class="hljs">-1
</code></pre>
<h3 id="stringutilscompareignorecase">StringUtils.compareIgnoreCase()</h3>
Finally, the case-insensitive version of the previous method - <code>compareIgnoreCase()</code>. It compares the lexicographical value of Strings, without taking the case into consideration:
<pre><code class="hljs">String s1 = &quot;A&quot;;
String s2 = &quot;a&quot;;

System.out.println(StringUtils.compareIgnoreCase(s1, s2));
</code></pre>
This would normally return <code>-32</code> since lower-case letters are separated from their upper-case counterparts by 32 places. However, this returns:
<pre><code class="hljs">0
</code></pre>
<h2 id="conclusion">Conclusion</h2>
String comparison in Java, as in other languages, is a common task. There's quite a few ways to go about it, both using built-in methods and the Apache Commons library.

David Landup

In this tutorial, we'll be comparing strings in Java using core methods and the Apache Commons library,

Comparing Strings with Java

<h2 id="isvsinpython">'is' vs '==' in Python</h2>
Python has two very similar operators for checking whether two objects are equal. These two operators are <code>is</code> and <code>==</code>.
They are usually confused with one another because with simple data types, like <code>int</code>s and <code>string</code>s (which many people start learning Python with) they seem to do the same thing:
<pre><code class="hljs">x = 5
s = &quot;example&quot;

print(&quot;x == 5: &quot; + str(x == 5))
print(&quot;x is 5: &quot; + str(x is 5))
print(&quot;s == &#x27;example&#x27;: &quot; + str(s == &quot;example&quot;))
print(&quot;s is &#x27;example&#x27;: &quot; + str(s is &quot;example&quot;))
</code></pre>
Running this code will result in:
<pre><code class="hljs">x == 5: True
x is 5: True
s == &#x27;example&#x27;: True
s is &#x27;example&#x27;: True
</code></pre>
This shows that <code>==</code> and <code>is</code> return the same value (<code>True</code>) in these cases. However, if you tried to do this with a more complicated structure:
<pre><code class="hljs">some_list = [1]

print(&quot;some_list == [1]: &quot; + str(some_list == [1]))
print(&quot;some_list is [1]: &quot; + str(some_list is [1]))
</code></pre>
This would result in:
<pre><code class="hljs">some_list == [1]: True
some_list is [1]: False
</code></pre>
Here it becomes obvious that these operators aren't the same.
<blockquote>
The difference comes from the fact that <code>is</code> checks for identity (of objects), while <code>==</code> checks for equality (of value).
</blockquote>
Here's another example that might clarify the difference between these two operators:
<pre><code class="hljs">some_list1 = [1]
some_list2 = [1]
some_list3 = some_list1

print(&quot;some_list1 == some_list2: &quot; + str(some_list1 == some_list2))
print(&quot;some_list1 is some_list2: &quot; + str(some_list1 is some_list2))
print(&quot;some_list1 == some_list3: &quot; + str(some_list1 == some_list3))
print(&quot;some_list1 is some_list3: &quot; + str(some_list1 is some_list3))
</code></pre>
This results in:
<pre><code class="hljs">some_list1 == some_list2: True
some_list1 is some_list2: False
some_list1 == some_list3: True
some_list1 is some_list3: True
</code></pre>
As we can see, <code>some_list1</code> is equal to <code>some_list2</code> by value (they're both equal to <code>[1]</code>]), but they are not identical, meaning they aren't the same object, even though they have equal values.
However, <code>some_list1</code> is both equal and identical to <code>some_list3</code> since they reference the same object in memory.
<h2 id="mutablevsimmutabledatatypes">Mutable vs Immutable Data Types</h2>
While this part of the problem now might be clear (when we have named variables), another question might pop up:
<blockquote>
How come <code>is</code> and <code>==</code> behave the same with unnamed <code>int</code> and <code>string</code> values (like <code>5</code> and <code>&quot;example&quot;</code>) but don't behave the same with unnamed lists (like <code>[1]</code>)?
</blockquote>
There are two kinds of data types in Python - mutable and immutable.
<ul>
<li>Mutable data types are data types which you can &quot;change&quot; over time</li>
<li>Immutable data types stay the same (have the same memory location, which is what <code>is</code> checks) once they are created</li>
</ul>
Mutable data types are: <code>list</code>, <code>dictionary</code>, <code>set</code>, and user-defined classes.
Immutable data types are: <code>int</code>, <code>float</code>, <code>decimal</code>, <code>bool</code>, <code>string</code>, <code>tuple</code>, and <code>range</code>.
Like many other languages Python handles immutable data types differently than mutable types, i.e. saves them in memory only once.
So every <code>5</code> you use in your code is the exact same <code>5</code> you use in other places in your code, and the same goes for string literals you use.
If you use the string <code>&quot;example&quot;</code> once, every other time you use <code>&quot;example&quot;</code> it will be the exact same object. See this <a href="#note">Note</a> for further clarification.
We will be using a Python function called <code>id()</code> which prints out a unique identifier for each object, to take a closer look at this mutability concept in action:
<pre><code class="hljs">s = &quot;example&quot;
print(&quot;Id of s: &quot; + str(id(s)))
print(&quot;Id of the String &#x27;example&#x27;: &quot; + str(id(&quot;example&quot;)) + &quot; (note that it&#x27;s the same as the variable s)&quot;)
print(&quot;s is &#x27;example&#x27;: &quot; + str(s is &quot;example&quot;))

print(&quot;Change s to something else, then back to &#x27;example&#x27;.&quot;)
s = &quot;something else&quot;
s = &quot;example&quot;
print(&quot;Id of s: &quot; + str(id(s)))
print(&quot;s is &#x27;example&#x27;: &quot; + str(s is &quot;example&quot;))
print()

list1 = [1]
list2 = list1
print(&quot;Id of list1: &quot; + str(id(list1)))
print(&quot;Id of list2: &quot; + str(id(list2)))
print(&quot;Id of [1]: &quot; + str(id([1])) + &quot; (note that it&#x27;s not the same as list1!)&quot;)
print(&quot;list1 == list2: &quot; + str(list1 == list2))
print(&quot;list1 is list2: &quot; + str(list1 is list2))

print(&quot;Change list1 to something else, then back to the original ([1]) value.&quot;)
list1 = [2]
list1 = [1]
print(&quot;Id of list1: &quot; + str(id(list1)))
print(&quot;list1 == list2: &quot; + str(list1 == list2))
print(&quot;list1 is list2: &quot; + str(list1 is list2))
</code></pre>
This outputs:
<pre><code class="hljs">Id of s: 22531456
Id of the String &#x27;example&#x27;: 22531456 (note that it&#x27;s the same as the variable s)
s is &#x27;example&#x27;: True
Change s to something else, then back to &#x27;example&#x27;.
Id of s: 22531456
s is &#x27;example&#x27;: True

Id of list1: 22103504
Id of list2: 22103504
Id of [1]: 22104664 (note that it&#x27;s not the same as list1!)
list1 == list2: True
list1 is list2: True
Change list1 to something else, then back to the original ([1]) value.
Id of list1: 22591368
list1 == list2: True
list1 is list2: False
</code></pre>
We can see that in the first part of the example, <code>s</code> returned to the exact same <code>&quot;example&quot;</code> object it was assigned to at the beginning, even if we change the value of <code>s</code> in the meantime.
However, <code>list</code> does not return the same object whose value is <code>[1]</code>, but a whole new object is created, even if it has the same value as the first <code>[1]</code>.
If you run the code above, you are likely to get different IDs for the objects, but the equalities will be the same.
<h2 id="whenareisandusedrespectively">When are 'is' and '==' Used Respectively?</h2>
The <code>is</code> operator is most commonly used when we want to compare the object to <code>None</code>, and restricting its usage to this particular scenario is generally advised unless you really (and I do mean really) want to check whether two objects are identical.
Besides, <code>is</code> is generally faster than the <code>==</code> operator because it simply checks for integer equality of the memory address.
Important note: The only situation when <code>is</code> works exactly as might be expected is with <a target="_blank" href="/the-singleton-design-pattern-in-python/">singleton</a> classes/objects (like <code>None</code>). Even with immutable objects, there are situations where <code>is</code> does not work as expected.
For example, for large <code>string</code> objects generated by some code logic, or large <code>int</code>s, <code>is</code> can (and will) behave unpredictably. Unless you go through the effort of interning (i.e. making absolutely sure that only one copy of a <code>string</code>/<code>int</code>/etc. exists), all the various immutable objects you plan to use, <code>is</code> will be unpredictable.
<blockquote>
The bottom line is: use <code>==</code> in 99% of cases.
</blockquote>
If two objects are identical they are also equal, and that the opposite isn't necessarily true.
<h2 id="overridingandoperators">Overriding '==' and '!=' Operators</h2>
Operators <code>!=</code> and <code>is not</code> behave in the same way as their &quot;positive&quot; counterparts do. Namely, <code>!=</code> returns <code>True</code> if objects don't have the same value, while <code>is not</code> returns <code>True</code> if the objects are not stored in the same memory address.
One other difference between these two operators is that you can override the behavior of <code>==</code>/<code>!=</code> for a custom class, while you can't override the behavior of <code>is</code>.
If you implement a custom <code>__eq()__</code> method in your class, you can change how the <code>==</code>/<code>!=</code> operators behave:
<pre><code class="hljs">class TestingEQ:
 def __init__(self, n):
 self.n = n

 # using the &#x27;==&#x27; to check whether both numbers
 # are even, or if both numbers are odd
 def __eq__(self, other):
 if (self.n % 2 == 0 and other % 2 == 0):
 return True
 else:
 return False


print(5 == TestingEQ(1))
print(2 == TestingEQ(10))
print(1 != TestingEQ(2))
</code></pre>
This results in:
<pre><code class="hljs">False
True
True
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In short, <code>==</code>/<code>!=</code> checks for equality (by value) and <code>is</code>/<code>is not</code> checks whether two objects are identical, i.e. checks their memory addresses.
However, avoid using <code>is</code> unless you know exactly what you're doing, or when dealing with singleton objects like <code>None</code>, since it can behave unpredictably.

Olivera Popović

In this tutorial, we'll dive into the difference between the 'is' and '==' operators in Python. We'll cover use cases of both and overload the '==' operator for custom value comparison.

'is' vs '==' - Python Object Comparison

'is' vs '==' in Python - Object Comparison

<h2 id="introduction">Introduction</h2>
When you want to run a project that has multiple sources, resources, etc., you need to make sure that all of the code is recompiled before the main program is compiled or run.
For example, imagine our software looks something like this:
<pre><code class="hljs">main_program.source -&gt; uses the libraries `math.source` and `draw.source`
math.source -&gt; uses the libraries `floating_point_calc.source` and `integer_calc.source`
draw.source -&gt; uses the library `opengl.source`
</code></pre>
So if we make a change in <code>opengl.source</code> for example, we need to recompile both <code>draw.source</code> and <code>main_program.source</code> because we want our project to be up-to-date on all ends.
This is a very tedious and time-consuming process. And because all good things in the software world come from some engineer being too lazy to type in a few extra commands, Makefile was born.
<blockquote>
Makefile uses the <code>make</code> utility, and if we're to be completely accurate, Makefile is just a file that houses the code that the <code>make</code> utility uses. However, the name Makefile is much more recognizable.
</blockquote>
Makefile essentially keeps your project up to date by rebuilding only the necessary parts of your source code whose <code>children</code> are out of date. It can also automatize compilation, builds and testing.
<blockquote>
In this context, a <code>child</code> is a library or a chunk of code which is essential for its parent's code to run.
</blockquote>
This concept is very useful and is commonly used with compiled programming languages. Now, you may be asking yourself:
<blockquote>
Isn't Python an interpreted language?
</blockquote>
Well, Python is technically both an interpreted and compiled language, because in order for it to interpret a line of code, it needs to pre-compile it into byte code which is not hardcoded for a specific CPU, and can be run after the fact.
A more detailed, yet concise explanation can be found on <a rel="nofollow noopener" target="_blank" href="https://nedbatchelder.com/blog/201803/is_python_interpreted_or_compiled_yes.html">Ned Batchelder's blog</a>. Also, if you need a refresher on how <a target="_blank" href="/programming-language-processors/">Programming Language Processors</a> work, we've got you covered.
<h2 id="conceptbreakdown">Concept Breakdown</h2>
Because Makefile is just an amalgamation of multiple concepts, there are a few things you'll need to know in order to write a Makefile:
<ol>
<li>Bash Scripting</li>
<li>Regular Expressions</li>
<li>Target Notation</li>
<li>Understanding your project's file structure</li>
</ol>
With these in hand, you'll be able to write instructions for the <code>make</code> utility and automate your compilation.
Bash is a command language (it's also a Unix shell but that's not really relevant right now), which we will be using to write actual commands or automate file generation.
For example, if we want to echo all the library names to the user:
<pre><code class="hljs">DIRS=project/libs
for file in $(DIRS); do
 echo $$file
done
</code></pre>
Target notation is a way of writing which files are dependent on other files. For example, if we want to represent the dependencies from the illustrative example above in proper target notation, we'd write:
<pre><code class="hljs">main_program.cpp: math.cpp draw.cpp
math.cpp: floating_point_calc.cpp integer_calc.cpp
draw.cpp: opengl.cpp
</code></pre>
As far as file structure goes, it depends on your programming language and environment. Some IDEs automatically generate some sort of Makefile as well, and you won't need to write it from scratch. However, it's very useful to understand the syntax if you want to tweak it.
Sometimes modifying the default Makefile is even mandatory, like when you want to make OpenGL and CLion play nice together.
<h3 id="bashscripting">Bash Scripting</h3>
Bash is mostly used for automation on Linux distributions, and is essential to becoming an all-powerful Linux &quot;wizard&quot;. It's also an imperative script language, which makes it very readable and easy to understand. Note that you can run bash on Windows systems, but it's not really a common use case.
First let's go over a simple &quot;Hello World&quot; program in Bash:
<pre><code class="hljs"># Comments in bash look like this

#!/bin/bash
# The line above indicates that we&#x27;ll be using bash for this script
# The exact syntax is: #![source]
echo &quot;Hello world!&quot;
</code></pre>
When creating a script, depending on your current <code>umask</code>, the script itself might not be executable. You can change this by running the following line of code in your terminal:
<pre><code class="hljs">chmod +x name_of_script.sh
</code></pre>
This adds execute permission to the target file. However, if you want to give more specific permissions, you can execute something similar to the following command:
<pre><code class="hljs">chmod 777 name_of_script.sh
</code></pre>
More information on <code>chmod</code> on <a rel="nofollow noopener" target="_blank" href="https://www.computerhope.com/unix/uchmod.htm">this link</a>.
Next, let's quickly go over some basics utilizing simple <code>if</code>-statements and variables:
<pre><code class="hljs">#!/bin/bash

echo &quot;What&#x27;s the answer to the ultimate question of life, the universe, and everything?&quot;
read -p &quot;Answer: &quot; number
# We dereference variables using the $ operator
echo &quot;Your answer: $number computing...&quot;
# if statement
# The double brackets are necessary, whenever we want to calculate the value of an expression or subexpression, we have to use double brackets, imagine you have selective double vision.
if (( number == 42 ))
then
 echo &quot;Correct!&quot;
 # This notation, even though it&#x27;s more easily readable, is rarely used.
elif (( number == 41 || number == 43 )); then
 echo &quot;So close!&quot;
 # This is a more common approach
else
 echo &quot;Incorrect, you will have to wait 7 and a half million years for the answer!&quot;
fi
</code></pre>
Now, there is an alternative way of writing flow control which is actually more common than if statements. As we all know Boolean operators can be used for the sole purpose of generating side-effects, something like:
<pre><code class="hljs">++a &amp;&amp; b++ 
</code></pre>
Which means that we first increment <code>a</code>, and then depending on the language we're using, we check if the value of the expression evaluates to <code>True</code> (generally if an integer is <code>&gt;0</code> or <code>=/=0</code> it means its <code>boolean</code> value is <code>True</code>). And if it is <code>True</code>, then we increment <code>b</code>.
This concept is called conditional execution and is used very commonly in bash scripting, for example:
<pre><code class="hljs">#!/bin/bash

# Regular if notation
echo &quot;Checking if project is generated...&quot;
# Very important note, the whitespace between `[` and `-d` is absolutely essential
# If you remove it, it&#x27;ll cause a compilation error
if [ -d project_dir ]
then
 echo &quot;Dir already generated.&quot;
else
 echo &quot;No directory found, generating...&quot;
 mkdir project_dir
fi
</code></pre>
This can be rewritten using a conditional execution:
<pre><code class="hljs">echo &quot;Checking if project is generated...&quot;
[ -d project_dir ] || mkdir project_dir 
</code></pre>
Or, we can take it even further with nested expressions:
<pre><code class="hljs">echo &quot;Checking if project is generated...&quot;
[ -d project_dir ] || (echo &quot;No directory found, generating...&quot; &amp;&amp; mkdir project_dir)
</code></pre>
Then again, nesting expressions can lead down a rabbit hole and can become extremely convoluted and unreadable, so it's not advised to nest more than two expressions at most.
You might be confused by the weird <code>[ -d ]</code> notation used in the code snippet above, and you're not alone.
The reasoning behind this is that originally conditional statements in Bash were written using the <code>test [EXPRESSION]</code> command. But when people started writing conditional expressions in brackets, Bash followed, albeit with a very unmindful hack, by just remapping the <code>[</code> character to the <code>test</code> command, with the <code>]</code> signifying the end of the expression, most likely implemented after the fact.
Because of this, we can use the command <code>test -d FILENAME</code> which checks if the provided file exists and is a directory, like this <code>[ -d FILENAME ]</code>.
<h2 id="regularexpressions">Regular Expressions</h2>
Regular expressions (regex for short) give us an easy way to generalize our code. Or rather to repeat an action for a specific subset of files that meet certain criteria. We'll cover some regex basics and a few examples in the code snippet below.
Note: When we say that an expression catches ( -&gt; ) a word, it means that the specified word is in the subset of words that the regular expression defines:
<pre><code class="hljs"># Literal characters just signify those same characters
StackAbuse -&gt; StackAbuse
sTACKaBUSE -&gt; sTACKaBUSE

# The or (|) operator is used to signify that something can be either one or other string
Stack|Abuse -&gt; Stack
 -&gt; Abuse
Stack(Abuse|Overflow) -&gt; StackAbuse
 -&gt; StackOverflow

# The conditional (?) operator is used to signify the potential occurrence of a string
The answer to life the universe and everything is( 42)?...
 -&gt; The answer to life the universe and everything is...
 -&gt; The answer to life the universe and everything is 42...
 
# The * and + operators tell us how many times a character can occur
# * indicates that the specified character can occur 0 or more times
# + indicates that the specified character can occur 1 or more times 
He is my( great)+ uncle Brian. -&gt; He is my great uncle Brian.
 -&gt; He is my great great uncle Brian.
# The example above can also be written like this:
He is my great( great)* uncle Brian.
</code></pre>
This is just the bare minimum you need for the immediate future with Makefile. Though, on the long term, learning Regular Expressions is a really good idea.
<h2 id="targetnotation">Target Notation</h2>
After all of this, now we can finally get into the meat of the Makefile syntax. Target notation is just a way of representing all the dependencies that exist between our source files.
Let's look at an example that has the same file structure as the example from the beginning of the article:
<pre><code class="hljs"># First of all, all pyc (compiled .py files) are dependent on their source code counterparts
main_program.pyc: main_program.py
 python compile.py $&lt;
math.pyc: math.py
 python compile.py $&lt;	
draw.pyc: draw.py
 python compile.py $&lt;

# Then we can implement our custom dependencies
main_program.pyc: main_program.py math.pyc draw.pyc
 python compile.py $&lt;
math.pyc: math.py floating_point_calc.py integer_calc.py
 python compile.py $&lt;	
draw.pyc: draw.py opengl.py
 python compile.py $&lt;
</code></pre>
Keep in mind that the above is just for the sake of clarifying how the target notation works. It's very rarely used in Python projects like this, because the difference in performance is in most cases negligible.
More often than not, Makefiles are used to set up a project, clean it up, maybe provide some help and test your modules. The following is an example of a much more realistic Python project Makefile:
<pre><code class="hljs"># Signifies our desired python version
# Makefile macros (or variables) are defined a little bit differently than traditional bash, keep in mind that in the Makefile there&#x27;s top-level Makefile-only syntax, and everything else is bash script syntax.
PYTHON = python3

# .PHONY defines parts of the makefile that are not dependant on any specific file
# This is most often used to store functions
.PHONY = help setup test run clean

# Defining an array variable
FILES = input output

# Defines the default target that `make` will to try to make, or in the case of a phony target, execute the specified commands
# This target is executed whenever we just type `make`
.DEFAULT_GOAL = help

# The @ makes sure that the command itself isn&#x27;t echoed in the terminal
help:
 @echo &quot;---------------HELP-----------------&quot;
 @echo &quot;To setup the project type make setup&quot;
 @echo &quot;To test the project type make test&quot;
 @echo &quot;To run the project type make run&quot;
 @echo &quot;------------------------------------&quot;

# This generates the desired project file structure
# A very important thing to note is that macros (or makefile variables) are referenced in the target&#x27;s code with a single dollar sign ${}, but all script variables are referenced with two dollar signs $${}
setup:
 
 @echo &quot;Checking if project files are generated...&quot;
 [ -d project_files.project ] || (echo &quot;No directory found, generating...&quot; &amp;&amp; mkdir project_files.project)
 for FILE in ${FILES}; do \
 touch &quot;project_files.project/$${FILE}.txt&quot;; \
 done

# The ${} notation is specific to the make syntax and is very similar to bash&#x27;s $() 
# This function uses pytest to test our source files
test:
 ${PYTHON} -m pytest
 
run:
 ${PYTHON} our_app.py

# In this context, the *.project pattern means &quot;anything that has the .project extension&quot;
clean:
 rm -r *.project
</code></pre>
With that in mind, let's open up the terminal and run the Makefile to help us out with generating and compiling a Python project:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-write-a-makefile-1.PNG" alt="running make with the makefile">
<h2 id="conclusion">Conclusion</h2>
Makefile and make can make your life much easier, and can be used with almost any technology or language.
It can automate most of your building and testing, and much more. And as can be seen from the example above, it can be used with both interpreted and compiled languages.

Vladimir Batoćanin

In this tutorial, we'll go over the basics of Makefiles - regex, target notation and bash scripting. We'll write a makefile for a Python project and then execute it with the make utility.

How to Write a Makefile - Automating Python Setup, Compilation, and Testing

<h2 id="introduction">Introduction</h2>
In this article, we'll be using the Java AWS SDK and API to create an S3 bucket, upload files to it, and finally - delete it.
One of the most popular services available on Amazon Web Services is the Simple Storage Service (S3).
S3 makes it easy for developers and other users to implement data storage for personal use or their applications. Data is stored using a model called <a target="_blank" rel="nofollow noopener" href="https://aws.amazon.com/what-is-cloud-object-storage/">Cloud Object Storage</a>, which stores the data itself (usually from a file), some metadata describing the object, and an ID to uniquely identify the object.
S3 provides a web interface which makes it easy to upload files for storage and retrieve them. Files can be organized into separate &quot;S3 buckets&quot; which are containers for data.
Data files can be further categorized into folders within buckets for familiar path-based organization and access. Each bucket is mapped to a URL that allows files within the bucket to be accessed over HTTP. Users have full control to set bucket-level or file-level permissions and thus determine access to buckets and their contents.
In addition to creating and working with S3 buckets through the web interface, AWS provides the SDKs that give us access to bucket operations.
<h2 id="awscredentials">AWS Credentials</h2>
Let's start by learning how to create a set of AWS credentials, which are required to access AWS and make API calls through the SDK. The easiest way to do this is to log into the AWS console and create a new IAM (Identity and Access Management) role:
<ol>
<li>
Log into the <a rel="noopener nofollow" target="_blank" href="https://aws.amazon.com">AWS Console</a>.
</li>
<li>
Click on the Services menu in the top left of the screen, search for IAM, and click on the dropdown option that appears.
</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/using-the-aws-java-sdk-to-work-with-s3-buckets-01.png" alt="AWS IAM Services Menu">
<ol start="3">
<li>Under the Security Status heading, expand the Create individual IAM users option and click the Manage Users button.</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/using-the-aws-java-sdk-to-work-with-s3-buckets-02.png" alt="AWS IAM Manage Users">
<ol start="4">
<li>
Click the Add user button.
</li>
<li>
Enter the user's name for your new IAM user and check the box for Programmatic access.
</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/using-the-aws-java-sdk-to-work-with-s3-buckets-03.png" alt="AWS IAM User Details">
<ol start="6">
<li>
Click the Next: Permissions button and then select Attach existing policies directly.
</li>
<li>
Type S3 into the search box and in the results, check the box for AmazonS3FullAccess.
</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/using-the-aws-java-sdk-to-work-with-s3-buckets-04.png" alt="AWS IAM S3 Permissions">
<ol start="8">
<li>
Click the Next: Tags button, then click the Next: Review button.
</li>
<li>
Review the IAM user configuration and click the Create user button.
</li>
<li>
You'll be taken to a confirmation page, where you can copy out the Access key ID and Secret access key which are the credentials you'll use to access the AWS API through the Java SDK.
</li>
</ol>
By default, the SDK will look up for the credentials in the Default credential profile file, which is a file typically located at <code>~/.aws/credentials</code> on your local machine. You'll need to create this file yourself and add the IAM credentials into it.
To configure this yourself, create the new file <code>~/.aws/credentials</code> and add the following contents, replacing the access key and secret key with the values from your newly created IAM user in the AWS console:
<pre><code class="hljs">aws_access_key_id = YOUR_ACCESS_KEY_ID
aws_secret_access_key = YOUR_SECRET_ACCESS_KEY
</code></pre>
Create a default region file for the AWS SDK to use by adding a new file called <code>~/.aws/config</code> with the following contents (you can replace the region with one closer to where your users live for optimal performance):
<pre><code class="hljs">region = US_WEST_2
</code></pre>
The local environment should now be configured for the AWS Java SDK to authenticate successfully.
<h2 id="installingthesdkwithmaven">Installing the SDK with Maven</h2>
If you're using Maven, add the following dependency to include the AWS Java SDK:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.amazonaws&lt;/groupId&gt;
 &lt;artifactId&gt;aws-java-sdk-s3&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or, if you're using Gradle:
<pre><code class="hljs">compile group: &#x27;com.amazonaws&#x27;, name: &#x27;aws-java-sdk&#x27;, version: &#x27;${version}&#x27;
</code></pre>
Now, instead of just the S3 dependency, you could use <code>aws-java-sdk</code>, which is the entire SDK. There's a lot of dependencies in the entire SDK - 219, to be exact, so if you're only using S3, there's no need to download them all.
At this point, we are ready to automate the creation of buckets, uploading files to them and the deletion of buckets using Java!
<h2 id="creatingans3bucketwithjava">Creating an S3 Bucket with Java</h2>
The AWS Java SDK for S3 provides several classes that can be used to create a new bucket. These are located in the <code>software.amazon.awssdk</code> library. These classes are:
<ul>
<li>Region: Represents an AWS hosting region to perform the SDK operations in.</li>
<li>S3Client: Used to set up and configure a client to connect to AWS S3 over web services.</li>
<li>CreateBucketRequest: Represents a web request for creating S3 buckets.</li>
<li>CreateBucketConfiguration: Represents the configuration for S3 bucket creation.</li>
</ul>
Let's take a look at how we can set up a bucket for creation:
<pre><code class="hljs">Region region = Region.US_WEST_2;
S3Client s3 = S3Client.builder().region(region).build();
String bucket = &quot;new-bucket12345&quot;;

CreateBucketRequest createBucketRequest = CreateBucketRequest
 .builder()
 .bucket(bucket)
 .createBucketConfiguration(CreateBucketConfiguration.builder()
 .locationConstraint(region.id())
 .build())
 .build();

s3.createBucket(createBucketRequest);
</code></pre>
First, we've set up a <code>Region</code> object. If we skipped this step, the default region in the <code>~/.aws/config</code> is used. Set the region closest to where your users will be.
Then, we've created an <code>S3Client</code> object and used its <code>builder()</code>, passing the region, to instantiate it.
Finally, to create a bucket, we'll need to pack everything in a request and fire that request using the <code>S3Client</code> instance.
To pack everything in a request, we call the <code>builder()</code> of the <code>CreateBucketRequest</code> class and pass the bucket's name and region ID.
Finally, we call the <code>createBucket()</code> method.
Note: Amazon bucket names must be unique globally. Change the <code>new-bucket12345</code> name with another one.
After running this code, the bucket indeed does show up in our AWS Console:
<img src="https://stackabuse.s3.amazonaws.com/media/using-the-aws-java-sdk-to-work-with-s3-buckets-5.PNG" alt="AWS S3 Bucket">
Now that our bucket is up and running, let's go ahead and upload some files to it!
<h2 id="uploadingafiletoans3bucket">Uploading a File to an S3 Bucket</h2>
To upload an object to an existing bucket, the AWS Java SDK for S3 provides us with <code>PutObjectRequest</code> and <code>RequestBody</code>, which are used with the <code>S3Client</code> and <code>Region</code>.
<ul>
<li>PutObjectRequest: Represents a web request for uploading an object to an S3 bucket.</li>
<li>RequestBody: Represents the body of the web request containing the object to upload.</li>
</ul>
Let's take a look at how we can use these classes to upload a file:
<pre><code class="hljs">public class UploadObject {
 public static void main(String[] args) throws IOException {
 
 Region region = Region.US_WEST_2;
 S3Client s3 = S3Client.builder().region(region).build();

 String bucket = &quot;new-bucket12345&quot;;
 String key = &quot;key&quot;;

 // Put Object
 s3.putObject(PutObjectRequest.builder().bucket(bucket).key(key)
 .build(), RequestBody.fromByteBuffer(getRandomByteBuffer(10000)));
 }

 private static ByteBuffer getRandomByteBuffer(int size) throws IOException {
 byte[] b = new byte[size];
 new Random().nextBytes(b);
 return ByteBuffer.wrap(b);
 }
}
</code></pre>
The <code>putObject()</code> method of the <code>S3Client</code> class accepts a <code>PutObjectRequest</code> object. We've populated it with a random byte buffer. When we run this code, a new file named <code>key</code> will be uploaded to the bucket.
Let's check the S3 bucket in the AWS console:
<img src="https://stackabuse.s3.amazonaws.com/media/using-the-aws-java-sdk-to-work-with-s3-buckets-06.png" alt="AWS S3 Bucket">
<h2 id="deletingans3bucket">Deleting an S3 Bucket</h2>
In addition to the previous classes, and in the same fashion, the <code>DeleteBucketRequest</code> class is used to send a request for the deletion of a bucket.
<pre><code class="hljs">Region region = Region.US_WEST_2;
S3Client s3 = S3Client.builder().region(region).build();

String bucket = &quot;new-bucket12345&quot;;

DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucket).build();

s3.deleteBucket(deleteBucketRequest);
</code></pre>
The same as before, we set up an <code>S3Client</code> with the <code>Region</code> instance and pass the bucket name. Finally, we instantiate a <code>DeleteBucketRequest</code> object with the bucket info and run the <code>deleteBucket()</code> method from the <code>S3Client</code> class.
After deleting the bucket, it will be removed from the S3 console.
<h2 id="conclusion">Conclusion</h2>
In this article, we discussed how to set up and configure the AWS SDK for Java, specifically for the S3 service. We covered the setup of credentials for AWS SDK authentication and adding required dependencies using Maven.
We also detailed the Java code for some common S3 operations such as creating a new bucket, uploading objects to a bucket, and deleting a bucket.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software developer and consultant with a passion for helping others improve their lives through code. Jacob is the author of the <a rel="noopener" href="https://initialcommit.com/store/coding-essentials-guidebook-for-developers" target="_blank">Coding Essentials Guidebook for Developers</a>, an introductory book that covers essential coding concepts and tools. It contains chapters on basic computer architecture, the Internet, Command Line, HTML, CSS, JavaScript, Python, Java, databases/SQL, Git, and more.

Marcus Sanatan

Jacob Stopak

In this article, we'll cover the AWS Java SDK and API to create an S3 bucket, upload files to the bucket, and delete the bucket.

AWS S3 with Java - Uploading Files, Creating and Deleting S3 Buckets

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be converting an array into a more versatile ArrayList in Java.
<ul>
<li><a href="#arraysaslist">Arrays.asList()</a></li>
<li><a href="#newarraylistarraysaslist">new ArrayList&lt;&gt;(Arrays.asList())</a> (Most popular and used approach)</li>
<li><a href="#newarraylistlistof">new ArrayList&lt;&gt;(List.of())</a></li>
<li><a href="#collectionsaddall">Collections.addAll()</a></li>
<li><a href="#collectorstolist">Collectors.toList()</a></li>
<li><a href="#collectorstocollection">Collectors.toCollection()</a></li>
<li><a href="#listsnewarraylist">Lists.newArrayList()</a></li>
</ul>
Arrays are simple and provide the basic functionality of grouping together a collection of objects or primitive data types. However, arrays are also limited - their size is fixed and even basic operations like adding new items at the beginning or rearranging elements can get complicated.
Thankfully, the Collections Framework introduced us to many very useful implementations of <code>List</code>s, <code>Set</code>s, and <code>Queue</code>s.
One of these is the <code>ArrayList</code>, a really versatile and popular implementation of a <code>List</code>.
An <code>ArrayList</code>'s constructor will accept any <code>Collection</code>. We can get creative with the type of collection we pass into it.
<h2 id="arraysaslist">Arrays.asList()</h2>
Let's start off with the simplest form of conversion. The <code>Arrays</code> helper class has a lot of useful methods. The <code>asList()</code> method returns the contents of the array in a <code>List</code>:
<pre><code class="hljs">Employee emp1 = new Employee(&quot;John&quot;);
Employee emp2 = new Employee(&quot;Sarah&quot;);
Employee emp3 = new Employee(&quot;Lily&quot;);

Employee[] array = new Employee[]{emp1, emp2, emp3};

List&lt;Employee&gt; list = Arrays.asList(array);
System.out.println(list);
</code></pre>
This will result in a <code>List</code> implementation (<code>ArrayList</code>) to be populated with <code>emp1</code>, <code>emp2</code> and <code>emp3</code>. Running this code results in:
<pre><code class="hljs">[Employee{name=&#x27;John&#x27;}, Employee{name=&#x27;Sarah&#x27;}, Employee{name=&#x27;Lily&#x27;}]
</code></pre>
<h2 id="newarraylistarraysaslist">new ArrayList&lt;&gt;(Arrays.asList())</h2>
A better approach than just assigning the return value of the helper method is to pass the return value into a <code>new ArrayList&lt;&gt;()</code>. This is the standard approach used by most people.
This is because the <code>asList()</code> method is backed by the original array.
<blockquote>
If you change the original array, the list will change as well. Also, <code>asList()</code> returns a fixed size, since it's backed by the fixed array. Operations that would expand or shrink the list would return a <code>UnsupportedOperationException</code>.
</blockquote>
To avoid these, we'll apply the features of an <code>ArrayList</code> by passing the returned value of <code>asList()</code> to the constructor:
<pre><code class="hljs">Employee[] array = new Employee[]{emp1, emp2, emp3};

List&lt;Employee&gt; list = new ArrayList&lt;&gt;(Arrays.asList(array));
System.out.println(list);
</code></pre>
This results in:
<pre><code class="hljs">[Employee{name=&#x27;John&#x27;}, Employee{name=&#x27;Sarah&#x27;}, Employee{name=&#x27;Lily&#x27;}]
</code></pre>
<h2 id="newarraylistlistof">new ArrayList&lt;&gt;(List.of())</h2>
Since Java 9, you can skip initializing an array itself and passing it down into the constructor. You can use <code>List.of()</code> and pass individual elements:
<pre><code class="hljs">List&lt;Employee&gt; list = new ArrayList&lt;&gt;(List.of(emp1, emp2, emp3));
System.out.println(list);
</code></pre>
This results in:
<pre><code class="hljs">[Employee{name=&#x27;John&#x27;}, Employee{name=&#x27;Sarah&#x27;}, Employee{name=&#x27;Lily&#x27;}]
</code></pre>
<h2 id="collectionsaddall">Collections.addAll()</h2>
The <code>Collections</code> class offers a myriad of useful helper methods and amongst them is the <code>addAll()</code> method. It accepts a <code>Collection</code> and a vararg of <code>elements</code> and joins them up.
It's very versatile and can be used with many collection/vararg flavors. We're using an <code>ArrayList</code> and an array:
<pre><code class="hljs">Employee[] array = new Employee[]{emp1, emp2, emp3};
List&lt;Employee&gt; list = new ArrayList&lt;&gt;();

Collections.addAll(list, array);
System.out.println(list);
</code></pre>
This results in:
<pre><code class="hljs">[Employee{name=&#x27;John&#x27;}, Employee{name=&#x27;Sarah&#x27;}, Employee{name=&#x27;Lily&#x27;}]
</code></pre>
<h2 id="collectorstolist">Collectors.toList()</h2>
If you're working with streams, rather than regular collections, you can collect the elements of the stream and pack them into a list via <code>toList()</code>:
<pre><code class="hljs">Employee[] array = new Employee[]{emp1, emp2, emp3};
List&lt;Employee&gt; list = Stream.of(array).collect(Collectors.toList());
System.out.println(list);
</code></pre>
Running this will yield:
<pre><code class="hljs">[Employee{name=&#x27;John&#x27;}, Employee{name=&#x27;Sarah&#x27;}, Employee{name=&#x27;Lily&#x27;}]
</code></pre>
<h2 id="collectorstocollection">Collectors.toCollection()</h2>
Similarly, you can use the <code>toCollection()</code> method to collect streams into different collections. In our case, we'll supply the <code>ArrayList::new</code> <a target="_blank" href="/method-references-in-java-8/">method reference</a> into it, though you could supply other references as well:
<pre><code class="hljs">Employee[] array = new Employee[]{emp1, emp2, emp3};
List&lt;Employee&gt; list = Stream.of(array)
 .collect(Collectors.toCollection(ArrayList::new));
System.out.println(list);
</code></pre>
This also results in:
<pre><code class="hljs">[Employee{name=&#x27;John&#x27;}, Employee{name=&#x27;Sarah&#x27;}, Employee{name=&#x27;Lily&#x27;}]
</code></pre>
<h2 id="listsnewarraylist">Lists.newArrayList()</h2>
Similar to the <code>Arrays.asList()</code> helper class and method, Google's <a rel="nofollow noopener" target="_blank" href="https://github.com/google/guava">Guava</a> project introduced us to the <code>Lists</code> helper class. The <code>Lists</code> helper class provides the <code>newArrayList()</code> method:
<pre><code class="hljs">Employee[] array = new Employee[]{emp1, emp2, emp3};
List&lt;Employee&gt; list = Lists.newArrayList(array);
</code></pre>
Now, the key takeaway of this approach was that you don't need to specify the type when initializing an <code>ArrayList</code>. This was really useful when you'd have a <code>&lt;Element &lt;Element, Element&gt;&gt;</code> list.
However, as Java 7 removed the need to explicitly set the type in the diamond operator, this became obsolete.
<h2 id="conclusion">Conclusion</h2>
There are numerous ways to convert an array to an ArrayList in Java. These span from calling helper methods to streaming the array and collecting the elements.

In this tutorial, we'll be going over many examples of how to convert a Java array into an ArrayList, pointing out the best practices.

How to Convert a Java Array to ArrayList

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be diving into the theory and implementation of Bucket Sort in Python.
Bucket Sort is a comparison-type algorithm which assigns elements of a list we want to sort in Buckets, or Bins. The contents of these buckets are then sorted, typically with another algorithm. After sorting, the contents of the buckets are appended, forming a sorted collection.
Bucket Sort can be thought of as a scatter-order-gather approach towards sorting a list, due to the fact that the elements are first scattered in buckets, ordered within them, and finally gathered into a new, sorted list.
We'll implement Bucket Sort in Python and analyze it's time complexity.
<h2 id="howdoesbucketsortwork">How does Bucket Sort Work?</h2>
Before jumping into its exact implementation, let's walk through the algorithm's steps:
<ol>
<li>Set up a list of empty buckets. A bucket is initialized for each element in the array.</li>
<li>Iterate through the bucket list and insert elements from the array. Where each element is inserted depends on the input list and the largest element of it. We can end up with <code>0..n</code> elements in each bucket. This will be elaborated on in the visual presentation of the algorithm.</li>
<li>Sort each non-empty bucket. You can do this with any sorting algorithm. Since we're working with a small dataset, each bucket won't have many elements so <a target="_blank" href="/insertion-sort-in-python/">Insertion Sort</a> works wonders for us here.</li>
<li>Visit the buckets in order. Once the contents of each bucket are sorted, when concatenated, they will yield a list in which the elements are arranged based on your criteria.</li>
</ol>
Let's take a look at the visual presentation of how the algorithm works. For example, let's assume that this is the input list:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-1.png" alt="bucket sort visualization">
The largest element is <code>1.2</code>, and the length of the list is <code>6</code>. Using these two, we'll figure out the optimal <code>size</code> of each bucket. We'll get this number by dividing the largest element with the length of the list. In our case, it's <code>1.2/6</code> which is <code>0.2</code>.
By dividing the element's value with this <code>size</code>, we'll get an index for each element's respective bucket.
Now, we'll create empty buckets. We'll have the same amount of buckets as the elements in our list:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-2.png" alt="bucket sort visualization">
We'll insert the elements in their respective buckets. Taking the first element into consideration - <code>1.2/0.2 = 6</code>, the index of its respective bucket is <code>6</code>. If this result is higher or equal to the length of the list, we'll just subtract <code>1</code> and it'll fit into the list nicely. This only happens with the largest number, since we got the <code>size</code> by dividing the largest element by the length.
We'll place this element in the bucket with the index of <code>5</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-3.png" alt="bucket sort visualization">
Likewise, the next element will be indexed to <code>0.22/0.2 = 1.1</code>. Since this is a decimal number, we'll floor it. This is rounded to <code>1</code>, and our element is placed in the second bucket:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-4.png" alt="bucket sort visualization">
This process is repeated until we've placed the last element in its respective bucket. Our buckets now look something along the lines of:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-5.png" alt="bucket sort visualization">
Now, we'll sort the contents of each non-empty bucket. We'll be using Insertion Sort since it's unbeaten with small lists like this. After Insertion Sort, the buckets look like this:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-6.png" alt="bucket sort visualization">
Now, it's just a matter of traversing the non-empty buckets and concatenating the elements in a list. They're sorted and ready to go:
<img src="https://stackabuse.s3.amazonaws.com/media/bucket-sort-in-python-7.png" alt="bucket sort visualization">
<h2 id="bucketsortimplementationinpython">Bucket Sort Implementation in Python</h2>
With that out of the way, let's go ahead and implement the algorithm in Python. Let's start off with the <code>bucket_sort()</code> function itself:
<pre><code class="hljs">def bucket_sort(input_list):
 # Find maximum value in the list and use length of the list to determine which value in the list goes into which bucket 
 max_value = max(input_list)
 size = max_value/len(input_list)

 # Create n empty buckets where n is equal to the length of the input list
 buckets_list= []
 for x in range(len(input_list)):
 buckets_list.append([]) 

 # Put list elements into different buckets based on the size
 for i in range(len(input_list)):
 j = int (input_list[i] / size)
 if j != len (input_list):
 buckets_list[j].append(input_list[i])
 else:
 buckets_list[len(input_list) - 1].append(input_list[i])

 # Sort elements within the buckets using Insertion Sort
 for z in range(len(input_list)):
 insertion_sort(buckets_list[z])
 
 # Concatenate buckets with sorted elements into a single list
 final_output = []
 for x in range(len (input_list)):
 final_output = final_output + buckets_list[x]
 return final_output
</code></pre>
The implementation is fairly straightforward. We've calculated the <code>size</code> parameter. Then, we instantiated a list of empty buckets and inserted elements based on their value and the <code>size</code> of each bucket.
Once inserted, we call <code>insertion_sort()</code> on each of the buckets:
<pre><code class="hljs">def insertion_sort(bucket):
 for i in range (1, len (bucket)):
 var = bucket[i]
 j = i - 1
 while (j &gt;= 0 and var &lt; bucket[j]):
 bucket[j + 1] = bucket[j]
 j = j - 1
 bucket[j + 1] = var
</code></pre>
And with that in place, let's populate a list and perform a Bucket Sort on it:
<pre><code class="hljs">def main():
 input_list = [1.20, 0.22, 0.43, 0.36,0.39,0.27]
 print(&#x27;ORIGINAL LIST:&#x27;)
 print(input_list)
 sorted_list = bucket_sort(input_list)
 print(&#x27;SORTED LIST:&#x27;)
 print(sorted_list)
</code></pre>
Running this code will return:
<pre><code class="hljs">Original list: [1.2, 0.22, 0.43, 0.36, 0.39, 0.27]
Sorted list: [0.22, 0.27, 0.36, 0.39, 0.43, 1.2]
</code></pre>
<h2 id="bucketsorttimecomplexity">Bucket Sort Time Complexity</h2>
<h3 id="worstcasecomplexity">Worst-Case Complexity</h3>
If the collection we're working with has a short range (like the one we've had in our example) - it's common to have many elements in a single bucket, where a lot of buckets are empty.
If all elements fall into the same bucket, the complexity depends exclusively on the algorithm we use to sort the contents of the bucket itself.
Since we're using Insertion Sort - its worst-case complexity shines when the list is in reverse order. Thus, the worst-case complexity for Bucket Sort is also O(n2).
<h3 id="bestcasecomplexity">Best-Case Complexity</h3>
The best-case would be having all of the elements already sorted. Additionally, the elements are uniformly distributed. This means that each bucket would have the same number of elements.
That being said, creating the buckets would take O(n) and Insertion sort would take O(k), giving us an O(n+k) complexity.
<h3 id="averagecasecomplexity">Average-Case Complexity</h3>
The average-case occurs in the vast majority of real-life collections. When the collection we want to sort is random. In that case, Bucket Sort takes O(n) to finish, making it very efficient.
<h2 id="conclusion">Conclusion</h2>
To sum it all up, we started off by getting an introduction to what Bucket sort is and went on to discuss what we need to know before we jump into its implementation in Python. After the implementation, we've performed a quick complexity analysis.

Muhammad Junaid Khalid

In this tutorial, we'll be diving into the theory and implementation of Bucket Sort in Python. We'll also be exploring its time complexity.

Bucket Sort in Python

Luka Čupić

In this article, we'll dive into what's the difference between an ArrayList and a LinkedList in Java. We'll compare their code and performance to highlight the distinction.

Difference Between ArrayList and LinkedList in Java - Code and Performance

Dan Nelson

We'll be tackling Statistical Hypothesis Analysis with Python with ANOVAs, Chi-Square and Pearson Correlation on the Gapminder dataset.

Statistical Hypothesis Analysis in Python with ANOVAs, Chi-Square and Pearson Correlation

Statistical Hypothesis Analysis in Python with ANOVAs, Chi-Square, and Pearson Correlation

<h2 id="introduction">Introduction</h2>
In this article, we are going to talk about JavaScript Template Literals. They were also called Template Strings prior to the ES2015 specification.
Other than that, we are also going to cover what Tagged Template Literals are and how we can use them with regular Template Literals.
<h2 id="whatisatemplateliteral">What is a Template Literal?</h2>
Template Literals were introduced with JavaScript ES2015 (ES6) to handle strings in an easier and more readable way.
It allows us to embed expressions (expression interpolation) inside a string declaration, handle multi-line strings and create &quot;tagged template literals&quot; which is a more advanced form of template literals.
<h2 id="theoldwayofhandlingstringtemplates">The Old Way of Handling String Templates</h2>
Before ES6, single quotes or double quotes were used to declare a string. Consider the following example:
<pre><code class="hljs">let x = &#x27;This is a sample string&#x27;;
let y = &quot;This is a sample string with a &#x27;quote&#x27; in it&quot;;
let z = &#x27;This is a sample string with a &quot;double quote&quot; in it&#x27;;

let a = &#x27;This is another sample with a \&#x27;quote\&#x27; in it&#x27;;
let b = &quot;This is yet another sample with a \&quot;double quote\&quot; in it&quot;;

// a -&gt; This is another sample with a &#x27;quote&#x27; in it
// b -&gt; This is yet another sample with a &quot;double quote&quot; in it
</code></pre>
Generally, we used the single quote declaration by default, and the double quote declaration if the string contains single quotes within it. The same applied the other way around - we use whatever quotes allow us to avoid using escape characters like in <code>a</code> and <code>b</code>.
Also, if we wanted to concatenate two strings, the plus operator was the most common way to do that:
<pre><code class="hljs">let firstName = &#x27;Janith&#x27;;
let lastName = &#x27;Kasun&#x27;;

let fullName = firstName + &#x27; &#x27; + lastName;

// fullName -&gt; Janith Kasun
</code></pre>
If we wanted to include white spacing (including the tab and new line), we used the new line character (<code>\n</code>) and the tab space character (<code>\t</code>) to do that.
The old syntax did not allow breaking the text into the next line without using special characters such as the newline:
<pre><code class="hljs">let info = &#x27;Name:\tJohn Doe\n&#x27;
info = info + &#x27;Age:\t20\n&#x27;;
info = info + &#x27;City:\tLondon&#x27;;

console.log(info);
</code></pre>
Running this code would result in:
<pre><code class="hljs">Name: John Doe
Age: 20
City: London
</code></pre>
However, as you can see in this example, using special characters reduces the code's readability.
<h2 id="es6templateliterals">ES6 Template Literals</h2>
The interchangeable use of single quotes (<code>'</code>) and double quotes (<code>&quot;</code>), as well as the use of special and escape characters can make things a bit tricky in certain situations. Let's see how we can avoid these issues by using template literals.
<h3 id="declaringatemplateliteral">Declaring a Template Literal</h3>
JavaScript template literals use the backtick character (`) to declare a string instead of single or double-quotes. For example:
<pre><code class="hljs">let x = `This is a new template literal`;
</code></pre>
You can use the quotes and double quotes inside the string declaration with template literals:
<pre><code class="hljs">let y = `This is a string with a &#x27;single quote&#x27;`;
let z = `This is a string with a &quot;double quote&quot;`;
</code></pre>
<h3 id="multilinestringandtabs">Multi-line String and Tabs</h3>
With template literals, we can just add a new line inside the declaration itself. Instead of using the new line character, we can simply break the code into the next line:
<pre><code class="hljs">console.log(`This is the first line
This is the second line`);
</code></pre>
This code results in:
<pre><code class="hljs">This is the first line
This is the second line
</code></pre>
<h3 id="expressionswithtemplateliteralsexpressioninterpolation">Expressions with Template Literals (Expression Interpolation)</h3>
If the only feature of Template Literals was avoiding the misuse of single and double quotes and breaking lines, they wouldn't be a game-changer. However, building dynamic strings and text was made really easy with the inclusion of expressions.
You can add an expression within a template literal and the resulting string will contain the evaluated value of the expression. For example, without template literals, we could be looking at something along the lines of:
<pre><code class="hljs">let a = 5;
let b = 10;
console.log(&#x27;The sum of &#x27; + a + &#x27; and&#x27; + b + &#x27; is &#x27; + (a + b));
</code></pre>
This would result in:
<pre><code class="hljs">The sum of 5 and 10 is 15
</code></pre>
Now, that's fine on the resulting end. But having to break the string in several places and adding the values like this is unreadable when you have more than just simple addition. Not to mention, a single typo can cause issues with implicit data type conversions and the whole statement becomes incorrect.
With template literals, we can simply add expressions, following the <code>${...}</code> syntax, directly into string declarations. When we run the code, the expressions are evaluated and their values are put in:
<pre><code class="hljs">let a = 5;
let b = 10;
console.log(`The sum of ${a} and ${b} is ${a+b}`);
</code></pre>
This also results in:
<pre><code class="hljs">The sum of 5 and 10 is 15
</code></pre>
This is a much cleaner solution to a fairly rudimentary task. Let's rewrite the whitespace example from before, using template literals:
<pre><code class="hljs">let info = `Name: John Doe
Age: 20
City: London`;

console.log(info);
</code></pre>
However, static information like this is rarely used. Let's populate an object with the same information and then read its values:
<pre><code class="hljs">const person = {
 firstName: &#x27;John&#x27;,
 lastName: &#x27;Doe&#x27;,
 age: 20,
 city: &#x27;London&#x27;
}

let info = `Name: ${person.firstName} ${person.lastName}
Age: ${person.age}
City: ${person.city}`;

console.log(info);
</code></pre>
This also results in:
<pre><code class="hljs">Name: John Doe
Age: 20
City: London
</code></pre>
<h3 id="taggedtemplateliterals">Tagged Template Literals</h3>
Tagged Template Literals provide a more advanced usage of template literals using a customizable function.
Consider the following scenario.
<blockquote>
There is a result sheet from a recent exam. The pass mark for the exam is 50. We want to create a tagged template that outputs if the candidate has passed the exam or not.
For example, the app would display &quot;John has passed the exam&quot; or &quot;Ann has failed the exam&quot;, based on their mark.
</blockquote>
Let's define a tagged template function that determines if the student has passed or failed:
<pre><code class="hljs">function exampleTag(personExp, strings, marksExp) {
 let resultStr;

 if (marksExp &gt;= 50) {
 resultStr = &#x27;passed&#x27;;
 } else {
 resultStr = &#x27;failed&#x27;
 }
 return `${personExp}${strings[0]}${resultStr}`;
}
</code></pre>
Here, based on the parameters passed to the <code>exampleTag()</code> function, we determine if the result is set to be <code>passed</code> or <code>failed</code>. Ultimately, we return a template literal. This template literal contains expressions that represent the person's name, a string and the marks.
Let's make a couple of people and pass them to the function:
<pre><code class="hljs">let p1 = {
 person: &#x27;John&#x27;,
 marks: 45
}

let p2 = {
 person: &#x27;Ann&#x27;,
 marks: 67
}

let ex1 = exampleTag`${p1.person} had ${p.marks}`;
let ex2 = exampleTag`${p2.person} had ${p.marks}`;

console.log(ex1);
console.log(ex2);
</code></pre>
Running this code will result in:
<pre><code class="hljs">John had failed
Ann had passed
</code></pre>
Although we just have one string here, <code>had</code>, we could've easily had many. Thus, the <code>strings</code> parameter is an array. You can reference each passed string, in accordance to their appearance in the template literal passed to the <code>exampleTag()</code> function.
<h3 id="rawstrings">Raw Strings</h3>
Finally, let's talk about the <code>raw</code> property when creating a tagged template literal.
This property is available on the first parameter of the tagged template. It allows you to get the value of the raw string without processing the escape characters from it.
Consider the following example:
<pre><code class="hljs">function rawTag(strings) {
 console.log(strings.raw[0]);
}

rawTag`this is a \t sample text with \ escape characters \n\t`;
</code></pre>
This would result in:
<pre><code class="hljs">this is a \t sample text with \ escape characters \n\t
</code></pre>
As you can see, we can use escape characters as raw text using the <code>raw</code> property with tagged templates.
You can also use the <code>String.raw()</code> function to do that, which is a built-in JavaScript tagged template literal that allows you to declare raw strings without processing the escape characters.
You can simply use this if you don't need any additional logics:
<pre><code class="hljs">let rawString = String.raw`this is a \t sample text with \ escape characters \n\t`
</code></pre>
This also results in:
<pre><code class="hljs">this is a \t sample text with \ escape characters \n\t
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered the old way of handling dynamic strings, whitespaces and escape characters. Then, we've jumped into template literals, expressions within template literals and finally tagged template literals.

Janith Kasun

In this tutorial, we'll dive into template literals in ES6 JavaScript/Node.js. We'll also be covering tagged template literals and template literal expressions.