<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.

David Landup

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.

ES6 Template/String Literals in Node.js

Leodanis Pozo Ramos

In this tutorial, we'll learn how to compute the mean, median, and mode in Python from scratch and with the Python statistics module.

Calculating Mean, Median and Mode in Python

Calculating Mean, Median, and Mode in Python

Dhrubajyoti Bhattacharjee

In this tutorial, we'll be diving into everything you need to know about Thymeleaf in order to get started with this templating engine for Java and Spring.

Getting Started with Thymeleaf in Java and Spring

<h2 id="introductiontoanyandall">Introduction to any() and all()</h2>
In this tutorial, we'll be covering the <code>any()</code> and <code>all()</code> functions in Python.
The <code>any(iterable)</code> and <code>all(iterable)</code> are built-in functions in Python and have been around since Python 2.5 was released. Both functions are equivalent to writing a series of <code>or</code> and <code>and</code> operators respectively between each of the elements of the passed <code>iterable</code>. They are both convenience functions that shorten the code by replacing boilerplate loops.
Both methods short-circuit and return a value as soon as possible, so even with huge iterables, they're as efficient as they can be.
<h2 id="theandoroperators">The and/or Operators</h2>
Let's remind ourselves how the <code>and</code>/<code>or</code> operators work, as these functions are based on them.
<h3 id="theoroperator">The or Operator</h3>
The <code>or</code> operator evaluates to <code>True</code> if any of the conditions (operands) are <code>True</code>.
<pre><code class="hljs">print(&quot;(2 == 2) or (3 == 3) evaluates to: &quot; + str((2 == 2) or (3 == 3)))
print(&quot;(2 == 2) or (3 == 2) evaluates to: &quot; + str((2 == 2) or (3 == 2)))
print(&quot;(2 == 0) or (3 == 2) evaluates to: &quot; + str((2 == 0) or (3 == 2)))
</code></pre>
Output:
<pre><code class="hljs">(2 == 2) or (3 == 3) evaluates to: True
(2 == 2) or (3 == 2) evaluates to: True
(2 == 0) or (3 == 2) evaluates to: False
</code></pre>
We can chain multiple <code>or</code>s in a single statement, and it will again evaluate to <code>True</code> if any of the conditions are <code>True</code>:
<pre><code class="hljs">print(str(False or False or False or True or False))
</code></pre>
This results in:
<pre><code class="hljs">True
</code></pre>
<h3 id="theandoperator">The and Operator</h3>
The <code>and</code> operator evaluates to <code>True</code> only if all conditions are <code>True</code>:
<pre><code class="hljs">print(&quot;(2 == 2) and (3 == 3) evaluates to: &quot; + str((2 == 2) and (3 == 3)))
print(&quot;(2 == 2) and (3 == 2) evaluates to: &quot; + str((2 == 2) and (3 == 2)))
print(&quot;(2 == 0) and (3 == 2) evaluates to: &quot; + str((2 == 0) and (3 == 2)))
</code></pre>
Output:
<pre><code class="hljs">(2 == 2) and (3 == 3) evaluates to: True
(2 == 2) and (3 == 2) evaluates to: False
(2 == 0) and (3 == 2) evaluates to: False
</code></pre>
Similarly to <code>or</code>, we can chain multiple <code>and</code> operators, and they will evaluate to <code>True</code> only if all the operands evaluate to <code>True</code>:
<pre><code class="hljs">print(str(True and True and True and False and True))
</code></pre>
This results in:
<pre><code class="hljs">False
</code></pre>
<h2 id="any">any()</h2>
The method <code>any(iterable)</code> behaves like a series of <code>or</code> operators between each element of the <code>iterable</code> we passed. It's used to replace loops similar to this one:
<pre><code class="hljs">for element in some_iterable:
 if element:
 return True
return False
</code></pre>
We get the same result by simply calling <code>any(some_iterable)</code>:
<pre><code class="hljs">print(any([2 == 2, 3 == 2]))
print(any([True, False, False]))
print(any([False, False]))
</code></pre>
Running this piece of code would result in:
<pre><code class="hljs">True
True
False
</code></pre>
Note: Unexpected behavior may happen when using <code>any()</code> with dictionaries and <a href="#booleanconversionandanyall">data types other than boolean</a>. If <code>any()</code> is used with a dictionary, it checks whether any of the keys evaluate to <code>True</code>, not the values:
<pre><code class="hljs">dict = {True : False, False: False}

print(any(dict))
</code></pre>
This outputs:
<pre><code class="hljs">True
</code></pre>
Whereas, if <code>any()</code> checked the values, the output would have been <code>False</code>.
The method <code>any()</code> is often used in combination with the <code>map()</code> method and list comprehensions:
<pre><code class="hljs">old_list = [2, 1, 3, 8, 10, 11, 13]
list_if_even = list(map(lambda x: x % 2 == 0, old_list))
list_if_odd = [x % 2 != 0 for x in old_list]

print(list_if_even)
print(list_if_odd)

