Usman Malik

Creating a Neural Network from Scratch in Python: Multi-class Classification

Adam McQuistan

Java's Object Methods: hashCode()

<h2 id="introduction">Introduction</h2>
Python has a wide variety of useful packages for machine learning and statistical analysis such as <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/">TensorFlow</a>, <a rel="nofollow" target="_blank" href="http://www.numpy.org/">NumPy</a>, <a rel="nofollow" target="_blank" href="http://scikit-learn.org/stable/">scikit-learn</a>, <a rel="nofollow" target="_blank" href="https://pandas.pydata.org/">Pandas</a>, and more. One package that is essential to most data science projects is <a rel="nofollow" target="_blank" href="https://matplotlib.org/">matplotlib</a>.
Available for any Python distribution, it can be installed on Python 3 with <code>pip</code>. Other methods are also available, check <a rel="nofollow" target="_blank" href="https://matplotlib.org/">https://matplotlib.org/</a> for more details.
<h2 id="installation">Installation</h2>
If you use an OS with a terminal, the following command would install matplotlib with pip:
<pre><code class="hljs">$ python3 -m pip install matplotlib
</code></pre>
<h2 id="importingenvironment">Importing &amp; Environment</h2>
In a Python file, we want to import the <code>pyplot</code> function that allows us to interface with a MATLAB-like plotting environment. We also import a <code>lines</code> function that lets us add lines to plots:
<pre><code class="hljs">import matplotlib.pyplot as plt
import matplotlib.lines as mlines
</code></pre>
Essentially, this plotting environment lets us save figures and their attributes as variables. These plots can then be printed and viewed with a simple command. For an example, we can look at the stock price of Google: specifically the date, open, close, volume, and adjusted close price (date is stored as an <code>np.datetime64</code>) for the most recent 250 days:
<pre><code class="hljs">import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cbook as cbook

