<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be converting a Java Array into a Java Stream for primitive types, as well as objects. This can be done either via Arrays.stream(), as well as Stream.of().
<h2 id="arraysstream">Arrays.stream()</h2>
A good way to turn an array into a stream is to use the <code>Arrays</code> class' <code>stream()</code> method. This works the same for both primitive types and objects.
<h3 id="primitivetypes">Primitive Types</h3>
For primitive types, you can use <code>Arrays.stream()</code> with an array reference as the parameter.
Optionally, you can also specify the range of indices that should be used as the starting and ending point of the stream/array. If these are not supplied, the entire array will be converted:
<pre><code class="hljs">// Entire array is used for constructing the Stream
Arrays.stream(T[] arr) 
// Construct Stream with a range of elements
Arrays.stream(T[] arr,int start_ind_Include,int end_ind_Exclude) 
)
</code></pre>
Let's instantiate an array and convert it into a stream:
<pre><code class="hljs">long[] array = {2, 5, 9, 10, 15, 18, 56};
LongStream stream = Arrays.stream(array);
System.out.println(&quot;Long stream:&quot;);
stream.forEach(x -&gt; System.out.print(x + &quot; &quot;));
</code></pre>
This results in:
<pre><code class="hljs">Long stream: 
2 5 9 10 15 18 56 
</code></pre>
Similarly, we can create a stream from a range of indices (0,4) by supplying them as the parameters. Note the starting index of the range is included and end index is not included when a range is specified:
<pre><code class="hljs">LongStream stream = Arrays.stream(array,0,4);
System.out.println(&quot;\nLong stream from index 0 to 3:&quot;);
stream.forEach(x -&gt; System.out.print(x + &quot; &quot;));
</code></pre>
This results in:
<pre><code class="hljs">Long stream from index 0 to 3: 
2 5 9 10 
</code></pre>
<h3 id="objects">Objects</h3>
For objects, <code>Arrays.stream()</code> returns a <code>Stream</code> of the specified object. It accepts an array reference and optionally takes in a range of indices. Let's make a <code>String</code> array and convert it into a <code>Stream</code>:
<pre><code class="hljs">String[] array = new String[]{&quot;John&quot;, &quot;Jenny&quot;, &quot;Martha&quot;, &quot;Adam&quot;};

// Create a Stream
Stream&lt;String&gt; stream = Arrays.stream(array);
System.out.println(&quot;Entire array:&quot;);
stream.forEach(c -&gt; System.out.println(c));

// Create a Stream from a range
System.out.println(&quot;\nSubarray:&quot;)
Stream&lt;String&gt; streamWithRange = Arrays.stream(array,0,2);
</code></pre>
The above code generates the following output:
<pre><code class="hljs">Entire array:
John
Jenny
Martha
Adam

Subarray:
John
Jenny
</code></pre>
<h2 id="streamof">Stream.of()</h2>
<h3 id="primitiveobjects">Primitive Objects</h3>
Instead of using the <code>Arrays</code> class, we can also use the goal class - <code>Stream</code>. The <code>of()</code> method, as the name implies, creates a <code>Stream</code> with a given collection, such as an array.
Keep in mind, <code>Stream.of()</code> returns a stream of objects, regardless of the type you're using. You'll have to flatten it for primitive types. The conversion/casting is done automatically for objects, since in that case, the <code>Stream.of()</code> method just calls <code>Arrays.stream()</code>.
Let's make a primitive <code>int</code> array:
<pre><code class="hljs">int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
Stream&lt;int[]&gt; stream = Stream.of(array);
System.out.println(&quot;\nInt stream: &quot;);
// Need to be flattened to its primitive type
stream.flatMapToInt(Arrays::stream).forEach(x -&gt; System.out.print(x + &quot; &quot;));
</code></pre>
The flattening is done via the <code>Arrays.stream()</code> method, which in this case just adds redundancy to the code. Instead of using <code>Stream.of()</code> on primitive arrays, we can use built-in classes for these such as <code>IntStream</code>.
This code results in:
<pre><code class="hljs">Int stream: 
1 2 3 4 5 6 7 8 9
</code></pre>
<h3 id="objects">Objects</h3>
Now, let's create a <code>Stream</code> of <code>String</code> type. We'll then filter out only names that start with the letter 'J':
<pre><code class="hljs">String[] array = new String[]{&quot;John&quot;, &quot;Jenny&quot;, &quot;Martha&quot;, &quot;Adam&quot;};

