Elements Of Programming Interviews Java Pdf Download

It's one of the important topics for coffee interview questions. Here I am listing some important java collections interview questions and answers to assist you in the interview. This is directly coming from my xiv+ years of feel in Java programming.

What are Collection related features in Java viii?

Java 8 has brought major changes in the Collection API. Some of the changes are:

Coffee Stream API for collection classes for supporting sequential too as parallel processing
Iterable interface is extended with forEach() default method that we can use to iterate over a collection. Information technology is very helpful when used with lambda expressions because its argument Consumer is a role interface.
Miscellaneous Collection API improvements such equally forEachRemaining(Consumer action) method in Iterator interface, Map replaceAll(), compute(), merge() methods.

What is Java Collections Framework? Listing out some benefits of Collections framework?

Collections are used in every programming linguistic communication and initial java release contained few classes for collections: Vector, Stack, Hashtable, Array. Simply looking at the larger scope and usage, Coffee i.ii came upward with Collections Framework that grouping all the collections interfaces, implementations and algorithms.
Java Collections have come through a long way with the usage of Generics and Concurrent Collection classes for thread-rubber operations. It also includes blocking interfaces and their implementations in java concurrent package.
Some of the benefits of collections framework are;

Reduced development effort by using core collection classes rather than implementing our own collection classes.
Lawmaking quality is enhanced with the use of well tested collections framework classes.
Reduced endeavour for code maintenance by using drove classes shipped with JDK.
Reusability and Interoperability

What is the benefit of Generics in Collections Framework?

Java one.5 came with Generics and all collection interfaces and implementations use information technology heavily. Generics permit u.s.a. to provide the blazon of Object that a collection can incorporate, so if you attempt to add any element of other type information technology throws compile time error.
This avoids ClassCastException at Runtime because you will become the error at compilation. Also Generics brand code clean since we don't need to use casting and instanceof operator. I would highly recommend to become through Java Generic Tutorial to understand generics in a better fashion.

What are the basic interfaces of Java Collections Framework?

Collection is the root of the collection hierarchy. A drove represents a grouping of objects known as its elements. The Coffee platform doesn't provide whatever directly implementations of this interface.

Gear up is a collection that cannot contain indistinguishable elements. This interface models the mathematical fix abstraction and is used to represent sets, such as the deck of cards.

List is an ordered collection and can contain duplicate elements. Yous tin admission any element from its index. The list is more than similar an array with dynamic length.

A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each fundamental tin can map to at most 1 value.

Some other interfaces are Queue, Dequeue, Iterator, SortedSet, SortedMap and ListIterator.

Why Drove doesn't extend Cloneable and Serializable interfaces?

Drove interface specifies grouping of Objects known as elements. How the elements are maintained is left up to the concrete implementations of Collection. For instance, some Drove implementations like List allow duplicate elements whereas other implementations similar Set don't.
A lot of the Collection implementations accept a public clone method. Yet, it doesn't make sense to include it in all implementations of Drove. This is because Collection is an abstract representation. What matters is the implementation.
The semantics and the implications of either cloning or serializing come into play when dealing with the actual implementation; so physical implementation should decide how it should be cloned or serialized, or even if it can exist cloned or serialized.
So mandating cloning and serialization in all implementations is less flexible and more restrictive. The specific implementation should decide as to whether it can be cloned or serialized.

Why Map interface doesn't extend Drove interface?

Although Map interface and its implementations are part of the Collections Framework, Map is non collections and collections are not Map. Hence information technology doesn't brand sense for Map to extend Collection or vice versa.
If Map extends Collection interface, and then where are the elements? The map contains key-value pairs and it provides methods to retrieve the list of Keys or values every bit Collection but it doesn't fit into the "group of elements" paradigm.

What is an Iterator?

The Iterator interface provides methods to iterate over any Collection. We can get iterator example from a Drove using iterator() method. Iterator takes the identify of Enumeration in the Java Collections Framework. Iterators allow the caller to remove elements from the underlying drove during the iteration. Java Collection iterator provides a generic manner for traversal through the elements of a collection and implements Iterator Design Pattern.

