Adam McQuistan

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.

Vuk Skobalj

Introduction to Java 8 Streams

<h2 id="overview">Overview</h2>
In this article, we'll cover the process of creating a <a rel="nofollow" target="_blank" href="https://www.docker.com/">Docker</a> image of a <a rel="nofollow" target="_blank" href="https://spring.io/projects/spring-boot">Spring Boot</a> application, using <a rel="nofollow" target="_blank" href="https://docs.docker.com/engine/reference/builder/">Dockerfile</a> and <a rel="nofollow" target="_blank" href="https://maven.apache.org/">Maven</a> and then run the image we've created.
The source code for this tutorial can be found <a rel="nofollow" target="_blank" href="https://github.com/dhananjay12/learning-spring/tree/master/demo-docker">on GitHub</a>.
This tutorial assumes that you have Docker installed on your machine. If not, you can follow the official <a rel="nofollow" target="_blank" href="https://docs.docker.com/install/">Docker install</a> guide based on your operating system.
If you'd like to read more about Docker, we've covered it in detail in - <a target="_blank" href="/docker-a-high-level-introduction/">Docker: A High Level Introduction</a>.
<h2 id="thespringbootapplication">The Spring Boot Application</h2>
Let's start off with a simple Spring Boot Application. The best way to start with a skeleton project is to visit <a rel="nofollow" target="_blank" href="https://start.spring.io/">Spring Initializr</a>. Select your preferred version of Spring Boot, and add the &quot;Web&quot; dependency. Generate it as a Maven project and you're all set!
<img class="img-responsive" alt="Spring Initializr" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-1.png">
The project includes a simple REST controller with a single mapping that just expects a name as the path variable and then generates a string to greet it:
<pre><code class="hljs">@RestController
public class DemoController {

 @GetMapping(&quot;/greet/{name}&quot;)
 public String greeting(@PathVariable String name) {
 return &quot;Hi!! &quot; + name;
 }
}
</code></pre>
To run the application, use the following Maven command from the project root folder:
<pre><code class="hljs">$ mvn spring-boot:run
</code></pre>
As usual, the application will be running on port 8080. To test this endpoint, navigate your browser (or use <a rel="nofollow" target="_blank" href="https://curl.haxx.se/">curl</a>, <a rel="nofollow" target="_blank" href="https://www.getpostman.com/">postman</a>, etc.) to &quot;<a href="http://localhost:8080/greet/john">http://localhost:8080/greet/john</a>&quot;, you will see a response that looks something like:
<img class="img-responsive" alt="REST response 1" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-2.png">
<h2 id="dockerizingthespringbootapp">Dockerizing the Spring Boot App</h2>
Now let's dockerize our previously made Spring Boot Application. We will cover the two most commonly used approaches:
<ul>
<li>Dockerfile – Specifying a file that contains native Docker commands to build the image</li>
<li>Maven – Using a Maven plugin to build the image</li>
</ul>
<h3 id="dockerizingusingdockerfile">Dockerizing using Dockerfile</h3>
A Dockerfile is just a regular <code>.txt</code> file that includes native Docker commands that are used to specify the layers of an image. To do so, let's create a text file named &quot;Dockerfile&quot;:
<img class="img-responsive" alt="Docker file" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-3.png">
The content of the file itself can look something like this:
<pre><code class="hljs">FROM java:8-jdk-alpine

COPY ./target/demo-docker-0.0.1-SNAPSHOT.jar /usr/app/

WORKDIR /usr/app

RUN sh -c &#x27;touch demo-docker-0.0.1-SNAPSHOT.jar&#x27;