Stream&lt;String&gt; stream = Stream.of(array);
System.out.println(&quot;Printing only names that start with &#x27;J&#x27;...&quot;);
stream.filter(string -&gt; string.startsWith(&quot;J&quot;))
 .forEach(string -&gt; System.out.pritnln(string));
</code></pre>
The code has the following output:
<pre><code class="hljs">Printing only names that start with &#x27;J&#x27;...
John
Jenny
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered the two ways you can create a Stream from an array. This goes for both primitive arrays and object arrays.
The <code>Arrays.stream()</code> method is a straightforward one, which accepts an array reference and an optional range. The <code>Stream.of()</code> method calls <code>Arrays.stream()</code> for object types, while it requires flattening for primitive types.

Mehreen Saeed

In this tutorial, we'll convert a Java Array to a Java Stream. This can be done for primitive types and objects, using the Arrays.stream() and Stream.of() methods.

Java: Convert Array to Stream

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be converting a Java Stream into a Java Array for primitive types, as well as objects.
<h2 id="streamtoarray">Stream.toArray()</h2>
The <code>toArray()</code> method is a built-in method from the <code>Stream</code> class which is really convenient to use when converting from a <code>Stream</code> to an array. It works for both primitive types and objects, though, there's a slight difference in the usage.
The method returns a new array, which means that we'll be packing the results into a new array for storage. For objects, we'll have to specify the object type and provide an array constructor of that type to the method as well.
<h3 id="primitivetypes">Primitive Types</h3>
Java 8 has special streams for primitive types, i.e., <code>IntStream</code>, <code>LongStream</code> and <code>DoubleStream</code>. Let's use an <code>IntStream</code> to store a range of integers, and then convert it into an array:
<pre><code class="hljs">IntStream stream = IntStream.range(10, 20);
int[] array = stream.toArray();
System.out.println(&quot;Printing array ...&quot;);

for (int i = 0; i &lt; array.length; ++i)
 System.out.print(array[i] + &quot; &quot;);
</code></pre>
This results in:
<pre><code class="hljs">Printing array ...
10 11 12 13 14 15 16 17 18 19 
</code></pre>
Streams are handy for data manipulation, so you might want to do preprocessing on a stream, rather than an array, and convert it into one in the end:
<pre><code class="hljs">IntStream stream = IntStream.range(10, 20);
// Filter out all even numbers
int[] array = stream.filter(x -&gt; x%2 == 0).toArray();
System.out.println(&quot;\nPrinting even numbers ...&quot;);
for (int i = 0; i &lt; array.length; ++i)
 System.out.print(array[i] + &quot; &quot;);
</code></pre>
This results in:
<pre><code class="hljs">Printing even numbers ...
10 12 14 16 18
</code></pre>
<h3 id="objects">Objects</h3>
For objects, the <code>toArray()</code> method takes in an array constructor reference for the respective object, and returns an array of that type. Let's make a <code>Stream</code> of <code>String</code> objects and convert it into an array:
<pre><code class="hljs">// Create a List of Strings
List&lt;String&gt; list = new ArrayList&lt;&gt;();
list.add(&quot;John&quot;);
list.add(&quot;Jenny&quot;);
list.add(&quot;Martha&quot;);

// Stream the List
Stream&lt;String&gt; stream = list.stream();

// Create an array using the toArray() method
String[] array = stream.toArray(String[]::new);
System.out.println(&quot;Printing String array ...&quot;);
for (int i = 0; i &lt; array.length; ++i)
 System.out.println(array[i]);
</code></pre>
This results in:
<pre><code class="hljs">Printing String array...
John
Jenny
Martha
</code></pre>
Note: The <code>toArray()</code> method requires the array constructor to be used and we've used a method reference to specify the type - <code>String[]::new</code>. <code>toArray()</code> returns an array of the specified type, and if the type isn't specified, a mismatch will occur:
<pre><code class="hljs">String[] array = stream.toArray();
</code></pre>
The result is a compiler error:
<pre><code class="hljs">error: incompatible types: Object[] cannot be converted to String[]
</code></pre>
Instead of the shorthand method references, we can also use Lambda Expressions to achieve this. Let's filter out only names that start with 'J':
<pre><code class="hljs">// Create a List of Strings
List&lt;String&gt; list = new ArrayList&lt;&gt;();
list.add(&quot;John&quot;);
list.add(&quot;Jenny&quot;);
list.add(&quot;Martha&quot;);

// Stream the List
Stream&lt;String&gt; stream = list.stream();

// Filter the stream element and convert to array
String[] array = stream
 .filter(string -&gt; string.startsWith(&quot;J&quot;))
 .toArray(size -&gt; new String[size]);
System.out.println(&quot;Printing names starting with &#x27;J&#x27;...&quot;);
for (int i = 0; i &lt; array.length; ++i)
 System.out.println(array[i]);
</code></pre>
This produces:
<pre><code class="hljs">Printing names starting with &#x27;J&#x27;...
John
Jenny
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've converted a <code>Stream</code> into an array. This can be done for primitive and object arrays via the <code>Stream.toArray()</code> method, albeit, with slightly different usage.

In this tutorial, we'll convert a Java Stream to a Java Array. This can be done for primitive types and objects, using the Stream.toArray() method.

Java: Convert Stream to Array

<h2 id="introduction">Introduction</h2>
This tutorial will go through some common techniques for removing elements from Java arrays. Manipulating array elements is an extremely common task as discussions about it can be found on many forums, particularly on StackOverflow.
Here's a list of the techniques and methods we'll go over in this article:
<ul>
<li><a href="#usingtwoarrays">Using Two Arrays</a></li>
<li><a href="#arrayutilsremove">ArraysUtils.remove()</a></li>
<li><a href="#usingaforloop">Using a <code>for</code> loop</a></li>
<li><a href="#systemarraycopy">System.arraycopy()</a></li>
</ul>
<h2 id="ashortbriefingonarrays">A Short Briefing on Arrays</h2>
Arrays are data structures common in many programming languages. Each array is stored in a single block of memory and it allows sequential storage and simple manipulation of elements:
<img src="https://stackabuse.s3.amazonaws.com/media/remove-an-element-from-an-array-in-java-1.png" alt="java array in memory">
Credit: <a target="_blank" rel="Nofollow noopener" href="https://codeforwin.org/">CodeForWin</a>
Elements are sequentially stored one after another. When someone wants to access an element at a certain index, pointer arithmetic (which is the mechanism under the hood) allows to quickly and efficiently obtain any particular element.
If the index of a requested element is <code>3</code>, the underlying mechanism simply needs to take the memory address of the zero-th element and add three times the size of each element. Since all array elements have the same size, this kind of computation leads directly to the element with index <code>3</code>. Furthermore, this happens in <code>O(1)</code> complexity which means it's as fast as it can be.
What makes removing an array element difficult is the fact that all elements are stored sequentially in a single memory block. Due to the nature of array's memory placement, it is simply impossible to remove the element directly.
Instead, to &quot;remove&quot; any element, all subsequent elements need to be shifted backward by one place. This will create an illusion that a specific element was removed.
<h2 id="usingtwoarrays">Using Two Arrays</h2>
The simplest pure Java way to do this is to make a new array, one element shorter than the original one and copy all element, except the one we'd like to remove, into it:
<pre><code class="hljs">int[] copy = new int[array.length - 1];

for (int i = 0, j = 0; i &lt; array.length; i++) {
 if (i != index) {
 copy[j++] = array[i];
 }
}
</code></pre>
Here, we're simply iterating over the original array and copying elements from the original array into the new array, skipping the one we'd like to remove.
The <code>copy</code> array now consists of:
<pre><code class="hljs">10, 20, 30, 50, 60, 70, 80, 90, 100
</code></pre>
<h2 id="arrayutilsremove">ArrayUtils.remove()</h2>
In case you're already using the Apache Commons library, you can use the <code>ArrayUtils.remove()</code> method.
Before working with Apache Commons, we'll want to add it to our project:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Using the method is really simple. We simply supply it with the array we'd like to remove an element from and its index:
<pre><code class="hljs">int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;
array = ArrayUtils.remove(array, index);
</code></pre>
It then returns the new array, which is stored in the <code>array</code> variable:
<pre><code class="hljs">10, 20, 30, 50, 60, 70, 80, 90, 100
</code></pre>
<h2 id="usingaforloop">Using a for loop</h2>
The seemingly simplest way to remove an element is to iterate the array manually using a <code>for</code> loop. Alternatively, a <code>while</code> loop can also be used but <code>for</code> is much more suitable for this type of task.
Say, we want to remove the third element:
<pre><code class="hljs">int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;
</code></pre>
The element corresponding to index <code>3</code> is <code>40</code>. To remove this element, we simply &quot;shift&quot; all elements after it. This means that we're going to iterate through all the elements after <code>40</code> and simply &quot;move&quot; them one place to the left.
Since it's not possible to just move an element, we copy its value instead. Subsequent copies will overwrite original values and the result will be as if the entire right part of the array was shifted leftward by one:
<pre><code class="hljs">for (int i = index; i &lt; array.length - 1; i++) {
 array[i] = array[i + 1];
}
</code></pre>
If we went and printed the modified array, this would be the result:
<pre><code class="hljs">10, 20, 30, 50, 60, 70, 80, 90, 100, 100
</code></pre>
Arrays are of fixed length. The last element, <code>100</code>, is duplicated because of this. Using a single array, it's impossible to remove an element without filling the new gap with some value.
You could override it with a dummy value, such as <code>-1</code>, but this solution isn't very valid. This is eliminated by <a href="#using-two-arrays">Using Two Arrays</a>.
<h2 id="systemarraycopy">System.arraycopy</h2>
A shorthand way of doing the exact same thing as before but in a single line of code is with the <code>System.arraycopy()</code> method:
<pre><code class="hljs">public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
</code></pre>
The method accepts a source array and the position from which to start copying. It also accepts a destination array and the position into which to start copying. The final argument is the number of elements to copy from the source array.
The <code>arraycopy</code> is generally used to copy contents from some source array into some destination array. Though, we can also copy an array, or a part of it, into itself. This allows us to shift a part of it to the left like last time:
<pre><code class="hljs">int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;
</code></pre>
To remove the element, we only need to write this one line of code:
<pre><code class="hljs">System.arraycopy(array, index + 1, array, index, array.length - index - 1);
</code></pre>
The method will copy all elements from the source array (<code>array</code>) starting one position right of the <code>index</code>. The elements will be copied into the same array (<code>array</code>) starting exactly at <code>index</code>. The result will be a perceived shifting of all elements right of the element we wanted to remove.
If we printed the result, we would still see the element <code>100</code> being duplicated for the same reason as in the previous section.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we showed a few ways of removing array elements. Some are quick and dirty, whereas some require additional overhead such as using additional libraries. It's always best to think about these things beforehand to get the idea of what kind of approach is right for any given situation.
The list of techniques shown in this tutorial is by no means exhaustive. There are plenty of ways to get creative in programming so we're sure you can find some other interesting approaches to remove elements from arrays.

Luka Čupić

In this tutorial, we'll showcase examples of how to remove an element from an array in Java using two arrays, ArrayUtils.remove(), a for loop and System.arraycopy().

Remove Element from an Array in Java

<h2 id="introduction">Introduction</h2>
JavaScript is a dynamically typed language, meaning that the interpreter determines the type of the variable at runtime. In practice, this allows us to use the same variable to store different types of data in the same code. It also means that without documentation and consistency, we do not always know the type of a variable in our code when we use it.
Operating on a string or array when we expect a number can bring strange results in our code. In this article, we'll look at various functions that can help determine if a variable we are using is a number.
Strings that contain numbers like &quot;10&quot; should not be accepted. In JavaScript, special values like <code>NaN</code>, <code>Infinity</code> and <code>-Infinity</code> are numbers too - though, we'll be ignoring those values.
With these requirements, the best function to use is the <a href="#usingthenumberisfinitefunction"><code>isFinite()</code></a> function from the built-in <code>Number</code> object.
However, developers have commonly used other functions for this purpose, particularly <code>Number.isNaN()</code> and the <code>typeof()</code> function.
Let's create a few variables for testing:
<pre><code class="hljs">let intVar = 2;
let floatVar = 10.5;
let stringVar = &#x27;4&#x27;;
let nanVar = NaN;
let infinityVar = Infinity;
let nullVar = null;
let undefinedVar = undefined;
</code></pre>
<h2 id="usingthenumberisfinitefunction">Using the Number.isFinite() function</h2>
The <code>Number.isFinite()</code> function checks if the variable is a number, but also checks if it's a finite value. Therefore, it returns <code>false</code> on numbers that are <code>NaN</code>, <code>Infinity</code> or <code>-Infinity</code>.
Let's test it out on the variables we've defined above:
<pre><code class="hljs">&gt; Number.isFinite(intVar);
true
&gt; Number.isFinite(floatVar);
true
&gt; Number.isFinite(stringVar);
false
&gt; Number.isFinite(nanVar);
false
&gt; Number.isFinite(infinityVar);
false
&gt; Number.isFinite(nullVar);
false
&gt; Number.isFinite(undefined);
false
</code></pre>
It's exactly what we wanted. The special non-finite numbers are ignored, as well as any variable that isn't a number type.
If you'd like to check if a variable is a number, your best bet is to use the <code>Number.isFinite()</code> function.
<h2 id="usingthenumberisnanfunction">Using the Number.isNaN() Function</h2>
The standard <code>Number</code> object has an <code>isNaN()</code> method. It takes one argument, and determines if its value is <code>NaN</code>. Since we want to check if a variable is a number, we will use the not operator, <code>!</code>, in our checks.
Now let's check if the not operator and <code>Number.isNaN()</code> function can filter only numbers:
<pre><code class="hljs">&gt; !Number.isNaN(intVar);
true
&gt; !Number.isNaN(floatVar);
true
&gt; !Number.isNaN(stringVar);
true # Wrong
&gt; !Number.isNaN(nanVar);
false
&gt; !Number.isNaN(infinityVar);
true # Wrong
&gt; !Number.isNaN(nullVar);
true # Wrong
&gt; !Number.isNaN(undefinedVar);
true # Wrong
</code></pre>
This method is a fairly permissive as it accepts values that are not numbers at all. This method is best suited for when you know you have a number and would to check if it is a <code>NaN</code> value, not for general number checking.
<h2 id="usingthetypeoffunction">Using the typeof() function</h2>
The <code>typeof()</code> function is a global function that accepts a variable or value as an argument and returns a string representation of its type. JavaScript has 9 types in total:
<ul>
<li><code>undefined</code></li>
<li><code>boolean</code></li>
<li><code>number</code></li>
<li><code>string</code></li>
<li><code>bigint</code></li>
<li><code>symbol</code></li>
<li><code>object</code></li>
<li><code>null</code> (<code>typeof()</code> shows as object)</li>
<li><code>function</code> (a special type of object)</li>
</ul>
To verify if a variable is a number, we simply we need to check if the value returned by <code>typeof()</code> is <code>&quot;number&quot;</code>. Let's try it out on test variables:
<pre><code class="hljs">&gt; typeof(intVar) == &#x27;number&#x27;;
true
&gt; typeof(floatVar) == &#x27;number&#x27;;
true
&gt; typeof(stringVar) == &#x27;number&#x27;;
false
&gt; typeof(nanVar) == &#x27;number&#x27;;
true # Wrong
&gt; typeof(infinityVar) == &#x27;number&#x27;;
true # Wrong
&gt; typeof(nullVar) == &#x27;number&#x27;;
false
&gt; typeof(undefined) == &#x27;number&#x27;;
false
</code></pre>
The <code>typeof()</code> function performs much better than <code>Number.isNaN()</code>. It correctly determines that a string variable, <code>null</code> and <code>undefined</code> are not numbers. However, it returns true for <code>NaN</code> and <code>Infinity</code>.
While that is the technically correct result, <code>NaN</code> and <code>Infinity</code> are special number values, for most use cases we would prefer to ignore them.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned how to check if a variable in JavaScript is a number. The <code>Number.isNaN()</code> function is only suitable if we know our variable is a number and need to verify if it specifically <code>NaN</code> or otherwise.
The <code>typeof()</code> function is suitable if your code can work with <code>NaN</code>, <code>Infinity</code> or <code>-Infinity</code> as well as other numbers.
The <code>Number.isFinite()</code> method captures all the finite numbers and was most appropriate for our requirements.

Marcus Sanatan

In this tutorial, we'll be covering how to check if a variable is a number in JavaScript. We'll use the isNan(), typeOf() and isFinite() functions to do that.

JavaScript: Check if Variable is a Number

<h2 id="introduction">Introduction</h2>
Python's built-in sequence representation is a list, defined as a heterogeneous sequence of elements, where each element has a definitive index in the sequence.

 <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: Heterogeneous sequence means that one list can contain elements of different types.

 </div>
 </div>
 </div>
 To use arrays, you'd have to import the <code>array</code> module, which does ship with Python itself, but lists are far more commonly used.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: To learn more about lists in Python, read our <a target="_blank" href="https://stackabuse.com/guide-to-lists-in-python/">&quot;Guide to Lists in Python&quot;</a>

 </div>
 </div>
 </div>
 Additionally - since the list syntax looks a lot like the syntax you'd use to define arrays in other programming languages - the terms &quot;array&quot; and &quot;list&quot; are oftentimes used interchangeably, even though they're not the same data structure.

 <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: It's worth noting that many of these methods work both for an array and a list!

 </div>
 </div>
 </div>
 <blockquote>
In this article, we'll go through some common ways for removing elements from Python arrays/lists.
</blockquote>
<h2 id="approach1usingremovemethod">Approach #1 - Using remove() Method</h2>
We can use the <code>remove()</code> method on any array or list in Python. To use it, we can simply pass the value of the element we want to remove. Let's imagine we have the following array:
<pre><code class="hljs">array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
</code></pre>
To remove, say, element <code>40</code>, we would simply write:
<pre><code class="hljs">array.remove(40)
</code></pre>
The result is the same array without the value <code>40</code>:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
<h2 id="approach2usingpopmethod">Approach #2 - Using pop() Method</h2>
Another way we can remove elements from list/array in Python is by using the <code>pop()</code> method. It accepts the index of the element we want to remove. If we had the same array/list as before (with values from 10 to 100), we could write something like the following:
<pre><code class="hljs">index = 3
array.pop(index)
</code></pre>
If we printed the result of the <code>pop()</code> method, it would be the value <code>40</code>:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
Similarly to how <code>pop()</code> works in the stack data structure, here <code>pop()</code> also returns the value that it had just removed.

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: To learn more about stacks in Python, read our article <a target="_blank" href="https://stackabuse.com/stacks-and-queues-in-python/">&quot;Stacks and Queues in Python&quot;</a>

 </div>
 </div>
 </div>
 The only difference is that with arrays, we can remove an arbitrary element. With stacks, only the top element (i.e. the last one added) can ever be removed.
<h2 id="approach3usingdelkeyword">Approach #3 - Using del Keyword</h2>
<code>del</code> is a Python keyword used for deleting objects. Its exact behavior changes depending on the context, so we can also use it to remove list elements.

 <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">
 Important: Arrays don't support the <code>del</code> keyword!

 </div>
 </div>
 </div>
 Once again, let's take the same array and index as before:
<pre><code class="hljs">array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
index = 3
</code></pre>
To remove the element at index <code>3</code>, we simply type the following:
<pre><code class="hljs">del array[index]
</code></pre>
If we now printed the contents of our array, we would get the following output:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
<h2 id="approach4usingnumpyarrays">Approach #4 - Using numpy Arrays</h2>
NumPy arrays are commonly used (especially in machine learning), so let's show one of the ways to remove an element from a <code>numpy</code> array. Before using <code>numpy</code>, it is necessary to import it:
<pre><code class="hljs">import numpy as np
</code></pre>
To create a <code>numpy</code> array, we can wrap our current list using <code>np.array()</code> as such:
<pre><code class="hljs">a = np.array(array)
</code></pre>
Alternatively, we could also declare a new array inside the method call itself:
<pre><code class="hljs">a = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
</code></pre>
Now to remove an element at index <code>3</code>, we use the following code:
<pre><code class="hljs">index = 3
a = np.delete(a, index)
</code></pre>
<code>delete()</code> is a static method declared in the <code>numpy</code> module. It accepts the array and the index of the element to remove.
The method returns a new array without the removed element:
<pre><code class="hljs">[10, 20, 30, 50, 60, 70, 80, 90, 100]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
There are different ways to remove a list element in Python. Sometimes we might want to remove an element by index and sometimes by value. Sometimes we're using Python's default array and sometimes a <code>numpy</code> array.
In all these cases, it's good to have multiple options to help us decide which of the techniques to use.

Dimitrije Stamenic

In this tutorial, we'll showcase examples of how to remove an element from an array in Python using remove(), pop(), the del keyword, and Numpy.

Remove Element from an Array in Python

How to Remove Elements from an Array/List in Python

Olivera Popović

In this article, we'll explain what Pandas DataFrames are and how they store information. Then, we'll create them manually and from files as well as manipulate the data stored inside of them.

Creating and Manipulating DataFrames in Python with Pandas

Python with Pandas: DataFrame Tutorial with Examples

<h2 id="introduction">Introduction</h2>
Java provides an extensive API for handling date and time. In this article, we'll use Java's DateTimeFormatter to format dates - <code>LocalDate</code>, <code>LocalDatetime</code>, <code>LocalTime</code> and <code>ZonedDateTime</code>.
Before formatting dates, you'll have to know <a target="_blank" href="/how-to-get-current-date-and-time-in-java">How to Get the Current Date and Time in Java</a>.
<h2 id="formatspecifiers">Format Specifiers</h2>
Date and time format specifiers are used for constructing patterns to represent data in a format we'd like to present it in.
In the real world, some date or time components are often represented in more than one way. When it comes to time and date format specifiers in Java, those components have two or more representations too - sometimes it is handy to use a short version, while longer versions are more concise and official.
<h2 id="datetimeformatter">DateTimeFormatter</h2>
Java 8 overhauled the Date/Time API with thread-safe classes that replaced the old and clunky <code>Date</code> and <code>Calendar</code> classes.
This also introduced us to the <code>DateTimeFormatter</code> class, as opposed to the <code>SimpleDateFormat</code> from the old API.
It's worth noting that <code>LocalDate</code> and <code>LocalTime</code> store information about only dates and times respectively, while a <code>LocalDateTime</code> holds information about both the date and time in a single object.
There are two ways of instantiating a <code>DateTimeFormatter</code>:
Writing a pattern:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter
 .ofPattern(&quot;EEE, MMM dd. yyyy.&quot;);
</code></pre>
Using a formatter:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
</code></pre>
Using a static method:
1. DateTimeFormatter.ofLocalizedDate(FormatStyle dateStyle) 
2. DateTimeFormatter.ofLocalizedTime(FormatStyle timeStyle) 
3. DateTimeFormatter.ofLocalizedDateTime(FormatStyle datetimeStyle) 
4. DateTimeFormatter.ofLocalizedDateTime(FormatStyle dateStyle, FormatStyle timeStyle)
For example, we could set up a <code>DateTimeFormatter</code> with:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter
 .ofLocalizedTime(FormatStyle.SHORT);
</code></pre>
Note that each one of them has a mandatory argument. <code>FormatStyle</code> is a built-in enum that provides a few values - <code>FULL</code>, <code>LONG</code>, <code>MEDIUM</code> and <code>SHORT</code>.
How the available enum patterns look when applied to a <code>ZonedDateTime</code> object is shown in the following table:
<table class="table table-striped" style="font-size:15px;">
<tr>
 <th> FormatStyle </th>
 <th> Description </th>
 <th> Date style </th>
 <th> Time style </th>
 <th> Date and time style </th>
</tr>
<tr>
 <th> FULL </th>
 <td> Highly detailed </td>
 <td> Thursday, August 13, 2020 </td>
 <td> 12:43:00 AM Central European Summer Time </td>
 <td> Thursday, August 13, 2020 at 12:43:48 AM Central European Summer Time </td>
</tr>
<tr>
 <th> LONG </th>
 <td> Contains most of the details </td>
 <td> August 13, 2020 </td>
 <td> 12:45:27 AM CEST </td>
 <td> August 13, 2020 at 12:44:40 AM CEST </td>
</tr>
<tr>
 <th> MEDIUM </th>
 <td> Some details included </td>
 <td> Aug 13, 2020 </td>
 <td> 12:45:49 AM </td>
 <td> Aug 13, 2020, 12:46:29 AM </td>
</tr>
<tr>
 <th> SHORT </th>
 <td> Typically numeric and shortest possible </td>
 <td> 8/13/20 </td>
 <td> 12:47 AM </td>
 <td> 8/13/20, 12:47 AM </td>
</tr>
</table>
<h3 id="formattinglocaltime">Formatting LocalTime</h3>
In the following code examples, we'll show how to get some of the predefined formatters to do the job for us, as well as making our own. It takes just a few lines of code:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM);
LocalTime time = LocalTime.now();

System.out.println(time.format(formatter));
</code></pre>
The resulting output is:
<pre><code class="hljs">5:17:00 AM
</code></pre>
Yet, we should be careful when using predefined formatters. In this case, we can't use <code>FormatStyle.LONG</code> or <code>FormatStyle.FULL</code>, because they also yield some time zone information which generally is not stored in <code>LocalTime</code> object.
Let's see how it looks when we make our own pattern:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ofPattern(&quot;HH:mm:ss a&quot;);
LocalTime time = LocalTime.now();
System.out.println(time.format(formatter));
</code></pre>
This outputs:
<pre><code class="hljs">10:58:28 AM
</code></pre>
Of course, you're free to fiddle around with the pattern.
<h3 id="formattinglocaldate">Formatting LocalDate</h3>
All the classes supported by <code>DateTimeFormatter</code> have a <code>format(DateTimeFormatter f)</code> method, so the process of applying pattern is fairly simple:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
LocalDate d = LocalDate.now();

System.out.println(d.format(formatter));
</code></pre>
This piece of code yields:
<pre><code class="hljs">Thursday, August 13, 2020
</code></pre>
<h3 id="formattinglocaldatetime">Formatting LocalDateTime</h3>
Formatting a <code>LocalDateTime</code> is done in the same fashion:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG, FormatStyle.MEDIUM);
LocalDateTime dateTime = LocalDateTime.now();

System.out.println(dateTime.format(formatter));
</code></pre>
The resulting output is:
<pre><code class="hljs">August 13, 2020, 5:29:28 AM
</code></pre>
Custom patterns are created in the similar matter:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter
 .ofPattern(&quot;eee, MMM dd. yyyy.\nHH:mm:ss a&quot;);
LocalDateTime dt = LocalDateTime.now();
System.out.println(dt.format(formatter));
</code></pre>
This piece of code yields:
<pre><code class="hljs">Tue, Aug 25. 2020.
11:05:20 AM
</code></pre>
<h3 id="formattingzoneddatetime">Formatting ZonedDateTime</h3>
This time we can casually use the predefined formatter for full output:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);
ZonedDateTime dateTime = ZonedDateTime.now();