What is divergence between Enumeration and Iterator interface?

Enumeration is twice as fast equally Iterator and uses very little retention. Enumeration is very basic and fits basic needs. Just the Iterator is much safer as compared to Enumeration because it e'er denies other threads to modify the collection object which is being iterated by it.
Iterator takes the identify of Enumeration in the Java Collections Framework. Iterators permit the caller to remove elements from the underlying collection that is not possible with Enumeration. Iterator method names have been improved to make its functionality articulate.

Why there is not method like Iterator.add() to add elements to the collection?

The semantics are unclear, given that the contract for Iterator makes no guarantees about the order of iteration. Note, even so, that ListIterator does provide an add performance, equally it does guarantee the gild of the iteration.

Why Iterator don't take a method to get next element directly without moving the cursor?

It can exist implemented on elevation of current Iterator interface just since its utilize will be rare, it doesn't brand sense to include it in the interface that everyone has to implement.

What is unlike between Iterator and ListIterator?

We can utilize Iterator to traverse Set and List collections whereas ListIterator can be used with Lists only.
Iterator can traverse in forward direction only whereas ListIterator can be used to traverse in both the directions.
ListIterator inherits from Iterator interface and comes with extra functionalities like adding an element, replacing an chemical element, getting index position for previous and adjacent elements.

What are dissimilar ways to iterate over a listing?

We can iterate over a list in two different ways – using iterator and using for-each loop.

                          List<Cord> strList = new ArrayList<>();  //using for-each loop for(String obj : strList){     System.out.println(obj); }  //using iterator Iterator<String> it = strList.iterator(); while(it.hasNext()){     String obj = it.next();     System.out.println(obj); }

Using iterator is more thread-safe considering it makes sure that if underlying list elements are modified, it will throw ConcurrentModificationException.

What do you understand by iterator fail-fast holding?

Iterator fail-fast property checks for any modification in the structure of the underlying collection everytime we try to get the next element. If there are any modifications found, it throws ConcurrentModificationException. All the implementations of Iterator in Drove classes are fail-fast past blueprint except the concurrent collection classes like ConcurrentHashMap and CopyOnWriteArrayList.

What is divergence between fail-fast and fail-prophylactic?

Iterator fail-safe holding piece of work with the clone of underlying drove, hence it'southward not affected by any modification in the collection. By pattern, all the collection classes in java.util package are fail-fast whereas collection classes in java.util.concurrent are fail-rubber.
Fail-fast iterators throw ConcurrentModificationException whereas fail-safe iterator never throws ConcurrentModificationException.
Check this mail for CopyOnWriteArrayList Example.

How to avoid ConcurrentModificationException while iterating a collection?

We tin can utilise concurrent collection classes to avert ConcurrentModificationException while iterating over a collection, for example CopyOnWriteArrayList instead of ArrayList.
Bank check this post for ConcurrentHashMap Instance.

Why there are no concrete implementations of Iterator interface?

Iterator interface declare methods for iterating a collection but its implementation is responsibility of the Collection implementation classes. Every collection class that returns an iterator for traversing has its own Iterator implementation nested class.
This allows collection classes to chose whether iterator is fail-fast or neglect-safety. For example ArrayList iterator is neglect-fast whereas CopyOnWriteArrayList iterator is neglect-safety.

What is UnsupportedOperationException?

UnsupportedOperationException is the exception used to bespeak that the functioning is not supported. It's used extensively in JDK classes, in collections framework coffee.util.Collections.UnmodifiableCollection throws this exception for all add and remove operations.

How HashMap works in Coffee?

HashMap stores key-value pair in Map.Entry static nested class implementation. HashMap works on hashing algorithm and uses hashCode() and equals() method in put and get methods.

When nosotros call put method by passing fundamental-value pair, HashMap uses Primal hashCode() with hashing to find out the index to shop the key-value pair. The Entry is stored in the LinkedList, and so if there is an already existing entry, it uses equals() method to check if the passed key already exists, if yeah it overwrites the value else it creates a new entry and stores this central-value Entry.

