Tech Tutorials

Thursday, January 11, 2024

Java Stream API Interview Questions And Answers

In this post Java Stream API Interview Questions and answers are listed. This compilation will help the Java developers in preparing for their interviews.

What is Stream API in Java?

Stream API is added in Java 8 and works very well in conjunction with lambda expressions. You can create a pipeline of stream operations to manipulate data by performing operations like search, filter, sort, count, map etc.
Read more about Stream API in Java here.

What is stream in Stream API?

A stream can be visualized as a pipeline. A stream pipeline consists of a source (which might be an array, a collection, a generator function, an I/O channel, etc.), zero or more intermediate operations (which transform a stream into another stream, such as filter(Predicate)), and a terminal operation (which produces a result or side-effect, such as count() or forEach(Consumer)).
Read more about Stream API in Java here.

Explain stream operations with an example?

In this example let's take an ArrayList as an input. There are two operations; take only those elements of the list which are greater than 5 and then sort the result. After that print the elements of the list.
```
// Creating the list
List<Integer> numList = Arrays.asList(34, 6, 3, 12, 65, 1, 8);
numList.stream().filter((n) -> n > 5).sorted().forEach(System.out::println); 
```
Here ArrayList is the data source for the stream and there are two intermediate operations–
- filter- Filter condition here is; take only those elements of the list which are greater than 5. Click to read more about filter() method.
- sorted- sort that filtered output of the last stream. Click to read more about sorted() method.
Terminal operation here is forEach statement (provided in Java 8) which iterates the sorted result and displays them. Read more about forEach statement in Java 8 here.

How many types of Stream operations are there?

Stream operations are divided into intermediate and terminal operations, and are combined to form stream pipelines.
- Intermediate operations return a new stream. They are always lazy; executing an intermediate operation does not actually perform any filtering, but instead creates a new stream that, when traversed, contains the elements of the initial stream that match the given predicate.
- Terminal operations such as Stream.forEach or IntStream.sum, may traverse the stream to produce a result or a side-effect. After the terminal operation is performed, the stream pipeline is considered consumed, and can no longer be used.
See some Stream API examples here.

What are Stateless and Stateful operations in Java stream?

Intermediate operations are further divided into stateless and stateful operations.
- Stateless operations, such as filter() and map(), retain no state from previously seen element when processing a new element, each element can be processed independently of operations on other elements.
- Stateful operations, such as distinct() and sorted(), may incorporate state from previously seen elements when processing new elements. Stateful operations may need to process the entire input before producing a result. For example, one cannot produce any results from sorting a stream until one has seen all elements of the stream.
See some Stream API examples here.

What is Parallel Stream in Java Stream API?

You can execute streams in serial or in parallel. When a stream executes in parallel, the Java runtime partitions the stream into multiple sub-streams.

As example- Collection has methods Collection.stream() and Collection.parallelStream(), which produce sequential and parallel streams respectively.
Read more about parallel stream here.

What is the benefit of using parallel stream?

When parallel stream is used the Java runtime partitions the stream into multiple sub-streams. This parallel execution of data, with each sub-stream running in a separate thread, will result in increase in performance.
Read more about parallel stream here.

Can you use streams with primitives?

Streams work only on object references. They can’t work on primitive types so you have two options to use primitives.
- You can wrap primitive types into a wrapper object. As example Stream<Integer>, Stream<Long> or Stream<Double>.
- Second and better option is to use primitive specializations of Stream like IntStream, LongStream, and DoubleStream that can store primitive values.
Read more about Primitive type streams in Java here.

How can you transform Stream to primitive type Stream?

Stream interface provides methods mapToInt, mapToDouble and mapToLong that can be used to transform stream of objects to a stream of primitive types.

As example- If you have a list of employee objects and you want to get the maximum salary. In that case you can take the salary field and use mapToInt method to get a stream of primitive types. Then you can use max method on that primmitive type stream.
```
OptionalInt maxSalary = empList.parallelStream().mapToInt(e -> e.getSalary()).max();
```
Read more about Primitive type streams in Java Stream API here.

What are Reduction Operations in Java Stream API?

Stream API contains many terminal operations (such as average, sum, min, max, and count) that return one value by combining the contents of a stream. These operations are called reduction operations because these operations reduce the stream to a single non-stream value.
Read more about Reduction Operations in Java Stream API here.

What are Map operation in Java Stream API?

Map operations are used to do the element mapping from one stream to another. Map operation will return a stream consisting of the results of applying the given function to the elements of this stream. So, whatever function is provided is applied on all the elements of the stream.

Since new stream is returned map operation is an intermediate operation.
Read more about Map operation in Java Stream API here.

What is a mutable reduction operation?

A mutable reduction operation can be defined as an operation that accumulates input elements into a mutable result container, such as a Collection or StringBuilder.
Read more about Reduction operation in Java Stream API here.