System.out.println(dateTime.format(formatter));
</code></pre>
This piece of code outputs:
<pre><code class="hljs">Thursday, August 13, 2020 at 5:32:49 AM Central European Summer Time
</code></pre>
When it comes to creating our own patterns for <code>ZonedDateTime</code>, we have all the freedom to use whichever specifier we'd like:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter
 .ofPattern(&quot;eee, MMM dd. yyyy.\nHH:mm:ss a - zzzz&quot;);
ZonedDateTime dateTime = ZonedDateTime.now();
System.out.println(dateTime.format(formatter));
</code></pre>
This outputs:
<pre><code class="hljs">Tue, Aug 25. 2020.
11:09:27 AM - Central European Summer Time
</code></pre>
<h3 id="formattingrules">Formatting rules</h3>
Format specifiers for <code>DateTimeFormatter</code> slightly differ from the ones for <code>SimpleDateFormat</code>. If you're used to working with <code>SimpleDateFormat</code>, you'll have to adjust some habits by a tiny bit:
<table class="table table-striped" style="white-space:nowrap; font-size:15px;">
 <tr>
 <th> Character </th>
 <th> Date or time component </th>
 <th> Content type </th>
 <th> Example </th>
 </tr>
 <tr>
 <th> Y/y </th>
 <td> Year </td>
 <td> Year </td>
 <td> 1969;69 </td>
 </tr>
 <tr>
 <th> M </th>
 <td> Month in year </td>
 <td> Number/Text </td>
 <td> August;Aug;08 </td>
 </tr>
 <tr>
 <th> w </th>
 <td> Week in year </td>
 <td> Number </td>
 <td> 21 </td>
 </tr>
 <tr>
 <th> W </th>
 <td> Week in month </td>
 <td> Number </td>
 <td> 2 </td>
 </tr>
 <tr>
 <th> d </th>
 <td> Day in month </td>
 <td> Number </td>
 <td> 07;15 </td>
 </tr>
 <tr>
 <th> D </th>
 <td> Day in year </td>
 <td> Number </td>
 <td> 176 </td>
 </tr>
 <tr>
 <th> Q/q </th>
 <td> Quarter of the year </td>
 <td> Number/Text </td>
 <td> 2:Q2:2nd quarter </td>
 </tr>
 <tr>
 <th> F </th>
 <td> Day of week in month (e.g. second Tuesday this month) </td>
 <td> Number </td>
 <td> 2;3 </td>
 </tr>
 <tr>
 <th> E </th>
 <td> Day name in week </td>
 <td> Text </td>
 <td> Monday;Mon;M </td>
 </tr>
 <tr>
 <th> e/c </th>
 <td> Localized day in week </td>
 <td> Number/Text </td>
 <td> Monday;Mon;M;1;01 </td>
 </tr>
 <tr>
 <th> u </th>
 <td> Day number of week (Monday = 1) </td>
 <td> Number </td>
 <td> 1 </td>
 </tr>
 <tr>
 <th> a </th>
 <td> Am/pm marker </td>
 <td> Text </td>
 <td> PM;AM </td>
 </tr>
 <tr>
 <th> h </th>
 <td> Hour in am/pm (1-12) </td>
 <td> Number </td>
 <td> 12 </td>
 </tr>
 <tr>
 <th> H </th>
 <td> Hour in day (0-23) </td>
 <td> Number </td>
 <td> 0 </td>
 </tr>
 <tr>
 <th> k </th>
 <td> Hour in day (1-24) </td>
 <td> Number </td>
 <td> 24 </td>
 </tr>
 <tr>
 <th> K </th>
 <td> Hour in am/pm (0-11) </td>
 <td> Number </td>
 <td> 0 </td>
 </tr>
 <tr>
 <th> m </th>
 <td> Minute in hour </td>
 <td> Number </td>
 <td> 43 </td>
 </tr>
 <tr>
 <th> s </th>
 <td> Second in minute </td>
 <td> Number </td>
 <td> 58 </td>
 </tr>
 <tr>
 <th> S </th>
 <td> Fraction of second </td>
 <td> Fraction </td>
 <td> 965 </td>
 </tr>
 <tr>
 <th> A </th>
 <td> Mili of the day </td>
 <td> Number </td>
 <td> 1234 </td>
 </tr>
 <tr>
 <th> n </th>
 <td> Nano of second </td>
 <td> Number </td>
 <td> 566787434 </td>
 </tr>
 <tr>
 <th> N </th>
 <td> Nano of day </td>
 <td> Number </td>
 <td> 56678743400 </td>
 </tr>
 <tr>
 <th> z </th>
 <td> Time zone name </td>
 <td> Zone name </td>
 <td> Pacific Standard Time; PST</td>
 </tr>
 <tr>
 <th> V </th>
 <td> Time zone ID </td>
 <td> Zone ID </td>
 <td> America/Los_Angeles; Z; -08:30 </td>
 </tr>
 <tr>
 <th> v </th>
 <td> Time zone name </td>
 <td> Zone name </td>
 <td> Pacific Time; PT0 </td>
 </tr>
 <tr>
 <th> G </th>
 <td> Era designator </td>
 <td> Text </td>
 <td> AD;Anno Domini;A </td>
 </tr>