When nosotros call get method by passing Key, again it uses the hashCode() to detect the index in the array and so utilize equals() method to find the correct Entry and return its value. The beneath epitome volition explain these detail clearly.

java-hashmap-entry-impl

The other important things to know about HashMap are capacity, load gene, threshold resizing. HashMap initial default chapters is 16 and load cistron is 0.75. The threshold is chapters multiplied by load factor and whenever we effort to add together an entry if map size is greater than the threshold, HashMap rehashes the contents of the map into a new array with a larger capacity. The capacity is e'er the power of ii, so if you know that you need to store a large number of key-value pairs, for example in caching data from the database, it's a good idea to initialize the HashMap with correct capacity and load gene.

What is the importance of hashCode() and equals() methods?

HashMap uses the Key object hashCode() and equals() method to determine the index to put the fundamental-value pair. These methods are also used when we effort to become value from HashMap. If these methods are non implemented correctly, two different Key's might produce the same hashCode() and equals() output and in that case, rather than storing it at a dissimilar location, HashMap volition consider the same and overwrite them.

Similarly all the collection classes that doesn't shop duplicate data utilise hashCode() and equals() to discover duplicates, so information technology'southward very important to implement them correctly. The implementation of equals() and hashCode() should follow these rules.

If o1.equals(o2), so o1.hashCode() == o2.hashCode()should e'er be true.
If o1.hashCode() == o2.hashCode is true, it doesn't hateful that o1.equals(o2) volition be true.

Tin can we use any class as Map key?

We can use any class equally Map Primal, nevertheless following points should be considered earlier using them.

If the class overrides equals() method, it should also override hashCode() method.
The class should follow the rules associated with equals() and hashCode() for all instances. Please refer earlier question for these rules.
If a class field is not used in equals(), you should non utilise it in hashCode() method.

All-time practise for user divers key class is to make it immutable, so that hashCode() value can be cached for fast performance. Also immutable classes make sure that hashCode() and equals() volition not change in future that will solve any issue with mutability.
For example, let's say I have a class MyKey that I am using for the HashMap key.

                                  //MyKey proper noun statement passed is used for equals() and hashCode() MyKey fundamental = new MyKey("Pankaj"); //assume hashCode=1234 myHashMap.put(fundamental, "Value");  // Below lawmaking will modify the key hashCode() and equals() // just its location is non inverse. cardinal.setName("Amit"); //assume new hashCode=7890  //below volition return nil because HashMap will try to await for key //in the same index as it was stored but since the key is mutated,  //there will exist no match and it volition return zilch. myHashMap.go(new MyKey("Pankaj"));

This is the reason why String and Integer are by and large used equally HashMap keys.

What are different Collection views provided past Map interface?

Map interface provides iii drove views:

Gear up<K> keySet(): Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's remove operation), the results of the iteration are undefined. The prepare supports element removal, which removes the respective mapping from the map, via the Iterator remove, Ready.remove, removeAll, retainAll, and clear operations. It does non support the add together or addAll operations.
Drove<5> values(): Returns a Drove view of the values independent in this map. The collection is backed by the map, so changes to the map are reflected in the drove, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator'southward remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator remove, Drove.remove, removeAll, retainAll, and clear operations. It does not support the add together or addAll operations.
Fix<Map.Entry<K, V>> entrySet(): Returns a Fix view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's remove operation, or the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports chemical element removal, which removes the respective mapping from the map, via the Iterator remove, Ready.remove, removeAll, retainAll, and clear operations. It does non support the add or addAll operations.

What is departure betwixt HashMap and Hashtable?

HashMap and Hashtable both implements Map interface and looks like, all the same, at that place is the post-obit difference between HashMap and Hashtable.

HashMap allows cipher key and values whereas Hashtable doesn't permit zip key and values.
Hashtable is synchronized but HashMap is not synchronized. Then HashMap is better for unmarried threaded environs, Hashtable is suitable for multi-threaded surroundings.
LinkedHashMap was introduced in Coffee 1.4 as a bracket of HashMap, and then incase you want iteration gild, yous tin easily switch from HashMap to LinkedHashMap just that is non the instance with Hashtable whose iteration order is unpredictable.
HashMap provides Set of keys to iterate and hence it's fail-fast but Hashtable provides Enumeration of keys that doesn't support this feature.
Hashtable is considered to be legacy grade and if you are looking for modifications of Map while iterating, you should use ConcurrentHashMap.