print(&quot;Are any of the elements even? &quot; + str(any(list_if_even)))
print(&quot;Are any of the elements odd? &quot; + str(any(list_if_odd)))
</code></pre>
This outputs:
<pre><code class="hljs">[True, False, False, True, True, False, False]
[False, True, True, False, False, True, True]
Are any of the elements even? True
Are any of the elements odd? True
</code></pre>
Note: If an empty <code>iterable</code> is passed to <code>any()</code>, the method returns <code>False</code>.
If you'd like to read more about <a target="_blank" href="/map-filter-and-reduce-in-python-with-examples/">the map(), filter() and reduce() functions</a>, we've got you covered!
<h2 id="all">all()</h2>
The <code>all(iterable)</code> method evaluates like a series of <code>and</code> operators between each of the elements in the <code>iterable</code> we passed. It is used to replace loops similar to this one:
<pre><code class="hljs">for element in iterable:
 if not element:
 return False
return True
</code></pre>
The method returns <code>True</code> only if every element in <code>iterable</code> evaluates to <code>True</code>, and <code>False</code> otherwise:
<pre><code class="hljs">print(all([2 == 2, 3 == 2]))
print(all([2 &gt; 1, 3 != 4]))
print(all([True, False, False]))
print(all([False, False]))
</code></pre>
This outputs:
<pre><code class="hljs">False
True
False
False
</code></pre>
Note: Just like with <code>any()</code>, unexpected behavior may happen when passing dictionaries and data types other than <code>boolean</code>. Again, if <code>all()</code> is used with a dictionary, it checks whether all of the keys evaluate to <code>True</code>, not the values.
Another similarity with <code>any()</code> is that <code>all()</code> is also commonly used in combination with the <code>map()</code> function and list comprehensions:
<pre><code class="hljs">old_list = [&quot;just&quot;, &quot;Some&quot;, &quot;text&quot;, &quot;As&quot;, &quot;An&quot;, &quot;example&quot;]
list_begins_upper = list(map(lambda x: x[0].isupper(), old_list))
list_shorter_than_8 = [len(x) &lt; 8 for x in old_list]

print(list_begins_upper)
print(list_shorter_than_8)

print(&quot;Do all the strings begin with an uppercase letter? &quot; + str(all(list_begins_upper)))
print(&quot;Are all the strings shorter than 8? &quot; + str(all(list_shorter_than_8)))
</code></pre>
This outputs:
<pre><code class="hljs">[False, True, False, True, True, False]
[True, True, True, True, True, True]
Do all the strings begin with an uppercase letter? False
Are all strings shorter than 8? True
</code></pre>
Note: If an empty <code>iterable</code> is passed to <code>all()</code>, the method returns <code>True</code>! This is because the code for <code>all()</code> checks if there are any <code>False</code> elements in the <code>iterable</code>, and in the case of an empty list there are no elements and therefore there are no <code>False</code> elements either.
<h2 id="booleanconversionandanyallfunctions">Boolean Conversion and any(), all() Functions</h2>
A common cause of confusion and errors when using any logical operators, and therefore when using <code>any()</code> and <code>all()</code> as well, is what happens when the elements aren't of the <code>boolean</code> data type. In other words, when they aren't exactly <code>True</code> of <code>False</code> but instead have to be evaluated to <code>True</code> or <code>False</code>.
Some programming languages don't evaluate non-<code>boolean</code> data types to <code>boolean</code>s. For example Java would complain if you tried something along the lines of <code>if(&quot;some string&quot;) </code> or <code>if(15)</code> and tell you that the type you used can't be converted to <code>boolean</code>.
Python on the other hand does no such thing, and will instead convert what you passed to <code>boolean</code> without warning you about it.
Python converts most things to <code>True</code> with a few exceptions:
<ul>
<li>Any numerical value equal to 0 (including 0.0) is treated as <code>False</code>. A common misconception here is that negative values (-2, -3.3,...) are treated as <code>False</code> as well, they are not treated as <code>False</code>!</li>
<li>Any empty sequence (or collection) is treated as <code>False</code>, including empty <code>string</code>s, empty <code>list</code>s, etc. Keep in mind that unexpected behavior might happen when using <code>all()</code> with an empty <code>iterable</code> (it will return <code>True</code>).</li>
<li>The actual <code>boolean</code> value <code>False</code> is of course treated as <code>False</code> as well as the special value <code>None</code>.</li>
</ul>
A few examples of how we can use the way Python &quot;boolean-izes&quot; other data types with <code>any()</code> and <code>all()</code>.
<pre><code class="hljs">list_of_strings = [&quot;yet&quot;, &quot;another&quot;, &quot;example&quot;,&quot;&quot;]
print(&quot;Do all strings have some content?&quot;, all(list_of_strings))

list_of_ints = [0, 0.0, -2, -5]
print(&quot;Are any of the ints different from 0?&quot;, any(list_of_ints))
</code></pre>
This outputs:
<pre><code class="hljs">Do all strings have some content? False
Are any of the ints different from 0? True
</code></pre>
Keep in mind that you might still want to write more readable code by not using implicit <code>boolean</code> conversion like this.
<h2 id="conclusion">Conclusion</h2>
Both the <code>any()</code> and <code>all()</code> functions are there for convenience sake and should be used only when they make the code shorter but maintain the readability.
In this article, we've jumped into the <code>any()</code> and <code>all()</code> functions and showcased their usage through several examples.

Olivera Popović

In this tutorial, we'll be going over examples and practical usage of the any() and all() convenience functions in Python.