<h2 id="introduction">Introduction</h2>
Time series analysis refers to the analysis of change in the trend of the data over a period of time. Time series analysis has a variety of applications. One such application is the prediction of the future value of an item based on its past values. Future stock price prediction is probably the best example of such an application. In this article, we will see how we can perform time series analysis with the help of a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Recurrent_neural_network">recurrent neural network</a>. We will be predicting the future stock prices of the Apple Company (AAPL), based on its stock prices of the past 5 years.
<h2 id="dataset">Dataset</h2>
The data that we are going to use for this article can be downloaded from <a rel="nofollow" target="_blank" href="https://finance.yahoo.com/quote/AAPL/history?p=AAPL&.tsrc=fin-srch">Yahoo Finance</a>. For training our algorithm, we will be using the Apple stock prices from 1st January 2013 to 31 December 2017. For the sake of prediction, we will use the Apple stock prices for the month of January 2018. So in order to evaluate the performance of the algorithm, download the actual stock prices for the month of January 2018 as well.
Let's now see how our data looks. Open the Apple stock price training file that contains data for five years. You will see that it contains seven columns: Date, Open, High, Low, Close, Adj Close and Volume. We will be predicting the opening stock price, therefore we are not interested in the rest of the columns.
If you plot the opening stock prices against the date, you will see the following plot:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/time-series-analysis-lstm-using-pythons-keras-library-1.png">
You can see that the trend is highly non-linear and it is very difficult to capture the trend using this information. This is where the power of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Long_short-term_memory">LSTM</a> can be utilized. LSTM (Long Short-Term Memory network) is a type of recurrent neural network capable of remembering the past information and while predicting the future values, it takes this past information into account.
Enough of the preliminaries, let's see how LSTM can be used for time series analysis.
<h2 id="predictingfuturestockprices">Predicting Future Stock Prices</h2>
Stock price prediction is similar to any other machine learning problem where we are given a set of features and we have to predict a corresponding value. We will perform the same steps as we do perform in order to solve any machine learning problem. Follow these steps:
<h3 id="importlibraries">Import Libraries</h3>
The first step, as always is to import the required libraries. Execute the following script to do so:
<pre><code class="hljs">import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
</code></pre>
<h3 id="importdataset">Import Dataset</h3>
Execute the following script to import the data set. For the sake of this article, the data has been stored in the Datasets folder, inside the &quot;E&quot; drive. You can change the path accordingly.
<pre><code class="hljs">apple_training_complete = pd.read_csv(r&#x27;E:\Datasets\apple_training.csv&#x27;)
</code></pre>
As we said earlier, we are only interested in the opening price of the stock. Therefore, we will filter all the data from our training set and will retain only the values for the Open column. Execute the following script:
<pre><code class="hljs">apple_training_processed = apple_training_complete.iloc[:, 1:2].values
</code></pre>
<h3 id="datanormalization">Data Normalization</h3>
As a rule of thumb, whenever you use a neural network, you should normalize or scale your data. We will use <code>MinMaxScaler</code> class from the <code>sklear.preprocessing</code> library to scale our data between 0 and 1. The <code>feature_range</code> parameter is used to specify the range of the scaled data. Execute the following script:
<pre><code class="hljs">from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range = (0, 1))

apple_training_scaled = scaler.fit_transform(apple_training_processed)
</code></pre>
<h3 id="converttrainingdatatorightshape">Convert Training Data to Right Shape</h3>
As I said earlier, in a time series problems, we have to predict a value at time T, based on the data from days T-N where N can be any number of steps. In this article, we are going to predict the opening stock price of the data based on the opening stock prices for the past 60 days. I have tried and tested different numbers and found that the best results are obtained when past 60 time steps are used. You can try different numbers and see how your algorithm performs.
Our feature set should contain the opening stock price values for the past 60 days while the label or dependent variable should be the stock price at the 61st day. Execute the following script to create feature and label set.
<pre><code class="hljs">features_set = []
labels = []
for i in range(60, 1260):
 features_set.append(apple_training_scaled[i-60:i, 0])
 labels.append(apple_training_scaled[i, 0])