How to decide between HashMap and TreeMap?

For inserting, deleting, and locating elements in a Map, the HashMap offers the best culling. If, however, you lot demand to traverse the keys in a sorted order, then TreeMap is your better alternative. Depending upon the size of your collection, it may be faster to add elements to a HashMap, and so convert the map to a TreeMap for sorted central traversal.

What are similarities and divergence betwixt ArrayList and Vector?

ArrayList and Vector are similar classes in many means.

Both are index based and backed upward by an array internally.
Both maintains the gild of insertion and nosotros can go the elements in the order of insertion.
The iterator implementations of ArrayList and Vector both are fail-fast by design.
ArrayList and Vector both allows zero values and random access to chemical element using index number.

These are the differences between ArrayList and Vector.

Vector is synchronized whereas ArrayList is non synchronized. However if you are looking for modification of list while iterating, yous should utilise CopyOnWriteArrayList.
ArrayList is faster than Vector because information technology doesn't have any overhead because of synchronization.
ArrayList is more versatile because we can get synchronized list or read-only list from it hands using Collections utility course.

What is deviation between Array and ArrayList? When will you apply Assortment over ArrayList?

Arrays can incorporate primitive or Objects whereas ArrayList can contain only Objects.
Arrays are fixed-size whereas ArrayList size is dynamic.
Arrays don't provide a lot of features similar ArrayList, such as addAll, removeAll, iterator, etc.

Although ArrayList is the obvious choice when we piece of work on the listing, at that place are a few times when an array is practiced to utilise.

If the size of listing is stock-still and mostly used to store and traverse them.
For list of primitive data types, although Collections apply autoboxing to reduce the coding try but yet information technology makes them boring when working on fixed size archaic data types.
If you are working on fixed multi-dimensional state of affairs, using [][] is far more easier than Listing<List<>>

What is departure between ArrayList and LinkedList?

ArrayList and LinkedList both implement List interface only in that location are some differences between them.

ArrayList is an index based data construction backed by Array, so information technology provides random admission to its elements with performance equally O(1) but LinkedList stores data as list of nodes where every node is linked to its previous and next node. So even though at that place is a method to get the element using index, internally it traverse from start to accomplish at the index node and so render the element, and so performance is O(n) that is slower than ArrayList.
Insertion, addition or removal of an chemical element is faster in LinkedList compared to ArrayList because there is no concept of resizing array or updating index when element is added in middle.
LinkedList consumes more memory than ArrayList because every node in LinkedList stores reference of previous and next elements.

Which drove classes provide random admission of its elements?

ArrayList, HashMap, TreeMap, Hashtable, and Vector classes provide random admission to its elements. Download java collections pdf for more data.

What is EnumSet?

java.util.EnumSet is Set implementation to use with enum types. All of the elements in an enum gear up must come from a unmarried enum type that is specified, explicitly or implicitly, when the set up is created. EnumSet is not synchronized and null elements are non immune. It also provides some useful methods like copyOf(Collection c), of(East first, E… rest) and complementOf(EnumSet s).

Check this post for java enum tutorial.

Which drove classes are thread-safe?

Vector, Hashtable, Properties and Stack are synchronized classes, and then they are thread-safe and can be used in multi-threaded surround. Java 1.v Concurrent API included some collection classes that allows modification of collection while iteration because they work on the clone of the collection, so they are safe to use in multi-threaded environment.

What are concurrent Collection Classes?

Java ane.5 Concurrent package (coffee.util.concurrent) contains thread-prophylactic drove classes that allow collections to exist modified while iterating. Past design Iterator implementation in coffee.util packages are fail-fast and throws ConcurrentModificationException. Simply Iterator implementation in java.util.concurrent packages are fail-safety and we tin alter the collection while iterating. Some of these classes are CopyOnWriteArrayList, ConcurrentHashMap, CopyOnWriteArraySet.