What is a collect method in Java stream?

Using collect method you can store the result of the stream operation into a collection. This is a terminal operation.

As example- If you have employee objects and you want a list having names of all the employees you can use the toList method of the Collectors class.
```
List<String> nameList = empList.stream().map(Employee::getName).collect(Collectors.toList());
```
Read more about Collecting in Java Stream API here.

What is flatMap() method in Java?

In mapping operation the given function is applied to all the elements of the stream. Where as flattening a structure, means bringing all the nested structures at the same level.

As example if you have a list of Strings, list<String> like - [[“a”, “b”, “c”], [“c”, “d”], [“c”, “e”, “f”]] then flattening it will bring everything to the same level and the structure you will have be like this-
```
[“a”, “b”, “c”, “c”, “d”, “c”, “e”, “f”]
```
flatMap() method means you are bringing both of them together, function will be applied to all the elements of the stream and then it will be flatten to have a single level structure.
Read more about FlatMap in Java here.

What is a Spliterator in Java?

Spliterators, like iterators, are for traversing the elements of a source. Spliterator can split the source and iterate the splitted parts in parallel. That way a huge data source can be divided into small sized units that can be traversed and processed in parallel.

You can also use spliterator even if you are not using parallel execution.
Read more about Spliterator in Java here.

Related Topics

Wednesday, January 10, 2024

Angular ngClass Directive With Examples

Using Angular ngClass directive you can dynamically add or remove CSS classes for a DOM element.

With ngClass the CSS classes can be provided in one of the following ways-

string- The CSS classes listed in the string (space delimited) are added.
```
 <some-element [ngClass]="'first second'">...</some-element>
```

Array- The CSS classes declared as Array elements are added.

<some-element [ngClass]="['first', 'second']">...</some-element>

Object- As a key, value pair where keys are CSS classes and values are conditions. CSS classes get added when the expression given in the value evaluates to a truthy value, otherwise they are removed.
```
<some-element [ngClass]="{'first': true, 'second': true, 'third': false}">...</some-element>
```

Angular ngClass directive example

Here is a simple example showing usage of ngClass. First add a CSS class.

app.component.css

.text-border {
  color: white;
  border: 1px dashed black;
  background-color: blue;
}

Then in the template you can add <div> elements, one with value as true (so that CSS class is added) and one with value as false (so that CSS class is removed).

<div class="container">
  <div [ngClass]="{'text-border': false}">
    This text has no border
  </div>
  <div [ngClass]="{'text-border': true}">
    This text has border
  </div>
</div>

But you will see the real power of ngClass, just like with ngStyle directive, when the CSS class assignment happens dynamically.

Angular ngClass directive dynamic class assignment

In this example we’ll simulate a message for network transfer. There is a button “show status” that shows the current status of the network transfer. After few clicks if network transfer is still not done message is displayed in red color.

CSS used

.text-border {
  color: white;
  border: 1px dashed black;
  background-color: red;
}

Component class

import { Component } from '@angular/core';
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  temp = [];
  onButtonClick(){
    this.temp.push('Still transferring packet');
  }
}

Whenever button is clicked on the UI, onButtonClick() function is called which adds one more message to the array.

Template

<div class="container">
  <button class="btn btn-primary" (click)="onButtonClick()">
    Show Status
  </button>
  <div *ngFor="let t of temp; let i = index">
    <span [ngClass]="{'text-border' : i > 5}">{{t}}</span>
  </div>
</div>

In the template ngFor directive is used to iterate through the array of messages. Using ngClass directive CSS class ‘text-border’ is added dynamically when the iteration index is greater than 5.

That's all for this topic Angular ngClass Directive With Examples. If you have any doubt or any suggestions to make please drop a comment. Thanks!

Related Topics

You may also like-

Tuesday, January 9, 2024

How HashMap Works Internally in Java

In this Java tutorial you'll learn how HashMap works internally in Java, which is also a favorite Java Collections interview question. Note that code snippets used here are from JDK 17.

There are four things you should know about HashMap before going into internal working of HashMap in Java-

HashMap works on the principal of hashing.
Map.Entry interface- This interface gives a map entry (key-value pair). HashMap in Java stores both key and value object, in bucket, as an object of Node class which implements this nested interface Map.Entry. Read more about Map.Entry interface here.
hashCode()- HashMap provides put(key, value) method for storing and get(key) method for retrieving values from HashMap. When put() method is used to store (Key, Value) pair, HashMap implementation calls hashcode on Key object to calculate a hash that is used to find a bucket where Entry object will be stored.
When get() method is used to retrieve value, again key object (passed with the get() method) is used to calculate a hash which is then used to find a bucket where that particular key is stored.
equals()- equals() method is used to compare objects for equality. In case of HashMap key object is used for comparison, also using equals() method Map knows how to handle hashing collision (hashing collision means more than one key having the same hash value, thus assigned to the same bucket). In that case objects are stored in a linked list, refer figure for more clarity.
Where hashCode() method helps in finding the bucket where that key is stored, equals() method helps in finding the right key as there may be more than one key-value pair stored in a single bucket.

