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

Managing Environment Variables in Java

Leandro Cofre

In this tutorial, we'll set up an H2 database in Node.js and Express and code the CRUD functionality for a REST API.

Integrating H2 with Node.js and Express

<h2 id="introduction">Introduction</h2>
In this article, we are going to take a look at what CORS is, how you can configure CORS with Express, and how to customize the CORS middleware to your needs.
<h2 id="whatiscors">What is CORS</h2>
CORS is shorthand for Cross-Origin Resource Sharing. It is a mechanism to allow or restrict requested resources on a web server depending on where the HTTP request was initiated.
This policy is used to secure a certain web server from access by other websites or domains. For example, only the allowed domains will be able to access hosted files in a server such as a stylesheet, image, or a script.
If you are currently on <code>http://example.com/page1</code> and you are referring an image from <code>http://image.com/myimage.jpg</code> you won't be able to fetch that image unless <code>http://image.com</code> allows cross-origin sharing with <code>http://example.com</code>.
There is an HTTP header called <code>origin</code> in each HTTP request. It defines where the domain request has originated from. We can use header information to restrict or allow resources from our web server to protect them.
<blockquote>
By default requests from any other origins will be restricted by the browser.
</blockquote>
For example, while you are still in the development stage - if you are using a frontend library such as React, your front end application will be served on <code>http://localhost:3000</code>. Meanwhile, your Express server might be running on a different port such as <code>http://localhost:2020</code>.
Because of this, you'll need to allow CORS between those servers.
If you see this common error in your browser console. CORS restrictions could be the issue:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-cors-with-node-js-1.png" alt="chrome cors">
CORS is really useful when you're offering a public API and would like to control the access to certain resources and how people use them.
Also, if you want to use your own API or files on a different web page you can simply configure CORS to allow that, while still blocking others out.
<h2 id="configuringcorswithexpress">Configuring CORS with Express</h2>
Let's start off with a fresh project. We'll make a directory for it, enter it and run <code>npm init</code> with the default settings:
<pre><code class="hljs">$ mkdir myapp
$ cd myapp
$ npm init -y
</code></pre>
Then let's install the required modules. We'll be using <code>express</code> and the <code>cors</code> middleware:
<pre><code class="hljs">$ npm i --save express
$ npm i --save cors
</code></pre>
Then let's start creating an express web application with two routes to demonstrate how CORS works.
We'll make a file, called <code>index.js</code> that acts as a web server, with a couple of request handlers:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const cors = require(&#x27;cors&#x27;);

const app = express();

app.get(&#x27;/&#x27;, (req, res) =&gt; {
 res.json({
 message: &#x27;Hello World&#x27;
 });
});

app.get(&#x27;/:name&#x27;, (req, res) =&gt; {
 let name = req.params.name;

 res.json({
 message: `Hello ${name}`
 });
});