ENTRYPOINT [&quot;java&quot;,&quot;-jar&quot;,&quot;demo-docker-0.0.1-SNAPSHOT.jar&quot;]
</code></pre>
Let's take a look at the commands and fully understand them before proceeding:
<ul>
<li>FROM – The keyword <code>FROM</code> tells Docker to use a given base image as a build base. We have used 'java' with the tag '8-jdk-alpine'. Think of a tag as a version. The base image changes from project to project. You can search for images on <a rel="nofollow" target="_blank" href="https://hub.docker.com/">docker-hub</a>.</li>
<li>COPY - This tells Docker to copy files from the local file-system to a specific folder inside the build image. Here, we copy our <code>.jar</code> file to the build image (Linux image) inside <code>/usr/app</code>.</li>
<li>WORKDIR - The <code>WORKDIR</code> instruction sets the working directory for any <code>RUN</code>, <code>CMD</code>, <code>ENTRYPOINT</code>, <code>COPY</code> and <code>ADD</code> instructions that follow in the Dockerfile. Here we switched the workdir to <code>/usr/app</code> so we don't have to write the long path again and again.</li>
<li>RUN - This tells Docker to execute a shell command-line within the target system. Here we practically just &quot;touch&quot; our file so that it has its modification time updated (Docker creates all container files in an &quot;unmodified&quot; state by default).</li>
<li>ENTRYPOINT - This allows you to configure a container that will run as an executable. It's where you tell Docker how to run your application. We know we run our spring-boot app as <code>java -jar &lt;app-name&gt;.jar</code>, so we put it in an array.</li>
</ul>
More documentation can be found on the <a rel="nofollow" target="_blank" href="https://docs.docker.com/engine/reference/builder/">Dockerfile reference</a> page.
Before moving further, we need a Spring Boot <code>.jar</code> file. This file will be used to create the Docker image as mentioned above.
Run the <code>mvn clean install</code> command to make sure that it's generated.
Let's build the image using this Dockerfile. To do so, move to the root directory of the application and run this command:
<pre><code class="hljs">$ docker build -t greeting-app .
</code></pre>
<img class="img-responsive" alt="Docker build 1" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-4.png">
We built the image using <code>docker build</code>. We gave it a name with the <code>-t</code> flag and specified the current directory where the Dockerfile is. The image is built and stored in our local docker registry.
Let's check our image:
<pre><code class="hljs">$ docker images
</code></pre>
<img class="img-responsive" alt="Docker images 1" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-5.png">
And finally, let's run our image:
<pre><code class="hljs">$ docker run -p 8090:8080 greeting-app 
</code></pre>
<img class="img-responsive" alt="Docker run 1" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-6.png">
We can run Docker images using the <code>docker run</code> command.
We know that each container is an isolated environment in itself and we have to map the port of the host operating system - <code>8090</code> and the port inside the container - <code>8080</code>, which is specified as the <code>-p 8090:8080</code> argument.
Now, we can access the endpoint on <code>http://localhost:8080/greet/john</code>:
<img class="img-responsive" alt="REST response 2" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-7.png">
Our Spring Boot application is successfully running within a Docker container!
<h3 id="dockerizingusingmaven">Dockerizing using Maven</h3>
In the previous section we wrote a simple Dockerfile and built our application using the native <code>docker build</code> command. However, there are a couple of issues that we may encounter in our projects using this method:
<ul>
<li>The <code>.jar</code> name - We have to mention the jar name (along with the version) in the file. As our application grows our versions will change and we have to, again and again, update this Dockerfile too.</li>
<li>Using the terminal - We have to manually open a terminal and run Docker commands. It would be nice if we could make it a part of a Maven life-cycle so that we can build images as a part of our CI/CD (Continuous Integration/Continuous Delivery) pipelines.</li>
</ul>
There are many Maven plugins available that we can use in our <code>pom.xml</code> file that would make our life much easier. The way that this Maven plugin works is that it internally creates the Dockerfile based on the configuration in the <code>pom.xml</code> file and then uses the generated Dockerfile to build the image.
Using this method, there's no need for us to manually update the name, nor run the terminal.
We will be using the <a rel="nofollow" target="_blank" href="https://github.com/fabric8io/docker-maven-plugin">fabric8io/docker-maven-plugin</a>.
The plugin should be located in our <code>pom.xml</code> file after the <code>build</code> tag. This will be an optional build plugin using Maven profiles. It's always a good idea to use this via profiles because we want the regular <code>mvn clean install</code> command to work on a developer's machine, which doesn't have Docker installed too:
<pre><code class="hljs">&lt;profiles&gt;
 &lt;profile&gt;
 &lt;activation&gt;
 &lt;property&gt;
 &lt;name&gt;docker&lt;/name&gt;
 &lt;/property&gt;
 &lt;/activation&gt;
 &lt;build&gt;
 &lt;plugins&gt;
 &lt;plugin&gt;
 &lt;groupId&gt;io.fabric8&lt;/groupId&gt;
 &lt;artifactId&gt;docker-maven-plugin&lt;/artifactId&gt;
 &lt;version&gt;0.26.0&lt;/version&gt;
 &lt;extensions&gt;true&lt;/extensions&gt;
 &lt;configuration&gt;
 &lt;verbose&gt;true&lt;/verbose&gt;
 &lt;images&gt;
 &lt;image&gt;
 &lt;name&gt;${project.artifactId}&lt;/name&gt;
 &lt;build&gt;
 &lt;from&gt;java:8-jdk-alpine&lt;/from&gt;
 &lt;entryPoint&gt;
 &lt;exec&gt;
 &lt;args&gt;java&lt;/args&gt;
 &lt;args&gt;-jar&lt;/args&gt;
 &lt;args&gt;/maven/${project.artifactId}-${project.version}.jar&lt;/args&gt;
 &lt;/exec&gt;
 &lt;/entryPoint&gt;
 &lt;assembly&gt;
 &lt;descriptorRef&gt;artifact&lt;/descriptorRef&gt;
 &lt;/assembly&gt;
 &lt;/build&gt;
 &lt;/image&gt;
 &lt;/images&gt;
 &lt;/configuration&gt;
 &lt;executions&gt;
 &lt;execution&gt;
 &lt;id&gt;build&lt;/id&gt;
 &lt;phase&gt;post-integration-test&lt;/phase&gt;
 &lt;goals&gt;
 &lt;goal&gt;build&lt;/goal&gt;
 &lt;/goals&gt;
 &lt;/execution&gt;
 &lt;/executions&gt;
 &lt;/plugin&gt;
 &lt;/plugins&gt;
 &lt;/build&gt;
 &lt;/profile&gt;