</table>
<ul>
<li>Text - If less than 4 pattern characters are used, component is presented in the short form. Exactly 4 pattern characters will use full form, and exactly 5 will use the narrow form.</li>
<li>Number - The number of pattern characters is the minimum number of digits. If that number is bigger than the number of digits we actually need to represent a number, then the number is prefixed with corresponding amount of zeros. <code>c</code> and <code>F</code> can only have one occurence, while <code>d</code>, <code>H</code>, <code>h</code>, <code>K</code>, <code>k</code>, <code>m</code> and <code>s</code> can have two occurences. Only <code>D</code> can be used up to three times.</li>
<li>Number/Text - If 3 or more pattern characters are used, the component is presented in textual form; otherwise in number.</li>
<li>Fraction - Possible character count is between 1 and 9. If less than 9 of them is stated, value is truncated with only the most significant digits being output.</li>
<li>Year - If the number of pattern characters is 2, the year is truncated to 2 rightmost digits, otherwise it is interpreted as a number.</li>
<li>Zone ID - If 2 pattern characters are used, zone ID is output; otherwise the exception is thrown.</li>
<li>Zone name - If the pattern character is <code>z</code> the output is the daylight savings aware zone name. If there is insufficient information to determine whether DST applies, the name ignoring Daylight Savings time will be used. If the count of characters is 1, 2 or 3, then the short name is output; if 4 the full name is output. Five or more characters throw an exception. As for the character <code>v</code>, DST is ignored. If 1 pattern character is used, then the short name is output; if 4 are used, the output is full name. Any other number of characters throw an exception.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this article, we've showcased how to format a <code>LocalDate</code>, <code>LocalTime</code>, <code>LocalDateTime</code> and <code>ZonedDateTime</code> using Java's <code>DateTimeFormatter</code> class.