</code></pre>
In the script above we create two lists: <code>feature_set</code> and <code>labels</code>. There are 1260 records in the training data. We execute a loop that starts from 61st record and stores all the previous 60 records to the <code>feature_set</code> list. The 61st record is stored in the <code>labels</code> list.
We need to convert both the <code>feature_set</code> and the <code>labels</code> list to the numpy array before we can use it for training. Execute the following script:
<pre><code class="hljs">features_set, labels = np.array(features_set), np.array(labels)
</code></pre>
In order to train LSTM on our data, we need to convert our data into the shape accepted by the LSTM. We need to convert our data into three-dimensional format. The first dimension is the number of records or rows in the dataset which is 1260 in our case. The second dimension is the number of time steps which is 60 while the last dimension is the number of indicators. Since we are only using one feature, i.e Open, the number of indicators will be one. Execute the following script:
<pre><code class="hljs">features_set = np.reshape(features_set, (features_set.shape[0], features_set.shape[1], 1))
</code></pre>
<h3 id="trainingthelstm">Training The LSTM</h3>
We have preprocessed our data and have converted it into the desired format. now is the time to create our LSTM. The LSTM model that we are going to create will be a sequential model with multiple layers. We will add four LSTM layers to our model followed by a dense layer that predicts the future stock price.
Let's first import the libraries that we are going to need in order to create our model:
<pre><code class="hljs">from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
</code></pre>
In the script above we imported the <code>Sequential</code> class from <code>keras.models</code> library and <code>Dense</code>, <code>LSTM</code>, and <code>Dropout</code> classes from <code>keras.layers</code> library.
As a first step, we need to instantiate the <code>Sequential</code> class. This will be our model class and we will add LSTM, Dropout and Dense layers to this model. Execute the following script
<pre><code class="hljs">model = Sequential()
</code></pre>
<h4 id="creatinglstmanddropoutlayers">Creating LSTM and Dropout Layers</h4>
Let's add LSTM layer to the model that we just created. Execute the following script to do so:
<pre><code class="hljs">model.add(LSTM(units=50, return_sequences=True, input_shape=(features_set.shape[1], 1)))
</code></pre>
To add a layer to the sequential model, the <code>add</code> method is used. Inside the <code>add</code> method, we passed our LSTM layer. The first parameter to the LSTM layer is the number of neurons or nodes that we want in the layer. The second parameter is <code>return_sequences</code>, which is set to true since we will add more layers to the model. The first parameter to the <code>input_shape</code> is the number of time steps while the last parameter is the number of indicators.
Let's now add a dropout layer to our model. Dropout layer is added to avoid over-fitting, which is a phenomenon where a machine learning model performs better on the training data compared to the test data. Execute the following script to add dropout layer.
<pre><code class="hljs">model.add(Dropout(0.2))
</code></pre>
Let's add three more LSTM and dropout layers to our model. Run the following script.
<pre><code class="hljs">model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))

model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))

