Since 2003, Python has ranked in the top 10 programming languages to learn and its ranking has been consistently improving ever since. According to a <a rel="nofollow" target="_blank" href="https://www.codingame.com/blog/best-programming-language-learn-2019/">statistic</a>, Python is one of the top 5 languages to learn in 2019 and has become an essential part of the programming community, thanks to its simplicity, flexibility, robustness, ease of use, compatibility, speed, and versatility. Furthermore, tech giants like Instagram, Spotify, and Google base, at least in part, their architecture in Python.
In short, Python has become a central component of the programming world with the rise of Silicon Valley and Wall Street poster child: <a rel="nofollow" target="_blank" href="https://www.inc.com/magazine/201509/maria-aspan/2015-inc5000-fintech-finally-lifts-off.html">Fintech</a>. The <a rel="nofollow" target="_blank" href="https://stxnext.com/blog/2017/09/19/why-python-should-be-technology-choice-your-fintech/">reasons are many</a>, but Python offers the security and scalability sought by the digital-first-approach trend assumed by a considerable portion of the business and financial sectors.
Python can be used to perform a ton of different tasks, ranging from machine learning and data science to robotics and hardware programming. In this article we will focus on how Python can be used for web development.
<h2 id="webdevelopmentusingpython">Web Development Using Python</h2>
Python offers something for everyone through its many frameworks and features. A framework is a bundle of packages and modules that provide an abstraction, or generic functionality, that can be selectively changed to create application-specific software. Using Python and its frameworks is the top choice for a <a href="https://cmsminds.com/website-development/" target="_blank" rel="noopener noreferrer">professional website development company</a> to create custom plugins, fetch data from external sources, or perform complex calculations.
But how do you know which web framework is right for you? For full-fledged web applications, <a rel="nofollow" target="_blank" href="https://www.djangoproject.com/">Django</a> and <a rel="nofollow" target="_blank" href="https://trypyramid.com/">Pyramid</a> are typically the way to go. For better control and visualization or prototyping an app, <a rel="nofollow" target="_blank" href="http://www.web2py.com/">Web2py</a> or <a rel="nofollow" target="_blank" href="http://flask.pocoo.org/">Flask</a> may have something to offer to your project. <a rel="nofollow" target="_blank" href="https://cherrypy.org/">CheeryPy</a> is a must for simple, minimalist solutions. <a rel="nofollow" target="_blank" href="http://www.tornadoweb.org/en/latest/">Tornado</a> will handle 10,000 or more concurrent connections to your app at the same time while <a rel="nofollow" target="_blank" href="https://plot.ly/products/dash/">Dash</a> is the perfect choice for analytical applications.
Over the next few sections, we'll provide a brief overview for three of the most popular selections by developers: Django, Pyramid, and Flask. After the overview we'll show the most popular framework, Django, in action through the use of an example login system.
<h3 id="django">Django</h3>
This framework is the embodiment of the &quot;batteries included&quot; phrase. Defined as &quot;the web framework for perfectionists with deadlines&quot;. Its built-in features allow for a wide range of web applications, like database applications, chat-bots, IoT solutions, etc. Given it's popularity, you'll often see Django as the topic of a <a target="_blank" rel="noopener" href="https://www.odinschool.com/web-development-course">web development course</a>.
Its DRY (Don't Repeat Yourself) philosophy not only allows, but also promotes, the reuse of code, greatly reducing the coding time. Furthermore, its modular/decoupled architecture allows seamless modification of the code components, allowing you to add or remove components as much as needed with little to no effort.
Django also possesses something called an ORM (Object-Relational Mapping), which makes it highly compatible with most of the popular databases, like SQL or Oracle, and also allows it to work with several databases at once.
Finally, Django is <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Search_engine_optimization">SEO</a> (Search Engine Optimization) friendly. For example, it allows the reduction of the page loading time through techniques like caching templates and compressing JavaScript files.
<h3 id="pyramid">Pyramid</h3>
This framework defines itself as &quot;not too small, not too big, just right&quot;. Pyramid is a finishing-focused framework with the ability to start small, allowing you to code a solid foundation for your solution, and then to scale it up as needed. It is similar to Django in its compatibility with small and large applications, but sets itself apart from Django in its complexity.
While on its own it can be considered a lean option when compared to other frameworks, Pyramid shines with its plugin system, allowing developers to plug-in whatever is needed, which allows for the implementation of multiple solutions for a given task.
Pyramid is even ideal for single-file applications, flexible authentication, and authorization or apps oriented to <a rel="nofollow" target="_blank" href="https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/viewconfig.html">view predicates</a>.
<h3 id="flask">Flask</h3>
While Pyramid and Django share the same core philosophy, Flask goes in the other direction. If the end goal is something simple, manageable, and customizable, I'd suggest that you always use Flask instead of using an overkill power horse like Django. Flask is heavily based on <a rel="nofollow" target="_blank" href="https://quintagroup.com/cms/python/jinja2">Jinja 2 templating</a> and the <a rel="nofollow" target="_blank" href="http://werkzeug.pocoo.org/">Werkzeug</a> WSGI (Web Server Gateway Interface) toolkit.
Self-defined as a micro-framework, Flask is tailored to small-scale solutions, like simple apps or API's, where lean functionality is a top priority. Flask is also the most used micro-framework for creating prototypes. When building a working application from the ground up in a short amount of time, it takes priority over the management of the said application in the long term.
<h2 id="simpleloginsystemwithdjango">Simple Login System with Django</h2>
In this section, we are going to explain how to create a simple login system with the Django framework. While a lot of things happen &quot;offstage&quot;, and many things can be customized to the developers' liking, only the most basic steps will be explained in order to demonstrate how easy it is to develop applications with the Django framework.
<h3 id="installingdjango">Installing Django</h3>
For this example, the <a rel="nofollow" target="_blank" href="https://pypi.org/project/pip/">PIP</a> module needs to be installed. Once that it is done, <a rel="nofollow" target="_blank" href="https://medium.freecodecamp.org/user-authentication-in-django-bae3a387f77d">Django can be installed</a> and a new project can be created as follows:
<pre><code class="hljs">$ python3 -m venv ~/.virtualenvs/dProject # Creates a virtual environment named dProject
$ source ~/.virtualenvs/dProject/bin/activate # A path is created
(dProject) $ pip install django # Django is installed
(dProject) $ django-admin.py startproject LoginProject_D # The project is created with the name LoginProject_D 
(dProject) $ ./manage.py migrate # Migrate creates a new SQLite database
(dProject) $ ./manage.py runserver # Calls the local server
(dProject) $ ./manage.py startapp dProject # This creates a dedicated app that will allow the making of a view and url registration.
</code></pre>
After this is done, the project can be previewed in a browser via the &quot;<a href="http://127.0.0.1:8000">http://127.0.0.1:8000</a>&quot; address. The Django welcome screen will load in the browser, indicating that installation was a success.
<h3 id="djangosauthapp">Django's Auth App</h3>
When a project is created, Django installs the &quot;auth&quot; app by default. This can be confirmed by checking the file <code>settings.py</code>, which is created automatically with the new project, under the &quot;INSTALLED_APPS&quot; section as follows:
<pre><code class="hljs">INSTALLED_APPS = [
 …
 &#x27;django.contrib.admin&#x27;,
 &#x27;django.contrib.auth&#x27;, # Here it is! Note that several built-in apps are included in this section.
 …
]
</code></pre>
<code>Django-auth</code>, or <code>django.contrib.auth</code>, is the Django framework's <a rel="nofollow" target="_blank" href="https://docs.djangoproject.com/en/2.1/ref/contrib/auth/">built-in authentication system</a>, and contains its default models. This app is responsible for user authentication, permissions, and groups.
In order to use the &quot;auth&quot; app, we need to add it to the project-level file <code>urls.py</code>:
<pre><code class="hljs"># Importing this module will allow us to set the routes login and logout views
from django.conf.urls import url
from django.contrib import admin
from django.contrib.auth import views as auth_views 

# This section adds Django site authentication urls (for login, logout, password management)
urlpatterns = [
 url(r&#x27;^login/$&#x27;, auth_views.login, name=&#x27;login&#x27;),
 url(r&#x27;^logout/$&#x27;, auth_views.logout, name=&#x27;logout&#x27;),
 url(r&#x27;^admin/&#x27;, admin.site.urls),
 path(&#x27;dProject/&#x27;, include(&#x27;django.contrib.auth.urls&#x27;)),
]
</code></pre>
The &quot;auth&quot; app provides us with the following URLs, each one associated with &quot;auth&quot; views, allowing us to use them by simply creating their view templates:
<pre><code class="hljs">dProject/login/ [name=&#x27;login&#x27;]
dProject/logout/ [name=&#x27;logout&#x27;]
dProject/password_change/ [name=&#x27;password_change&#x27;]
dProject/password_change/done/ [name=&#x27;password_change_done&#x27;]
dProject/password_reset/ [name=&#x27;password_reset&#x27;]
dProject/password_reset/done/ [name=&#x27;password_reset_done&#x27;]
dProject/reset/&lt;uidb64&gt;/&lt;token&gt;/ [name=&#x27;password_reset_confirm&#x27;]
dProject/reset/done/ [name=&#x27;password_reset_complete&#x27;]
</code></pre>
The <code>django.contrib.auth.views.login</code> view will create the <code>registration/login.html</code> template by default. This creates a folder named REGISTRATION with a <code>login.html</code> template within. The following block of code is a basic login template that can be used:
<pre><code class="hljs">{% extends &#x27;base.html&#x27; %}

{% block title %}Login{% endblock %}

{% block content %}
 &lt;h2&gt;Login&lt;/h2&gt;
 &lt;form method=&quot;post&quot;&gt; #This is a standard form to send data.
 {% csrf_token %} #Security tag to prevent &lt;a target=&quot;_blank&quot; href=&quot;https://www.owasp.org/index.php/Cross-site_Scripting_(XSS)&quot;&gt;XSS Attacks&lt;/a&gt;, among other concerns.
 {{ form.as_p }} #Outputs the form&#x27;s contents between paragraph tags.
 &lt;button type=&quot;submit&quot;&gt;Login&lt;/button&gt; #A submit button. 
 &lt;/form&gt;
{% endblock %}
</code></pre>
Finally, we set the project to look for the &quot;templates&quot; folder through the <code>settings.py</code> file, updating <code>DIRS</code>:
<pre><code class="hljs">TEMPLATES = [
 {
 ...
 &#x27;DIRS&#x27;: [os.path.join(BASE_DIR, &#x27;templates&#x27;)],
 ...
 },
]
</code></pre>
Voilà! A simple login page that can correctly authenticate a user through a username and password validation.
<h2 id="conclusion">Conclusion</h2>
Python has been widely used for server-side programming, owing to its dynamic website creation capabilities. This language is widely used for fast prototyping and building highly scalable web applications by technology leaders like Google and even NASA!
Python is, without a doubt, a must when taking a digital-first approach to staying competitive, which is further enhanced by the meteoric rise of the fin-tech industry.
Furthermore, these Python frameworks reduce the development effort through the provision of a variety of built-in functionalities. The only challenge would be which one to use, tailored to specific needs for better results.

Guest Contributor

A Brief Look at Web Development in Python

<h2 id="overview">Overview</h2>
Most websites today offer a subscription to a newsletter of any sort to let us know about their great deals, discounts, new products, services, and receipts.
When signing up on a website, we also (in most cases) receive an email to verify our email address and link it to the account you're signing up for.
This can be a great marketing tactic and can really grow your business and platform, so knowing how to build a simple system to send emails is a must, especially if you're launching a platform that offers a product or service of any sort.
To achieve this, we'll use one of Java's core libraries - <code>javax.mail</code>.
<h2 id="sendingaplaintextemail">Sending a Plain Text Email</h2>
Although our example email below isn't as exciting as the well-designed emails with custom buttons and pictures, a simple email like this is often sent for registration or password reset means:
<pre><code class="hljs">public class EmailSender {
 public static void main(String[] args) {
 String recipient = &quot;recipient@gmail.com&quot;;
 String sender = &quot;sender@gmail.com&quot;;
 String host = &quot;localhost&quot;;

 Properties properties = System.getProperties();
 properties.setProperty(&quot;mail.smtp.host&quot;, host);

 Session session = Session.getDefaultInstance(properties);

 try {
 MimeMessage message = new MimeMessage(session);
 message.setFrom(new InternetAddress(sender));
 message.addRecipient(Message.RecipientType.TO, new InternetAddress(recipient));
 message.addRecipients(Message.RecipientType.TO, new Address[...]); // email to multiple recipients
 message.setSubject(&quot;Hello World!&quot;);
 message.setText(&quot;And hello from the body of the message!&quot;);

 Transport.send(message);

 } catch (AddressException e) {
 e.printStackTrace();
 } catch (MessagingException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>
We're introduced with a couple of classes here:
<ul>
<li><code>Properties</code> - Represents any set of properties and defaults.</li>
<li><code>Session</code> - Collects the properties and defaults used by the mail's API.</li>
<li><code>MimeMessage</code> - Represents the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/MIME">MIME</a> style email message.</li>
<li><code>InternetAddress</code> - Represents a <a rel="nofollow" target="_blank" href="http://www.ietf.org/rfc/rfc822.txt">RFC882</a> syntax internet address - &quot;user@host.domain&quot;</li>
</ul>
<h2 id="sendingemailwithhtml">Sending Email with HTML</h2>
HTML emails are very common and you probably see them every day in your inbox. All the new fancy catalogs and eye-popping products are decorated to appeal as much as possible, just like their website counter-parts.
Sending an email with HTML is a bit different from the preceding example in just a single line:
<pre><code class="hljs">public class EmailSender {

 public static void main(String[] args) {
 String recipient = &quot;recipient@gmail.com&quot;;
 String sender = &quot;sender@gmail.com&quot;;
 String host = &quot;localhost&quot;;

 Properties properties = System.getProperties();
 properties.setProperty(&quot;mail.smtp.host&quot;, host);

 Session session = Session.getDefaultInstance(properties);

 try {
 MimeMessage message = new MimeMessage(session);
 message.setFrom(new InternetAddress(sender));
 message.addRecipient(Message.RecipientType.TO, new InternetAddress(recipient));
 message.setSubject(&quot;Hello World!&quot;);

 message.setContent(&quot;&lt;h1&gt;Message Header&lt;/h1&gt;&quot; +
 &quot;&lt;p&gt;This is a paragraph &lt;/p&gt;&quot; +
 &quot;&lt;p&gt;This is another paragraph&lt;/p&gt;&quot;, &quot;text/html&quot;);

 Transport.send(message);

 } catch (AddressException e) {
 e.printStackTrace();
 } catch (MessagingException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>
By using the <code>.setContent()</code> method, and setting the type to be <code>text/html</code>, we're able to add HTML to our email message.
The method accepts either a <code>MultiPart</code> object or an Object/String, and simply sets the arguments as the content of the message.
<h2 id="sendingemailwithanattachment">Sending Email with an Attachment</h2>
In many cases you might like to send an email with an attachment of any kind. For example, after a customer orders your product or pays for your service - you'd want to send a receipt to confirm the purchase.
If your product or service requires legal documents, a customer may also receive a legal document to sign and send back, all of which can be done with email.
In any of these cases, this requires a bit of a different approach than our previous examples:
<pre><code class="hljs">public class EmailSender {

 public static void main(String[] args) {
 String recipient = &quot;recipient@gmail.com&quot;;
 String sender = &quot;sender@gmail.com&quot;;
 String host = &quot;localhost&quot;;

 Properties properties = System.getProperties();
 properties.setProperty(&quot;mail.smtp.host&quot;, host);

 Session session = Session.getDefaultInstance(properties);

 try {
 MimeMessage message = new MimeMessage(session);
 message.setFrom(new InternetAddress(sender));
 message.addRecipient(Message.RecipientType.TO, new InternetAddress(recipient));
 message.setSubject(&quot;Receipt for your product!&quot;);

 BodyPart messageBodyPart = new MimeBodyPart();
 messageBodyPart.setText(&quot;Thank you for buying with us, here&#x27;s a receipt for your product.&quot;);

 Multipart multipart = new MimeMultipart();
 multipart.addBodyPart(messageBodyPart);

 messageBodyPart = new MimeBodyPart();
 DataSource source = new FileDataSource(&quot;receipt.txt&quot;);
 multipart.addBodyPart(messageBodyPart);

 message.setContent(multipart);

 Transport.send(message);

 } catch (AddressException e) {
 e.printStackTrace();
 } catch (MessagingException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>
Here, we're being introduced to a few new classes:
<ul>
<li><code>BodyPart</code> - An abstract class that represents a part of a <code>Multipart</code></li>
<li><code>Multipart</code> - A container for multiple <code>BodyPart</code> objects</li>
<li><code>DataSource</code> - Provides a type for an arbitrary collection of data, as well as access to it in the form of <code>InputStreams</code> and <code>OutputStreams</code></li>
</ul>
When adding a <code>Multipart</code> as content, we can add as many <code>BodyParts</code> into it, and after adding one, we can use the same reference variable to initialize a new one, and store it into the <code>Multipart</code> as well.
<h2 id="conclusion">Conclusion</h2>
These are the three of the most common things you'd need to know to send emails of any sort in plain old Java, without any additional third-party libraries.

David Landup

How to Send Emails in Java

Converting a string to a date in Java (or any programming language) is a fundamental skill and is useful to know when working on projects. Sometimes, it's simply easier to work with a string to represent a date, and then convert it into a <code>Date</code> object for further use.
In this article, we'll go over the many methods and libraries you can use to convert a Java string into a date object.
<h2 id="thedatetimeapi">The Date/Time API</h2>
The Date/Time API in Java works with the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a> format by default, which is <code>(yyyy-MM-dd)</code>.
All Dates by default follow this format, and all Strings that are converted must follow it if you're using the default formatter.
<h3 id="parse">parse()</h3>
This API defines a <code>parse()</code> method that accepts a sequence of characters and uses the <code>ISO_LOCAL_DATE</code> format to parse the input:
<pre><code class="hljs">parse(CharSequence);
</code></pre>
Alternatively, you can use the two-argument variant of this method, defining a different formatter:
<pre><code class="hljs">parse(CharSequence, DateTimeFormatter);
</code></pre>
A <code>DateTimeFormatter</code> is used for formatting and parsing date-time objects in the new Date/Time API. All date-time classes from this API contain a method for parsing and formatting, where each accepts a DateTimeFormatter to define a pattern.
<h3 id="convertingastringtolocaldate">Converting a String to LocalDate</h3>
A <code>LocalDate</code> represents a date, without time in ISO-8601 format.
It differs from <code>Date</code> in the fact that it doesn't store time as a millisecond offset since epoch, but rather simply the current date. It's also a newer implementation from the Date/Time API and offers its own format/parse method, as well as addition and subtraction of days, weeks and years, which doesn't exist in the Date variant.
To convert a string to a <code>LocalDate</code> object, it's enough to write:
<pre><code class="hljs">LocalDate date = LocalDate.parse(&quot;2018-09-16&quot;);
</code></pre>
This is the equivalent of writing the proceeding code to instantiate a <code>LocalDate</code> object:
<pre><code class="hljs">LocalDate date = LocalDate.of(2018, 09, 16);
</code></pre>
<h3 id="convertingastringtolocaltime">Converting a String to LocalTime</h3>
<code>LocalTime</code> represents time, without a time-zone in ISO-8601 format. It doesn't store time based on the offset since epoch, and it offers nanosecond precision.
Just like the LocalDate, it provides a lot of very useful parsing and formatting methods built in, as well as the means to add or subtract time from it.
To convert a string to a <code>LocalTime</code> object, it's enough to write:
<pre><code class="hljs">LocalTime localTime = LocalTime.parse(&quot;8:00&quot;);
</code></pre>
This is the equivalent of writing the proceeding code to instantiate a <code>LocalTime</code> object:
<pre><code class="hljs">LocalTime localTime = LocalTime.of(8, 00);
</code></pre>
<h3 id="convertingastringtolocaldatetime">Converting a String to LocalDateTime</h3>
The <code>LocalDateTime</code> is the most used class regarding Date/Time in Java. It represents a combination of date and time, and can be used for many purposes:
<pre><code class="hljs">LocalDateTime localDateTime = LocalDateTime.parse(&quot;2018-09-16T08:00:00&quot;);
</code></pre>
This format may seem confusing at first, but it's actually rather simple:
<img class="img-responsive" alt="localdatetime" src="https://s3.amazonaws.com/stackabuse/media/how-convert-string-date-java-1.png">
The &quot;Time&quot; marker simply represents a line between the <code>LocalDate</code> and <code>LocalTime</code> parts of the format.
You can also easily format this <code>LocalDateTime</code> into a more readable format:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.ofPattern(&quot;yyyy-MM-dd HH:mm:ss&quot;);
String formatDateTime = localDateTime.format(formatter);
</code></pre>
Running this piece of code and printing <code>formatDateTime</code> would yield:
<pre><code class="hljs">2018-09-16 08:00:00
</code></pre>
You would typically do this to show the result to the end user in string format, while performing operations on the <code>LocalDateTime</code> object beforehand.
<h3 id="convertingastringtozoneddatetime">Converting a String to ZonedDateTime</h3>
Depending on the project you're working on you might need to handle different time zones when dealing with dates and time.
Converting a String to a <code>ZonedDateTime</code> object is as simple as:
<pre><code class="hljs">ZonedDateTime zonedDateTime = ZonedDateTime.parse(&quot;2018-09-16T08:00:00+00:00[Europe/London]&quot;);
</code></pre>
The example above shows how you would initialize a <code>ZonedDateTime</code> for London.
<h3 id="convertingastringusingacustomformatter">Converting a String using a Custom Formatter</h3>
Sometimes, we could wish to use our own custom formatter, that accepts a string in the most varied ways and still not throw a <code>DateTimeParseException</code>.
Here are some of the most common patterns you would use:
<ul>
<li><code>y</code>: Year (2018, 18)</li>
<li><code>M</code>: Month in a year (August, Aug, 08)</li>
<li><code>d</code>: Day in a month (1, 5, 25)</li>
<li><code>E</code>: Name of a day in a week (Monday, Saturday)</li>
<li><code>a</code>: Ante meridiem/Post meridiem marker (AM, PM)</li>
<li><code>H</code>: Hour in a 24h style (1, 7, 14, 21)</li>
<li><code>h</code>: Hour in a 12h style (1, 5, 12)</li>
<li><code>m</code>: Minute in an hour (1, 25, 54)</li>
<li><code>s</code>: Second in a minute (1, 25, 54)</li>
</ul>
And some you might not use that often:
<ul>
<li><code>G</code>: Era designator (AD, CE)</li>
<li><code>Y</code>: Week year (2018, 18)</li>
<li><code>w</code>: Week in a a year (25, 53)</li>
<li><code>W</code>: Week in a month (2)</li>
<li><code>D</code>: Day in a year (254)</li>
<li><code>F</code>: Day of week in a month (3)</li>
<li><code>E</code>: Day name in a week (Monday, Mon)</li>
<li><code>u</code>: Day number of a week (1, 4)</li>
<li><code>k</code>: Hour in a day (17)</li>
<li><code>K</code>: Hour in a day in AM/PM (5)</li>
<li><code>S</code>: Millisecond (1245)</li>
<li><code>z</code>: General Time Zone (Pacific Standard Time;PST;GMT-8:00)</li>
<li><code>Z</code>: RFC 822 Time Zone (-0800)</li>
<li><code>X</code>: ISO 8601 Time Zone (-08, -0800, -8:00)</li>
</ul>
Note: Week year differs from a year - A week year is in sync with a <code>WEEK_OF_YEAR</code> cycle. All weeks between the first and last weeks (inclusive) have the same week year value. Therefore, the first and last days of a week year may have different calendar year values.
Note: <code>K</code> and <code>H</code> differ the same way <code>k</code> and <code>h</code> differ. <code>H</code> and <code>h</code> refer to the 0-23 and 1-12 model respectively, while <code>K</code> and <code>k</code> refer to the 0-11 and 1-24 respectively.
If this still doesn't satisfy your need for a custom formatter, you can use <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatterBuilder.html">DateTimeFormatterBuilder</a> to build very specific and complex formatters. Amongst other things, DateTimeFormatter is built using this class.
<h2 id="javautildate">java.util.Date</h2>
This is an older approach, which isn't used often today, but it's still worth covering since sometimes we still use the classes from these APIs:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;dd-MM-yyyy&quot;);

Date date = formatter.parse(&quot;22-Sep-2018&quot;);
</code></pre>
There are many patterns that we can pass into the constructor of <code>SimpleDateFormat</code>. You can combine pretty much any number of formats using the available patterns.
It's not possible to set a timezone for a Date, because it simply doesn't contain such information. However, it's easy to format the date and add the timezone information to a String:
<pre><code class="hljs">SimpleDateFormat formatter = new SimpleDateFormat(&quot;dd-M-yyyy hh:mm:ss a&quot;);
formatter.setTimeZone(TimeZone.getTimeZone(&quot;UTC&quot;));

Date date = formatter.parse(&quot;22-09-2018 08:23:43 PM&quot;);
String formattedDate = formatter.format(date);

System.out.println(date);
System.out.println(formattedDate);
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">Sat Sep 22 22:23:43 CEST 2018
22-9-2018 08:23:43 PM
</code></pre>
&quot;22:23:43 CEST&quot; corresponds to the &quot;10:23:43PM&quot; time, while the formatted date represents &quot;8:23:43 PM&quot; since it's in a different time zone.
<h2 id="simpledateformatvsdatetimeformatter">SimpleDateFormat vs DateTimeFormatter</h2>
Reading this article, it's fair to raise the question - &quot;What is the difference, and which one should I be using?&quot;
<code>DateTimeFormatter</code> has been added in Java 8 with the new Date/Time API, and replaces the older, now less frequently used <code>SimpleDateFormat</code>. It's thread-safe unlike its older counterpart and offers new functionality:
<pre><code class="hljs">// SimpleDateFormat
SimpleDateFormat formatter = new SimpleDateFormat(&quot;dd-M-yyyy&quot;);
Date date = new Date();
String formattedDate = formatter.format(date);
Date parsedDate = formatter.parse(formattedDate);

// DateTimeFormatter
LocalDate date = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(&quot;dd-M-yyyy&quot;);
String formattedDate = date.format(formatter);
LocalDate parsedDate = LocalDate.parse(formattedDate, formatter); 
</code></pre>
It's clear to see the difference between these two. In the older way, a formatter is used to format and then parse the date. In the newer way, dates have their own format and parse methods and use a <code>DateTimeFormatter</code> simply for the pattern.
If you're using Java 8 and the new API, use DateTimeFormatter, whereas if you're still using an older version of Java, use SimpleDateFormat.
<h2 id="jodatime">Joda-Time</h2>
<a rel="nofollow" target="_blank" href="http://www.joda.org/joda-time/">Joda-Time</a> was developed to counter the problems with the old Java time and date classes.
As of Java 8, these problems have been corrected, and Joda-Time has served its purpose. Even the authors of it advise migrating to official <code>java.time</code> to work with dates and time.
In the case that this is impossible, and for those who still use a version of Java prior to Java 8, Joda-Time is still a great library to use.
A dependency for this library can easily be added with a <a rel="nofollow" target="_blank" href="https://maven.apache.org/">Maven</a> dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;joda-time&lt;/groupId&gt;
 &lt;artifactId&gt;joda-time&lt;/artifactId&gt;
 &lt;version&gt;{version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Working with Joda-Time is very similar to working with Java's Date/Time API:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.forPattern(&quot;dd-MM-yyyy HH:mm:ss&quot;);

DateTime dateTime = DateTime.parse(&quot;22-Sep-2018 8:15:43&quot;, formatter);
</code></pre>
Joda-Time's <code>DateTime</code> class supports timezones as well:
<pre><code class="hljs">DateTimeFormatter formatter = DateTimeFormatter.forPattern(&quot;dd-MM-yyyy HH:mm:ss&quot;);

DateTime dateTime = DateTime.parse(&quot;22-Sep-2018 8:15:43&quot;, formatter);
DateTime dateTimeZoned = dateTime.withZone(DateTimeZone.forID(&quot;Europe/London));
</code></pre>
For a full list of time zone IDs available for use, visit the <a rel="nofollow" target="_blank" href="http://joda-time.sourceforge.net/timezones.html">official docs</a>.
<h2 id="apachecommons">Apache Commons</h2>
<a rel="nofollow" target="_blank" href="https://commons.apache.org/">Apache Commons</a> is a useful library used in many projects.
To add this library to your project, you can use the Maven dependency:
<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>
Both of the implementations below accept an array of patterns. These methods will parse each pattern after another. If no pattern matches the input string, a <code>ParseException</code> is thrown.
<h3 id="usingdatetimeconverter">Using DateTimeConverter</h3>
<pre><code class="hljs">DateTimeConverter dtc = new DateConverter();
dtc.setPatterns(new String[] { &quot;yyyy-MM-dd&quot;, &quot;yyyy-MM-dd hh:mm:ss&quot; });
ConvertUtils.register(dtc, Date.class);
</code></pre>
<h3 id="usingdateutils">Using DateUtils</h3>
<pre><code class="hljs">Date date = DateUtils.parseDate(&quot;22-Sep-2018&quot;, String[] {&quot;dd-MM-yyyy HH:mm:ss&quot;, &quot;dd-MM-yyyy&quot;});
</code></pre>
<h2 id="conclusion">Conclusion</h2>
We've covered multiple ways to convert a simple String into Date and Date-Time classes in Java. Some of these approaches utilize third-party libraries which you might already have in your project, and some are done utilizing the APIs Java offers.

How to Convert a String to Date in Java

Vuk Skobalj

Docker: A High Level Introduction

Usman Malik

Creating a Neural Network from Scratch in Python

In Computer Science, a file is a resource used to record data discretely in a computer’s storage device. In Java, a resource is usually an object implementing the <code>AutoCloseable</code> interface.
Reading files and resources have many usages:
<ul>
<li>Statistics, Analytics, and Reports</li>
<li>Machine Learning</li>
<li>Dealing with large text files or logs</li>
</ul>
Sometimes, these files can be absurdly large, with giga-bytes or tera-bytes being stored, and reading through them in entirety is inefficient.
Being able to read a file line by line gives us the ability to seek only the relevant information and stop the search once we have found what we're looking for. It also allows us to break up the data into logical pieces, like if the file was CSV-formatted.
There are a few different options to choose from when you need to read a file line by line.
<h2 id="scanner">Scanner</h2>
One of the easiest ways of reading a file line by line in Java could be implemented by using the <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html">Scanner</a> class. A Scanner breaks its input into tokens using a delimiter pattern, which in our case is the newline character:
<pre><code class="hljs">Scanner scanner = new Scanner(new File(&quot;filename&quot;));
while (scanner.hasNextLine()) {
 String line = scanner.nextLine();
 // process the line
}
</code></pre>
The <code>hasNextLine()</code> method returns <code>true</code> if there is another line in the input of this scanner, but the scanner itself does not advance past any input or read any data at this point.
To read the line and move on, we should use the <code>nextLine()</code> method. This method advances the scanner past the current line and returns the input that wasn't reached initially. This method returns the rest of the current line, excluding any line separator at the end of the line. The read position is then set to the beginning of the next line, which will be read and returned upon calling the method again.
Since this method continues to search through the input looking for a line separator, it may buffer all of the input while searching for the end of the line if no line separators are present.
<h2 id="bufferedreader">Buffered Reader</h2>
The <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/7/docs/api/java/io/BufferedReader.html">BufferedReader</a> class represents an efficient way of reading the characters, arrays, and lines from a character-input stream.
As described in the naming, this class uses a buffer. The default amount of data that is buffered is 8192 bytes, but it could be set to a custom size for performance reasons:
<pre><code class="hljs">BufferedReader br = new BufferedReader(new FileReader(file), bufferSize);
</code></pre>
The file, or rather an instance of a <code>File</code> class, isn't an appropriate data source for the <code>BufferedReader</code>, so we need to use a <code>FileReader</code>, which extends <code>InputStreamReader</code>. It is a convenience class for reading information from text files and isn't necessarily suitable for reading a raw stream of bytes:
<pre><code class="hljs">try (BufferedReader br = new BufferedReader(new FileReader(file))) {
 String line;
 while ((line = br.readLine()) != null) {
 // process the line
 }
}
</code></pre>
The initialization of a buffered reader was written using the try-with-resources syntax, specific to Java 7 or higher. If you're using an older version, you should initialize the <code>br</code> variable before the <code>try</code> statement and close it in the <code>finally</code> block.
Here's an example of the previous code without the try-with-resources syntax:
<pre><code class="hljs">BufferedReader br = new BufferedReader(new FileReader(file));
try {
 String line;
 while ((line = br.readLine()) != null) {
 // process the line
 }
} finally {
 br.close();
}
</code></pre>
The code will loop through the lines of the provided file and stop when it meets the <code>null</code> line, which is the end of the file.
Don't get confused as the <code>null</code> isn't equal to an empty line and the file will be read until the end.
<h3 id="thelinesmethod">The lines Method</h3>
A <code>BufferedReader</code> class also has a <code>lines</code> method that returns a <code>Stream</code>. This stream contains lines that were read by the <code>BufferedReader</code>, as its elements.
You can easily convert this stream into a list if you need to:
<pre><code class="hljs">List&lt;String&gt; list = new ArrayList&lt;&gt;();

try (BufferedReader br = new BufferedReader(new FileReader(file))) {
 list = br.lines().collect(Collectors.toList()); 
}
</code></pre>
Reading through this list is the same as reading through a Stream, which are covered in the next section:
<pre><code class="hljs">list.forEach(System.out::println);
</code></pre>
<h2 id="java8streams">Java 8 Streams</h2>
If you're already familiar with the Java 8 <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html">Streams</a>, you can use them as a cleaner alternative to the legacy loop:
<pre><code class="hljs">try (Stream&lt;String&gt; stream = Files.lines(Paths.get(fileName))) {
 stream.forEach(System.out::println);
}
</code></pre>
Here we're using try-with-resources syntax once again, initializing a lines stream with the <code>Files.lines()</code> static helper method. The <code>System.out::println</code> method reference is used for the demo purposes, and you should replace it with whatever code you'll be using to process your lines of text.
In addition to a clean API, streams are very useful when you want to apply multiple operations to the data or filter something out.
Let's assume we have a task to print all of the lines that are found in a given text file and end with the &quot;/&quot; character. The lines should be transformed to the uppercase and sorted alphabetically.
By modifying our initial &quot;Streams API&quot; example we'll get a very clean implementation:
<pre><code class="hljs">try (Stream&lt;String&gt; stream = Files.lines(Paths.get(fileName))) {
 stream
 .filter(s -&gt; s.endswith(&quot;/&quot;))
 .sorted()
 .map(String::toUpperCase)
 .forEach(System.out::println);
}
</code></pre>
The <code>filter()</code> method returns a stream consisting of the elements of this stream that match the given predicate. In our case we're leaving only those that end with the &quot;/&quot;.
The <code>map()</code> method returns a stream consisting of the results of applying the given function to the elements of this stream.
The <code>toUpperCase()</code> method of a <code>String</code> class helps us to achieve the desired result and is being used here as a method reference, just like the <code>println</code> call from our previous example.
The <code>sorted()</code> method returns a stream consisting of the elements of this stream, sorted according to the natural order. You're also able to provide a custom <code>Comparator</code>, and in that case sorting will be performed according to it.
While the order of operations could be changed for the <code>filter()</code>, <code>sorted()</code>, and <code>map()</code> methods, the <code>forEach()</code> should be always placed in the end as it's a terminal operation. It returns <code>void</code> and for that matter, nothing can be chained to it further.
<h2 id="apachecommons">Apache Commons</h2>
If you're already using <a rel="nofollow" target="_blank" href="https://commons.apache.org">Apache Commons</a> in your project, you might want to utilize the helper that reads all the lines from a file into a <code>List&lt;String&gt;</code>:
<pre><code class="hljs">List&lt;String&gt; lines = FileUtils.readLines(file, &quot;UTF-8&quot;);
for (String line: lines) {
 // process the line
}
</code></pre>
Remember, that this approach reads all lines from the file into the <code>lines</code> list and only then the execution of the <code>for</code> loop starts. It might take a significant amount of time, and you should think twice before using it on large text files.
<h2 id="conclusion">Conclusion</h2>
There are multiple ways of reading a file line by line in Java, and the selection of the appropriate approach is entirely a programmer's decision. You should think of the size of the files you plan to process, performance requirements, code style and libraries that are already in the project. Make sure to test on some corner cases like huge, empty, or non-existent files, and you'll be good to go with any of the provided examples.

Vasyl Lagutin

Reading a File Line by Line in Java

<h2 id="introduction">Introduction</h2>
Pickling is a popular method of preserving food. According to <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Pickling">Wikipedia</a>, it is also a pretty ancient procedure – although the origins of pickling are unknown, the ancient Mesopotamians probably used the process 4400 years ago. By placing a product in a specific solution, it is possible to drastically increase its shelf life. In other words, it's a method that lets us store food for later consumption.
If you're a Python developer, you might one day find yourself in need of a way to store your Python objects for later use. Well, what if I told you, you can pickle Python objects too?
<h2 id="serialization">Serialization</h2>
Serialization is a process of transforming objects or data structures into byte streams or strings. A byte stream is, well, a stream of bytes – one byte is composed of 8 bits of zeros and ones. These byte streams can then be stored or transferred easily. This allows the developers to save, for example, configuration data or user's progress, and then store it (on disk or in a database) or send it to another location.
Python objects can also be serialized using a module called <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/pickle.html">Pickle</a>.
One of the main differences between pickling Python objects and pickling vegetables is the inevitable and irreversible change of the pickled food's flavor and texture. Meanwhile, pickled Python objects can be easily un-pickled back to their original form. This process, by the way, is universally known as deserialization.
Pickling (or serialization in general) should not be confused with compression. The purpose of pickling is to translate data into a format that can be transferred from RAM to disk. Compression, on the other hand, is a process of encoding data using fewer bits (in order to save disk space).
Serialization is especially useful in any software where it's important to be able to save some progress on disk, quit the program and then load the progress back after reopening the program. Video games might be the most intuitive example of serialization's usefulness, but there are many other programs where saving and loading a user's progress or data is crucial.
<h2 id="picklevsjson">Pickle vs JSON</h2>
There is a chance that you have heard of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/JSON">JSON</a> (JavaScript Object Notation), which is a popular format that also lets developers save and transmit objects encoded as strings. This method of serialization has some advantages over pickling. JSON format is human-readable, language-independent, and faster than pickle.
It does have, however, some important limitations as well. Most importantly, by default, only a limited subset of Python built-in types can be represented by JSON. With Pickle, we can easily serialize a very large spectrum of Python types, and, importantly, custom classes. This means we don't need to create a custom schema (like we do for JSON) and write error-prone serializers and parsers. All of the heavy lifting is done for you with Pickle.
<h2 id="whatcanbepickledandunpickled">What can be Pickled and Unpickled</h2>
The following types can be serialized and deserialized using the Pickle module:
<ul>
<li>All native data types supported by Python (booleans, None, integers, floats, complex numbers, strings, bytes, byte arrays)</li>
<li>Dictionaries, sets, lists, and tuples - as long as they contain pickle-able objects</li>
<li>Functions and classes that are defined at the top level of a module</li>
</ul>
It is important to remember that pickling is not a language-independent serialization method, therefore your pickled data can only be un-pickled using Python. Moreover, it's important to make sure that objects are pickled using the same version of Python that is going to be used to unpickle them. Mixing Python versions, in this case, can cause many problems.
Additionally, functions are pickled by their name references, and not by their value. The resulting pickle does not contain information on the function's code or attributes. Therefore, you have to make sure that the environment where the function is unpickled is able to import the function. In other words, if we pickle a function and then unpickle it in an environment where it's either not defined or not imported, an exception will be raised.
It is also very important to note that pickled objects can be used in malevolent ways. For instance, un-pickling data from an untrusted source can result in the execution of a malicious piece of code.
<h2 id="picklingapythonlist">Pickling a Python List</h2>
The following very simple example shows the basics of using the Pickle module in <a rel="nofollow" target="_blank" href="https://www.python.org/download/releases/3.0/">Python 3</a>:
<pre><code class="hljs">import pickle

test_list = [&#x27;cucumber&#x27;, &#x27;pumpkin&#x27;, &#x27;carrot&#x27;]

with open(&#x27;test_pickle.pkl&#x27;, &#x27;wb&#x27;) as pickle_out:
 pickle.dump(test_list, pickle_out)
</code></pre>
First, we have to import the <code>pickle</code> module, which is done in line 1. In line 3 we define a simple, three element list that will be pickled.
In line 5 we state that our output pickle file's name will be <code>test_pickle.pkl</code>. By using the <code>wb</code> option, we tell the program that we want to write (<code>w</code>) binary data (<code>b</code>) inside of it (because we want to create a byte stream). Note that the <code>pkl</code> extension is not necessary – we're using it in this tutorial because that's the extension included in Python's documentation.
In line 6 we use the <code>pickle.dump()</code> method to pickle our test list and store it inside the <code>test_pickle.pkl</code> file.
I encourage you to try and open the generated pickle file in your text editor. You'll quickly notice that a byte stream is definitely not a human-readable format.
<h2 id="unpicklingapythonlist">Un-pickling a Python List</h2>
Now, let's unpickle the contents of the test pickle file and bring our object back to its original form.
<pre><code class="hljs">import pickle

with open(&#x27;test_pickle.pkl&#x27;, &#x27;rb&#x27;) as pickle_in:
 unpickled_list = pickle.load(pickle_in)

print(unpickled_list)
</code></pre>
As you can see, this procedure is not more complicated than when we pickled the object. In line 3 we open our <code>test_pickle.pkl</code> file again, but this time our goal is to read (<code>r</code>) the binary data (<code>b</code>) stored within it.
Next, in line 5, we use the <code>pickle.load()</code> method to unpickle our list and store it in the <code>unpickled_list</code> variable.
You can then print the contents of the list to see for yourself that it is identical to the list we pickled in the previous example. Here is the output from running the code above:
<pre><code class="hljs">$ python unpickle.py
[&#x27;cucumber&#x27;, &#x27;pumpkin&#x27;, &#x27;carrot&#x27;]
</code></pre>
<h2 id="picklingandunpicklingcustomobjects">Pickling and Unpickling Custom Objects</h2>
As I mentioned before, using Pickle, you can serialize your own custom objects. Take a look at the following example:
<pre><code class="hljs">import pickle

class Veggy():
 def __init__(self):
 self.color = &#x27;&#x27;
 def set_color(self, color):
 self.color = color

cucumber = Veggy()
cucumber.set_color(&#x27;green&#x27;)

with open(&#x27;test_pickle.pkl&#x27;, &#x27;wb&#x27;) as pickle_out:
 pickle.dump(cucumber, pickle_out)

with open(&#x27;test_pickle.pkl&#x27;, &#x27;rb&#x27;) as pickle_in:
 unpickled_cucumber = pickle.load(pickle_in)

print(unpickled_cucumber.color)
</code></pre>
As you can see, this example is almost as simple as the previous one. Between the lines 3 and 7 we define a simple class that contains one attribute and one method that changes this attribute. In line 9 we create an instance of that class and store it in the <code>cucumber</code> variable, and in line 10 we set its attribute <code>color</code> to &quot;green&quot;.
Then, using the exact same functions as in the previous example, we pickle and unpickle our freshly created <code>cucumber</code> object. Running the code above results in the following output:
<pre><code class="hljs">$ python unpickle_custom.py
green
</code></pre>
Remember, that we can only unpickle the object in an environment where the class <code>Veggy</code> is either defined or imported. If we create a new script and try to unpickle the object without importing the <code>Veggy</code> class, we'll get an &quot;AttributeError&quot;. For example, execute the following script:
<pre><code class="hljs">import pickle

with open(&#x27;test_pickle.pkl&#x27;, &#x27;rb&#x27;) as pickle_in:
 unpickled_cucumber = pickle.load(pickle_in)

print(unpickled_cucumber.color)
</code></pre>
In the output of the script above, you will see the following error:
<pre><code class="hljs">$ python unpickle_simple.py
Traceback (most recent call last):
 File &quot;&lt;pyshell#40&gt;&quot;, line 2, in &lt;module&gt;
 unpickled_cucumber = pickle.load(pickle_in)
AttributeError: Can&#x27;t get attribute &#x27;Veggy&#x27; on &lt;module &#x27;__main__&#x27; (built-in)&gt;
</code></pre>
<h2 id="conclusion">Conclusion</h2>
As you can see, thanks to the Pickle module, serialization of Python objects is pretty simple. In our examples, we pickled a simple Python list – but you can use the exact same method to save a large spectrum of Python data types, as long as you make sure your objects contain only other pickle-able objects.
Pickling has some disadvantages, the biggest of which might be the fact that you can only unpickle your data using Python – if you need a cross-language solution, JSON is definitely a better option. And finally, remember that pickles can be used to carry the code that you don't necessarily want to execute. Similarly to pickled food, as long as you get your pickles from trusted sources, you should be fine.

Mateusz Dobrychlop

Introduction to the Python Pickle Module

NumPy Tutorial: A Simple Example-Based Guide

<h2 id="introduction">Introduction</h2>
In this article, we'll be diving into Reading and Writing Files in Java.
When programming, whether you're creating a mobile app, a web application, or just writing scripts, you often have the need to read or write data to a file. This data could be cache data, data you retrieved for a dataset, an image, or just about anything else you can think of.
In this tutorial, we are going to show the most common ways you can read and write to files in Java.
Java provides several API (also known as <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/tutorial/essential/io/">Java I/O</a>) to read and write files since its initial releases. With subsequent releases, Java I/O has been improved, simplified and enhanced to support new features.
Before we get into some actual examples, it would help to understand the classes available to you that will handle the reading and writing of data to files. In the following sections we'll provide a brief overview of the Java I/O classes and explain what they do, then we'll take a look at Java NIO Streams, and finally we'll show some examples of reading and writing data to files.
<h2 id="iostreams">I/O Streams</h2>
There are two types of Streams you can use to interact with files:
<ol>
<li>Character Streams</li>
<li>Byte Streams</li>
</ol>
For each of the above stream types, there are several supporting classes shipped with Java, which we'll take a quick look at below.
<h3 id="characterstreams">Character Streams</h3>
Character Streams are used to read or write the characters data type. Let's look at the most commonly used classes. All of these classes are defined under the <code>java.io</code> package.
Here are some classes you should know that can be used to read character data:
<ul>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/Reader.html">Reader</a>: An abstract class to read a character stream.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/InputStreamReader.html">InputStreamReader</a>: Class used to read the byte stream and converts to character stream.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/FileReader.html">FileReader</a>: A class to read the characters from a file.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/BufferedReader.html">BufferedReader</a>: This is a wrapper over the <code>Reader</code> class that supports buffering capabilities. In many cases this is the most preferable class to read data because more data can be read from the file in one <code>read()</code> call, reducing the number of actual I/O operations with the file system.</li>
</ul>
And here are some classes you can use to write character data to a file:
<ul>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/Writer.html">Writer</a>: This is an abstract class to write the character streams.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/OutputStreamWriter.html">OutputStreamWriter</a>: This class is used to write character streams and also convert them to byte streams.</li>
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileWriter.html" rel="nofollow" target="_blank">FileWriter</a>: A class to actually write characters to the file.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/BufferedWriter.html">BufferedWriter</a>: This is a wrapper over the <code>Writer</code> class, which also supports buffering capabilities. This is the most preferable class to write data to a file since more data can be written to the file in one <code>write()</code> call. And like the <code>BufferedReader</code>, this reduces the number of total I/O operations with the file system.</li>
</ul>
<h3 id="bytestreams">Byte Streams</h3>
Byte Streams are used to read or write byte data with files. This is different from before in the way they treat the data. Here you work with raw bytes, which could be characters, image data, Unicode data (which takes 2 bytes to represent a character), etc.
In this section we'll take a look at the most commonly used classes. All of these classes are defined under the <code>java.io</code> package.
Here are the classes used to read the byte data:
<ul>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html">InputStream</a>: An abstract class to read the byte streams.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/FileInputStream.html">FileInputStream</a>: A class to simply read bytes from a file.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/BufferedInputStream.html">BufferedInputStream</a>: This is a wrapper over <code>InputStream</code> that supports buffering capabilities. As we saw in the character streams, this is a more efficient method than <code>FileInputStream</code>.</li>
</ul>
And here are the classes used to write the byte data:
<ul>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/OutputStream.html">OutputStream</a>: An abstract class to write byte streams.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/FileOutputStream.html">FileOutputStream</a>: A class to write raw bytes to the file.</li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/io/BufferedOutputStream.html">ByteOutputStream</a>: This class is a wrapper over <code>OutputStream</code> to support buffering capabilities. And again, as we saw in the character streams, this is a more efficient method than <code>FileOutputStream</code> thanks to the buffering.</li>
</ul>
<h2 id="javaniostreams">Java NIO Streams</h2>
<a target="_blank" rel="nofollow" href="https://docs.oracle.com/javase/8/docs/api/java/nio/package-summary.html">Java NIO</a> is a non-blocking I/O API which was introduced back in Java 4 and can be found in the <code>java.nio</code> package. In terms of performance, this is a big improvement in the API for I/O operations.
Buffers, Selectors, and Channels are the three primary components of Java NIO, although in this article we'll focus strictly on using the NIO classes for interacting with files, and not necessarily the concepts behind the API.
As this tutorial is about reading and writing files, we will discuss only the related classes in this short section:
<ul>
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/nio/file/Path.html" rel ="nofollow" target="_blank">Path</a>: This is a hierarchical structure of an actual file location and is typically used to locate the file you want to interact with.</li>
<li><a href= "https://docs.oracle.com/javase/8/docs/api/java/nio/file/Paths.html" rel="nofollow" target="_blank">Paths</a>: This is a class that provides several utility methods to create a <code>Path</code> from a given string URI.</li>
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html" target="_blank" rel="nofollow">Files</a>: This is another utility class which has several methods to read and write files without blocking the execution on threads.</li>
</ul>
Using these few classes, you can easily interact with files in a more efficient way.
<h2 id="thedifferencebetweenjavaioandnio">The Difference Between Java I/O and NIO</h2>
The main difference between these two packages is that the <code>read()</code> and <code>write()</code> methods of Java IO are blocking calls. By this we mean that the thread calling one of these methods will be blocked until the data has been read or written to the file.
On the other hand, in the case of NIO, the methods are non-blocking. This means that the calling threads can perform other tasks (like reading/writing data from another source or update the UI) while the <code>read</code> or <code>write</code> methods wait for their operation to complete. This can result in a significant performance increase if you're dealing with many IO requests or lots of data.
<h2 id="examplesofreadingandwritingtextfiles">Examples of Reading and Writing Text Files</h2>
In the previous sections, we have discussed the different APIs provided by Java and now it's time to use these API classes in some code.
The example code below handles reading and writing text files using the various classes we detailed above. To simplify things, and provide a better comparison of the actual methods being used, the input and output are going to remain the same between the examples.
Note: To avoid any confusion on the file path, the example code will read on and write from a file in the user's home directory. The user's home directory can be found using <code>System.getProperty(&quot;user.home&quot;);</code>, which is what we use in our examples.
<h3 id="readingandwritingwithfilereaderandfilewriter">Reading and Writing with FileReader and FileWriter</h3>
Let's start by using the <code>FileReader</code> and <code>FileWriter</code> classes:
<pre><code class="hljs">String directory = System.getProperty(&quot;user.home&quot;);
String fileName = &quot;sample.txt&quot;;
String absolutePath = directory + File.separator + fileName;

// Write the content in file 
try(FileWriter fileWriter = new FileWriter(absolutePath)) {
 String fileContent = &quot;This is a sample text.&quot;;
 fileWriter.write(fileContent);
 fileWriter.close();
} catch (IOException e) {
 // Cxception handling
}

// Read the content from file
try(FileReader fileReader = new FileReader(absolutePath)) {
 int ch = fileReader.read();
 while(ch != -1) {
 System.out.print((char)ch);
 fileReader.close();
 }
} catch (FileNotFoundException e) {
 // Exception handling
} catch (IOException e) {
 // Exception handling
}
</code></pre>
Both classes accept a String, representing the path to the file in their constructors. You can also pass a <code>File</code> object as well as a <code>FileDescriptor</code>.
The <code>write()</code> method writes a valid character sequence - either a <code>String</code>, a <code>char[]</code>. Additionally, it can write a single <code>char</code> represented as an <code>int</code>.
The <code>read()</code> method reads and returns character-by-character, allowing us to use the read data in a <code>while</code> loop for example.
Don't forget to close both of these classes after use!
<h3 id="readingandwritingwithbufferedreaderandbufferedwriter">Reading and Writing with BufferedReader and BufferedWriter</h3>
Using <code>BufferedReader</code> and <code>BufferedWriter</code> classes:
<pre><code class="hljs">String directory = System.getProperty(&quot;user.home&quot;);
String fileName = &quot;sample.txt&quot;;
String absolutePath = directory + File.separator + fileName;

// Write the content in file 
try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(absolutePath))) {
 String fileContent = &quot;This is a sample text.&quot;;
 bufferedWriter.write(fileContent);
} catch (IOException e) {
 // Exception handling
}

// Read the content from file
try(BufferedReader bufferedReader = new BufferedReader(new FileReader(absolutePath))) {
 String line = bufferedReader.readLine();
 while(line != null) {
 System.out.println(line);
 line = bufferedReader.readLine();
 }
} catch (FileNotFoundException e) {
 // Exception handling
} catch (IOException e) {
 // Exception handling
}
</code></pre>
<h3 id="readingandwritingwithfileinputstreamandfileoutputstream">Reading and Writing with FileInputStream and FileOutputStream</h3>
Using <code>FileInputStream</code> and <code>FileOutputStream</code> classes:
<pre><code class="hljs">String directory = System.getProperty(&quot;user.home&quot;);
String fileName = &quot;sample.txt&quot;;
String absolutePath = directory + File.separator + fileName;

// write the content in file 
try(FileOutputStream fileOutputStream = new FileOutputStream(absolutePath)) {
 String fileContent = &quot;This is a sample text.&quot;;
 fileOutputStream.write(fileContent.getBytes());
} catch (FileNotFoundException e) {
 // exception handling
} catch (IOException e) {
 // exception handling
}

// reading the content of file
try(FileInputStream fileInputStream = new FileInputStream(absolutePath)) {
 int ch = fileInputStream.read();
 while(ch != -1) {
 System.out.print((char)ch);
 ch = fileInputStream.read();
 }
} catch (FileNotFoundException e) {
 // exception handling
} catch (IOException e) {
 // exception handling
}
</code></pre>
<h3 id="readingandwritingwithbufferedinputstreamandbufferedoutputstream">Reading and Writing with BufferedInputStream and BufferedOutputStream</h3>
Using <code>BufferedInputStream</code> and <code>BufferedOutputStream</code> classes:
<pre><code class="hljs">String directory = System.getProperty(&quot;user.home&quot;);
String fileName = &quot;sample.txt&quot;;
String absolutePath = directory + File.separator + fileName;

// write the content in file 
try(BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(absolutePath))) {
 String fileContent = &quot;This is a sample text.&quot;;
 bufferedOutputStream.write(fileContent.getBytes());
} catch (IOException e) {
 // exception handling
}

// read the content from file
try(BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(absolutePath))) {
 int ch = bufferedInputStream.read();
 while(ch != -1) {
 System.out.print((char)ch);
 ch = bufferedInputStream.read();
 }
} catch (FileNotFoundException e) {
 // exception handling
} catch (IOException e) {
 // exception handling
}
</code></pre>
<h3 id="readingandwritingwithjavanioclasses">Reading and Writing with Java.nio Classes</h3>
Using the <code>java.nio</code> classes:
<pre><code class="hljs">String directory = System.getProperty(&quot;user.home&quot;);
String fileName = &quot;sample.txt&quot;;

String content = &quot;This is a sample text.&quot;;
Path path = Paths.get(directory, fileName);

try {
 Files.write(path, content.getBytes(), StandardOpenOption.CREATE);
} catch (IOException e) {
 // exception handling
}

try {
 List&lt;String&gt; list = Files.readAllLines(path);
 list.forEach(line -&gt; System.out.println(line));
} catch (IOException e) {
 // exception handling
}
</code></pre>
Another way to retrieve the content via the <code>Files</code> class, which is more important if you're not reading text data, is to use the <code>readAllBytes</code> method to read the data in to a byte array:
<pre><code class="hljs">try { 
 byte[] data = Files.readAllBytes(path);
 System.out.println(new String(data));
} catch (IOException e) {
 // exception handling
}
</code></pre>
In case you are interested in using streams with <code>java.nio</code>, you can also use the below methods provided by the <code>Files</code> class, which work just like the streams we covered earlier in the article:
<pre><code class="hljs">Files.newBufferedReader(path)
Files.newBufferedWriter(path, options)
Files.newInputStream(path, options)
Files.newOutputStream(path, options)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article we have covered the most common ways to read and write data to a file using both the Java I/O package and the newer Java NIO package. Whenever possible, we recommend to use the Java NIO classes for file operations due to its non-blocking API, and in addition the code is a bit more maintainable and readable.

Scott Robinson

In this tutorial, we'll be reading from and writing to files in Java using FileReader, FileWriter, BufferedReader, BufferedWriter, FileInputStream, FileOutputStream, etc.