Mina Krivokuća

In this tutorial, we'll format a LocalDate, LocalTime, LocalDateTime and ZonedDateTime object in Java using DateTimeFormatter with examples, using both patterns and StyleFormat enums.

Java: Format Dates with DateTimeFormatter

<h2 id="introduction">Introduction</h2>
Java provides an extensive API for handling date and time. In this article we'll use Java's SimpleDateFormat to format dates.
Before formatting dates, you'll have to know <a target="_blank" href="/how-to-get-current-date-and-time-in-java">How to Get the Current Date and Time in Java</a>.
<h2 id="formatspecifiers">Format Specifiers</h2>
Date and time format specifiers are used for constructing patterns to represent data in a format we'd like to present it in.
In the real world, some date or time components are often represented in more than one way. When it comes to time and date format specifiers in Java, those components have two or more representations too - sometimes it is handy to use a short version, while longer versions are more concise and official.
<h2 id="simpledateformat">SimpleDateFormat</h2>
<code>SimpleDateFormat</code> only works with <code>Date</code> objects and . In Java 8, several other classes are added to replace the existing date and time API, so it is not unusual to stumble upon deprecated constructors and methods when handling <code>Date</code> objects.
Creating a <code>SimpleDateFormat</code> object is fairly easy. The constructor accepts a string pattern:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;EEE, MMM dd. yyyy.&quot;);
</code></pre>
It is worth mentioning that if we call the constructor with no arguments, a formatter object will be made with default pattern of:
<pre><code class="hljs">MM/dd/yy, H:mm aa
</code></pre>
If we change our mind about the pattern later, we can always apply another one to an object that we have previously created, and the old one will be overridden:
<pre><code class="hljs">formatter.applyPattern(&quot;&#x27;date&#x27;: yyyy.MM.dd -- &#x27;time&#x27;: H:mm:ss&quot;);
</code></pre>
Note: In this pattern, we wanted some words to be interpreted literally - so we escaped them with single quotes.
For brevity's sake, we've put the <a href="#formattingrules">Formatting Rules</a> at the end of the article if you're not familiar with them.
<h3 id="formattingsystemcurrenttimemillis">Formatting System.currentTimeMillis()</h3>
Formatting the number of milliseconds passed since the UNIX epoch, namely January 1, 1970, 00:00:00 GMT, is fairly simple:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;EEE, MMM dd. yyyy. -- H:mm aa&quot;);