Read these posts to acquire nigh them in more than detail.

Avoid ConcurrentModificationException
CopyOnWriteArrayList Example
HashMap vs ConcurrentHashMap

What is BlockingQueue?

java.util.concurrent.BlockingQueue is a Queue that supports operations that look for the queue to become non-empty when retrieving and removing an element, and expect for space to go available in the queue when adding an element.

BlockingQueue interface is part of the java collections framework and it'south primarily used for implementing the producer-consumer problem. We don't need to worry about waiting for the infinite to be bachelor for producer or object to exist available for consumers in BlockingQueue equally it's handled past implementation classes of BlockingQueue.

Java provides several BlockingQueue implementations such as ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue, etc.
Check this post for apply of BlockingQueue for producer-consumer trouble.

What is Queue and Stack, list their differences?

Both Queue and Stack are used to store data earlier processing them. java.util.Queue is an interface whose implementation classes are nowadays in java concurrent package. Queue allows retrieval of element in First-In-Starting time-Out (FIFO) order but it's not always the case. There is too Deque interface that allows elements to exist retrieved from both end of the queue.
The stack is similar to queue except that it allows elements to be retrieved in Terminal-In-Showtime-Out (LIFO) order.
Stack is a class that extends Vector whereas Queue is an interface.

What is Collections Form?

coffee.util.Collections is a utility class consists exclusively of static methods that operate on or render collections. It contains polymorphic algorithms that operate on collections, "wrappers", which return a new collection backed by a specified collection, and a few other odds and ends.

This class contains methods for collection framework algorithms, such as binary search, sorting, shuffling, reverse, etc.

What is Comparable and Comparator interface?

Java provides a Comparable interface which should be implemented past any custom course if nosotros want to use Arrays or Collections sorting methods. The comparable interface has a compareTo(T obj) method which is used by sorting methods. Nosotros should override this method in such a way that it returns a negative integer, zero, or a positive integer if "this" object is less than, equal to, or greater than the object passed equally an argument.

But, in nigh real-life scenarios, we want sorting based on different parameters. For example, every bit a CEO, I would similar to sort the employees based on Salary, an HR would similar to sort them based on age. This is the situation where we need to use Comparator interface because Comparable.compareTo(Object o) method implementation can sort based on 1 field only and we tin't choose the field on which nosotros want to sort the Object.

Comparator interface compare(Object o1, Object o2) method need to be implemented that takes two Object argument, it should be implemented in such a way that it returns negative int if the first statement is less than the 2nd one and returns zero if they are equal and positive int if the outset argument is greater than the second ane.

Bank check this post for employ of Comparable and Comparator interface to sort objects.

What is difference between Comparable and Comparator interface?

Comparable and Comparator interfaces are used to sort collection or array of objects.

Comparable interface is used to provide the natural sorting of objects and we tin use it to provide sorting based on single logic.
Comparator interface is used to provide different algorithms for sorting and we can choose the comparator we want to use to sort the given collection of objects.

How tin nosotros sort a list of Objects?

If we need to sort an assortment of Objects, we can employ Arrays.sort(). If we need to sort a list of objects, we can use Collections.sort(). Both these classes have overloaded sort() methods for natural sorting (using Comparable) or sorting based on criteria (using Comparator).
Collections internally uses Arrays sorting method, so both of them have same performance except that Collections accept erstwhile to convert list to array.

While passing a Collection every bit argument to a role, how can we make sure the function will non be able to modify it?

We can create a read-only drove using Collections.unmodifiableCollection(Drove c) method before passing it as argument, this will brand sure that any performance to change the drove will throw UnsupportedOperationException.

How can we create a synchronized drove from given collection?

We can use Collections.synchronizedCollection(Collection c) to go a synchronized (thread-safe) collection backed by the specified collection.

What are common algorithms implemented in Collections Framework?

Java Collections Framework provides algorithm implementations that are commonly used such as sorting and searching. Collections class contain these method implementations. Most of these algorithms work on List merely some of them are applicable for all kinds of collections.
Some of them are sorting, searching, shuffling, min-max values.