app.listen(2020, () =&gt; {
 console.log(&#x27;server is listening on port 2020&#x27;);
});
</code></pre>
Let's run the app and the server:
<pre><code class="hljs">$ node index.js
</code></pre>
Now, if you go to <code>http://localhost:2020/</code> - the server should return a JSON message:
<pre><code class="hljs">{
 &quot;message&quot;: &quot;Hello World&quot;
}
</code></pre>
Alternatively, if you go to <code>http://localhost:2020/something</code> you should see:
<pre><code class="hljs">{
 &quot;message&quot;: &quot;Hello something&quot;
}
</code></pre>
<h2 id="enableallcorsrequests">Enable All CORS Requests</h2>
If you want to enable CORS for all the request you can simply use the <code>cors</code> middleware before configuring your routes:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const cors = require(&#x27;cors&#x27;);

const app = express();

app.use(cors())

......
</code></pre>
This will allow all the routes to be accessed anywhere on the web if that is what you need. So in our example, both routes will be accessible for every domain.
For example, if our server is running on <code>http://www.example.com</code> and serves content such as images - we allow other domains, such as <code>http://www.differentdomain.com</code> to refer the content from <code>http://www.example.com</code>.
Thus, a web page on <code>http://www.differentdomain.com</code> can use our domain as a source for an image:
<pre><code class="hljs">&lt;img src=&quot;http://www.example.com/img/cat.jpg&quot;&gt;
</code></pre>
<h2 id="enablecorsforasingleroute">Enable CORS for a Single Route</h2>
But if you need a certain route to be accessible and not other routes, you can configure <code>cors</code> in a certain route as a middleware instead of configuring it to the whole app:
<pre><code class="hljs">app.get(&#x27;/&#x27;, cors(), (req, res) =&gt; {
 res.json({
 message: &#x27;Hello World&#x27;
 });
});
</code></pre>
This will allow a certain route to be accessible by any domain. So in your case, only the <code>/</code> route will be accessible for every domain. The <code>/:name</code> route will be only accessible for the requests that are initiated in the same domain as the API which is <code>http://localhost:2020</code> in our case.
For example, if you try to send a fetch request to the <code>/</code> path from a different origin - it will be successful and you will get the <code>Hello World</code> message as the response:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020/&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));
</code></pre>
You should see the response from the server is successfully logged into the console if you run this code:
<pre><code class="hljs">{
 message: &#x27;Hello World&#x27;
}
</code></pre>
But if you try to access any other path other than the root path such as <code>http://localhost:2020/name</code> or <code>http://localhost:2020/img/cat.png</code> this request will be blocked by the browser:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020/name/janith&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));
</code></pre>
You should see the following error if you try to run this code in a different web app:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-cors-with-node-js-2.png" alt="console error">
<h2 id="configurecorswithoptions">Configure CORS with Options</h2>
You can also use the configuration options with CORS to customize this further. You can use configuration to allow a single domain or subdomain access, configure HTTP methods that are allowed such as <code>GET</code> and <code>POST</code> depending on your requirements.
Here is how you can allow a single domain access using CORS options:
<pre><code class="hljs">var corsOptions = {
 origin: &#x27;http://localhost:8080&#x27;,
 optionsSuccessStatus: 200 // For legacy browser support
}

app.use(cors(corsOptions));
</code></pre>
If you configure the domain name in the origin - the server will allow CORS from the configured domain. So the API will be accessible from <code>http://localhost:8080</code> in our case and blocked for other domains.
If we send a <code>GET</code> request, accessing any path should work, since the options are applied at app-level, not at function-level.
So, if we run the following code and send a request from <code>http://localhost:8080</code> to <code>http://localhost:2020</code>:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020/&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));

// Or