String formatted = formatter.format(System.currentTimeMillis());
System.out.println(formatted);
</code></pre>
Running this piece of code yields:
<pre><code class="hljs">Tue, Aug 11. 2020. -- 4:48 AM
</code></pre>
Internally, the <code>long</code> value is converted into a <code>Date</code>.
<h3 id="formattingjavautildate">Formatting java.util.Date</h3>
Formatting a <code>Date</code> is essentially the same, though, we supply a <code>Date</code> instance ourselves:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;EEE, MMM dd. yyyy. -- H:mm aa&quot;);

Date date = new Date();
String formatted = formatter.format(date);
System.out.println(formatted);
</code></pre>
The resulting output is:
<pre><code class="hljs">Tue, Aug 11. 2020. -- 4:52 AM
</code></pre>
<h3 id="formattingjavautilcalendar">Formatting java.util.Calendar</h3>
Using a <code>Calendar</code> makes it easier to customize and play around with custom dates. If some important timestamp requires an emphasis, it's easy to do with a <code>Calendar</code>:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;EEE, MMM dd. yyyy. -- H:mm aa&quot;);

Calendar calendar = Calendar.getInstance();
calendar.set(1969, Calendar.AUGUST, 15, 17, 35, 27);

# SimpleDateFormat works with Dates
Date date = calendar.getTime();