&lt;/profiles&gt;
</code></pre>
Let's take a closer look at this:
<ul>
<li>Our profile is named <code>docker</code> - If we have to build the image using Maven, we should run the command with <code>-Ddocker</code>.</li>
<li>The <code>&lt;name&gt;</code> tag - This tag specifies the image name, which is the <code>artifactId</code> - in our case, it's <code>demo-docker</code>.</li>
<li>The <code>&lt;from&gt;</code> tag - This tag specifies the base image of <code>java:8-jdk-alpine</code>.</li>
<li>The <code>&lt;args&gt;</code> tag - This tag is used to specify how the image should run.</li>
</ul>
Now let's build the image:
<pre><code class="hljs">$ mvn clean install -Ddocker 
</code></pre>
<img class="img-responsive" alt="Docker build 2" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-8.png">
Let's check our image:
<pre><code class="hljs">$ docker images
</code></pre>
<img class="img-responsive" alt="Docker images 2" src="https://s3.amazonaws.com/stackabuse/media/running-spring-boot-apps-docker-9.png">
Finally, we'll run our image:
<pre><code class="hljs">$ docker run -p 8090:8080 demo-docker 
</code></pre>
Now check the REST endpoint (<a href="http://localhost:8090/greet/john">http://localhost:8090/greet/john</a>) in the browser.
Note: You have to stop the previously running containers that are using port <code>8090</code>, or else you will get an error.
You can easily check what containers are running using:
<pre><code class="hljs">$ docker ps 
</code></pre>
Now, if the port is already in use, you can either change the port or remove the old container using:
<pre><code class="hljs">$ docker rm -f &lt;container-id&gt;
</code></pre>
Another easy way is to stop all of the containers:
<pre><code class="hljs"> $ docker rm -f $(docker ps -a -q) 
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we covered the two most commonly used ways to containerize a Spring Boot application using Docker.
The first approach was done by using a simple Dockerfile to build the image, and the second approach is using a Maven plugin.
Once the image is created, there are many ways to run it. In this article, we relied on the native <code>docker run</code> command. A more approachable way is to use docker-compose if you have many images that you need to run.
For a production environment we usually go for <a rel="nofollow" target="_blank" href="https://kubernetes.io/">Kubernetes</a> or <a rel="nofollow" target="_blank" href="https://docs.docker.com/engine/swarm/">Docker-swarm</a> so as to scale our application based on network traffic automatically.

Dhananjay Singh

Dockerizing a Spring Boot Application

<h2 id="introductiontotensorflow">Introduction to TensorFlow</h2>
<a rel="nofollow" target="_blank" href="https://www.tensorflow.org/">TensorFlow</a> is a deep learning framework that provides an easy interface to a variety of functionalities, required to perform state of the art deep learning tasks such as image recognition, text classification and so on. It is a machine learning framework developed by Google and is used for designing, building, and training of deep learning models such as the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Artificial_neural_network">Neural Networks</a>. The <a rel="nofollow" target="_blank" href="https://cloud.google.com/vision/">Google Cloud Vision</a> and <a rel="nofollow" target="_blank" href="https://www.deepmind.com/research/highlighted-research/alphago">AlphaGo</a> are some of the examples of the applications built on top of TensorFlow. TensorFlow is an open source library and can be downloaded and used for free.
In this article, we will see how to install TensorFlow on a Windows machine.
<h2 id="tensorflowinstallationtypes">TensorFlow Installation Types</h2>
When installing TensorFlow, you can choose either the CPU-only or GPU-supported version. I'd recommend installing the CPU version if you need to design and train simple machine learning models, or if you're just starting out. However, the CPU version can be slower while performing complex tasks, especially those involving image processing. If you need to use TensorFlow to process a huge amount of data, especially cases in which the data involves images, I'd recommend installing the GPU-supported version.
GPU supported TensorFlow requires you to install a number of libraries and drivers. It supports the NVIDIA GPU card, with support for CUDA Compute 3.5 or higher.
You must install the following software in order to run the GPU version of TensorFlow:
<ul>
<li>NVIDIA GPU drivers</li>
<li>CUDA Toolkit: CUDA 9.0.</li>
<li>NCCL 2.2 (optional)</li>
<li>cuDNN SDK (7.2 or higher)</li>
<li>TensorRT for improved latency and throughput.</li>
</ul>
<h2 id="choosingtheinstallationmethod">Choosing the Installation Method</h2>
On Windows, TensorFlow can be installed via either &quot;pip&quot; or &quot;anaconda&quot;. Python comes with the <code>pip</code> package manager, so if you have already installed Python, then you should have <code>pip</code> as well. The package can install TensorFlow together with its dependencies.
<a rel="nofollow" target="_blank" href="https://www.anaconda.com/">Anaconda</a> is also a great option for installing TensorFlow, but it is not shipped with Python like <code>pip</code> is, therefore you must download and install it separately.
Both packages are open source, so feel free to choose the one you like.
<h2 id="installationwithpip">Installation with pip</h2>
To get the <code>pip</code> package manager, you first need to install Python. Download the latest version of Python from the <a rel="nofollow" target="_blank" href="https://www.python.org/downloads/">official Python website</a> and install it.
Once the installation completes, check for the version of <code>pip</code> running on your system. To do so, go to the command prompt and type:
<pre><code class="hljs">$ pip3 --version
</code></pre>
Since you have installed the latest version of Python, that is, Python 3.x, you have <code>pip3</code>, and not <code>pip</code>. The latter was used with Python 2.7.
It is now finally time to install TensorFlow. Run the windows command prompt as an administrator. To do so, go to the start menu on your Windows machine, search for <code>cmd</code>, right click it and choose &quot;Run as administrator&quot;.
After that, you only have to run one simple command to install TensorFlow. Here is the command:
<pre><code class="hljs">$ pip3 install --upgrade tensorflow
</code></pre>
The command will take some time to execute, so remain patient. With <code>pip</code>, you can install TensorFlow with GPU support as follows:
<pre><code class="hljs">$ pip3 install tensorflow-gpu
</code></pre>
And that's it! You can now skip to the section &quot;Verifying the Installation&quot; below to make sure it is installed correctly.
<h2 id="installationwithanaconda">Installation with Anaconda</h2>
Python is not shipped with Anaconda, so you must first install it on your system. You can download it from <a rel="nofollow" target="_blank" href="https://www.anaconda.com/download/#windows">Anaconda.com</a>.
Once the package is downloaded, double-click it to start the installation. Installation instructions for Anaconda can be found at <a target="_blank" href="/python-tutorial-for-absolute-beginners/#installationandsetup">this link</a>. The installer will be verified and a welcome window will pop up.
<img class="img-responsive" alt="Welcome to Anaconda" src="https://s3.amazonaws.com/stackabuse/media/installing-tensorflow-windows-1.jpg">
Click &quot;Next&quot;. In the next window, you will be required to accept the terms of the Anaconda agreement.
<img class="img-responsive" alt="License Agreement" src="https://s3.amazonaws.com/stackabuse/media/installing-tensorflow-windows-2.jpg">
Click &quot;I Agree&quot;. You will be prompted to choose the installation type, whether just for you or for all users. Choose the option you need and click &quot;Next&quot;.
You can install it in the default directory or browse to another directory. Click &quot;Next&quot;.
You will see the window for &quot;Advanced Options&quot;. Check the second checkbox, that is, &quot;Register Anaconda as my default Python 3.6&quot;.
<img class="img-responsive" alt="Advanced Installation Options" src="https://s3.amazonaws.com/stackabuse/media/installing-tensorflow-windows-3.jpg">
Click &quot;Install&quot; and the installation process will begin.
Once the installation completes, you will get the following message:
<img class="img-responsive" alt="Installation Complete" src="https://s3.amazonaws.com/stackabuse/media/installing-tensorflow-windows-4.jpg">
Click &quot;Next&quot; and &quot;Finish&quot; in the subsequent windows to complete the installation of Anaconda.
Now that you have installed Anaconda, you can use <code>conda</code>, a package manager used for the management of virtual environments and installation of packages for Anaconda.
Go to the Windows start menu, and type “anaconda prompt”. From the options click &quot;Anaconda Prompt&quot; to launch the prompt as shown in the figure below:
<img class="img-responsive" alt="Anaconda Prompt" src="https://s3.amazonaws.com/stackabuse/media/installing-tensorflow-windows-5.png">
To see details of the <code>conda</code> package, type this command in the prompt:
<pre><code class="hljs">$ conda info
</code></pre>
We will now create a Python virtual environment with <code>conda</code>. A virtual environment is an isolated working copy of Python, capable of maintaining its own files, paths, and directories so that you can work with specific versions of the different Python libraries without affecting the other Python projects.
To create a virtual environment for the TensorFlow, execute the <code>conda create</code> command with the following syntax:
<pre><code class="hljs">$ conda create -n [environment-name]
</code></pre>
Let us name the environment as <code>tensorenviron</code>. Although you can use any name you want.
<pre><code class="hljs">$ conda create -n tensorenviron
</code></pre>
You will be prompted to allow the process to proceed. Just type &quot;y&quot; for &quot;yes&quot; and press the enter key on your keyboard. The environment will be created successfully.
We can then activate the environment we have just created:
<pre><code class="hljs">$ activate tensorenviron
</code></pre>
You will see the prompt change.
Next, run the following command to install TensorFlow:
<pre><code class="hljs">$ conda install tensorflow
</code></pre>
A list of packages to be installed alongside TensorFlow will be shown. The command will prompt you to confirm the installation of these packages. Type &quot;y&quot; and then press the enter key. The progress of the installation process will be shown on the command prompt.
<h2 id="verifyingtheinstallation">Verifying the Installation</h2>
Now that TensorFlow has been installed, we can verify whether the installation was successful or not. To do so, we can run Python's <code>import</code> statement and see if we can successfully import the TensorFlow library.
In the previously opened command prompt, which should be using the virtual environment in which you installed TensorFlow, type <code>python</code> to get to the Python terminal:
<pre><code class="hljs">$ python
</code></pre>
Now try to import the library:
<pre><code class="hljs">import tensorflow as tf
</code></pre>
If everything is okay, the command will return nothing other than the Python prompt. However, if the installation was unsuccessful, you will get an error.
<h2 id="resources">Resources</h2>
Just starting out with TensorFlow? Getting it installed is just the first step. If you want to learn more beyond this then we recommend trying a more detailed resource, like the <a class="amazon-link" rel="nofollow" target="_blank" href="https://stackabu.se/hands-on-machine-learning-scikit-learn-tensorflow">Hands-On Machine Learning with Scikit-Learn and TensorFlow</a> book. You'll learn a lot from this book, and not only about TensorFlow and Scikit-Learn, but Machine Learning in general.
<h2 id="conclusion">Conclusion</h2>
TensorFlow is a machine learning framework used for the development of deep learning models. The framework was developed by Google, and comes in two flavors, the CPU-only, and the GPU-supported versions. The latter is more powerful than the former and is more suitable for image processing tasks. In this article, we saw how we can install TensorFlow on a Windows machine using the pip command as well as through the Anaconda framework.