fetch(&#x27;http://localhost:2020/name/janith&#x27;)
 .then(response =&gt; response.json())
 .then(data =&gt; console.log(data))
 .catch(err =&gt; console.error(err));
</code></pre>
We're allowed to fetch the information from that application and domain.
You can also configure allowed HTTP methods if you'd like:
<pre><code class="hljs">var corsOptions = {
 origin: &#x27;http://localhost:8080&#x27;,
 optionsSuccessStatus: 200 // For legacy browser support
 methods: &quot;GET, PUT&quot;
}

app.use(cors(corsOptions));
</code></pre>
If we send a <code>POST</code> request from <code>http://localhost:8080</code>, it'll be blocked by the browser as only <code>GET</code> and <code>PUT</code> are supported:
<pre><code class="hljs">fetch(&#x27;http://localhost:2020&#x27;, {
 method: &#x27;POST&#x27;,
 body: JSON.stringify({name: &quot;janith&quot;}),
})
.then(response =&gt; response.json())
.then(data =&gt; console.log(data))
.catch(err =&gt; console.error(err));
</code></pre>
To see a full list of configuration options, please refer the <a rel="nofollow noopener" target="_blank" href="<https://www.npmjs.com/package/cors#configuration-options>">official documentation</a>.
<h2 id="configuringdynamiccorsoriginsusingafunction">Configuring Dynamic CORS Origins using a Function</h2>
If configurations do not satisfy your requirements, you can create your function to customize CORS.
For example, let's assume that you want to allow CORS sharing for <code>.jpg</code> files <code>http://something.com</code> and <code>http://example.com</code>:
<pre><code class="hljs">const allowlist = [&#x27;http://something.com&#x27;, &#x27;http://example.com&#x27;];

 const corsOptionsDelegate = (req, callback) =&gt; {
 let corsOptions;

 let isDomainAllowed = whitelist.indexOf(req.header(&#x27;Origin&#x27;)) !== -1;
 let isExtensionAllowed = req.path.endsWith(&#x27;.jpg&#x27;);

 if (isDomainAllowed &amp;&amp; isExtensionAllowed) {
 // Enable CORS for this request
 corsOptions = { origin: true }
 } else {
 // Disable CORS for this request
 corsOptions = { origin: false }
 }
 callback(null, corsOptions)
}

app.use(cors(corsOptionsDelegate));
</code></pre>
The callback function will accept two parameters. The first one is an error where we passed <code>null</code> and the second one is options where we passed <code>{ origin: false }</code>. The second parameter could be many options that are constructed using the <code>request</code> object from the Express request handler.
So a web app which is hosted on <code>http://something.com</code> or <code>http://example.com</code> would be able to refer to an image with <code>.jpg</code> extension from the server as we have configured in our custom function.
So the following image attachment will be successful from either of these:
<pre><code class="hljs">&lt;img src=&quot;http://yourdomain.com/img/cat.jpg&quot;&gt;
</code></pre>
But the following attachment will be blocked:
<pre><code class="hljs">&lt;img src=&quot;http://yourdomain.com/img/cat.png&quot;&gt;
</code></pre>
<h2 id="loadinglistofallowedoriginsfromasdatasource">Loading List of Allowed Origins from as Data Source</h2>
You can use also use a list of allowed domains from a database or using any backing data source to allow CORS:
<pre><code class="hljs">var corsOptions = {
 origin: function (origin, callback) {
 // Loading a list of allowed origins from the database
 // Ex.. origins = [&#x27;http://example.com&#x27;, &#x27;http//something.com&#x27;]
 database.loadOrigins((error, origins) =&gt; {
 callback(error, origins);
 });
 }
}

app.use(cors(corsOptions));
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered what CORS is and how you can configure it with Express. Then, we've set up CORS for all requests, for specific requests, added options and restrictions as well as defined a custom function for dynamic CORS configuration.

Janith Kasun

In this article, we'll set up CORS with Express and Node.js and configure it for single routes, all routes and allow for dynamic configuration.

Handling CORS with Node.js

<h2 id="introduction">Introduction</h2>
Command line arguments (parameters) are strings of text used to pass additional information to a program when an application is run through the <a target="_blank" href="https://en.wikipedia.org/wiki/Command-line_interface">command line interface</a> (CLI) of an operating system.
In this tutorial, we'll be accessing the arguments (parameters) passed into the main method of a Java application and reading them. We'll also map them to different data types so that we can handle them and alter the flow of the code based on the input.
<h2 id="accessingcommandlinearguments">Accessing Command Line Arguments</h2>
The entry-point for every Java program is the <code>main()</code> method:
<pre><code class="hljs">public static void main(String[] args) {
 // Do something
}
</code></pre>
The arguments passed to the program as it was initialized are stored in the <code>args</code> array. Alternatively, Java also supports a vararg in this place:
<pre><code class="hljs">public static void main(String... args) {
 // Do something
}
</code></pre>
That being said, we can easily access each argument passed into this method. Let's start out by printing them out, one by one:
<pre><code class="hljs">public class Main {
public static void main(String[] args) {
 for (int i = 0; i &lt; args.length; i++)
 System.out.println(String.format(&quot;Argument %d: %s&quot;, i, args[i]));
 }
}
</code></pre>
We'll then compile this <code>.java</code> file:
<pre><code class="hljs">javac Main.java
</code></pre>
After which, we can run it:
<pre><code class="hljs">java Main Hello World
</code></pre>
This results in:
<pre><code class="hljs">Argument 0: Hello
Argument 1: World
</code></pre>
<h2 id="mappingargumentstodatatypes">Mapping Arguments to Data Types</h2>
The arguments themselves are an array of Strings. So really, everything we pass is a String. Though, we can convert Strings into different data types as well:
<pre><code class="hljs">java Main Hello 15 true 
</code></pre>
This prints out:
<pre><code class="hljs">Argument 0: Hello
Argument 1: 15
Argument 2: true
</code></pre>
Say we wanted to allow the users to print a String a set number of times, and have a flag that toggles a log message that displays the number of the iteration. The arguments provided above would thus print <code>Hello</code> 15 times, with a log message on each <code>print()</code> statement.
Let's do that:
<pre><code class="hljs">public class Main {
 public static void main(String[] args) {

 String s = &quot;&quot;;
 int n = 0;
 boolean flag = false;

 try {
 s = args[0];
 } catch (Exception e) {
 System.out.println(&quot;The first argument must be present.&quot;);
 System.exit(1);
 }
 try {
 n = Integer.parseInt(args[1]);
 } catch (NumberFormatException e) {
 System.out.println(&quot;The second argument must be an integer.&quot;);
 System.exit(1);
 }

 try {
 flag = Boolean.parseBoolean(args[2]);
 } catch (Exception e) {
 System.out.println(&quot;The third argument must be parseable to boolean.&quot;);
 System.exit(1);
 }

 for (int i = 0; i &lt; n; i++) {
 System.out.println(s);
 if (flag)
 System.out.println(String.format(&quot;Iteration %d&quot;, i));
 }
 }
}
</code></pre>
Now, let's compile the code again:
<pre><code class="hljs">javac Main.java
</code></pre>
And then, let's run it with no arguments:
<pre><code class="hljs">java Main
</code></pre>
We're greeted with:
<pre><code class="hljs">The first argument must be present.
</code></pre>
If we provide the arguments:
<pre><code class="hljs">java Main Hello 5 true
</code></pre>
We'll be greeted with:
<pre><code class="hljs">Hello
Iteration 0
Hello
Iteration 1
Hello
Iteration 2
Hello
Iteration 3
Hello
Iteration 4
</code></pre>
<h2 id="settingargumentsinides">Setting Arguments in IDEs</h2>
This assumes that you run the code through the command line, which isn't always the case. Most people use IDEs to work on their projects, which have a convenient &quot;Run&quot; button instead.
Thankfully, you can tell the IDE to pass these arguments into the run call. Here are examples of how you can do that with some popular IDEs:
<h3 id="eclipse">Eclipse</h3>
Under &quot;Run&quot;-&gt;&quot;Run Configurations&quot;:
<img src="https://stackabuse.s3.amazonaws.com/media/command-line-arguments-in-java-1.PNG" alt="Eclipse set arguments">
<h3 id="intellij">IntelliJ</h3>
Under &quot;Run&quot;-&gt;&quot;Edit Configurations&quot;:
<img src="https://stackabuse.s3.amazonaws.com/media/command-line-arguments-in-java-2.PNG" alt="IntelliJ Setting arguments">
<h2 id="conclusion">Conclusion</h2>
In this article, we've taken a look at how we can access the command line arguments passed into a Java application when it's run.
Then, we've mapped the passed arguments into different data types and handled them accordingly. With this in mind, it's easy to create simple CLI tools and alter the flow of code based on the passed arguments.

David Landup

In this tutorial, we'll be handling command line arguments in Java. We'll access and read them, as well as map the arguments to data types to alter the flow of code.

Command Line Arguments in Java - Accessing and Mapping to Data Types

<h2 id="introduction">Introduction</h2>
Text translation is a difficult computer problem that gets better and easier to solve every year. Big companies like Google are actively working on improving their text translation services which enables the rest of us to use them freely.
Apart from their great personal use, these services can be used by developers through various APIs. This article is about <code>TextBlob</code> which uses one such API to perform text translation.
<h2 id="whatistextblob">What is TextBlob?</h2>
<code>TextBlob</code> is a text-processing library written in Python. According to its <a rel="nofollow noopener" target="_blank" href="https://textblob.readthedocs.io/en/dev/">documentation</a>, it can be used for part-of-speech tagging, parsing, sentiment analysis, spelling correction, translation, and more. In this article, we'll focus on text translation.
Internally, <code>TextBlob</code> relies on Google Translate's API. This means that an active Internet connection is required for performing translations.
<h2 id="installingtextblob">Installing TextBlob</h2>
Let's start off by installing <code>TextBlob</code> using <code>pip</code>, and downloading the corpora of words it needs to function:
<pre><code class="hljs">$ pip install -U textblob
$ python -m textblob.download_corpora
</code></pre>
<h2 id="usingtextblob">Using TextBlob</h2>
Using <code>TextBlob</code> is straightforward and simple. We just import it, assign a string to the constructor and then translate it via the <code>translate()</code> function:
<pre><code class="hljs">from textblob import TextBlob

blob = TextBlob(&quot;Buongiorno!&quot;)
print(blob.translate(to=&#x27;en&#x27;))
</code></pre>
The <code>translate()</code> function accepts two arguments - <code>from_lang</code> and <code>to</code>. The <code>from_lang</code> is automatically set depending on the language TextBlob detects.
The above example uses the Italian phrase <code>Buongiorno</code> which translates to <code>Good morning</code> in English.
Sometimes, we might wish to detect a language to decide if the text needs translation at all. To detect the language of some text, <code>TextBlob</code>'s <code>detect_language()</code> function is used:
<pre><code class="hljs">from textblob import TextBlob

blob = TextBlob(&quot;Buongiorno!&quot;)
if (blob.detect_language() != &#x27;en&#x27;)
 blob.translate(to=&#x27;en&#x27;))
</code></pre>
<h2 id="translationexamplesandaccuracy">Translation Examples and Accuracy</h2>
<h3 id="sentencetranslationfromenglishintohindi">Sentence Translation From English into Hindi</h3>
As our first example, we'll see how well English is translated into Hindi:
<pre><code class="hljs">blob = TextBlob(&#x27;TextBlob is a great tool for developers&#x27;)
print(blob.translate(to=&#x27;hi&#x27;))
</code></pre>
The result is the following:
<pre><code class="hljs">डेवलपर्स के लिए एक बढ़िया टूल है
</code></pre>
<h3 id="translatingrussianpoetryintocroatian">Translating Russian Poetry into Croatian</h3>
Let's see how TextBlob manages poetry. The following is the work of a Russian poet Vladimir Mayakovsky, first in Russian and then in English:
<pre><code class="hljs">Послушайте! 
Ведь, если звезды зажигают - 
значит - это кому-нибудь нужно? 
Значит - кто-то хочет, чтобы они были? 
Значит - кто-то называет эти плевочки 
жемчужиной?
</code></pre>
<pre><code class="hljs">Listen! 
See, if stars light up 
does it mean that there is someone who needs it? 
Does it mean that someone wants them to exist? 
It means that someone calls these little spits 
magnificent.
</code></pre>
We'll feed the original poem in Cyrillic to <code>TextBlob</code> and see how well it translates into Croatian. Since both Russian and Croatian and Slavic languages, the translation is expected to be relatively good:
<pre><code class="hljs">from textblob import TextBlob

poem = &#x27;Послушайте! Ведь, если звезды зажигают - значит - это кому-нибудь нужно? Значит - кто-то хочет, чтобы они были? Значит - кто-то называет эти плевочки жемчужиной?&#x27;

blob = TextBlob(poem)
print(blob.translate(to=&#x27;hr&#x27;))
</code></pre>
By running the above code, we get the following output (formatted for convenience):
<pre><code class="hljs">Slušati!
Uostalom, ako su zvijezde upaljene
znači li to nekome treba?
Dakle - netko želi da to budu?
Dakle - netko naziva ove pljuvačke
biserom?
</code></pre>
Most of the translation is good except for the first word which would sound better if it were <code>Slušajte</code> instead of <code>Slušati</code>, in vocative. Although not perfect, you could understand the translation.
<h3 id="translatingarrayofgermanwordsintoenglish">Translating Array of German Words into English</h3>
In some cases, we won't have full sentences to translate. We might have a list or an array of words. These are a lot easier to translate, since there's no context to potentially change the translation:
<pre><code class="hljs">from textblob import TextBlob

worter = [&#x27;einer&#x27;, &#x27;zwei&#x27;, &#x27;drei&#x27;, &#x27;vier&#x27;, &#x27;fünf&#x27;, &#x27;sechs&#x27;, &#x27;sieben&#x27;, &#x27;acht&#x27;, &#x27;neun&#x27;, &#x27;zehn&#x27;]

for w in worter:
 blob = TextBlob(w)
 print(blob.translate(to=&#x27;en&#x27;))
</code></pre>
The result is:
<pre><code class="hljs">one
two
three
four
five
six
seven
eight
nine
ten
</code></pre>
Looks good!
<h3 id="translatingfoodfromenglishintofrench">Translating Food from English into French</h3>
Finally, let's translate an English word into French:
<pre><code class="hljs">from textblob import TextBlob

blob = TextBlob(&#x27;An apple&#x27;)
print(blob.translate(to=&#x27;fr&#x27;))
</code></pre>
The French translation is <code>Une pomme</code>. Bon Appétit!
<h2 id="conclusion">Conclusion</h2>
Translation is an interesting but difficult computer problem. Deep learning and other AI methods are becoming increasingly good at understanding language and performing automated language translation. <code>TextBlob</code> is one of the tools available to developers that can be used for performing such automated language translations.
There are many benefits to this kind of approach, however, not all translations are perfect. These techniques are still evolving and if you're in need of a high-quality translation of great importance, it is always best to consult with a professional translator.
For all other purposes, however, tools such as <code>TextBlob</code> are more than enough to provide convenience for simple translation and satisfy the curiosity of developers using them.

Luka Čupić

In this tutorial, we'll use TextBlob with Python to perform translation of strings and words through various languages.

Translating Strings in Python with TextBlob

In this tutorial, we'll use the JayDeBeApi package to connect Python to the H2 Database driver. We've created a RESTful Flask application with CRUD capabilities.

Integrating H2 with Python and Flask

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll be reading a file into a String in Java. There are a few ways we can read the textual contents of a file.
Here's a list of all the classes and methods we'll go over:
<ul>
<li><a href="#files.lines">Files.lines()</a></li>
<li><a href="#files.readstring">Files.readString()</a></li>
<li><a href="#files.readallbytes">Files.readAllBytes()</a></li>
<li><a href="#filereader">FileReader</a></li>
<li><a href="#bufferedreader">BufferedReader</a></li>
<li><a href="#scanner">Scanner</a></li>
</ul>
<h2 id="fileslines">Files.lines()</h2>
The <code>Files</code> class contains static methods for working with files and directories. A useful method is <code>lines()</code> which returns a stream of strings: <code>Stream&lt;String&gt;</code>. From this stream, one can obtain lines contained in a file.
The method accepts a <code>Path</code> to the file we'd like to read with an optional <code>Charset</code>. We'll use <a target="_blank" href="/the-try-with-resources-statement-in-java"><code>try-with-resources</code></a> syntax to automate flushing and closing:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

try (Stream&lt;String&gt; stream = Files.lines(path, StandardCharsets.UTF_8)) {
 stream.forEach(System.out::println);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
Since the method returns a <code>Stream</code>, we use its <a target="_blank" href="/guide-to-java-streams-foreach-with-examples/"><code>forEach()</code></a> method to iterate over the lines, with a <a target="_blank" href="/method-references-in-java-8">method reference</a> for brevity.
Instead of printing each line, a <code>StringBuilder</code> can be used to append lines:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

StringBuilder sb = new StringBuilder();

try (Stream&lt;String&gt; stream = Files.lines(path)) {
 stream.forEach(s -&gt; sb.append(s).append(&quot;\n&quot;));
 
} catch (IOException ex) {
 // Handle exception
}

String contents = sb.toString();
</code></pre>
With <code>StringBuilder</code>, the entire file can be represented in a single <code>String</code> (the <code>contents</code> variable above). Before performing such iterations, it's important to consider the length of the input file.
If the file is not too large, it's okay to put it in a String, though, if it's hundreds of megabytes in size, it's not so wise.
<h2 id="filesreadstring">Files.readString()</h2>
Since Java 11, the <code>Files</code> class introduced us to the <code>readString()</code> method, which accepts a <code>Path</code> to the file, as well as a <code>Charset</code>.
Unlike <code>Files.lines()</code>, it returns a <code>String</code> directly, instead of a <code>Stream</code> object:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

String contents = null;
try {
 contents = Files.readString(path, StandardCharsets.ISO_8859_1);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
<h2 id="filesreadallbytes">Files.readAllBytes()</h2>
A more low-level approach to reading is the <code>Files.readAllBytes()</code> method, which returns a <code>byte[]</code>. It's up to the developer to use these bytes - convert them to a String, process them as they are, etc.
This method also accepts a <code>Path</code> to the file we'd like to read:
<pre><code class="hljs">Path path = Paths.get(&quot;input.txt&quot;);

byte[] bytes = null;
try {
 bytes = Files.readAllBytes(path);
} catch (IOException ex) {
 // Handle exception
}
</code></pre>
Now, the <code>bytes</code> array holds all the information from the <code>input.txt</code> file. The easiest way to convert it into a String is to put them in a constructor with an optional <code>Charset</code>:
<pre><code class="hljs">String str = new String(bytes, StandardCharsets.UTF_8);
</code></pre>
Note: Solutions like reading all bytes are only appropriate in circumstances where we're dealing with small file sizes. It's not performance-friendly and it doesn't make much sense to keep large files in the program's memory.
<h2 id="scanner">Scanner</h2>
<code>Scanner</code> is a particularly useful class for reading content from streams. Since it works with abstract streams, it can also be used for reading strings. <code>Scanner</code> works by breaking the input into tokens which are sequentially retrieved from the input stream.
Since we are working with strings, we would like to use methods that return strings. <code>Scanner</code> has <code>next()</code> and <code>nextLine()</code> exactly for that. Both methods return objects of type <code>String</code>. The former is used to read arbitrary strings, whereas the latter parses and returns entire lines.
If each line contains the right amount of data then <code>nextLine()</code> is an ideal choice. If there is important information in the file that's broken down into smaller chunks but not necessarily lines (or the file contains, say, a single line) then <code>next()</code> might be a better option.
<code>Scanner</code>'s constructor accepts many objects - <code>Path</code>s, <code>InputStream</code>s, <code>File</code>s, etc. We'll use a <code>File</code>:
<pre><code class="hljs">File file = new File(&quot;input.txt&quot;);
Scanner sc = new Scanner(file);

while(sc.hasNext()) {
 System.out.println(sc.next());
}
</code></pre>
We're using a <code>while</code> loop as long as the <code>sc</code> has more elements. If we didn't check with <code>hasNext()</code>, <code>sc</code> would throw a <code>NoSuchElementexception</code> if we try accessing an element after the last one.
The idea of using <code>hasNext()</code> and <code>next()</code> methods come from the <a target="_blank" href="java-iterable-interface-iterator-listiterator-and-spliterator"><code>Iterator</code></a> interface, as <code>Scanner</code> internally implements it.
<h2 id="filereader">FileReader</h2>
The <code>FileReader</code> is used to read files. It offers the <code>read()</code> and <code>read(char[])</code> methods, which return a single character and multiple characters respectively. Also, it accepts a <code>File</code> or <code>String</code> into the constructor.
<h3 id="filereaderreadchar">FileReader.read(char[])</h3>
Let's open a file using <code>FileReader</code> and read its contents:
<pre><code class="hljs">FileReader in = new FileReader(&quot;input.txt&quot;);

char[] chars = new char[256];
int n = in.read(chars, 0, chars.length);

String contents = new String(chars);
</code></pre>
The <code>read()</code> method accepts a sequence of characters (that we're storing the read characters in), the starting point and the ending point of what we'd like to read. Specifically, we've decided to read 256 characters at most. If <code>input.txt</code> has more, we'll read only 256 characters. If it has less, the readable characters are returned.
The return value, stored inside integer <code>n</code> can be used to check how many characters the method actually read. In case the end of the stream has been reached, the method returns <code>-1</code>.
Since the method fills a <code>char[]</code>, we can convert it into a <code>String</code>. A similar result can be obtained by using <code>String.valueOf(char[])</code>.
<h3 id="filereaderread">FileReader.read()</h3>
The <code>read()</code> method, without a <code>char[]</code> reads a single character at a time. We'll want to iterate through the contents and read each character ourselves:
<pre><code class="hljs">FileReader in = new FileReader(&quot;input.txt&quot;);

StringBuilder sb = new StringBuilder();

while(in.read() != -1) {
 sb.append(in.read());
}

String contents = sb.toString();
in.close();
</code></pre>
Here, we check if the read character isn't <code>-1</code>, which indicates that there are no characters left to read. If not, we <code>append()</code> it to a <code>StringBuilder</code> and finally, convert it to a <code>String</code>.
Note: Both <code>read()</code> and <code>read(char[])</code> read bytes, convert them into characters, and return them one by one. This is inefficient and should be done with buffering when possible.
<h2 id="bufferedreader">BufferedReader</h2>
<code>BufferedReader</code> is an object designed to read text from a character-input stream. It is buffered, meaning that it uses an internal buffer for temporary storage. As we've seen in the previous section, &quot;regular&quot; <code>Reader</code>s can sometimes be inefficient.
It's advised to wrap any potentially costly <code>Reader</code> into a <code>BufferedReader</code> to increase performance since buffering characters enables more efficient reading of the input text.
Let's instantiate a <code>BufferedReader</code>:
<pre><code class="hljs">BufferedReader in = new BufferedReader(new FileReader(&quot;input.txt&quot;));
</code></pre>
At this point, we have a buffered reader object ready to read contents from <code>input.txt</code>. In this example, we'll be reading the file line-by-line, although <code>BufferedReader</code> supports reading single characters individually and also multiple characters into an array.
Let's use this <code>BufferedReader</code> instance to read a file and store its contents, line-by-line, into a String:
<pre><code class="hljs">StringBuilder sb = new StringBuilder();

while(in.readLine != null) {
 sb.append(in.readLine()).append(&quot;\n&quot;);
}

String contents = sb.toString();
in.close();
</code></pre>
Once again, we are using <code>StringBuilder</code> to collect all the lines. To separate each line, we append the null-terminator (<code>\n</code>) between them. Finally, we close the stream.
<h2 id="conclusion">Conclusion</h2>
In this article, we went over some common techniques for reading files into strings in Java. There are many options but most of them have a similar core principle: provide a path to the file, read the contents into a data structure (e.g. <code>char[]</code> or a String); then perform some final processing to collect all file contents in an appropriate manner.
We've covered the <code>File.lines()</code> method, the <code>Files.readString()</code> method, the <code>Files.readAllBytes()</code> method, as well as the <code>Scanner</code>, <code>FileReader</code> and <code>BufferedReader</code> classes.

In this tutorial, we'll use the Files.lines(), Files.readString(), Files.readAllBytes() methods, and the FileReader, BufferedReader and Scanner classes to read a File into a String in Java with examples.