String formatted = formatter.format(date);
System.out.println(formatted);
</code></pre>
The resulting output is:
<pre><code class="hljs">Fri, Aug 15. 1969. -- 17:35 PM
</code></pre>
<h3 id="formattingrules">Formatting Rules</h3>
For clarity's sake, if you're not already familiar with the formatting rules/patterns used in the article, here's a list of the most notably used format specifiers:
<table class="table table-striped" style="white-space:nowrap; font-size:15px;">
 <tr>
 <th> Character </th>
 <th> Date or time component </th>
 <th> Content type </th>
 <th> Example </th>
 </tr> 
 <tr>
 <th> Y/y </th>
 <td> Year </td>
 <td> Year </td>
 <td> 1969;69 </td>
 </tr> 
 <tr>
 <th> M </th>
 <td> Month in year </td>
 <td> Month </td>
 <td> August;Aug;08 </td>
 </tr> 
 <tr>
 <th> w </th>
 <td> Week in year </td>
 <td> Number </td>
 <td> 21 </td>
 </tr>
 <tr>
 <th> W </th>
 <td> Week in month </td>
 <td> Number </td>
 <td> 2 </td>
 </tr> 
 <tr>
 <th> d </th>
 <td> Day in month </td>
 <td> Number </td>
 <td> 07;15 </td>
 </tr> 
 <tr>
 <th> D </th>
 <td> Day in year </td>
 <td> Number </td>
 <td> 176 </td>
 </tr>
 <tr>
 <th> F </th>
 <td> Day of week in month (e.g. second Tuesday this month) </td>
 <td> Number </td>
 <td> 2;3 </td>
 </tr>
<tr>
 <th> E </th>
 <td> Day name in week </td>
 <td> Text </td>
 <td> Monday;Mon </td>
 </tr>
<tr>
 <th> u </th>
 <td> Day number of week (Monday = 1)</td>
 <td> Number </td>
 <td> 1 </td>
 </tr>
<tr>
 <th> a </th>
 <td> Am/pm marker </td>
 <td> Text </td>
 <td> PM;AM </td>
 </tr>
<tr>
 <th> h </th>
 <td> Hour in am/pm (1-12) </td>
 <td> Number </td>
 <td> 12 </td>
 </tr>
<tr>
 <th> H </th>
 <td> Hour in day (0-23) </td>
 <td> Number </td>
 <td> 0 </td>
 </tr>
<tr>
 <th> k </th>
 <td> Hour in day (1-24) </td>
 <td> Number </td>
 <td> 24 </td>
 </tr>
<tr>
 <th> K </th>
 <td> Hour in am/pm (0-11) </td>
 <td> Number </td>
 <td> 0 </td>
 </tr>
<tr>
 <th> m </th>
 <td> Minute in hour </td>
 <td> Number </td>
 <td> 43 </td>
 </tr>
<tr>
 <th> s </th>
 <td> Second in minute </td>
 <td> Number </td>
 <td> 58 </td>
 </tr>
<tr>
 <th> S </th>
 <td> Milisecond in second </td>
 <td> Number </td>
 <td> 965 </td>
 </tr>
<tr>
 <th> z </th>
 <td> Time zone </td>
 <td> Time zone </td>
 <td> CEST;GMT-08:00 </td>
 </tr>
<tr>
 <th> G </th>
 <td> Era designator </td>
 <td> Text </td>
 <td> AD </td>
 </tr>
</table>
Each content type follows certain rules, mainly regarding the number of pattern characters used in the formatter pattern:
<ul>
<li>Year - If the formatter's <code>Calendar</code> is Gregorian and the number of pattern characters is 2, the year is truncated to 2 rightmost digits, otherwise it is interpreted as a number. In other calendars, calendar specific forms are applied.</li>
<li>Month - If the number of pattern characters is 3 or more, the month is shown as text; otherwise it's shown as a number. There are short and full textual forms available - if the number of pattern characters is 4 or more, the full form is shown; otherwise the short one is shown.</li>
<li>Number - The number of pattern characters is the minimum number of digits. If that number is bigger than the number of digits we actually need to represent a number, then the number is prefixed with the corresponding amount of zeros.</li>
<li>Text - If the number of pattern characters is 4 or more, the full form is used; otherwise a short or abbreviated form is used, if available.</li>
<li>Time zone - They are shown as text if they have names. There are short and full forms available - if the number of pattern characters is 4 or more, the full form is shown; otherwise the short one is shown. Some time zones do not have names, and they can be shown in various different forms of which one is e.g. the GMT offset value.</li>
</ul>
Here are some examples of patterns and the results they produce:
<table class="table table-striped" style="white-space:nowrap; font-size:15px;">
 <tr>
 <th> Date and time pattern </th>
 <th> Result </th>
 </tr>
 <tr>
 <td> "EEEE, MMM dd. yyyy. -- H:mm aa zzzz" </td>
 <td> Friday, Aug 15. 1969. -- 17:35 PM Central European Standard Time </td>
 </tr>
<tr>
 <td> "EEE, MMM dd. yyyy. -- H:mm aa zz" </td>
 <td> Fri, Aug 15. 1969. -- 17:35 PM CET </td>
 </tr>
<tr>
 <td> "MMMM yyyy. GGGG" </td>
 <td> September 0200. AD </td>
 </tr>
<tr>
 <td> "MMM yyy. GG" </td>
 <td> Sep 200. AD </td>
 </tr>