** Bucket term used here is actually an index of array, that array is called table in HashMap implementation. Thus table[0] is referred as bucket0, table[1] as bucket1 and so on.

Table of contents

How elements are stored internally in Java HashMap
Importance of hashCode() and equals() method in HashMap
How put() method of Java HashMap works internally
How HashMap get() method works internally
When null Key is inserted in a HashMap
HashMap implementation changes in Java 8

How elements are stored internally in Java HashMap

HassMap class in Java internally uses an array called table of type Node to store the elements which is defined in the HashMap class as-

transient Node<K,V>[] table;

Node is defined as a static class with in a Hashmap.

static class Node<K,V> implements Map.Entry<K,V> {
  final int hash;
  final K key;
  V value;
  Node<K,V> next;
  ..
  ..  
}

As you can see for each element four things are stored in the following fields-

hash- For storing Hashcode calculated using the key.
key- For holding key of the element.
value- For storing value of the element.
next- To store reference to the next node when a bucket has more than one element and a linkedlist is formed with in a bucket to store elements.

Following image shows how Node(key-value pair) objects are stored internally in table array of the HashMap class.

Importance of hashCode() and equals() method in HashMap

How important it is to have a proper hash code and equals method can be seen through the help of the following program, explanation of this example will also help in understanding the working of HashMap's put()method (next section).

public class HashMapTest {
  public static void main(String[] args) {
    Map <Key, String> cityMap = new HashMap<Key, String>();
    cityMap.put(new Key(1, "NY"),"New York City" );
    cityMap.put(new Key(2, "ND"), "New Delhi");
    cityMap.put(new Key(3, "NW"), "Newark");
    cityMap.put(new Key(4, "NP"), "Newport");

    System.out.println("size before iteration " + cityMap.size());
    Iterator <Key> itr = cityMap.keySet().iterator();
    while (itr.hasNext()){
      System.out.println(cityMap.get(itr.next()));     
    }
    System.out.println("size after iteration " + cityMap.size());    
  }
}

// This class' object is used as key
// in the HashMap
class Key{
  int index;
  String Name;
  Key(int index, String Name){
    this.index = index;
    this.Name = Name;
  }
 
  @Override
  // A very bad implementation of hashcode
  // done here for illustrative purpose only 
  public int hashCode(){
    return 5;
  }
 
  @Override
  // A very bad implementation of equals
  // done here for illustrative purpose only 
  public boolean equals(Object obj){
    return true;
  }
}

Output

size before iteration 1
Newport
size after iteration 1

Refer Overriding hashCode() and equals() method in Java to know more about hashCode() and equals() methods.

How put() method of Java HashMap works internally

Lets get through the above example to see what is happening, this will also help in understanding how put() method of HashMap works internally.

Notice that I am inserting 4 values in the HashMap, still in the output it says size is 1 and iterating the map gives me the last inserted entry. Why is that? Answer lies in, how hashCode() and equals() method are implemented for the key Class. Have a look at the hashCode() method of the class Key which always returns "5" and the equals() method which is always returning "true".

When a value is put into HashMap it calculates a hash using key object and for that it uses the hashCode() method of the key object class (or its parent class). Based on the calculated hash value HashMap implementation decides which bucket should store the particular Entry object.

In my code the hashCode() method of the key class always returns "5". This effectively means, calculated hash value, is same for all the entries inserted in the HashMap. Thus all the entries are stored in the same bucket.

HashMap implementation uses equals() method to see if the key is equal to any of the already inserted keys (Recall that there may be more than one entry in the same bucket). Note that, with in a bucket key-value pair entries (Entry objects) are stored in a linked-list (Refer figure for more clarity). In case hash is same, but equals() returns false (which essentially means more than one key having the same hash or hash collision) Entry objects are stored, with in the same bucket, in a linked-list.

In my code, I am always returning true for equals() method so the HashMap implementation "thinks" that the keys are equal and overwrites the value. So, in a way using hashCode() and equals() I have "tricked" HashMap implementation to think that all the keys (even though different) are same, thus overwriting the values.

In a nutshell there are three steps in the internal implementation of HashMap put() method-

Using hashCode() method, hash value will be calculated. In which bucket particular entry will be stored is ascertained using that hash.
equals() method is used to find if such a key already exists in that bucket, if not found then a new node is created with the map entry and stored within the same bucket. A linked-list is used to store those nodes.
If equals() method returns true, it means that the key already exists in the bucket. In that case, the new value will overwrite the old value for the matched key.