model.add(LSTM(units=50))
model.add(Dropout(0.2))
</code></pre>
<h4 id="creatingdenselayer">Creating Dense Layer</h4>
To make our model more robust, we add a dense layer at the end of the model. The number of neurons in the dense layer will be set to 1 since we want to predict a single value in the output.
<pre><code class="hljs">model.add(Dense(units = 1))
</code></pre>
<h4 id="modelcompilation">Model Compilation</h4>
Finally, we need to compile our LSTM before we can train it on the training data. The following script compiles the our model.
<pre><code class="hljs">model.compile(optimizer = &#x27;adam&#x27;, loss = &#x27;mean_squared_error&#x27;)
</code></pre>
We call the compile method on the Sequential model object which is &quot;model&quot; in our case. We use the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Mean_squared_error">mean squared error</a> as loss function and to reduce the loss or to optimize the algorithm, we use the <a rel="nofollow" target="_blank" href="https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/">adam</a> optimizer.
<h4 id="algorithmtraining">Algorithm Training</h4>
Now is the time to train the model that we defined in the previous few steps. To do so, we call the <code>fit</code> method on the <code>model</code> and pass it our training features and labels as shown below:
<pre><code class="hljs">model.fit(features_set, labels, epochs = 100, batch_size = 32)
</code></pre>
Depending upon your hardware, model training can take some time.
<h3 id="testingourlstm">Testing our LSTM</h3>
We have successfully trained our LSTM, now is the time to test the performance of our algorithm on the test set by predicting the opening stock prices for the month of January 2018. However, as we did with the training data, we need to convert our test data in the right format.
Let's first import our test data. Execute the following script:
<pre><code class="hljs">apple_testing_complete = pd.read_csv(r&#x27;E:\Datasets\apple_testing.csv&#x27;)
apple_testing_processed = apple_testing_complete.iloc[:, 1:2].values
</code></pre>
In the above script, we import our test data and as we did with the training data, we removed all the columns from the test data except the column that contains opening stock prices.
If the opening stock prices for the month of January 2018 are plotted against the dates, you should see the following graph.
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/time-series-analysis-lstm-using-pythons-keras-library-2.png">
You can see that the trend is highly non-linear. Overall, the stock prices see small rise at the start of the month followed by a downward trend at the end of the month, with a slight increase and decrease in the stock prices in-between. It is extremely difficult to forecast such a trend. Let's see if the LSTM we trained is actually able to predict such a trend.
<h4 id="convertingtestdatatorightformat">Converting Test Data to Right Format</h4>
For each day of January 2018, we want our feature set to contain the opening stock prices for the previous 60 days. For the 1st of January, we need the stock prices for the previous 60 days. To do so, we need to concatenate our training data and test data before preprocessing. Execute the following script to do so:
<pre><code class="hljs">apple_total = pd.concat((apple_training_complete[&#x27;Open&#x27;], apple_testing_complete[&#x27;Open&#x27;]), axis=0)
</code></pre>
Now let's prepare our test inputs. The input for each day should contain the opening stock prices for the previous 60 days. That means we need opening stock prices for the 20 test days for the month of January 2018 and the 60 stock prices from the last 60 days for the training set. Execute the following script to fetch those 80 values.
<pre><code class="hljs">test_inputs = apple_total[len(apple_total) - len(apple_testing_complete) - 60:].values
</code></pre>
As we did for the training set, we need to scale our test data. Execute the following script:
<pre><code class="hljs">test_inputs = test_inputs.reshape(-1,1)
test_inputs = scaler.transform(test_inputs)
</code></pre>
We scaled our data, now let's prepare our final test input set that will contain previous 60 stock prices for the month of January. Execute the following script:
<pre><code class="hljs">test_features = []
for i in range(60, 80):
 test_features.append(test_inputs[i-60:i, 0])
</code></pre>
Finally, we need to convert our data into the three-dimensional format which can be used as input to the LSTM. Execute the following script:
<pre><code class="hljs">test_features = np.array(test_features)
test_features = np.reshape(test_features, (test_features.shape[0], test_features.shape[1], 1))
</code></pre>
<h4 id="makingpredictions">Making Predictions</h4>
Now is the time to see the magic. We preprocessed our test data and now we can use it to make predictions. To do so, we simply need to call the <code>predict</code> method on the model that we trained. Execute the following script:
<pre><code class="hljs">predictions = model.predict(test_features)
</code></pre>
Since we scaled our data, the predictions made by the LSTM are also scaled. We need to reverse the scaled prediction back to their actual values. To do so, we can use the <code>ìnverse_transform</code> method of the scaler object we created during training. Take a look at the following script:
<pre><code class="hljs">predictions = scaler.inverse_transform(predictions)
</code></pre>
Finally, let's see how well did our algorithm predicted the future stock prices. Execute the following script:
<pre><code class="hljs">plt.figure(figsize=(10,6))
plt.plot(apple_testing_processed, color=&#x27;blue&#x27;, label=&#x27;Actual Apple Stock Price&#x27;)
plt.plot(predictions , color=&#x27;red&#x27;, label=&#x27;Predicted Apple Stock Price&#x27;)
plt.title(&#x27;Apple Stock Price Prediction&#x27;)
plt.xlabel(&#x27;Date&#x27;)
plt.ylabel(&#x27;Apple Stock Price&#x27;)
plt.legend()
plt.show()
</code></pre>
The output looks like this:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/time-series-analysis-lstm-using-pythons-keras-library-3.png">
In the output, the blue line represents the actual stock prices for the month of January 2018, while the red line represents the predicted stock prices. You can clearly see that our algorithm has been able to capture the overall trend. The predicted prices also see a bullish trend at the beginning followed by a bearish or downwards trend at the end. Amazing, isn't it?
<h3 id="conclusion">Conclusion</h3>
A long short-term memory network (LSTM) is one of the most commonly used neural networks for time series analysis. The ability of LSTM to remember previous information makes it ideal for such tasks. In this article, we saw how we can use LSTM for the Apple stock price prediction. I would suggest that you download stocks of some other organization like Google or Microsoft from Yahoo Finance and see if your algorithm is able to capture the trends.

Usman Malik

Time Series Analysis with LSTM using Python's Keras Library

Mateusz Dobrychlop

Python GUI Development with Tkinter: Part 3

<h2 id="introduction">Introduction</h2>
Handling files is an entry-level and fundamental skill for any programmer. They're very commonly used to store application data, user configurations, videos, images, etc. There are a countless number of use-cases for files in software applications, so you'd be smart to make yourself deeply familiar with the tasks of manipulating files. These tasks could include (among others) creating, deleting, and moving files.
In this article, we'll cover the process of working with files using the Python programming language. The built-in methods it offers makes it very easy to handle files using a relatively small amount of code. As with anything in programming, there are many ways to achieve the same goal when it comes to files, but in this article we'll stick with the basics and show the most common ways to perform these actions.
<h2 id="creatingfilesinpython">Creating Files in Python</h2>
<h3 id="fileopeningmodes">File Opening Modes</h3>
There are modes in which you can open a file in Python. The mode you choose depends on how you plan to use the file, or what kind of data you'll be reading (writing) from (to) the file. This mode is specified when opening a file using the built-in <code>open()</code> method, explained in further detail in the next section.
Let's take a look at some of the possible combinations of file modes:
<ul>
<li><code>w</code>: Opens a file for writing and creates a new file if it doesn't yet exist. In the case that the file does exist, it overwrites it.</li>
<li><code>w+</code>: Opens a file for writing but also for reading and creating it if it doesn't exist. If a file already exists, it overwrites it.</li>
<li><code>r</code>: Opens a file for reading only.</li>
<li><code>rb</code>: Opens a file for reading in Binary format.</li>
<li><code>wb</code>: Opens a file for writing in Binary format.</li>
<li><code>wb+</code>: Opens a file for writing and reading in Binary format.</li>
<li><code>a</code>: Opens a file for appending at the end of the file.</li>
<li><code>+</code>: In general, this character is used along side <code>r</code>, <code>w</code>, or <code>a</code> and means both writing and reading.</li>
</ul>
If no file mode is specified, then <code>r</code> will be assumed by default.
When choosing a mode, take in to careful consideration what your use-case is and what all the file will be used for for the duration that it is open.
<h3 id="open">open()</h3>
As with just about anything in Python, performing many file-related tasks is very simple. For example, creating a file in Python can be done in a single line of code:
<pre><code class="hljs">myFile = open(&quot;new.txt&quot;, &quot;w+&quot;)
</code></pre>
In the example above we have opened a file, &quot;new.txt&quot; for reading and writing. In our case, since the file does not already exist, it is automatically created.
The <code>open()</code> method accepts many arguments, although the majority of the time you'll only use these two:
<ul>
<li>filename – Required field to specify the name of the file we wish to open/create. In our example, &quot;new.txt&quot;</li>
<li>mode – Optional argument to specify the file opening mode, in our example &quot;w+&quot;</li>
</ul>
You can omit the second argument, in which case it will be assumed by Python as <code>r</code>.
The other arguments not listed here allow you to configure buffering, encodings, newline handling, etc. For more info on these arguments, check out the <a rel="nofollow" target="_blank" href="https://docs.python.org/3.3/library/functions.html#open">official Python documentation</a> on the <code>open</code> method.
<h3 id="close">close()</h3>
When you open a file you always need to make sure that you also close it. This can be done using the file object's <code>close()</code> method, or opening it using the <code>with</code> keyword that Python provides, which closes it automatically when out of scope. After closing the file, it won't be available for reading or writing within your code anymore, unless you open it back up.
Keeping your files open will use up system resources, slow down your program, and in some cases prevent the file from being used by other code. Python's garbage collection does it's best to automatically close files when they're not being used anymore, but you shouldn't rely on it.
If a file is already closed, calling <code>close()</code> on it again won't affect it at all:
<pre><code class="hljs">myFile.close()
myFile.close() # Doesn&#x27;t affect the file
</code></pre>
<h2 id="movingfilesinpython">Moving Files in Python</h2>
To move a file in Python, we will need to import the <code>os</code> and <code>shutil</code> modules that provide us the ability to copy, move, and remove files in Python. Both of these modules provide methods to do so, although in many cases the <code>shutil</code> module has more convenient methods.
<pre><code class="hljs">import os
import shutil

# Move a file by renaming it&#x27;s path
os.rename(&#x27;/Users/billy/d1/xfile.txt&#x27;, &#x27;/Users/billy/d2/xfile.txt&#x27;)

# Move a file from the directory d1 to d2
shutil.move(&#x27;/Users/billy/d1/xfile.txt&#x27;, &#x27;/Users/billy/d2/xfile.txt&#x27;)
</code></pre>
Keep in mind that the destination directory needs to exist in order for this example to work. Once you've set up the directories &quot;d1&quot; and &quot;d2&quot; (or just changed the example to fit your directory structure), run the code. Now check out the &quot;d2&quot; directory and you should see the xfile.txt if now present in that directory.
Pretty simple, right?
<h2 id="deletingfilesinpython">Deleting Files in Python</h2>
As you probably guessed, it's pretty easy to remove a file in Python using the <code>remove()</code> method from the <code>os</code> module.
In our example below, we'll delete the &quot;xfile.txt&quot;. All we need to do is call the <code>remove()</code> method with the path of the file we want to delete:
<pre><code class="hljs">import os

# Delete xfile.txt
os.remove(&#x27;/Users/billy/d2/xfile.txt&#x27;)
</code></pre>
Now check out the &quot;d2&quot; directory again and the file xfile.txt will now be done. Simple as that!
<h2 id="conclusion">Conclusion</h2>
In this article, we showed very simple examples of how to create, move, and delete files in Python using the built-in functions such as <code>open()</code>, <code>shutil.move()</code>, and <code>os.remove()</code>. In addition, we presented a simple introduction and explanation of Python file modes.

Guest Contributor

How to Create, Move, and Delete Files in Python

Applying Wrapper Methods in Python for Feature Selection

<h2 id="overview">Overview</h2>
In this article, we'll cover the process of creating custom both checked and unchecked exceptions in Java.
If you'd like to read more about exceptions and exception handling in Java, we've covered it in detail in - <a rel="nofollow" target="_blank" href="/exception-handling-in-java-a-complete-guide-with-best-and-worst-practices/">Exception Handling in Java: A Complete Guide with Best and Worst Practices</a>
<h2 id="whyusecustomexceptions">Why Use Custom Exceptions?</h2>
Although Java exceptions, as they are, cover nearly all exceptional cases and conditions, your application might throw a specific custom exception, unique to your code and logic.
Sometimes, we need to create our own for representing business logic exceptions, i.e. exceptions that are specific to our business logic or workflow. For example <code>EmailNotUniqueException</code>, <code>InvalidUserStateException</code>, etc.
They help application clients to better understand what went wrong. They are particularly useful for doing exception handling for REST APIs as different business logic constraints require different response codes to be sent back to the client.
If defining a custom exception doesn't provide benefit over using a regular exception in Java, there's no need to define custom exceptions and you should just stick to the ones that are already available - no need to invent hot water again.
<h2 id="customcheckedexception">Custom Checked Exception</h2>
Let's consider a scenario where we want to validate an email that is passed as an argument to a method.
We want to check whether it's valid or not. Now we could use Java's built-in <code>IllegalArgumentException</code>, which is fine if we are just checking for a single thing like whether it matches a predefined REGEX or not.
But suppose we also have a business condition to check that all emails in our system need to be unique. Now we have to perform a second check (DB/network call). We can, of course, use the same <code>IllegalArgumentException</code>, but it will be not clear what the exact cause is - whether the email failed REGEX validation or the email already exists in the database.
Let's create a custom exception to handle this situation. To create an exception, like any other exception, we have to extend the <code>java.lang.Exception</code> class:
<pre><code class="hljs">public class EmailNotUniqueException extends Exception {

 public EmailNotUniqueException(String message) {
 super(message);
 }
}

</code></pre>
Note that we provided a constructor that takes a <code>String</code> error message and calls the parent class constructor. Now, this is not mandatory but it's a common practice to have some sort of details about the exception that occurred.
By calling <code>super(message)</code>, we initialize the exception's error message and the base class takes care of setting up the custom message, according to the <code>message</code>.
Now, let's use this custom exception in our code. Since we're defining a method that can throw an exception in the service layer, we'll mark it with the <code>throws</code> keyword.
If the input email already exists in our database (in this case a list), we <code>throw</code> our custom exception:
<pre><code class="hljs">public class RegistrationService { 
 List&lt;String&gt; registeredEmails = Arrays.asList(&quot;abc@gmail.com&quot;, &quot;xyz@gmail.com&quot;);

 public void validateEmail(String email) throws EmailNotUniqueException {
 if (registeredEmails.contains(email)) {
 throw new EmailNotUniqueException(&quot;Email Already Registered&quot;);
 }
 }
}

</code></pre>
Now let's write a client for our service. Since it's a checked exception, we have to adhere to the handle-or-declare rule. In the proceeding example, we decided to &quot;handle&quot; it:
<pre><code class="hljs">public class RegistrationServiceClient { 
 public static void main(String[] args) {
 RegistrationService service = new RegistrationService();
 try {
 service.validateEmail(&quot;abc@gmail.com&quot;);
 } catch (EmailNotUniqueException e) {
 // logging and handling the situation
 }
 }
}

</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">mynotes.custom.checked.exception.EmailNotUniqueException: Email Already Registered 
 at mynotes.custom.checked.exception.RegistrationService.validateEmail(RegistrationService.java:12)
 at mynotes.custom.checked.exception.RegistrationServiceClient.main(RegistrationServiceClient.java:9)

</code></pre>
Note: The exception handling process is omitted for brevity but is an important process nonetheless.
<h2 id="customuncheckedexception">Custom Unchecked Exception</h2>
This works perfectly fine but our code has become a bit messy. Additionally, we are forcing the client to capture our exception in a <code>try-catch</code> block. In some cases, this can lead to forcing developers to write boilerplate code.
In this case, it can be beneficial to create a custom runtime exception instead. To create a custom unchecked exception we have to extend the <code>java.lang.RuntimeException</code> class.
Let's consider the situation where we have to check if the email has a valid domain name or not:
<pre><code class="hljs">public class DomainNotValidException extends RuntimeException {

 public DomainNotValidException(String message) {
 super(message);
 }
}

</code></pre>
Now let use it in our service:
<pre><code class="hljs">public class RegistrationService {

 public void validateEmail(String email) {
 if (!isDomainValid(email)) {
 throw new DomainNotValidException(&quot;Invalid domain&quot;);
 }
 }

 private boolean isDomainValid(String email) {
 List&lt;String&gt; validDomains = Arrays.asList(&quot;gmail.com&quot;, &quot;yahoo.com&quot;, &quot;outlook.com&quot;);
 if (validDomains.contains(email.substring(email.indexOf(&quot;@&quot;) + 1))) {
 return true;
 }
 return false;
 }
}

</code></pre>
Notice that we did not have to use the <code>throws</code> keywords at the method signature since it is an unchecked exception.
Now let's write a client for our service. We don't have to use a <code>try-catch</code> block this time:
<pre><code class="hljs">public class RegistrationServiceClient {

 public static void main(String[] args) {
 RegistrationService service = new RegistrationService();
 service.validateEmail(&quot;abc@gmail1.com&quot;);
 }
}

</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">Exception in thread &quot;main&quot; mynotes.custom.unchecked.exception.DomainNotValidException: Invalid domain 
 at mynotes.custom.unchecked.exception.RegistrationService.validateEmail(RegistrationService.java:10)
 at mynotes.custom.unchecked.exception.RegistrationServiceClient.main(RegistrationServiceClient.java:7)

</code></pre>
Note: Of course, you can surround your code with a <code>try-catch</code> block to capture the arising exception but now it's not being forced by the compiler.
<h2 id="rethrowinganexceptionwrappedinsideacustomexception">Rethrowing an Exception Wrapped Inside a Custom Exception</h2>
Sometimes we need to catch an exception and re-throw it by adding in a few more details. This is usually common if you have various error codes defined in your application that needs to be either logged or returned to the client in case of that particular exception.
Suppose your application has a standard <code>ErrorCodes</code> class:
<pre><code class="hljs">public enum ErrorCodes { 
 VALIDATION_PARSE_ERROR(422);

 private int code;

 ErrorCodes(int code) {
 this.code = code;
 }

 public int getCode() {
 return code;
 }
}

</code></pre>
Let's create our custom exception:
<pre><code class="hljs">public class InvalidCurrencyDataException extends RuntimeException {

 private Integer errorCode;

 public InvalidCurrencyDataException(String message) {
 super(message);
 }

 public InvalidCurrencyDataException(String message, Throwable cause) {
 super(message, cause);
 }

 public InvalidCurrencyDataException(String message, Throwable cause, ErrorCodes errorCode) {
 super(message, cause);
 this.errorCode = errorCode.getCode();
 }

 public Integer getErrorCode() {
 return errorCode;
 }
}

</code></pre>
Notice we have multiple constructors and let the service class decide which one to use. Since we are rethrowing the exception, it's always a good practice to capture the root cause of the exception hence the <code>Throwable</code> argument which can be passed` to the parent class constructor.
We are also capturing the error code in one of the constructors and set the <code>errorCode</code> within the exception itself. The <code>errorCode</code> could be used by the client for logging or any other purpose. This helps in a more centralized standard for exception handling.
Lets write our service class:
<pre><code class="hljs">public class CurrencyService { 
 public String convertDollarsToEuros(String value) {
 try {
 int x = Integer.parseInt(value);
 } catch (NumberFormatException e) {
 throw new InvalidCurrencyDataException(&quot;Invalid data&quot;, e, ErrorCodes.VALIDATION_PARSE_ERROR);
 }
 return value;
 }
}

</code></pre>
So we caught the standard <code>NumberFormatException</code>and threw our own <code>InvalidCurrencyDataException</code>. We passed the parent exception to our custom exception so that we won't lose the root cause from which they occurred.
Let's write a test client for this service:
<pre><code class="hljs">public class CurrencyClient { 
 public static void main(String[] args) {
 CurrencyService service = new CurrencyService();
 service.convertDollarsToEuros(&quot;asd&quot;);
 }
}

</code></pre>
Output:
<pre><code class="hljs">Exception in thread &quot;main&quot; mynotes.custom.unchecked.exception.InvalidCurrencyDataException: Invalid data 
 at mynotes.custom.unchecked.exception.CurrencyService.convertDollarsToEuro(CurrencyService.java:10)
 at mynotes.custom.unchecked.exception.CurrencyClient.main(CurrencyClient.java:8)
Caused by: java.lang.NumberFormatException: For input string: &quot;asd&quot; 
 at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
 at java.lang.Integer.parseInt(Integer.java:580)
 at java.lang.Integer.parseInt(Integer.java:615)
 at mynotes.custom.unchecked.exception.CurrencyService.convertDollarsToEuro(CurrencyService.java:8)
 ... 1 more

</code></pre>
As you can see we have a nice stack-trace of the exception which could be useful for debugging purposes.
<h2 id="bestpracticesforcustomexceptions">Best Practices for Custom Exceptions</h2>
<ul>
<li>Adhere to the general naming convention throughout the Java ecosystem - All custom exception class names should end with &quot;Exception&quot;</li>
<li>Avoid making custom exceptions if standard exceptions from the JDK itself can serve the purpose. In most cases, there's no need to define custom exceptions.</li>
<li>Prefer runtime exceptions over checked exceptions. Frameworks like <a href="https://spring.io/">Spring</a> have wrapped all checked exception to runtime exceptions, hence not forcing the client to write boilerplate code that they don't want or need to.</li>
<li>Provide many overloaded constructors based on how the custom exception would be thrown. If it's being used for rethrowing an existing exception then definitely provide a constructor that sets the cause.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
Custom exceptions are used for specific business logic and requirements. In this article, we've discussed the need for them as well as covered their usage.
The code for the examples used in this article can be found on <a rel="nofollow" target="_blank" href="https://github.com/StackAbuse/java">Github</a>.

Time Series Analysis with LSTM using Python's Keras Library

Python GUI Development with Tkinter: Part 3

How to Create, Move, and Delete Files in Python

Applying Wrapper Methods in Python for Feature Selection

How to Make Custom Exceptions in Java

Asynchronous Python for Web Development

Overloading Functions and Operators in Python

Java's Object Methods: clone()

Applying Filter Methods in Python for Feature Selection