with cbook.get_sample_data(&#x27;goog.npz&#x27;) as datafile:
 price_data = np.load(datafile)[&#x27;price_data&#x27;].view(np.recarray)
price_data = price_data[-250:] # get the most recent 250 trading days
</code></pre>
We then transform the data in a way that is done quite often for time series, etc. We find the difference, <code>$d_i$</code>, between each observation and the one before it:
<code>$$d_i = y_i - y_{i - 1} $$</code>
<pre><code class="hljs">delta1 = np.diff(price_data.adj_close) / price_data.adj_close[:-1]
</code></pre>
We can also look at the transformations of different variables, such as volume and closing price:
<pre><code class="hljs"># Marker size in units of points^2
volume = (15 * price_data.volume[:-2] / price_data.volume[0])**2
close = 0.003 * price_data.close[:-2] / 0.003 * price_data.open[:-2]
</code></pre>
<h2 id="plottingascatterplot">Plotting a Scatter Plot</h2>
To actually plot this data, you can use the <code>subplots()</code> functions from <code>plt</code> (<code>matplotlib.pyplot</code>). By default this generates the area for the figure and the axes of a plot.
Here we will make a scatter plot of the differences between successive days. To elaborate, x is the difference between day i and the previous day. y is the difference between day i+1 and the previous day (i):
<pre><code class="hljs">fig, ax = plt.subplots()
ax.scatter(delta1[:-1], delta1[1:], c=close, s=volume, alpha=0.5)

ax.set_xlabel(r&#x27;$\Delta_i$&#x27;, fontsize=15)
ax.set_ylabel(r&#x27;$\Delta_{i+1}$&#x27;, fontsize=15)
ax.set_title(&#x27;Volume and percent change&#x27;)

ax.grid(True)
fig.tight_layout()

plt.show()
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-1.png">
We then create labels for the x and y axes, as well as a title for the plot. We choose to plot this data with grids and a tight layout.
<code>plt.show()</code> displays the plot for us.
<h2 id="addingaline">Adding a Line</h2>
We can add a line to this plot by providing x and y coordinates as lists to a <code>Line2D</code> instance:
<pre><code class="hljs">import matplotlib.lines as mlines

fig, ax = plt.subplots()
line = mlines.Line2D([-.15,0.25], [-.07,0.09], color=&#x27;red&#x27;)
ax.add_line(line)

# reusing scatterplot code
ax.scatter(delta1[:-1], delta1[1:], c=close, s=volume, alpha=0.5)

ax.set_xlabel(r&#x27;$\Delta_i$&#x27;, fontsize=15)
ax.set_ylabel(r&#x27;$\Delta_{i+1}$&#x27;, fontsize=15)
ax.set_title(&#x27;Volume and percent change&#x27;)

ax.grid(True)
fig.tight_layout()

plt.show()
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-2.png">
<h2 id="plottinghistograms">Plotting Histograms</h2>
To plot a histogram, we follow a similar process and use the <code>hist()</code> function from <code>pyplot</code>. We will generate 10000 random data points, x, with a mean of 100 and standard deviation of 15.
The <code>hist</code> function takes the data, x, number of bins, and other arguments such as density, which normalizes the data to a probability density, or alpha, which sets the transparency of the histogram.
We will also use the library <a rel="nofollow" target="_blank" href="https://pypi.org/project/mlab/">mlab</a> to add a line representing a normal density function with the same mean and standard deviation:
<pre><code class="hljs">import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt

mu, sigma = 100, 15
x = mu + sigma*np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 30, density=1, facecolor=&#x27;blue&#x27;, alpha=0.75)

# add a &#x27;best fit&#x27; line
y = mlab.normpdf( bins, mu, sigma)
l = plt.plot(bins, y, &#x27;r--&#x27;, linewidth=4)

plt.xlabel(&#x27;IQ&#x27;)
plt.ylabel(&#x27;Probability&#x27;)
plt.title(r&#x27;$\mathrm{Histogram\ of\ IQ:}\ \mu=100,\ \sigma=15$&#x27;)
plt.axis([40, 160, 0, 0.03])
plt.grid(True)

plt.show()
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-3.png">
<h2 id="barcharts">Bar Charts</h2>
While histograms helped us with visual densities, bar charts help us view counts of data. To plot a bar chart with matplotlib, we use the <code>bar()</code> function. This takes the counts and data labels as x and y, along with other arguments.
As an example, we could look at a sample of the number of programmers that use different languages:
<pre><code class="hljs">import numpy as np
import matplotlib.pyplot as plt
 
objects = (&#x27;Python&#x27;, &#x27;C++&#x27;, &#x27;Java&#x27;, &#x27;Perl&#x27;, &#x27;Scala&#x27;, &#x27;Lisp&#x27;)
y_pos = np.arange(len(objects))
performance = [10,8,6,4,2,1]
 
plt.bar(y_pos, performance, align=&#x27;center&#x27;, alpha=0.5)
plt.xticks(y_pos, objects)
plt.ylabel(&#x27;Usage&#x27;)
plt.title(&#x27;Programming language usage&#x27;)
 
plt.show()
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-4.png">
<h2 id="plottingimages">Plotting Images</h2>
Analyzing images is very common in Python. Not surprisingly, we can use matplotlib to view images. We use the <a rel="nofollow" trarget="_blank" href="https://pypi.org/project/opencv-python/">cv2</a> library to read in images.
The <code>read_image()</code> function summary is below:
<ul>
<li>reads the image file</li>
<li>splits the color channels</li>
<li>changes them to RGB</li>
<li>resizes the image</li>
<li>returns a matrix of RGB values</li>
</ul>
The rest of the code reads in the first five images of cats and dogs from data used in an image recognition CNN. The pictures are concatenated and printed on the same axis:
<pre><code class="hljs">import matplotlib.pyplot as plt
import numpy as np
import os, cv2

cwd = os.getcwd()
TRAIN_DIR = cwd + &#x27;/data/train/&#x27;

ROWS = 256
COLS = 256
CHANNELS = 3

train_images = [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR)] # use this for full dataset
train_dogs = [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR) if &#x27;dog&#x27; in i]
train_cats = [TRAIN_DIR+i for i in os.listdir(TRAIN_DIR) if &#x27;cat&#x27; in i]

def read_image(file_path):
 img = cv2.imread(file_path, cv2.IMREAD_COLOR) #cv2.IMREAD_GRAYSCALE
 b,g,r = cv2.split(img)
 img2 = cv2.merge([r,g,b])
 return cv2.resize(img2, (ROWS, COLS), interpolation=cv2.INTER_CUBIC)

for a in range(0,5):
 cat = read_image(train_cats[a])
 dog = read_image(train_dogs[a])
 pair = np.concatenate((cat, dog), axis=1)
 plt.figure(figsize=(10,5))
 plt.imshow(pair)
 plt.show()
</code></pre>
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-5.png">
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-6.png">
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-7.png">
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-8.png">
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/a-brief-introduction-matplotlib-data-visualization-9.png">
<h2 id="conclusion">Conclusion</h2>
In this post we saw a brief introduction of how to use matplotlib to plot data in scatter plots, histograms, and bar charts. We also added lines to these plots. Finally, we saw how to read in images using the cv2 library and used matplotlib to plot the images.

Guest Contributor

A Brief Introduction to matplotlib for Data Visualization

Java's Object Methods: equals(Object)

Mateusz Dobrychlop

Python GUI Development with Tkinter

Vasyl Lagutin

Reading and Writing XML in Java

<h2 id="introduction">Introduction</h2>
This article is a continuation of a series of articles describing the often forgotten about methods of the Java language's base Object class. Below are the methods of the base Java Object present in all Java objects due to the implicit inheritance of Object along with links to each article of this series.
<ul>
<li><a target="_blank" href="/javas-object-methods-tostring/">toString</a></li>
<li>getClass (you are here)</li>
<li><a target="_blank" href="https://stackabuse.com/javas-object-methods-equals-object">equals</a></li>
<li><a target="_blank" href="https://stackabuse.com/javas-object-methods-hashcode">hashCode</a></li>
<li><a target="_blank" href="/javas-object-methods-clone/">clone</a></li>
<li><a target="_blank" href="/javas-object-methods-finalize/">finalize</a></li>
<li><a target="_blank" href="/javas-object-methods-wait-notify/">wait &amp; notify</a></li>
</ul>
The focus of this article is the <code>getClass()</code> method, which is used to access metadata about the class of the object you are working with.
<h2 id="thegetclassmethod">The getClass() Method</h2>
The somewhat confusing or misunderstood Object method <code>getClass()</code> returns an instance of the Class class, which contains information about the class that <code>getClass()</code> was called from. Whew, if you're not confused already by that last statement, good for you, because I am and I wrote it!
Let me try to unpack that sentence with a demonstration of how this might be used. Below you will find the <code>Person</code> class I used in the initial article on the Object class's <code>toString()</code> method.
<pre><code class="hljs">package com.adammcquistan.object;

import java.time.LocalDate;

public class Person {
 private String firstName;
 private String lastName;
 private LocalDate dob;

 public Person(String firstName, String lastName, LocalDate dob) {
 this.firstName = firstName;
 this.lastName = lastName;
 this.dob = dob;
 }

 public String getFirstName() {
 return firstName;
 }

 public void setFirstName(String firstName) {
 this.firstName = firstName;
 }

 public String getLastName() {
 return lastName;
 }

 public void setLastName(String lastName) {
 this.lastName = lastName;
 }

 public LocalDate getDob() {
 return dob;
 }

 public void setDob(LocalDate dob) {
 this.dob = dob;
 }

 @Override
 public String toString() {
 return &quot;&lt;Person: firstName=&quot; + firstName + &quot;, lastName=&quot; + lastName + &quot;, dob=&quot; + dob + &quot;&gt;&quot;;
 }
}
</code></pre>
Let's focus on the overridden <code>toString()</code> method, which lists the name of the class, Person, along with the values of the instance's fields. Instead of &quot;hard-coding&quot; the name of the class, Person, in the string itself I could have actually used the <code>getClass()</code> method to return an instance of the Class class, which will contain that info and allow me to use it like so:
<pre><code class="hljs">public class Person {
 // omitting everything else remaining the same

 @Override
 public String toString() {
 Class c = getClass();
 return &quot;&lt;&quot; + c.getName() + &quot;: firstName=&quot; + firstName + &quot;, lastName=&quot; + lastName + &quot;, dob=&quot; + dob + &quot;&gt;&quot;;
 }
}
</code></pre>
This would lead to replacing the original hard-coded &quot;Person&quot; text with the fully qualified class name of &quot;com.adammcquistan.object.Person&quot;. The Class class is packed full of different methods that allow you to identify all kinds of things about the class object that <code>getClass()</code> was called on.
For example, if I wanted to get a more simplified <code>toString()</code> representation of my <code>Person</code> class I could simply swap out the <code>c.getName()</code> call with <code>c.getSimpleName()</code> like shown below. This in turn would return &quot;Person&quot; instead of the fully qualified class name &quot;com.adammcquistan.object.Person&quot;.
<pre><code class="hljs">public class Person {
 // omitting everything else remaining the same

 @Override
 public String toString() {
 Class c = getClass();
 return &quot;&lt;&quot; + c.getSimpleName() + &quot;: firstName=&quot; + firstName + &quot;, lastName=&quot; + lastName + &quot;, dob=&quot; + dob + &quot;&gt;&quot;;
 }
}
</code></pre>
A major difference in the semantics of how <code>getClass()</code> is used in comparison to the other <code>Object</code> methods is that <code>getClass()</code> cannot be overridden because it is declared as a <code>final</code> method.
<h2 id="whatistheclassobjectgoodfor">What is the Class object Good For?</h2>
At this point you may be asking yourself, &quot;Ok I guess it is pretty cool that I can get information about a class by calling getClass() and retrieving its Class object representation, but how is this useful to me as a programmer?&quot;. Believe me, I've asked myself this question as well and my general conclusion has been... it's not. At least it is not really from an everyday programmer's perspective. However, if you happen to be a library or framework developer then you are likely to get very familiar with the information and behavior of <code>Class</code> objects because it is essential for the concept known as <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Reflection_(computer_programming)">reflection</a>.
Reflection allows for two primary things: (i) runtime investigation of objects and their contents and, (ii) dynamic access to fields and execution of methods during runtime.
Item number one was already demonstrated above by using <code>getClass()</code> to get a runtime representation of the <code>Person</code> class to access either the fully qualified or simple class name in a modified version of the <code>toString()</code> method.
The second item is a bit more involved to whip up an example for, but it is something that is quite helpful to be able to access metadata on a class. Some of the information that you can interrogate an instance of <code>Class</code> for are things like constructors, fields, and methods plus other things like inheritance hierarchies of a class, like its super classes and interfaces.
An example of this is the ability to use debuggers in an IDE like Eclipse and Netbeans to see the member's and their values in a class while the program is in execution.
Take for example the following:
<pre><code class="hljs">public class Main {
 public static void main(String[] args) {
 Person me = new Person(&quot;Adam&quot;, &quot;McQuistan&quot;, LocalDate.parse(&quot;1987-09-23&quot;));

 Class c = me.getClass();
 for (Field f : c.getDeclaredFields()) {
 f.setAccessible(true);
 try {
 System.out.println(f.getName() + &quot; = &quot; + f.get(me));
 } catch (Exception e) {
 e.printStackTrace();
 }

 }
 }
}
</code></pre>
Would output the following:
<pre><code class="hljs">firstName = Adam
lastName = McQuistan
dob = 1987-09-23
</code></pre>
Again, no non-masochist would probably ever do this in regular everyday programming, but you will see this type of thing done often in frameworks.
<h2 id="conclusion">Conclusion</h2>
In this article I described the meaning and use of the mysterious <code>getClass()</code> method of the Java Object class. I have shown how it can be used to get metadata on a class instance such as the name of the class of an object at runtime as well as provided an explanation of why accessing a Class instance may be useful.
As always, thanks for reading and don't be shy about commenting or critiquing below.

Java's Object Methods: getClass()

<h2 id="introduction">Introduction</h2>
In this article I will be kicking off a series of articles describing the often forgotten methods of the Java language's base Object class. Below are the methods of the base Java Object, which are present in all Java objects due to the implicit inheritance of Object. Links to each article of this series are included for each method as the articles are published.
<ul>
<li>toString (you are here)</li>
<li><a target="_blank" href="https://stackabuse.com/javas-object-methods-getclass/">getClass</a></li>
<li><a target="_blank" href="https://stackabuse.com/javas-object-methods-equals-object">equals</a></li>
<li><a target="_blank" href="https://stackabuse.com/javas-object-methods-hashcode">hashCode</a></li>
<li><a target="_blank" href="https:://stackabuse.com/javas-object-methods-clone">clone</a></li>
<li><a target="_blank" href="/javas-object-methods-finalize/">finalize</a></li>
<li><a target="_blank" href="/javas-object-methods-wait-notify/">wait &amp; notify</a></li>
</ul>
In the sections that follow I will be describing what these methods are, their base implementations, and how to override them when needed. The focus of this first article is the <code>toString()</code> method which is used to give a string representation that identifies an object instance and conveys its content and / or meaning in human readable form.
<h2 id="thetostringmethod">The toString() Method</h2>
At first glance the <code>toString()</code> method may seem like a fairly useless method and, to be honest, its default implementation is not very helpful. By default the <code>toString()</code> method will return a string that lists the name of the class followed by an @ sign and then a hexadecimal representation of the memory location the instantiated object has been assigned to.
To help aid in my discussion of the ubiquitous Java Object methods I will work with a simple <code>Person</code> class, defined like so:
<pre><code class="hljs">package com.adammcquistan.object;

import java.time.LocalDate;

public class Person {
 private String firstName;
 private String lastName;
 private LocalDate dob;
 
 public Person() {}
 
 public Person(String firstName, String lastName, LocalDate dob) {
 this.firstName = firstName;
 this.lastName = lastName;
 this.dob = dob;
 }

 public String getFirstName() {
 return firstName;
 }

 public void setFirstName(String firstName) {
 this.firstName = firstName;
 }

 public String getLastName() {
 return lastName;
 }

 public void setLastName(String lastName) {
 this.lastName = lastName;
 }

 public LocalDate getDob() {
 return dob;
 }

 public void setDob(LocalDate dob) {
 this.dob = dob;
 }
}

</code></pre>
Along with this class I have a rudimentary <code>Main</code> class to run the examples shown below to introduce the features of the base implementation of <code>toString()</code>.
<pre><code class="hljs">package com.adammcquistan.object;

import java.time.LocalDate;

public class Main {
 public static void main(String[] args) {
 Person me = new Person(&quot;Adam&quot;, &quot;McQuistan&quot;, LocalDate.parse(&quot;1987-09-23&quot;));
 Person me2 = new Person(&quot;Adam&quot;, &quot;McQuistan&quot;, LocalDate.parse(&quot;1987-09-23&quot;));
 Person you = new Person(&quot;Jane&quot;, &quot;Doe&quot;, LocalDate.parse(&quot;2000-12-25&quot;));
 System.out.println(&quot;1. &quot; + me.toString());
 System.out.println(&quot;2. &quot; + me);
 System.out.println(&quot;3. &quot; + me + &quot;, &quot; + you);
 System.out.println(&quot;4. &quot; + me + &quot;, &quot; + me2);
}
</code></pre>
The output looks like this:
<pre><code class="hljs">1. com.adammcquistan.object.Person@458ad742
2. com.adammcquistan.object.Person@458ad742
3. com.adammcquistan.object.Person@458ad742, com.adammcquistan.object.Person@5afa04c
4. com.adammcquistan.object.Person@458ad742, com.adammcquistan.object.Person@6ea12c19
</code></pre>
The first thing to mention is that the output for lines one and two are identical, which shows that when you pass an object instance to methods like <code>print</code>, <code>println</code>, <code>printf</code>, as well as loggers, the <code>toString()</code> method is implicitly called. 
Additionally, this implicit call to <code>toString()</code> also occurs during concatenation as shown in line 3's output.
Ok, now its time for me to interject my own personal opinion when it comes to Java programming best practices. What stands out to you as potentially worrisome about line 4 (actually any of the output for that matter)?
Hopefully you are answering with a question along these lines, &quot;well Adam, it's nice that the output tells me the class name, but what the heck am I to do with that gobbledygook memory address?&quot;.
And I would respond with, &quot;Nothing!&quot;. It's 99.99% useless to us as programmers. A much better idea would be for us to override this default implementation and provide something that is actually meaningful, like this:
<pre><code class="hljs">public class Person {
 // omitting everyting else remaining the same

 @Override
 public String toString() {
 return &quot;&lt;Person: firstName=&quot; + firstName + &quot;, lastName=&quot; + lastName + &quot;, dob=&quot; + dob + &quot;&gt;&quot;;
 }
}
</code></pre>
Now if I rerun the earlier Main class I get the following greatly improved output:
<pre><code class="hljs">1. &lt;Person: firstName=Adam, lastName=McQuistan, dob=1987-09-23&gt;
2. &lt;Person: firstName=Adam, lastName=McQuistan, dob=1987-09-23&gt;
3. &lt;Person: firstName=Adam, lastName=McQuistan, dob=1987-09-23&gt;, &lt;User: firstName=Jane, lastName=Doe, dob=2000-12-25&gt;
4. &lt;Person: firstName=Adam, lastName=McQuistan, dob=1987-09-23&gt;, &lt;User: firstName=Adam, lastName=McQuistan, dob=1987-09-23&gt;
</code></pre>
OMG! Something that I can read! With this implementation I now stand a fighting chance of actually being able to comprehend what is going on in a log file. This is especially helpful when tech support is screaming about erratic behavior relating to People instances in the program I'm on the hook for.
<h2 id="caveatsforimplementingandusingtostring">Caveats for Implementing and Using toString()</h2>
As shown in the previous section, implementing an informative <code>toString()</code> method in your classes is a rather good idea as it provides a way to meaningfully convey the content and identity of an object. However, there are times when you will want to take a slightly different approach to implementing them.
For example, say you have an object that simply contains too much state to pack into the output of a <code>toString()</code> method or when the object mostly contains a collection of utility methods. In these cases it is often advisable to output a simple description of the class and its intentions.
Consider the following senseless utility class which finds and returns the oldest person of a list of People objects.
<pre><code class="hljs">public class OldestPersonFinder {
 public List&lt;Person&gt; family;
 
 public OldestPersonFinder(List&lt;Person&gt; family) {
 this.family = family;
 }

 public Person oldest() {
 if (family.isEmpty()) {
 return null;
 }
 Person currentOldest = null;
 for (Person p : family) {
 if (currentOldest == null || p.getDob().isAfter(currentOldest.getDob())) {
 currentOldest = p;
 }
 }
 return currentOldest;
 }

 @Override
 public String toString() {
 return &quot;Class that finds the oldest Person in a List&quot;;
 }
}
</code></pre>
In this case it would not be very helpful to loop over the entire collection of <code>Person</code> objects in the family <code>List</code> instance member and build some ridiculously large string to return representing each <code>Person</code>. Instead, it is much more meaningful to return a string describing the intentions of the class which in this case is to find the <code>Person</code> who is the oldest.
Another thing that I would like to strongly suggest is to make sure you provide access to all information specific to your class's data that you include in the output to your <code>toString()</code> method.
Say, for example, I had not provided a getter method for my <code>Person</code> class's <code>dob</code> member in a vain attempt to keep the person's age a secret. Unfortunately, the users of my <code>Person</code> class are eventually going to realize that they can simply parse the output of the <code>toString()</code> method and acquire the data they seek that way. Now if I ever change the implementation of <code>toString()</code> I am almost certain to break their code. On the other hand, let me say that it's generally a bad idea to go parsing an object's <code>toString()</code> output for this very reason.
<h2 id="conclusion">Conclusion</h2>
This article described the uses and value in the often forgotten about <code>toString()</code> method of the Java base Object class. I have explained the default behavior and given my opinion as to why I think it is a best practice to implement your own class specific behavior.
As always, thanks for reading and don't be shy about commenting or critiquing below.

Java's Object Methods: toString()

<h2 id="introduction">Introduction</h2>
The main subject of this article is advanced data processing topics using a new functionality added to Java 8 – The Stream API and the Collector API.
To get the most out of this article you should already be familiar with the main Java APIs, the <code>Object</code> and <code>String</code> classes, and the Collection API.
<h2 id="streamapi">Stream API</h2>
The <code>java.util.stream</code> package consists of classes, interfaces, and many types to allow for functional-style operations over elements. Java 8 introduces a concept of a Stream that allows the programmer to process data descriptively and rely on a multi-core architecture without the need to write any special code.
<h2 id="whatisastream">What is a Stream?</h2>
A <code>Stream</code> represents a sequence of objects derived from a source, over which aggregate operations can be performed.
From a purely technical point of view, a Stream is a typed interface - a stream of T. This means that a stream can be defined for any kind of object, a stream of numbers, a stream of characters, a stream of people, or even a stream of a city.
From a developer point of view, it is a new concept that might just look like a Collection, but it is in fact much different from a Collection.
There are a few key definitions we need to go through to understand this notion of a Stream and why it differs from a Collection:
<h3 id="astreamdoesnotholdanydata">A Stream does not Hold any Data</h3>
The most common misconception which I'd like to address first - a stream does not hold any data. This is very important to keep that in mind and understand.
There is no data in a Stream, however, there is data held in a Collection.
A <code>Collection</code> is a structure that holds its data. A Stream is just there to process the data and pull it out from the given source, or move it to a destination. The source might be a Collection, though it might also be an array or I/O resource. The stream will connect to the source, consume the data, and process the elements in it in some way.
<h3 id="astreamshouldntmodifythesource">A Stream shouldn't Modify the Source</h3>
A stream should not modify the source of the data it processes. This is not really enforced by the compiler of the JVM itself, so it is merely a contract. If I am to build my own implementation of a stream, I should not modify the source of the data I am processing. Although it is perfectly fine to modify the data in the stream though.
Why is that so? Because if we want to process this data in parallel, we are going to distribute it among all the cores of our processors and we do not want to have any kind of visibility or synchronization issues that could lead to bad performances or errors. Avoiding this kind of interference means that we shouldn't modify the source of the data while we're processing it.
<h3 id="asourcemaybeunbounded">A Source may be Unbounded</h3>
Probably the most powerful point out of these three. It means that the stream in itself can process as much data as we want. Unbounded does not mean that a source has to be infinite. In fact, a source may be finite, but we might not have access to the elements contained in that source.
Suppose the source is a simple text file. A text file has a known size even if it is very big. Also suppose that the elements of that source are, in fact, the lines of this text file.
Now, we might know the exact size of this text file but if we do not open it and manually go through the content, we'll never know how many lines it has. This is what unbounded means - we might not always know beforehand the number of elements a stream will process from the source.
Those are the three definitions of a stream. So we can see from those three definitions that a stream really has nothing to do with a collection. A collection holds its data. A collection can modify the data it holds. And of course, a collection holds a known and finite amount of data.
<h2 id="streamcharacteristics">Stream Characteristics</h2>
<ul>
<li>Element sequence - Streams provide a set of elements of a particular type in a sequential manner. The stream gets an element on demand and never stores an item.</li>
<li>Source - Streams take a collection, array, or I/O resources as a source for their data.</li>
<li>Aggregate operations - Streams support aggregate operations such as forEach, filter, map, sorted, match, and others.</li>
<li>Overriding - Most operations over a Stream returns a Stream, which means their results can be chained. The function of these operations is to take input data, process it, and return the target output. The <code>collect()</code> method is a terminal operation that is usually present at the end of operations to indicate the end of the Stream processing.</li>
<li>Automated iterations - Stream operations carry out iterations internally over the source of the elements, as opposed to collections where explicit iteration is required.</li>
</ul>
<h2 id="creatingastream">Creating a Stream</h2>
We can generate a stream with the help of a few methods:
<h3 id="stream">stream()</h3>
The <code>stream()</code> method returns the sequential stream with a Collection as its source. You can use any collection of objects as a source:
<pre><code class="hljs">private List&lt;String&gt; list = new Arrays.asList(&quot;Scott&quot;, &quot;David&quot;, &quot;Josh&quot;);
list.stream();
</code></pre>
<h3 id="parallelstream">parallelStream()</h3>
The <code>parallelStream()</code> method returns a parallel stream with a Collection as its source:
<pre><code class="hljs">private List&lt;String&gt; list = new Arrays.asList(&quot;Scott&quot;, &quot;David&quot;, &quot;Josh&quot;);
list.parallelStream().forEach(element -&gt; method(element));
</code></pre>
The thing with parallel streams is that when executing such an operation, the Java runtime segregates the stream into multiple substreams. It executes the aggregate operations and the combines the result. In our case, it calls the <code>method</code> with each element in the stream in parallel.
Although, this can be a double-edged sword, since executing heavy operations this way could block other parallel streams since it blocks the threads in the pool.
<h3 id="streamof">Stream.of()</h3>
The static <code>of()</code> method can be used to create a Stream from an array of objects or individual objects:
<pre><code class="hljs">Stream.of(new Employee(&quot;David&quot;), new Employee(&quot;Scott&quot;), new Employee(&quot;Josh&quot;));
</code></pre>
<h3 id="streambuilder">Stream.builder()</h3>
And lastly, you can use the static <code>.builder()</code> method to create a Stream of objects:
<pre><code class="hljs">Stream.builder&lt;String&gt; streamBuilder = Stream.builder();

streamBuilder.accept(&quot;David&quot;);
streamBuilder.accept(&quot;Scott&quot;);
streamBuilder.accept(&quot;Josh&quot;);

Stream&lt;String&gt; stream = streamBuilder.build();
</code></pre>
By calling the <code>.build()</code> method, we pack the accepted objects into a regular Stream.
<h2 id="filteringwithastream">Filtering with a Stream</h2>
<pre><code class="hljs">public class FilterExample {
 public static void main(String[] args) {
 List&lt;String&gt; fruits = Arrays.asList(&quot;Apple&quot;, &quot;Banana&quot;, &quot;Cherry&quot;, &quot;Orange&quot;);

 // Traditional approach
 for (String fruit : fruits) {
 if (!fruit.equals(&quot;Orange&quot;)) {
 System.out.println(fruit + &quot; &quot;);
 }
 }

 // Stream approach
 fruits.stream() 
 .filter(fruit -&gt; !fruit.equals(&quot;Orange&quot;))
 .forEach(fruit -&gt; System.out.println(fruit));
 }
}
</code></pre>
A traditional approach to filtering out a single fruit would be with a classic for-each loop.
The second approach uses a Stream to filter out the elements of the Stream that match the given predicate, into a new Stream that is returned by the method.
Additionally, this approach uses a <code>forEach()</code> method, that performs an action for each element of the returned stream. You can replace this with something called a method reference. In Java 8, a method reference is the shorthand syntax for a lambda expression that executes just one method.
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/introduction-to-java-8-streams-1.png">
The method reference syntax is simple, and you can even replace the previous lambda expression <code>.filter(fruit -&gt; !fruit.equals(&quot;Orange&quot;))</code> with it:
<pre><code class="hljs">Object::method;
</code></pre>
Let's update the example and use method references and see how it looks like:
<pre><code class="hljs">public class FilterExample {
 public static void main(String[] args) {
 List&lt;String&gt; fruits = Arrays.asList(&quot;Apple&quot;, &quot;Banana&quot;, &quot;Cherry&quot;, &quot;Orange&quot;);

 fruits.stream()
 .filter(FilterExample::isNotOrange)
 .forEach(System.out::println);
 }
 
 private static boolean isNotOrange(String fruit) {
 return !fruit.equals(&quot;Orange&quot;);
 }
}
</code></pre>
Streams are easier and better to use with Lambda expressions and this example highlights how simple and clean the syntax looks compared to the traditional approach.
<h2 id="mappingwithastream">Mapping with a Stream</h2>
A traditional approach would be to iterate through a list with an enhanced for loop:
<pre><code class="hljs">List&lt;String&gt; models = Arrays.asList(&quot;BMW&quot;, &quot;Audi&quot;, &quot;Peugeot&quot;, &quot;Fiat&quot;);

System.out.print(&quot;Imperative style: &quot; + &quot;\n&quot;);

for (String car : models) {
 if (!car.equals(&quot;Fiat&quot;)) {
 Car model = new Car(car);
 System.out.println(model);
 }
}
</code></pre>
On the other hand, a more modern approach is to use a Stream to map:
<pre><code class="hljs">List&lt;String&gt; models = Arrays.asList(&quot;BMW&quot;, &quot;Audi&quot;, &quot;Peugeot&quot;, &quot;Fiat&quot;);
 
System.out.print(&quot;Functional style: &quot; + &quot;\n&quot;);

models.stream()
 .filter(model -&gt; !model.equals(&quot;Fiat&quot;))
// .map(Car::new) // Method reference approach
// .map(model -&gt; new Car(model)) // Lambda approach
 .forEach(System.out::println);
</code></pre>
To illustrate mapping, consider this class:
<pre><code class="hljs">private String name;
 
public Car(String model) {
 this.name = model;
}

// getters and setters

@Override
public String toString() {
 return &quot;name=&#x27;&quot; + name + &quot;&#x27;&quot;;
}
</code></pre>
It's important to note that the <code>models</code> list is a list of Strings – not a list of <code>Car</code>. The <code>.map()</code> method expects an object of type T and returns an object of type R.
We're converting String into a type of Car, essentially.
If you run this code, the imperative style and functional style should return the same thing.
<h2 id="collectingwithastream">Collecting with a Stream</h2>
Sometimes, you'd want to convert a Stream to a Collection or Map. Using the utility class Collectors and the functionalities it offers:
<pre><code class="hljs">List&lt;String&gt; models = Arrays.asList(&quot;BMW&quot;, &quot;Audi&quot;, &quot;Peugeot&quot;, &quot;Fiat&quot;);

List&lt;Car&gt; carList = models.stream()
 .filter(model -&gt; !model.equals(&quot;Fiat&quot;))
 .map(Car::new)
 .collect(Collectors.toList());
</code></pre>
<h2 id="matchingwithastream">Matching with a Stream</h2>
A classic task is to categorize objects according to certain criteria. We can do this by matching the needed information to the object information and check if that's what we need:
<pre><code class="hljs">List&lt;Car&gt; models = Arrays.asList(new Car(&quot;BMW&quot;, 2011), new Car(&quot;Audi&quot;, 2018), new Car(&quot;Peugeot&quot;, 2015));

boolean all = models.stream().allMatch(model -&gt; model.getYear() &gt; 2010);
System.out.println(&quot;Are all of the models newer than 2010: &quot; + all);

boolean any = models.stream().anyMatch(model -&gt; model.getYear() &gt; 2016);
System.out.println(&quot;Are there any models newer than 2016: &quot; + any);

boolean none = models.stream().noneMatch(model -&gt; model.getYear() &lt; 2010);
System.out.println(&quot;Is there a car older than 2010: &quot; + none);
</code></pre>
<ul>
<li><code>allMatch()</code> - Returns <code>true</code> if all elements of this stream match the provided predicate.</li>
<li><code>anyMatch()</code> - Returns <code>true</code> if any element of this stream match the provided predicate.</li>
<li><code>noneMatch()</code> - Returns <code>true</code> if no element of this stream matches the provided predicate.</li>
</ul>
In the preceding code example, all of the given predicates are satisfied and all will return <code>true</code>.
<h2 id="conclusion">Conclusion</h2>
Most people today are using Java 8. Though not everybody is using Streams. Just because they represent a newer approach to programming and represent a touch with functional style programming along with lambda expressions for Java, doesn't necessarily mean that it's a better approach. They simply offer a new way of doing things. It's up to developers themselves to decide whether to rely on functional or imperative style programming. With a sufficient level of exercise, combining both principles can help you improve your software.
As always, we encourage you to check out the <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html">official documentation</a> for additional information.