What is Big-O notation? Give some examples?

The Big-O notation describes the performance of an algorithm in terms of the number of elements in a data construction. Since Drove classes are information structures, we ordinarily tend to use Big-O notation to chose the collection implementation to use based on time, retentiveness and operation.

Example ane: ArrayList become(index i) is a constant-time operation and doesn't depend on the number of elements in the list. So its functioning in Big-O notation is O(1).
Example 2: A linear search on array or listing performance is O(n) because we need to search through entire listing of elements to detect the chemical element.

What are best practices related to Java Collections Framework?

Chosing the right type of drove based on the need, for instance if size is fixed, we might want to employ Assortment over ArrayList. If nosotros have to iterate over the Map in society of insertion, nosotros need to use LinkedHashMap. If nosotros don't desire duplicates, we should use Set.
Some collection classes allows to specify the initial capacity, then if we take an estimate of number of elements we volition store, we tin use it to avoid rehashing or resizing.
Write plan in terms of interfaces not implementations, information technology allows us to change the implementation easily at afterwards point of time.
Always apply Generics for type-safety and avoid ClassCastException at runtime.
Utilise immutable classes provided by JDK equally fundamental in Map to avert implementation of hashCode() and equals() for our custom class.
Use Collections utility form as much as possible for algorithms or to get read-only, synchronized or empty collections rather than writing ain implementation. It volition enhance code-reuse with greater stability and low maintainability.

What is Coffee Priority Queue?

PriorityQueue is an unbounded queue based on a priority heap and the elements are ordered in their natural club or we can provide Comparator for ordering at the fourth dimension of creation. PriorityQueue doesn't allow null values and we tin't add any object that doesn't provide natural ordering or we don't have any comparator for them for ordering. Coffee PriorityQueue is non thread-safe and provided O(log(n)) time for enqueing and dequeing operations. Check this mail for java priority queue example.

Why tin can't nosotros write code equally `List<Number> numbers = new ArrayList<Integer>();`?

Generics doesn't back up sub-typing because it will cause issues in achieving blazon safety. That's why Listing<T> is non considered as a subtype of List<Due south> where S is the super-type of T. To understanding why it'due south non allowed, let's see what could accept happened if it has been supported.

                          List<Long> listLong = new ArrayList<Long>(); listLong.add(Long.valueOf(x)); List<Number> listNumbers = listLong; // compiler fault listNumbers.add(Double.valueOf(1.23));

Every bit you can run across from higher up code that IF generics would have been supporting sub-typing, nosotros could have easily add a Double to the list of Long that would take acquired ClassCastException at runtime while traversing the listing of Long.

Why can't we create generic assortment? or write code every bit `List<Integer>[] array = new ArrayList<Integer>[10];`

Nosotros are non immune to create generic arrays because array comport type information of its elements at runtime. This information is used at runtime to throw ArrayStoreException if elements type doesn't match to the defined type. Since generics type information gets erased at compile time by Blazon Erasure, the assortment store check would have been passed where information technology should have failed. Let'due south sympathize this with a elementary example code.

                          Listing<Integer>[] intList = new List<Integer>[v]; // compile error Object[] objArray = intList; List<Double> doubleList = new ArrayList<Double>(); doubleList.add(Double.valueOf(ane.23)); objArray[0] = doubleList; // this should fail just information technology would laissez passer because at runtime intList and doubleList both are only Listing

Arrays are covariant by nature i.eastward S[] is a subtype of T[] whenever S is a subtype of T but generics doesn't back up covariance or sub-typing every bit nosotros saw in the last question. So if we would have been allowed to create generic arrays, because of type erasure nosotros would non become an array shop exception even though both types are not related.

To know more about Generics, read Java Generics Tutorial.

I will keep on adding more questions on coffee collections framework as and when I found them, if you constitute it useful delight share it with others besides, it motivates me in writing more like these. 🙂

Delight permit me know if I accept missed whatsoever important question, I will include that to list.

DOWNLOAD HERE

Posted by: herbertprinell.blogspot.com

Elements Of Programming Interviews Java Pdf Download UPDATED