<tr>
 <td> "MM-dd-yyyy HH:mm:ss:SSSS" </td>
 <td> 09-15-2020 17:35:27:0953 </td>
 </tr>
</table>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered the <code>SimpleDateFormat</code> class and how we can use it to format dates.
We've formatted the current time (in milliseconds) since the start of UNIX time, a regular <code>Date</code> object and a <code>Calendar</code> object.
Finally, we've covered the formatting specifiers and formatting rules applied to the <code>SimpleDateFormat</code> results.

In this article, we'll use Java's SimpleDateFormat class with examples to show how to format a Date and Calendar in Java.

Java: Format Dates with SimpleDateFormat

<h2 id="introduction">Introduction</h2>
Variables are named memory locations. Their values are saved in memory, which we can't typically remember as they're not human-friendly and shift around. Though, if we name the memory location, such as <code>a</code>, it's a lot easier to remember.
Environment variables are a lot like usual programming variables, except that they're set somewhere outside the program. That can be used by the operating system, JVM, a microservice our program is using, etc.
More precisely, they're key/value pairs, where the key is what can be thought of as the name of the environment variable and value is, well, value. Their values are always strings.
When people refer to environment variables they usually mean those set by the operating system. You've likely had to deal with <code>PATH</code> and <code>JAVA_HOME</code> in the past - those are environment variables.
Environment variables vary across operating systems and it can sometimes be tough to make portable programs that rely on them, but nothing is making them inherently difficult to work with.
The operating system's environment variables have its analog in the JVM world - <a target="_blank" rel="nofollow noopener" href="https://docs.oracle.com/javase/tutorial/essential/environment/properties.html">Properties</a>. They're beyond the scope of this article, but bear mentioning as they are quite a similar concept at a smaller scale.
<h2 id="queryingenvironmentvariables">Querying Environment Variables</h2>
Your operating system stores its environment variables as key/value pairs. You can use <code>System.getenv()</code> to retrieve those values. If you use it without an argument, you'll get a <code>Map</code> object as the return value:
<pre><code class="hljs">Map&lt;String, String&gt; env = System.getenv();

for(String envName : env.keySet()){
 System.out.println(String.format(&quot;%s : %s&quot;, envName, env.get(envName)));
}
</code></pre>
Here's a truncated view of the results:
<pre><code class="hljs">PROCESSOR_ARCHITECTURE : AMD64
MIC_LD_LIBRARY_PATH : C:\Program Files (x86)\Common Files\Intel\Shared Libraries\compiler\lib\mic
PSModulePath : C:\WINDOWS\system32\WindowsPowerShell\v1.0\Modules\
SystemDrive : C:
AWE_DIR : D:\Awesomium\1.6.6\
FPS_BROWSER_USER_PROFILE_STRING : Default
PATHEXT : .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
DriverData : C:\Windows\System32\Drivers\DriverData
HerokuPath : E:\Heroku
ProgramData : C:\ProgramData
ProgramW6432 : C:\Program Files
</code></pre>
You can also pass it a <code>String</code> corresponding to the variable's name (key) and it will return the respective variable's value as a <code>String</code>:
<pre><code class="hljs">System.out.println(System.getenv(&quot;NUMBER_OF_PROCESSORS&quot;));
</code></pre>
<pre><code class="hljs">8
</code></pre>
<h2 id="processbuilderandenvironment">ProcessBuilder and Environment</h2>
Java has a <code>Process</code> class for dealing with operating system processes. To make it simpler to create a process, there's a <a target="_blank" href="/executing-shell-commands-with-java/#processbuilder">ProcessBuilder</a> class and you can simply &quot;add&quot; commands to its instance to run.
Each process can have its own environment. Your program will have its environment set by the operating system, but programs you start as processes can have a modified &quot;hand-made&quot; environment.
To edit an environment, you have to fetch its reference from your <code>ProcessBuilder</code> object by using the <code>environment()</code> getter. Like with reading environment variables from <code>System</code>, you'll get a <code>Map</code> and can then modify it with usual <code>Map</code> operations.
After creating an environment, we'll create a command. This depends on the operating system. Here, we have a rudimentary check which alters the command adequately:
<pre><code class="hljs">// Setting up the environment...
ProcessBuilder processBuilder = new ProcessBuilder();
Map&lt;String, String&gt; env = processBuilder.environment();
env.put(&quot;PING_WEBSITE&quot;, &quot;stackabuse.com&quot;);

if (System.getProperty(&quot;os.name&quot;).startsWith(&quot;Windows&quot;)) {
 processBuilder.command(&quot;cmd.exe&quot;, &quot;/c&quot;, &quot;ping -n 3 %PING_WEBSITE%&quot;)
} else {
 processBuilder.command(&quot;/bin/bash&quot;, &quot;-c&quot;, &quot;ping $PING_WEBSITE$&quot;);
}

try {
 // Starting the process...
 Process process = processBuilder.start();

 // Reading the output of the process
 try (BufferedReader reader = new BufferedReader(
 new InputStreamReader(process.getInputStream()))) {

 String line;

 while ((line = reader.readLine()) != null) {
 System.out.println(line);
 }
 }

 // Catch the exit code of our process
 int ret = process.waitFor();

 System.out.printf(&quot;Program exited with code: %d&quot;, ret);

} catch (IOException | InterruptedException e) {
 // Handle exception...
 e.printStackTrace();
}
</code></pre>
<pre><code class="hljs">Pinging stackabuse.com [172.67.218.223] with 32 bytes of data:
Reply from 172.67.218.223: bytes=32 time=12ms TTL=57
Reply from 172.67.218.223: bytes=32 time=12ms TTL=57
Reply from 172.67.218.223: bytes=32 time=15ms TTL=57

Ping statistics for 172.67.218.223:
 Packets: Sent = 3, Received = 3, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
 Minimum = 12ms, Maximum = 15ms, Average = 13ms
Program exited with code: 0
Process finished with exit code 0
</code></pre>
We've created a new environment variable called <code>PING_WEBSITE</code> with a fixed value. You could modify this program to set the value of <code>PING_WEBSITE</code> to user input, a command-line argument, or read the value from a file.
If you'd like to read on <a target="_blank" href="/java-command-line-arguments-accessing-and-mapping-data-types/">How to Parse and Map Command-Line Arguments in Java</a> or <a target="_blank" href="/how-to-get-user-input-in-java">How to Get User Input in Java</a>, we've got you covered!
<h2 id="conclusion">Conclusion</h2>
We have introduced the concept of environment variables, explained what they're used for and analogous concepts, as well as their system-dependent nature.
Then, we printed the environment variables using Java's <code>System.getEnv()</code> method, as well as created processes using <code>ProcessBuilder</code> and executed commands that rely on environment variables.

Darinka Zobenica

In this tutorial, we'll manage environment variables using Java with examples of getting environment variable names and keys as well as setting them and running processes.