Since AMQP is gaining more a more popularity these days I decided to dive in to this new protocol and share with you my knowledge. The first questions that appeared in my head when I started learning AMQP were what’s the difference between AMQP vs JMS and why would I use AMQP if we have JMS?
First of all, the main difference is that JMS is an API and AMQP is protocol. JMS describes how to send message whereas AMQP describes how message should be constructed. In other words, with JMS you have possibility easily to replace your broker with another broker without or almost without changes in your code. Continue reading Advanced Message Queuing Protocol (AMQP)
Optional class is a nice solution that can be used to solve NullPointerException problem or in such cases when you need to express an empty value. In other words, it can be compared with a box that might contain something or be empty.
The class was introduced in Java 8 and you can see that it’s widely used in Stream API. For instance, such methods like min, max and average return Optional. Since the stream source can be empty it’s better to return Optional rather than null. Because Optional class provides rich functionality to handle different scenarios in functional way. Continue reading Optional Class Overview
In this post I will make overview with examples of Collectors class which provides very cool functionality that can be applied on a stream. The functionality is quite similar to some features in SQL language. For instance, it allows you to make an averaging, grouping, partitioning, summing and many other cool things. In order to use stream reduction API you need to be familiar with Collector interface and Collectors class.
Collectors is an utility class that contains factory methods which you should use most of the time, whereas Collector is an interface that can be used for implementation more specific reduction operation.
Continue reading Stream Reduction Operations
One of the greatest thing in Java 8 is new Stream API which essentially is a new fancy iterator over the collections or any other sequence of data. To work with Streams you need to compose a stream pipeline which consists of source, zero or more intermediate operations and a terminal operation.
The interfaces and classes that belongs to stream API can be found in java.util.stream package.
Continue reading Stream Operations Overview
Java 8 provided a lot of new and very useful features that we can use in our everyday life. In this post I decided make an overview with examples of most commonly used built-in functional interfaces.
I’d like to start from the definition, what is the functional interface? By the definition any interface that has only one abstract method is considered to be a functional interface. Another name for such interfaces is Single Abstract Method interfaces (SAM Interfaces). For instance, Runnable is absolutely legal FI and as you can see it’s annotated now with FunctionalInterface annotation. Continue reading Functional Interfaces Overview
In this part I’ll try to make an overview of java.util.concurrent framework that provides high-level building blocks for creating concurrent applications. These building blocks have high performance, thread-safe, widely used in Java world and moreover they have been thoroughly tested.
The reason why this framework was introduced in Java 1.5 is that low-level API such as wait(), notify() and so on are too primitive and force developers to create their own custom high-level libraries.
Continue reading Java Concurrency Overview Part 2