Taimoor Choudhary

In this tutorial, we'll go over how to read and write YAML files in Java with SnakeYAML, a popular alternative to Jackson.

Reading and Writing YAML Files in Java with SnakeYAML

<h2 id="introduction">Introduction</h2>
In Linux, <code>ls -l</code> would list the files and directories in a particular path, with their names, dates, and sizes (disk usage). The first thing you'll notice using that command is that the size of directories is always shown as <code>4096</code> bytes (or 4,0K if you're using <code>ls -lh</code>) even though they contain files that are greater than 4 KB in size. The reason is that <code>ls</code> returns meta-data for the directories, not the actual size.
So what's the shortest and easiest way to get the size of a directory in Linux, you ask? To get the total size of a directory in Linux, you can use the <code>du</code> (disk-usage) command.
In this article, we'll take a look at some of the most common usages of the <code>du</code> commands, including but not limited to <code>du -sh</code>, <code>du -ch</code>, and <code>du --max-depth</code>.
<h2 id="gettingsizeofdirectoryinlinuxwithdu">Getting Size of Directory in Linux with du</h2>
To see the full description and argument list of <code>du</code> command, refer to the <code>man du</code>.
If we type <code>du</code> without any arguments, it will list all the directory names and sizes for the current working directory and all subdirectories recursively:
<pre><code class="hljs">$ du
2156	./corpora/state_union
64	./corpora/names
7624	./corpora/conll2002
432	./corpora/toolbox/rotokas
### ...
246984	./corpora
16792	./tokenizers/punkt/PY3
36028	./tokenizers/punkt
49420	./tokenizers
296408	.
</code></pre>
<h3 id="getsizeofthecurrentworkingdirectory">Get Size of the Current Working Directory</h3>
To get the size of the current working directory only, and not the subdirectories, we can use <code>du -s</code> or <code>du --summarize</code>:
<pre><code class="hljs">$ du -s
296408	.
</code></pre>
We can add the <code>-h</code> parameter to get the size in a more human-readable format:
<pre><code class="hljs">$ du -sh
290M	.
</code></pre>
We can also use <code>du</code> with <code>$PATH</code> parameter to get the size of a directory that is located somewhere other than the current working directory:
<pre><code class="hljs">$ sudo du /var -sh # or &quot;du -sh /var&quot; if you prefer
11G	/var
</code></pre>
Note that you would need to use it with <code>sudo</code> privileges for some directories, otherwise you would get a <code>Permission denied</code> error.
<h3 id="getsizeoffirstlevelsubdirectories">Get Size of First-Level Subdirectories</h3>
To get size of first-level subdirectories as well as the total size of the path directory:
<pre><code class="hljs">$ sudo du /var/* -shc
6,1M	/var/backups
144M	/var/cache
4,0K	/var/crash
7,2G	/var/lib
4,0K	/var/local
0	/var/lock
3,0G	/var/log
4,0K	/var/mail
4,0K	/var/metrics
4,0K	/var/opt
0	/var/run
3,8M	/var/snap
52K	/var/spool
72K	/var/tmp
28K	/var/www
11G	total
</code></pre>
<code>-c</code> or <code>--total</code> returns the total size of the path (<code>11G	total</code>). <code>*</code> lists all the first-level subdirectories in the <code>/var/</code> directory. We can also add <code>--exclude</code> to exclude any directory:
<pre><code class="hljs">$ sudo du /var/* -shc --exclude=lib
6,1M	/var/backups
144M	/var/cache
4,0K	/var/crash
4,0K	/var/local
0	/var/lock
3,0G	/var/log
4,0K	/var/mail
4,0K	/var/metrics
4,0K	/var/opt
0	/var/run
3,8M	/var/snap
52K	/var/spool
72K	/var/tmp
28K	/var/www
3,2G	total
</code></pre>
Note that excluding <code>lib</code> also affects the total size (<code>3,2G	total</code>). This is also equivalent of <code>sudo du /var/ -h --exclude=lib --max-depth=1</code>
<pre><code class="hljs">$ sudo du /var/ -h --exclude=lib --max-depth=1
4,0K	/var/mail
52K	/var/spool
3,8M	/var/snap
4,0K	/var/metrics
144M	/var/cache
6,1M	/var/backups
72K	/var/tmp
4,0K	/var/crash
3,0G	/var/log
4,0K	/var/opt
28K	/var/www
4,0K	/var/local
3,2G	/var/
</code></pre>
<code>--max-depth=N</code> will return all subdirectory levels that are equal or less than the number <code>N</code>. Setting <code>--max-depth</code> to <code>1</code> returns the first-level, <code>2</code> for the second, and so on.
<h3 id="getsizeofallsubdirectories">Get Size of All Subdirectories</h3>
To recursively get all subdirectories of <code>/var/</code>, you can use <code>sudo du /var/ -h</code>. Or you can pass a number to the <code>--max-depth</code> that you're sure is greater than or equal to the max level of subdirectory depth: <code>sudo du /var/ -h --max-depth=999</code>.
The second option is more of a workaround rather than the most efficient way.
<h2 id="getsizeofdirectoryinlinuxwithtreeduh">Get Size of Directory in Linux with <code>tree --du -h</code></h2>
<code>tree</code> is a recursive directory listing program that will list directories and files in a tree-like format. Note that <code>tree</code> is not installed by default. For Debian/Ubuntu, we can install the <code>tree</code> by running <code>sudo apt install tree</code>.
After the installation complete, we use the <code>tree</code> command to list names and sizes of all directories and files in a particular path, in a tree-like format:
<pre><code class="hljs">$ tree /var/www/ --du -h
/var/www/
├── [4.2K] demosite
│ └── [ 189] index.html
└── [ 15K] html
 └── [ 11K] index.html

 23K used in 2 directories, 2 files
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to get directory sizes in Linux. You can use these commands on Linux remote machines, servers, and/or Linux machines with or without GUI.
For most of the cases <code>du</code> command would be sufficient. It has also the advantage of being installed by default. On the other hand, the <code>tree</code> command would provide a more visual and detailed user interface to display almost the same results, making it a powerful alternative for <code>du</code>.

Marcus Sanatan

Ruslan Hasanov

This articles covers the du Linux/Unix utility to get the size of a directory. We'll explore its behavior and options, and even use it with the tree utility.

Get Total Size of Directory in Linux

Get Total Size of a Directory in Linux

Darinka Zobenica

In this article, we go into the theory and implementation of A* in Java with detailed explanations and practical examples.

Graphs in Java - A* Algorithm

<h2 id="introduction">Introduction</h2>
Variables act as a container to store data. A developer can use type hints when creating variables or passing arguments, however, that's an optional feature in Python, and many codebases, old and new, are yet to have them. It's more common for a variable in Python to have no information of the type being stored.
If we had code that needed a dictionary but lacked type hints, how can we avoid errors if the variable used is not a dictionary?
In this tutorial, we'll take a look at how to check if a variable is a dictionary in Python, using the <code>type()</code> and <code>isinstance()</code> functions, as well as the <code>is</code> operator:
<ul>
<li><a href="#checkifvariableisadictionarywithtype">Check if Variable is Dictionary with type()</a></li>
<li><a href="#checkifvariableisadictionarywithisoperator">Check if Variable is Dictionary with is Operator</a></li>
<li><a href="#checkifvariableisadictionarywithisinstance">Check if Variable is Dictionary with isinstance()</a></li>
</ul>
Developers usually use <code>type()</code> and <code>is</code>, though, these can be limited in certain contexts, in which case, it's better to use the <code>isinstance()</code> function.
<h2 id="checkifvariableisadictionarywithtype">Check if Variable is a Dictionary with type()</h2>
We can use the <code>type()</code> function to instantly get the type of any variable. For a variable of type <code>Dictionary</code>, it must return <code>&lt;class 'dict'&gt;</code>:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
print(type(squares))
</code></pre>
This results in:
<pre><code class="hljs">&lt;class &#x27;dict&#x27;&gt;
</code></pre>
<h2 id="checkifvariableisadictionarywithisoperator">Check if Variable is a Dictionary with is Operator</h2>
In Python, <code>is</code> is an identity operator. It verifies if both the operands are identical to each other. Being identical indicates that they refer to the same memory location.
We can use the <code>is</code> operator with the result of a <code>type()</code> call with a variable and the <code>dict</code> class. It will output <code>True</code> only if the <code>type()</code> points to the same memory location as the <code>dict</code> class. Otherwise, it will output <code>False</code>.
As a sanity check, we can use the <code>id()</code> function to get the address of the object in memory and verify the comparison:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
print(type(squares) is dict) # True
print(&quot;memory address of type(squares):&quot;, id(type(squares)))
print(&quot;memory address of dict:&quot;, id(dict)) # Should have same ID as type(squares)
</code></pre>
This code will produce the following output on a Python interpreter:
<pre><code class="hljs">True
memory address of type(squares): 1609576584
memory address of dict: 1609576584
</code></pre>
Note: The memory address may vary for you, but the same ID should be present for both the <code>type(squares)</code> and <code>dict</code>.
One caveat of this method is that it fails to work if the variable is a type that's a subclass of <code>dict</code>. For example, the previous code would not work if the <code>squares</code> variable was an Ordered Dictionary instead:
<pre><code class="hljs">from collections import OrderedDict

squares = OrderedDict([(1, 1), (2, 4), (3, 9)])
print(type(squares) is dict) # False
print(&quot;memory address of type(squares):&quot;, id(type(squares)))
print(&quot;memory address of dict:&quot;, id(dict)) # Different ID as they&#x27;re different classes
</code></pre>
This outputs:
<pre><code class="hljs">False
memory address of type(squares): 9464512
memory address of dict: 9481952
</code></pre>
If your code is required to work on subclasses of Dictionaries, then you would prefer to use the <code>isinstance()</code> method.
<h2 id="checkifvariableisadictionarywithisinstance">Check if Variable is a Dictionary with isinstance()</h2>
As we have seen, the <code>is</code> operator will return <code>True</code> when the memory address of both the objects is the same. If we have a Dictionary of type inherited from class <code>dict</code>, it will return <code>False</code>. For example, a Dictionary of a subclass of <code>dict</code> like <code>OrderedDict</code> or <code>defaultdict</code> will not point to the same memory address as of <code>dict</code>.
Here we have the <code>isinstance()</code> function to the rescue. This function takes two arguments; an object and a class. If the object is an instance of the class or its subclasses, it will return <code>True</code>. If the object is not an instance of the given class, whether direct or indirect, it returns <code>False</code>.
Here is a code example to check if the variable is a Dictionary using the <code>isinstance()</code> function:
<pre><code class="hljs">from collections import OrderedDict

# Variable of type dict
squares = {1: 1, 2: 4, 3: 9}
print(isinstance(squares, dict)) # True

# Variable of type OrderedDict (Subclass of dict)
cubes = OrderedDict(((1, 1), (2, 8)))
print(isinstance(cubes, dict)) # True
</code></pre>
This code will produce the following output on a Python interpreter:
<pre><code class="hljs">True
True
</code></pre>
<h2 id="conclusion">Conclusion</h2>
This tutorial showed ways in which we can check if a variable is a Dictionary. We have first seen the <code>type()</code> function which outputs <code>&lt;class 'dict'&gt;</code> for any Dictionary object. Then we have seen the use of the <code>is</code> operator to check if the type of variable points to <code>dict</code> in the memory location. This returns <code>True</code> or <code>False</code> accordingly.
Lastly, we have seen that <code>is</code> fails at identifying inherited Dictionary objects. When we want to capture inherited objects, we can use the <code>isinstance()</code> function. It returns <code>True</code> if the object is directly or indirectly an instance of the given class (<code>dict</code> in this article), and <code>False</code> otherwise.
As both these methods return <code>True</code> or <code>False</code>, we can easily use them in conditional statements. Unless you explicitly want to reject subclasses of <code>dict</code>, the <code>isinstance()</code> function is the most reliable way to check if a variable is a Dictionary.

Naazneen Jatu

In Python, we can use these two ways to check if a given variable is a Dictionary: the type() function and the is operator; and the isinstance() function

Python: Check if Variable is a Dictionary

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at how to get the number of days between two dates in Python.
We'll be using the built-in <code>datetime</code> package, that allows you to really easily work with <code>datetime</code> objects in Python.
<h2 id="creatingadatetimeobject">Creating a Datetime Object</h2>
As datetime is a built-in module, you can access it right away by importing it at the top of your Python file.
You can construct <code>datetime</code> objects in a few different ways:
<pre><code class="hljs">from datetime import datetime

date_string = &quot;1 January, 2021&quot;

now = datetime.now() # Create Datetime based on system clock
dt1 = datetime(day=1, month=1, year=2021) # Create Datetime with given arguments
dt2 = datetime.strptime(date_string, &quot;%d %B, %Y&quot;) # Create Datetime from String
</code></pre>
There are certain rules to follow when it comes to <a target="_blank" href="/converting-strings-to-datetime-in-python/">Converting Strings to Datetime in Python</a>.
<h2 id="getnumberofdaysbetweendatesinpython">Get Number of Days Between Dates in Python</h2>
Trying to measure the numbers of days between dates without using the datetime module is a deceptively complex task - between accounting for leap years and the number of days in each month, trying to create your own implementation is nonsensical.
<blockquote>
With <code>datetime</code> however, it becomes trivial.
</blockquote>
You can simply subtract a <code>date</code> or <code>datetime</code> from each other, to get the number of days between them:
<pre><code class="hljs">from datetime import datetime

date1 = datetime.now()
date2 = datetime(day=1, month=7, year=2021)

timedelta = date2 - date1
print(timedelta)
</code></pre>
This returns a <code>timedelta</code> object, which contains <code>days</code>, <code>seconds</code> and <code>microseconds</code> and represents the duration between any two <code>date</code>/<code>time</code> or <code>datetime</code> objects.
Printing this object will return the days, hours, minutes, seconds and microseconds to that event:
<pre><code class="hljs">149 days, 5:22:52.255124
</code></pre>
If you're not interested in some of these metrics, you can specify which of them you'd like to access with <code>timedelta.days</code>, <code>timedelta.seconds</code> and <code>timedelta.microseconds</code>:
<pre><code class="hljs">now = datetime.now()
new_years = datetime(day=1, month=1, year=2022)
countdown = new_years - now

print(&#x27;Today is: &#x27;, now)
print(&#x27;New Year is on: &#x27;, new_years)
print(&#x27;Days until New Years: &#x27;, countdown.days)
</code></pre>
Here, we've assigned the days between <code>now</code> and <code>new_years</code> into <code>countdown</code>, which is a <code>timedelta</code> object.
Then, we can simply access the <code>days</code> parameter of that object to get the number of days between them. This results in:
<pre><code class="hljs">Today is: 2021-02-01 18:35:12.272524
New Year is on: 2022-01-01 00:00:00
Days until New Years: 333
</code></pre>
<h2 id="addingandsubtractingdaysusingtimedelta">Adding and Subtracting Days Using TimeDelta</h2>
What if instead of trying to subtract two known dates from each other, you wanted to add or subtract a time-frame? For example, a customer subscribed to your service for a monthly fee. You'll want to remind them to renew it after 30 days.
You can construct a time-frame for those 30 days, using <code>timedelta</code> and add or subtract that from any other <code>datetime</code> object:
<pre><code class="hljs">from datetime import datetime, timedelta

now = datetime.now()
thirty_days = timedelta(days=30)

print(&#x27;In 30 days: &#x27;, now + thirty_days)
print(&#x27;30 days ago: &#x27;, now - thirty_days)
</code></pre>
This results in:
<pre><code class="hljs">In 30 days: 2021-03-03 18:41:49.922082
30 days ago: 2021-01-02 18:41:49.922082
</code></pre>
This is an incredibly useful feature when trying to implement scheduling, or retrieving database entries based on a moving window (such as the trailing 30 days).
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've covered everything you need to know about getting the number of days between two dates in Python.
We've worked with <code>datetime</code> objects and <code>timedelta</code> to achieve this functionality.

Spencer Porter

In this tutorial, we'll go over how to get the number of days between two dates in Python, using the datetime module and timedelta objects, as well as add and subtract fixed timeframes.

Python: Get Number of Days Between Dates

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to remove keys from Python dictionaries. This can be done with the <code>pop()</code> function, the <code>del</code> keyword, and with dict comprehensions.
<h2 id="removeakeyusingpopkeyd">Remove a Key Using pop(key,d)</h2>
The <code>pop(key, d)</code> function removes a key from a dictionary and returns its value. It takes two arguments, the key is removed and the optional value to return if the key isn't found. Here's an example of popping an element with only the required <code>key</code> argument:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
popped_value = my_dict.pop(1)

line = &quot;The value removed from the dictionary of the key: 1 is {}&quot;
print(line.format(popped_value))
</code></pre>
This snippet returns the following output:
<pre><code class="hljs">The value removed from the dictionary of the key: 1 is a
</code></pre>
Now, observe what happens when we try to remove a key that doesn't exist:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
popped_value = my_dict.pop(3)

line = &quot;The value removed from the dictionary of the key: 3 is {}&quot;
print(line.format(popped_value))
</code></pre>
This raises a KeyError, as expected since it doesn't exist:
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
KeyError: 3
</code></pre>
If you call <code>pop()</code> on a key that doesn't exist, Python would return a <code>KeyError</code>. So only use <code>pop(key)</code> if you're confident that the key exists in the dictionary.
If you are unsure if the key exists then put a value for the second, optional argument for <code>pop()</code> - the default value. Instead of throwing a KeyError it will return that value.
The above snippet can be rewritten as:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
removed_value = my_dict.pop(3, None)

line = &quot;The value removed from the dictionary of the key: 3 is {}&quot;
print(line.format(removed_value))
</code></pre>
And now it doesn't throw an error when we run it:
<pre><code class="hljs">The value removed from the dictionary of the key: 3 is None
</code></pre>
<h2 id="removeakeyusingdeldictkey">Remove a Key Using del dict[key]</h2>
Another way to remove a key from a dictionary is through the <code>del</code> keyword. This keyword can remove any object. It can also delete a key-value pair of a dictionary like this: <code>del dict_name[key]</code>:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
del my_dict[1]

line = &quot;The dictionary after deletion is {}&quot;
print(line.format(my_dict))
</code></pre>
The above snippet returns the following output, denoting the dictionary with just the left out value(s):
<pre><code class="hljs">The dictionary after deletion is {2: &#x27;b&#x27;}
</code></pre>
Unlike <code>pop()</code>, no value is returned when deleted. If you are looking to preserve the existing dictionary input, you can find the next section to be useful.
<h2 id="removemultipledictionarykeyswithdictcomprehensions">Remove Multiple Dictionary Keys with Dict Comprehensions</h2>
The previous methods update a dictionary in-place, meaning that the key-value pair is destroyed. If the original key needs to be preserved, we can use a custom function to do so. In Python, it's commonly known that we can use list comprehensions to create a new list based on an existing one. We can do the same with dictionaries using dict comprehensions.
So instead of deleting values in a list, we can use a dict comprehension to create a new dictionary with a condition that excludes the values we don't want.
Take the following example where we create a new dictionary that doesn't have a key of <code>1</code>:
<pre><code class="hljs">my_dict = {1: &quot;a&quot;, 2: &quot;b&quot;}
my_dict2 = {k: v for k, v in my_dict.items() if k != 1}

line = &quot;The new dictionary is {}&quot;
print(line.format(my_dict2))
</code></pre>
This snippet generates the following output, printing the new dictionary:
<pre><code class="hljs">The new dictionary is {2: &#x27;b&#x27;}
</code></pre>
Note that we're creating a new dictionary, adding to our program's memory usage. For dictionaries of bigger sizes, if we don't exclude a lot of members then we're nearly doubling the memory used for that data.
<h2 id="benchmarkingfunctionefficiency">Benchmarking Function Efficiency</h2>
We have observed three methods so far. But which method is the fastest among the three?
Let's create a random dictionary on which we will be testing out our methods. The following function <code>gen_random_dict(n)</code> takes a list as an argument and creates a dictionary with random seeded integers:
<pre><code class="hljs">import random

def gen_random_dict(n):
 random.seed(0)
 mydict = {}
 for i in range(n):
 nmbr = random.randrange(1, n, 1)
 mydict[nmbr] = &quot;value &quot;+ str(nmbr)
 return mydict
</code></pre>
In this same file, let's add some functions that delete a key in each of the ways we discussed:
<pre><code class="hljs"># Remove a key using pop function
def remove_using_pop(dict_input):
 dict_input.pop(1)
 return None


# Remove a key using del keyword
def remove_using_del(dict_input):
 del dict_input[1]
 return None


# Remove a key using condition
def remove_using_condition(dict_input):
 return {k: v for k, v in dict_input.items() if k != 1}
</code></pre>
Finally, add the following code that uses the <code>timeit</code> module that measures the execution time of our code:
<pre><code class="hljs">import timeit


if __name__ == &quot;__main__&quot;:
 func_to_be_tested = &quot;remove_using_pop(gen_random_dict(10000))&quot;
 setup_stmt = &quot;from __main__ import remove_using_pop, gen_random_dict&quot;
 runtime1 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
 func_to_be_tested = &quot;remove_using_del(gen_random_dict(10000))&quot;
 setup_stmt = &quot;from __main__ import remove_using_del, gen_random_dict&quot;
 runtime2 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
 func_to_be_tested = &quot;remove_using_condition(gen_random_dict(10000))&quot;
 setup_stmt = &quot;from __main__ import remove_using_condition, gen_random_dict&quot;
 runtime3 = timeit.timeit(func_to_be_tested, setup=setup_stmt, number=1)
 print(&quot;Runtime for removing key from Dict:&quot;)
 print(&quot;\t1) Using Pop: {}&quot;.format(str(runtime1)))
 print(&quot;\t2) Using Del: {}&quot;.format(str(runtime2)))
 print(&quot;\t3) Using Condition: {}&quot;.format(str(runtime3)))
</code></pre>
While results may vary on your computer, the pattern should be consistent. Here's the output we got after executing this script:
<pre><code class="hljs">Runtime for removing key from Dict:
 1) Using Pop: 0.015606499999194057
 2) Using Del: 0.01090950000070734
 3) Using Condition: 0.011443700001109391
</code></pre>
Using the <code>del</code> keyword has an edge over the rest of the methods. Although the time difference doesn't seem to be very dramatic on smaller dictionaries. Though, it will make a huge impact when the size of the dictionary is large.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned three ways by which a key-value pair can be removed from a dictionary - <code>pop()</code>, <code>del</code>, and dict comprehensions. Choosing the right method for the right size of dictionary can help in decreasing the runtime of the script and the memory usage.

Sathiya Sarathi Gunasekaran

Let's learn three ways to remove key-value pairs from a Python dictionary - the `pop()` function, the `del` keyword, and dict comprehensions.


Python: How to Remove a Key from a Dictionary

<h2 id="introduction">Introduction</h2>
A dictionary in Python is a collection of items that store data as key-value pairs. We can access and manipulate dictionary items based on their key. Dictionaries are mutable and allow us to add new items to them.
The quickest way to add a single item to a dictionary is by using a dictionary's index with a new key and assigning a value. For example, we add a new key-value pair like this:
<pre><code class="hljs">snacks[&#x27;chocolate&#x27;] = 5
</code></pre>
Python allows adding multiple items to dictionaries as well. In this tutorial, we'll take a look at how to add keys to a dictionary in Python.
<h2 id="addkeytoapythondictionary">Add Key to a Python Dictionary</h2>
There are multiple ways to add a new key-value pair to an existing dictionary. Let's have a look at a few common ways to do so.
<h3 id="addkeywithvalue">Add Key with Value</h3>
We can add a new key to a dictionary by assigning a value to it. If the key is already present, it overwrites the value it points to. The key has to be written in subscript notation to the dictionary like this:
<pre><code class="hljs">my_dictionary[new_key] = new_value
</code></pre>
This key-value pair will be added to the dictionary. If you're using Python 3.6 or later, it will be added as the last item of the dictionary.
Let's make a dictionary, and then add a new key-value pair with this approach:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
squares[4] = 16 # Adding new key-value pair
print(squares)
</code></pre>
This will result in:
<pre><code class="hljs">{1: 1, 2: 4, 3: 9, 4: 16}
</code></pre>
<h3 id="addkeytodictionarywithoutvalue">Add Key to Dictionary without Value</h3>
If you'd just like to add a key, without a value, you can simply put <code>None</code> instead of the value, with any of the methods covered in this article:
<pre><code class="hljs">squares = {1: 1, 2: 4, 3: 9}
squares[&#x27;x&#x27;] = None # Adding new key without value
print(squares)
</code></pre>
This results in:
<pre><code class="hljs">{1: 1, 2: 4, 3: 9, &#x27;x&#x27;: None}
</code></pre>
<h3 id="addmultiplekeyvaluepairswithupdate">Add Multiple Key-Value Pairs with update()</h3>
In Python, we can add multiple key-value pairs to an existing dictionary. This is achieved by using the <code>update()</code> method. This method takes an argument of type <code>dict</code> or any iterable that has the length of two - like <code>((key1, value1),)</code>, and updates the dictionary with new key-value pairs.
If the key is already present in the dictionary, it gets overwritten with the new value.
The keys can also be passed as keyword arguments to this method with their corresponding values, like <code>dictionary.update(new_key=new_value)</code>.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: This is arguably the most popular method of adding new keys and values to a dictionary.

 </div>
 </div>
 </div>
 Let's use the <code>update()</code> method to add multiple key-value pairs to a dictionary:
<pre><code class="hljs">rainbow = {&#x27;red&#x27;: 1}

# Update by passing dictionary 
new_key_values_dict = {&#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3}
rainbow.update(new_key_values_dict)
print(&quot;update by passing dictionary&quot;)
print(rainbow)

# Update by passing iterables
new_key_values_itr = ((&#x27;green&#x27;,4), (&#x27;blue&#x27;,5))
rainbow.update(new_key_values_itr)
print(&quot;update by passing iterables&quot;)
print(rainbow)

# Update using keyword arguments
rainbow.update(indigo=6, violet=7)
print(&quot;update using keyword arguments&quot;)
print(rainbow)
</code></pre>
Running this code will produce the following output:
<pre><code class="hljs">update by passing dictionary
{&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3}
update by passing iterables
{&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5}
update using keyword arguments
{&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}
</code></pre>
<h3 id="usingmergeoperatorpython39">Using Merge Operator (Python 3.9+)</h3>
From Python version 3.9, Merge (<code>|</code>) and Update (<code>|=</code>) operators have been added to the built-in <code>dict</code> class.
These are very convenient methods to add multiple key-value pairs to a dictionary. The Merge (<code>|</code>) operator creates a new dictionary with the keys and values of both of the given dictionaries. We can then assign this result to a new dictionary.
Whereas the Update (<code>|=</code>) operator, adds the key-value pairs of the second dictionary into the first dictionary. So, the existing dictionary gets updated with multiple key-value pairs from another dictionary.
Here's an example of using Merge (<code>|</code>) and Update (<code>|=</code>) operators to add new keys to a dictionary:
<pre><code class="hljs">colors_set1 = {‘red’: 1, &#x27;orange’: 2, &#x27;yellow&#x27;: 3}
colors_set2 = {&#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}

# Merge operator
rainbow = colors_set1 | colors_set2
print(&quot;using merge:&quot;, rainbow)

# Update operator
colors_set1 |= colors_set2
print(&quot;using update:&quot;, colors_set1)
</code></pre>
This code will produce the following output on the Python(3.9+) interpreter:
<pre><code class="hljs">using merge: {&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}
using update: {&#x27;red&#x27;: 1, &#x27;orange&#x27;: 2, &#x27;yellow&#x27;: 3, &#x27;green&#x27;: 4, &#x27;blue&#x27;: 5, &#x27;indigo&#x27;: 6, &#x27;violet&#x27;: 7}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned how we can add a new key to a dictionary. We first added the key-value pair using subscript notation - we added a key to a dictionary by assigning a value to it. We then looked at the <code>update()</code> method to add multiple key-value pairs to a dictionary. We've also used the <code>update()</code> method with parameters of type dictionary, tuple, and keyword arguments. Lastly, we probed into the Merge and Update operators available from Python versions 3.9 onwards.
The <code>update()</code> method of dictionary proves to be the most popular way to add new keys to an existing dictionary.

Let's add new keys to a Python dictionary. We'll add a single key, and multiple keys with the update() function, merge operator | and update operator |= 

Python: How to Add Keys to Dictionary

Python: How to Add Keys to a Dictionary

<h2 id="introduction">Introduction</h2>
Form Data Validation is a very common, and rudimentary step in building any web application with user input. We want to make sure that certain ranges are respected, and that certain formats are followed. For example, we'll want to make sure that the user isn't <code>-345</code> years old, or that their email address is valid.
There are many ways to validate form data - and the method you use depends on your application. In general, you'll want to perform <a target="_blank" href="client-side-form-validation-using-vanilla-javascript">client-side validation</a>, as well as server-side validation. Client-side validation makes sure that unfiltered data doesn't even reach the back-end, while server-side validation makes sure that the wrong data isn't processed further.
In this article, we'll cover how to perform form data validation in Spring Boot with Thymeleaf, as the template engine.
We'll leverage Spring Boot's built-in <a rel="nofollow noopener" target="_blank" href="https://beanvalidation.org/">Bean Validation API</a>, which makes this process simple and straightforward.
<h2 id="springbootvalidationmavendependency">Spring Boot Validation Maven Dependency</h2>
Spring Boot allows us to define validation criteria using annotations. In your Domain Model, you can simply annotate fields with the constraints, and it'll enforce them.
For the validation annotations to work we need to add the following dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-starter-validation&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
<h2 id="domainmodel">Domain Model</h2>
Let's define a simple POJO, with a few fields that we want to validate:
<pre><code class="hljs">@Entity
public class Person {

 @Id
 @GeneratedValue(strategy= GenerationType.AUTO)
 private Long id;

 @NotEmpty
 @Size(min = 5)
 private String fullName;

 @NotEmpty
 @Email
 private String email;

 @NotNull
 @Min(value = 18)
 private Integer age;

 // Getters and Setters

}
</code></pre>
Now, let's break the annotations we used:
<ul>
<li><code>@NotEmpty</code> - is used to constrain a field of type <code>String</code>, <code>Collection</code>, <code>Map</code>, or <code>Array</code> to not be <code>null</code> or empty.</li>
<li><code>@Size([min = x, max = y])</code> - is used to define the rules for the size of a <code>String</code>, <code>Collection</code>, <code>Map</code>, or <code>Array</code>.</li>
<li><code>@Email</code> - helps us to validate the string against a regex which defines the structure of a valid email.</li>
<li><code>@NotNull</code> - tells Spring the field should not be null, but it can be empty.</li>
<li><code>@Min</code> and <code>@Max</code> are used to specify the limits of a variable. For example, the <code>@Min</code> age could be set to, say, 18.</li>
</ul>
<h2 id="persistencelayerrepository">Persistence Layer - Repository</h2>
To create a simple CRUD repository, all we have to do is extend the <code>JpaRepository</code> and supply our domain model and the ID's data type:
<pre><code class="hljs">@Repository
public interface PersonRepository extends JpaRepository&lt;Person, Long&gt; {
}
</code></pre>
<h2 id="creatingaformwiththymeleaf">Creating a Form with Thymeleaf</h2>
Now, let's make a simple form using HTML and Bootstrap to collect information:
<pre><code class="hljs">&lt;form th:action=&quot;@{/add}&quot; th:object=&quot;${person}&quot; method=&quot;post&quot; class=&quot;form&quot;&gt;
 &lt;div class=&quot;form-group&quot;&gt;
 &lt;label for=&quot;fullName&quot;&gt;Name&lt;/label&gt;
 &lt;input class=&quot;form-control&quot; type=&quot;text&quot; th:field=&quot;*{fullName}&quot; id=&quot;fullName&quot; placeholder=&quot;Full Name&quot;&gt;
 &lt;div class=&quot;alert alert-warning&quot; th:if=&quot;${#fields.hasErrors(&#x27;fullName&#x27;)}&quot; th:errors=&quot;*{fullName}&quot;&gt;&lt;/div&gt;
 &lt;/div&gt;
 &lt;div class=&quot;form-group&quot;&gt;
 &lt;label for=&quot;email&quot;&gt;Email&lt;/label&gt;
 &lt;input class=&quot;form-control&quot; type=&quot;text&quot; th:field=&quot;*{email}&quot; id=&quot;email&quot; placeholder=&quot;Email&quot;&gt;
 &lt;div class=&quot;alert alert-warning&quot; th:if=&quot;${#fields.hasErrors(&#x27;email&#x27;)}&quot; th:errors=&quot;*{email}&quot;&gt;&lt;/div&gt;
 &lt;/div&gt;
 &lt;div class=&quot;form-group&quot;&gt;
 &lt;label for=&quot;age&quot;&gt;Age&lt;/label&gt;
 &lt;input class=&quot;form-control&quot; type=&quot;text&quot; th:field=&quot;*{age}&quot; id=&quot;age&quot; placeholder=&quot;Age&quot;&gt;
 &lt;div class=&quot;alert alert-warning&quot; th:if=&quot;${#fields.hasErrors(&#x27;age&#x27;)}&quot; th:errors=&quot;*{age}&quot;&gt;&lt;/div&gt;
 &lt;/div&gt;
 &lt;input type=&quot;submit&quot; class=&quot;btn btn-success&quot; value=&quot;Add User&quot;&gt;
&lt;/form&gt;
</code></pre>
The form points to <code>/add</code> and sends a <code>POST</code> request. The fields in our object, <code>fullName</code>, <code>age</code> and <code>email</code> are in the form, signified by <code>th:field</code>. Since we've got our <code>th:object=${person}</code>,we can refer to this <code>person</code> object by substituting it with a <code>*</code> before the fields.
<code>*{fullName}</code> is the same as <code>${person.fullName}</code>. Each input also has a hidden <code>&lt;div&gt;</code> which is shown only if the <code>${#fields.hasErrors()}</code> calls evaluate to <code>true</code>. If there aren't errors, this div doesn't exist. If there are, the <code>th:errors</code> tag lets us specify a message. If we simply pass in the field that causes the error, such as <code>th:errors=&quot;*{age}&quot;</code>, the default message from the Bean Validator API are used, for that field.
This results in a form that looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-thymeleaf-form-data-validation-with-bean-validator-1.png" alt="basic html form">
Since these messages aren't very user-friendly, we'll want to customize them by supplying our own messages.
<h2 id="controller">Controller</h2>
Now, let's make a controller that'll handle a request to save a <code>Person</code> into the database. As usual, we'll have a <code>@GetMapping()</code> to show the form, and a <code>@PostMapping</code> to handle the request. In the method signature of the <code>@PostMapping</code>, we'll annotate the POJO with <code>@Valid</code>.
The <code>@Valid</code> annotation triggers the Bean Validator to check if the fields populated in the object conform to the annotations we've used in the class definition. If you don't use the <code>@Valid</code> annotation, it won't check anything, and even values you might not expect can be populated in the object.
In our case, the <code>Person person</code> object is the object that's populated with the inputs of a form:
<pre><code class="hljs">@GetMapping(&quot;/add&quot;)
public String showAddPersonForm(Person person) {
 return &quot;add-person&quot;;
}

@PostMapping(&quot;/add&quot;)
public String addPerson(@Valid Person person, BindingResult result, Model model) {
 if (result.hasErrors()) {
 return &quot;add-person&quot;;
 }
 repository.save(person);
 return &quot;redirect:/index&quot;;
}
</code></pre>
If there are any issues with this <code>Person</code>, the <code>${fields}</code> attribute will have errors within it, tied to the field that caused the error.
<h2 id="customizingerrormessages">Customizing Error Messages</h2>
To set a custom message for any validation constraint, you can use the <code>message</code> option:
<pre><code class="hljs">@NotEmpty(message = &quot;Field can&#x27;t be empty!)
private String field;
</code></pre>
You can simply write these messages out in your model, like this. Though, it's considered good practice to put the validation messages in a <code>properties</code> file, that you can reference. This is done since you can bundle all validation messages together, and can update them if the models get changed at a later date.
Let's make our <code>ValidationMessages.properties</code> under <code>src/main/resources</code>:
<pre><code class="hljs">Size.Person.FullName=The Full Name should have at least 5 characters
</code></pre>
We will then modify the <code>Person</code> model, and supply this property as the <code>message</code> of the <code>@Size</code> annotation:
<pre><code class="hljs">@NotEmpty(message = &quot;The Full Name can&#x27;t be null&quot;)
@Size(min = 5, message = &quot;{Size.Person.FullName}&quot;)
private String fullName;
</code></pre>
Let's go back to our form and see how it looks now:
<img src="https://stackabuse.s3.amazonaws.com/media/spring-boot-thymeleaf-form-data-validation-with-bean-validator-2.png" alt="customized error messages spring boot bean validator">
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over how to use the Bean Validator API that Spring Boot uses to effortlessly perform form data validation with Thymeleaf.
We've created a domain model, annotated our fields with Bean Validator constraints. Then, we've made a repository and controller to display the form and process it, as well as save the relevant information into a <code>Person</code> object, making sure that the fields are validated with the <code>@Valid</code> annotation.
You can find the source code <a rel="nofollow noopener" target="_blank" href="https://github.com/alexchirea/SimpleSpringBootApp/tree/SpringValidationFormThymeleaf">on GitHub</a>.

Alex Chirea

In this tutorial, we'll cover how to perform Spring Boot Thymeleaf Form Data Validation using the well-known Bean Validator library.

Spring Boot Thymeleaf Form Data Validation with Bean Validator

<h2 id="introduction">Introduction</h2>
Printing an array is a quick way to give us visibility on the values of the contents inside. Sometimes the array values are the desired output of the program.
In this article, we'll take a look at how to print an array in Java using four different ways.
While the &quot;best way&quot; depends on what your program needs to do, we begin with the simplest method for printing and then show more verbose ways to do it.
<ul>
<li><a href="#printanarrayusingarraystostringandarraysdeeptostring">Print an Array Using Arrays.toString() and Arrays.deepToString()</a></li>
<li><a href="#printanarrayusingjava8streams">Print an Array Using Java 8 Streams</a></li>
<li><a href="#printanarraybyconvertingtolist">Print an Array by Converting to List</a></li>
<li><a href="#printanarrayusingforloops">Print an Array Using For Loops</a></li>
<li><a href="#convertingtolistandusinganiterator">Converting To List and Using an Iterator</a></li>
</ul>
<h2 id="printanarrayusingarraystostringandarraysdeeptostring">Print an Array Using Arrays.toString() and Arrays.deepToString()</h2>
The built-in <code>toString()</code> method is an extremely simple way to print out formatted versions of objects in Java.
Every data type in Java is considered a class and by default, every class inherits from <code>java.lang.Object</code>, the root of Java's class hierarchy. That's why every class has a <code>toString()</code> method. However, arrays don't override the <code>toString()</code> method to format the output nicely, and it just returns the inherited value, which is the hash of the object.
We print arrays using the <code>toString()</code> method from the class in <code>java.util.Arrays</code>.
Take this example where we print the values of an array of integers:
<pre><code class="hljs">int[] intSequence = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

System.out.println(Arrays.toString(intSequence));
</code></pre>
The code above will output the following:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
Note how all the elements are comma-separated and in square brackets. This method is like a visual representation of the array.
We can use this method to print arrays of different types as well:
<pre><code class="hljs">double[] doubleValues = {5.5, 2.37, 9.9, 1.02};
System.out.println(Arrays.toString(doubleValues));

String[] stringValues = {&quot;alabama&quot;, &quot;arkansas&quot;, &quot;kentucky&quot;};
System.out.println(Arrays.toString(stringValues));
</code></pre>
These respectively result in:
<pre><code class="hljs">[5.5, 2.37, 9.9, 1.02]
[alabama, arkansas, kentucky]
</code></pre>
The <code>toString()</code> method is only effective for one-dimensional arrays. When we have nested arrays we need use the <code>deepToString()</code> method:
<pre><code class="hljs">double[][] coordinates = {{40.50, 50.75}, {22.25, 32.75}};
System.out.println(Arrays.deepToString(coordinates));

String[][] songLines = {{&quot;Take your nose off my keyboard&quot;}, {&quot;What you bothering me for?&quot;}};
System.out.println(Arrays.deepToString(songLines));
</code></pre>
These result in:
<pre><code class="hljs">[[40.5, 50.75], [22.25, 32.75]]
[[Take your nose off my keyboard], [What you bothering me for?]]
</code></pre>
If you need a visual of what's in your array at a glance, the <code>toString()</code> and <code>deepToString()</code> methods are your best option.
However, these methods don't allow you to format your output. This approach is basically just a workaround for the fact that arrays don't override the <code>toString()</code> method by default.
If you'd prefer some flexibility with the formatting, you might consider using Java 8 Streams.
<h2 id="printanarrayusingjava8streams">Print an Array Using Java 8 Streams</h2>
One option for printing an array is to convert it to a stream of objects, then print each element in the stream. We have a few options to leverage streams to print our array.
For example, we can print our array line by line like this:
<pre><code class="hljs">String[] languages = {&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};
Arrays.stream(languages).forEach(System.out::println);
</code></pre>
In this case, we use the static <code>stream()</code> method of the <code>Arrays</code> class to create a sequential stream of our data. For each element in our stream, we call the <code>println()</code> function on it, making it appear line by line like this:
<pre><code class="hljs">Java
Python
JavaScript
</code></pre>
Note: We reference the <code>println()</code> function like this: <code>System.out::println</code>. The <code>::</code> in Java is a method reference operator. The <code>forEach()</code> function can either use a <a href="/lambda-expressions-in-java/" target="_blank">lambda function</a> or a <a href="/method-references-in-java-8/" target="_blank">method reference</a>.
Alternatively, we can use the <code>Stream</code> class from <code>java.util.stream.Stream</code> to similarly call the <code>println()</code> function on a stream of our array data. We can construct a Stream of this data using <code>Stream.of()</code>:
<pre><code class="hljs">String[] languages = {&quot;Java&quot;, &quot;Python&quot;, &quot;JavaScript&quot;};
Stream.of(languages).forEach(System.out::println);
</code></pre>
With this code we'll get the same output:
<pre><code class="hljs">Java
Python
JavaScript
</code></pre>
Let's try this out with nested arrays as well, adding the release dates of the initial versions of these languages:
<pre><code class="hljs">String[][] languages = {{&quot;Java&quot;, &quot;1996&quot;}, {&quot;Python&quot;, &quot;1994&quot;}, {&quot;JavaScript&quot;, &quot;1995&quot;}};

Arrays.stream(languages).forEach(System.out::println);
// OR
Stream.of(languages).forEach(System.out::println);
</code></pre>
The output for each print via streams would look something like this:
<pre><code class="hljs">[Ljava.lang.String;@e9e54c2
[Ljava.lang.String;@65ab7765
[Ljava.lang.String;@1b28cdfa
</code></pre>
That doesn't work very well... We're calling <code>println()</code> on array objects again. We'll have to stream those objects again, and print their elements.
To print nested arrays, we can use a lambda expression in the <code>forEach()</code> function that can go to the second level, by making another stream of each level, and printing the entries out that way:
<pre><code class="hljs">String[][] languages = {{&quot;Java&quot;, &quot;1996&quot;}, {&quot;Python&quot;, &quot;1994&quot;}, {&quot;JavaScript&quot;, &quot;1995&quot;}};

Arrays.stream(languages).forEach(s -&gt; Arrays.stream(s).forEach(System.out::println)); 
// OR
Stream.of(languages).forEach(s -&gt; Arrays.stream(s).forEach(System.out::println));
</code></pre>
This lambda function prints the elements in each nested array. When compiled and executed, we would get this output:
<pre><code class="hljs">Java
1996
Python
1994
JavaScript
1995
</code></pre>
Streams make working with collections a breeze. But Java is flexible to provide even more ways. The traditional for-loop does a lot for us still. Let's have a look at printing an array with loops.
<h2 id="printanarraybyconvertingtolist">Print an Array by Converting to List</h2>
You can easily convert a Java array into a <code>List</code> implementation. There are various ways to do that, and we've covered each in detail in our <a target="_blank" href="/how-to-convert-a-java-array-to-arraylist">How to Convert a Java Array to ArrayList</a> article.
In short, calling <code>toString()</code>, or just printing out (which implicitly calls <code>toString()</code>) on a <code>List</code> implementation, will print out the contents:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List&lt;Integer&gt; numberList = Arrays.asList(numbers);

System.out.println(numberList);
</code></pre>
This results in:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
</code></pre>
Additionally, you can use <code>.forEach()</code> natively on any <code>Collection</code>, which a <code>List</code> is. So, you can just go ahead and do this as well:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.asList(numbers).forEach(System.out::println);
</code></pre>
Though, this isn't a nicely formatted option:
<pre><code class="hljs">12345678910
</code></pre>
You can ditch the method reference and just use a lambda for more control:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.asList(numbers)
 .forEach(number -&gt; System.out.print(String.format(&quot;%d, &quot;, number)));
</code></pre>
This results in:
<pre><code class="hljs">1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 
</code></pre>
<h2 id="printanarrayusingforloops">Print an Array Using For Loops</h2>
A more well-known approach to printing an array in Java is to use a <code>for</code> loop. With a <code>for</code> loop we get the index of the element, and we can use the index to get the element of an array.
We set up a <code>for</code> loop with a variable, commonly named <code>i</code>, as the counter starting from element <code>0</code>. This is then followed by the condition that compares <code>i</code> to the number of elements in the array.
Note: The number of elements in the array that will be used in the loop's condition should never be hardcoded. Java provides an attribute called <code>length</code> that allows the programmer to dynamically calculate the number of elements in an array.
Last but not least, our <code>for</code> loop takes the incremental value. In our case we will use the <code>i++</code> notation to keep increasing our counter by one element in each iteration.
Once our loop is all set and ready, we will simply use the <code>System.out.println()</code> statement to display each element in the array using the rectangular bracket notation <code>[i]</code> taking as input our counter <code>i</code>.
Here's an example where we print all the elements of an integer array line by line:
<pre><code class="hljs">int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int i = 0; i &lt; numbers.length; i++){
 System.out.println(numbers[i]);
}
</code></pre>
Executing this code would print the following in your console:
<pre><code class="hljs">1
2
3
4
5
6
7
8
9
10
</code></pre>
There isn't much more to using <code>for</code> loops. They're quite flexible and conceptually simple. For example, if you had nested arrays then you'll use nested <code>for</code> loops.
Finally, let's have a look at iterators and lists.
<h2 id="convertingtolistandusinganiterator">Converting To List and Using an Iterator</h2>
A Java iterator object allows us to display each element of our array without having to use the index approach we covered in the <code>for</code> loop section.
To use iterators, we have to change the datatype of the array to a <code>List</code>. We can do this by using the <code>Array.asList()</code> method and save the list values returned in a new variable. The <code>asList()</code> method takes in the array, and turns it into a <code>List</code> implementation.
Next, you will need an iterator object to set up your array iterator. An iterator is like a pointer that points to every element in the array. The iterator helps you to inspect each element in a singular manner.
To create an iterator object, we will use the <code>iterator()</code> method of our <code>List</code>. Once our iterator object was created we’ll use the <code>while</code> loop as it offers a more compact way of printing each element returned by the iterator.
The <code>while</code> loop's condition will contain a call to the <code>hasNext()</code> method of our iterator. Inside the <code>while</code> loop, we print each element by calling <code>System.out.println()</code>. We get elements from the iterator by calling the <code>next()</code> method. The <code>while</code> loop will keep iterating over each element until we have traversed our array (via the <code>List</code>).
Here's an example where we take an array of integers and print each element line by line by using an iterator:
<pre><code class="hljs">Integer[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
List&lt;Integer&gt; numberList = Arrays.asList(numbers);
Iterator&lt;Integer&gt; numberIterator = numberList.iterator();

while(numberIterator.hasNext()) {
 System.out.println(numberIterator.next());
}
</code></pre>
Compared to the for loops, this method is preferred by developers who rather not deal with array indices. You are guaranteed the upcoming element with <code>next()</code>. Iterators are powerful because we use this same flow for any type of <code>List</code> like an <code>ArrayList</code> or a <code>LinkedList</code>, as well as other collections like a <code>Map</code> or a <code>Set</code>!
<h2 id="conclusion">Conclusion</h2>
In this article, we covered the main methods used to print an array in Java. We started by using the built-in Java methods <code>toString()</code> and <code>deepToString()</code>.
From there, we used streams so that we can quickly print array elements line by line. We've also covered how to convert an array to a list, which you can either just call or use the Java 8 Stream API for more granular control.
Then, we used the traditional <code>for</code> loop structure to print every element individually.
Last but not least, we used the iterator object to print every element separately using the <code>next()</code> method inside a <code>while</code> loop. The approaches covered in the chapter can be used depending on the use case and the problem you are trying to solve.

Mohamed Echout

In this tutorial, we'll print arrays in Java using the toString() and deepToString() methods, streams, for loops and iterators, with examples and explanations!