How Java HashMap get() method works internally

As we already know how Entry objects are stored in a bucket and what happens in the case of Hash Collision it is easy to understand what happens when key object is passed in the get() method of the HashMap to retrieve a value.

Using the key (passed in the get() method) hash value will be calculated to determine the bucket where that Entry object is stored, in case there are more than one Entry object with in the same bucket (stored as a linked-list) equals() method will be used to find out the correct key. As soon as the matching key is found get() method will return the value object stored in the Entry object.

When null Key is inserted in a HashMap

HashMap in Java also allows null as key, though there can only be one null key in HashMap. While storing the Entry object HashMap implementation checks if the key is null, in case key is null, it is always mapped to bucket 0, as hash is not calculated for null keys.

HashMap implementation changes in Java 8

Though HashMap implementation in Java provides constant time performance O(1) for get() and put() methods but that is in the ideal case when the Hash function distributes the objects evenly among the buckets.

But the performance may worsen in the case hashCode() used is not proper and there are lots of hash collisions. As we know now that in case of hash collision entry objects are stored as a node in a linked-list and equals() method is used to compare keys. That comparison to find the correct key with in a linked-list is a linear operation so in a worst case scenario the complexity becomes O(n).

To address this issue in Java 8 hash elements use balanced trees instead of linked lists after a certain threshold is reached. Which means HashMap starts with storing Entry objects in linked list but after the number of items in a hash becomes larger than a certain threshold, the hash changes from using a linked list to a balanced tree, this improves the worst case performance from O(n) to O(log n).

Points to note-

HashMap works on the principal of hashing.
HashMap in Java uses the hashCode() method to calculate a hash value. Hash value is calculated using the key object. This hash value is used to find the correct bucket where Entry object will be stored.
HashMap uses the equals() method to find the correct key whose value is to be retrieved in case of get() and to find if that key already exists or not in case of put().
With in the internal implementation of HashMap hashing collision means more than one key having the same hash value, in that case Entry objects are stored as a linked-list with in a same bucket.
With in a bucket values are stored as Entry objects which contain both key and value.
In Java 8 hash elements use balanced trees instead of linked lists after a certain threshold is reached while storing values. This improves the worst case performance from O(n) to O(log n).

That's all for this topic How HashMap Works Internally in Java. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Java Advanced Tutorial Page | Return to Java Collections Framework Tutorial Page>>>

Related Topics

You may also like-

Monday, January 8, 2024

Benefits, Disadvantages And Limitations of Autowiring in Spring

Though autowiring in Spring makes life easy by wiring the dependencies automatically thus requiring less code to write but at the same time there are few limitations and disadvantages of autowiring in Spring too and that is the topic of this post.

Benefits of autowiring

Using autowiring means you don't need to explicitly wire the bean properties, Spring will do it automatically. So autowiring requires less configuration code.
Provides several modes for autowiring like byName, byType, constructor. So you have the flexibility to choose how you want to autowire the dependencies.

Disadvantages of autowiring in Spring

Explicit wiring has an advantage that you can explicitly wire the bean you want but Autowiring is not that exact. For example, if you are using constructor autowiring and there is not exactly one bean of the constructor argument type in the container then Spring won't be able to determine which of those beans has to be wired. In case of ambiguity Spring autowiring won't try to guess instead it throws an exception.
Wiring information may not be available to tools that may generate documentation from a Spring container.
Within the container there may be multiple bean definitions matching the type specified by the setter method or constructor argument to be autowired. Within the container there may be multiple bean definitions matching the type specified by the setter method or constructor argument to be autowired. In that case Spring won't be able to decide which bean to use for autowiring. If no unique bean definition is available, an exception is thrown.

Limitations of autowiring

Explicit dependencies in property and constructor-arg settings always override autowiring.
You cannot autowire so-called simple properties such as primitives, Strings, and Classes (and arrays of such simple properties). This limitation in autowiring is by-design.

Reference- https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html

That's all for this topic Benefits, Disadvantages And Limitations of Autowiring in Spring. If you have any doubt or any suggestions to make please drop a comment. Thanks!

>>>Return to Spring Tutorial Page

Related Topics

You may also like-

Sunday, January 7, 2024

Java Basics Tutorial

Java, one of the most popular programming language, was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc. in 1991. It was publicly released in 1995.

Java is an object oriented, high level language but what sets it apart is that Java is platform independent and it can run on a variety of platforms.

This Java beginners tutorial helps in understanding the basic concepts of Java programming language.

Java Getting Started

How to Install Java in Ubuntu

First Java Program - Hello World Java Program

Primitive Data Types in Java

Java Variable Types With Examples

Literals in Java

What Are JVM, JRE And JDK in Java

Java is a Strongly Typed Language

Operators in Java

Arithmetic And Unary Operators in Java