InstanceOfJava: java Collections interview Questions

java Collections interview Questions

Java program to reverse ArrayList elements

Posted by: Instanceofjava Posted date: 11:41 PM / comment : 0 java Collections interview Questions

How to reverse an ArrayList in java.
By using Collections.reverse() method we can reverse ArrayList in java.

#1: Java Example program to reverse ArrayList

package com.instanceofjava;
import java.util.ArrayList;
import java.util.Collections;
public class ReverseArrayList {
/**
* @author www.Instanceofjava.com
* @category interview questions
*
* Description: Java Example program to reverse an ArrayList
*
*/
public static void main(String[] args) {
ArrayList<String> arrayList= new ArrayList<>();
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");
Collections.reverse(arrayList);
System.out.println(arrayList);
}
}

Output:

[Orange, Banana, Apple]

#2: Java Example program to print arraylist in reverse order

reverse arraylist in java example program

How to convert list to set in java with example program

Posted by: Instanceofjava Posted date: 10:49 PM / comment : 0 java Collections interview Questions , java programming interview questions

Java program to convert list to set.
Convert ArrayList of string to HashSet in java example program
How to convert List to Set in java
Set<String> strSet = new HashSet<String>(arrList);
HashSet having a constructor which will take list as an argument.
Lets see how to convert list to Set using java program.

#1: Java Example Program to Convert List to Set.

package com.instanceofjava;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
public class ListToSet {
/**
* @author www.Instanceofjava.com
* @category interview questions
*
* Description: Convert List to set in java with example program
*
*/
public static void main(String[] args) {
ArrayList<String> arrList= new ArrayList<>();
arrList.add("Java");
arrList.add("List to String");
arrList.add("Example Program");
Set<String> strSet = new HashSet<String>(arrList);
System.out.println(strSet);
}
}

Output:

[Java, Example Program, List to String]

Using java.util.stream we can convert List to set in java 8
We can use java 8 java.util.stream.Collectors
arrList.stream().collect(Collectors.toSet());

#2: Java Example program to convert List to Set using java 8.

package com.instanceofjava;
import java.util.ArrayList;
import java.util.Set;
import java.util.stream.Collectors;
public class ListToSet {
/**
* @author www.Instanceofjava.com
* @category interview questions
*
* Description: Convert List to set in java with example program
*
*/
public static void main(String[] args) {
ArrayList<String> arrList= new ArrayList<>();
arrList.add("Java");
arrList.add("List to String");
arrList.add("Example Program");
Set<String> strSet = arrList.stream().collect(Collectors.toSet());
System.out.println(strSet);
}
}

Output:

Java 8 stream filter method example program

Posted by: Instanceofjava Posted date: 7:42 PM / comment : 0 java Collections interview Questions , java interview programs , java8

We can use java 8 stream class filter method to filter the values from a list /map in java
By Using filter() and collect() methods of stream class we can achieve this.
Lets see an example program to filter value from list without using java 8 streams and with java 8 stream filter.

#1: Java Example program to filter . remove value from list without using java 8 stream

package com.instanceofjava.filtermethodjava8
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author www.Instanceofjava.com
* @category interview programs
*
* Description: Remove value from list without using java 8 stream filter method
*
*/
public class fillterListJava8{
private static List<String> filterList(List<String> fruits, String filter) {
List<String> result = new ArrayList<>();
for (String fruit : fruits) {
if (!filter.equals(fruit)) {
result.add(fruit);
}
}
return result;
}
public static void main(String[] args) {
List<String> fruits = Arrays.asList("apple", "banana", "lemon");
System.out.println("Before..");
for (String str : fruits) {
System.out.println(str);
}
List<String> result = filterList(fruits, "lemon");
System.out.println("After..");
for (String str : result) {
System.out.println(str);
}
}
}

Output:

Before..
apple
banana
lemon
After..
apple
banana

#2: Java Example program to filter . remove value from list using java 8 java.util.stream

package com.instanceofjava.java8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author www.Instanceofjava.com
* @category interview programs
*
* Description: Remove value from list using java 8 stream filter method
*
*/
public class filterMethodOfStream {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("apple", "banana", "lemon");
String value="lemon";
List<String> result = fruits.stream()
.filter(line -> !value.equals(line))
.collect(Collectors.toList());
result.forEach(System.out::println);
for (String str : result) {
System.out.println(str);
}
}
}

Output:

Benefits of arraylist in java over arrays

Posted by: Instanceofjava Posted date: 1:10 PM / comment : 0 java Collections interview Questions , java programming interview questions

Disadvantages of arrays:

Check the disadvantages of arrays in below article.
Advantages and disadvantages of arrays in java

Advantages / Benefits of arraylist in java:

We have some disadvantages of arrays like arrays are fixed in length. and we need to mention size of the array while creation itself.
So we have some advantages of arraylist when compared to arrays in java.
Here the major advantages of arraylist over arrays.

1.ArrayList is variable length

One of the major benefit of arraylist is it is dynamic in size. we can increase as well as decrease size of the arraylist dynamically.
Resizable.

Program #1: Java example program to explain the advantages of ArrayList: resizable

package collections;
import java.util.ArrayList;
public class ArrayListExample {
/**
* Advantages of arrayList over arrays in java
* @author www.instanceofjava.com
*/
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list.size());
list.add(4);
list.add(5);
System.out.println(list.size());
list.remove(1);
System.out.println(list.size());
}
}

Output:

In the above program by using add and remove methods of ArrayList we can change the size of the ArrayList

2.Default initial capacity is 10.

One of the major benefit of arraylist is by default it will assign default size as 10.
Whenever we create object of ArrayList constructor of ArrayList assign default capacity as 10.

3.Insert and remove elements also at particular position of ArrayList

Another advantage of ArrayList is it can add and remove elements at particular position.

Program #2: Java example program to explain the advantages of ArrayList:Add and remove elements at particular position.

package collections;
import java.util.ArrayList;
public class ArrayListExample {
/**
* Advantages of arrayList over arrays in java
* @author www.instanceofjava.com
*/
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
list.add(0,4);
System.out.println(list);
list.add(2,5);
System.out.println(list);
list.remove(3);
System.out.println(list);
System.out.println(list.size());
}
}

Output:

[1, 2, 3]
[4, 1, 2, 3]
[4, 1, 5, 2, 3]
[4, 1, 5, 3]
4

4.Add any type of data into ArrayList.

We can add different type of objects in to the ArrayList.
In this scenario avoid mentioning generics while declaring ArrayList.

Program #3: Java example program to explain the advantages of ArrayList: Add any type of Object.

5.Traverse in both directions.

We can traverse both direction using List Iterator.

Program #4: Java example program to explain the advantages of ArrayList: Traverse in both directions.

package collections;
import java.util.ArrayList;
import java.util.ListIterator;
public class ArrayListExample {
/**
* Advantages of arrayList over arrays in java
* @author www.instanceofjava.com
*/
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("ArrayList Advantages");
list.add("ArrayList benefits");
list.add("ArrayList in java");
ListIterator iterator = list.listIterator();
System.out.println("**ArrayList Elements in forward direction**");
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
System.out.println("**ArrayList Elements in backward direction**");
while (iterator.hasPrevious())
{
System.out.println(iterator.previous());
}
}
}

Output:

**ArrayList Elements in forward direction**
ArrayList Advantages
ArrayList benefits
ArrayList in java
**ArrayList Elements in backward direction**
ArrayList in java
ArrayList benefits
ArrayList Advantages

6.ArrayList allows Multiple null values

We can add multiple null elements to ArrayList

Program #5: Java example program to explain the benefits of ArrayList: Add null elements

package collections;
import java.util.ArrayList;
public class ArrayListExample {
/**
* Advantages of arrayList over arrays in java
* @author www.instanceofjava.com
*/
public static void main(String[] args) {
ArrayList<String> arraylist = new ArrayList<String>();
arraylist.add(null);
arraylist.add(null);
arraylist.add(null);
System.out.println(arraylist);
}
}

Output:

[null, null, null]

7.ArrayList allows to add duplicate elements

We can add duplicate elements into arrayList

Program #6: Java example program to explain the advantages of ArrayList: Add any type of Object.

package collections;
import java.util.ArrayList;
public class ArrayListExample {
/**
* Advantages of arrayList over arrays in java
* @author www.instanceofjava.com
*/
public static void main(String[] args) {
ArrayList<String> arraylist = new ArrayList<String>();
arraylist.add("ArrayList");
arraylist.add("ArrayList");
arraylist.add("ArrayList");
System.out.println(arraylist);
}
}

Output:

[ArrayList, ArrayList, ArrayList]

8.ArrayList has many methods to manipulate stored objects.

ArrayList has many methods to manipulate stored objects.
addAll(), isEmpty(). lastIndexOf() etc.

How to Sort list of objects by multiple fields in java

Posted by: Instanceofjava Posted date: 1:00 PM / comment : 0 java Collections interview Questions

In order to compare objects we have comparable and comparator in java.
If you want to do custom sorting we will use comparator in java
We need to use different comparators for sorting objects by different fields.
And using Collections.sort(List, Comparator).
We can sort list of class objects by using cmparator.
By this we can compare two objects field by field. actually many.
Lets see an example program to sort list of student objects by name rollno and marks using comparator. Here comparator means we need to develop sorting logic in separate class which implements comparator interface and overrides compare() method.

Program 1: Write a java example program to sort list of objects

Student class:

Define a class as student add variables.
Define a constructor to assign values to variables.
Define a toString() method to print each variable value inside object values when we print object.

package com.sortobjects;
/**
* How to sort list of class objects
* @author www.instanceofjava.com
*/
public class Student {
String name;
int Rollno;
float marks;
Student(String name, int Rollno, float marks){
this.name=name;
this.marks=marks;
this.Rollno=Rollno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRollno() {
return Rollno;
}
public void setRollno(int rollno) {
Rollno = rollno;
}
public float getMarks() {
return marks;
}
public void setMarks(float marks) {
this.marks = marks;
}
public String toString() {
return ("Name:"+name+"\tRollNo:"+Rollno+"\tMarks"+marks);
}
}

NameComparator:

This class sort list of student class objects by name.

package com.sortobjects;
import java.util.Comparator;
public class NameComparator implements Comparator<Student>{
/**
* How to sort list of class objects
* @author www.instanceofjava.com
*/
@Override
public int compare(Student obj1, Student obj2) {
return obj1.getName().compareTo(obj2.getName());
}
}

RollNoComparator :

This class sort list of student class objects by Rollno.

package com.sortobjects;
import java.util.Comparator;
public class RollNoComparator implements Comparator<Student>{
/**
* How to sort list of class objects
* @author www.instanceofjava.com
*/
@Override
public int compare(Student obj1, Student obj2) {
return ((Integer)obj1.getRollno()).compareTo((Integer)obj2.getRollno());
}
}

MarksComparator:

This class will compare list of student class objects by marks

package com.sortobjects;
import java.util.Comparator;
public class MarksComparator implements Comparator<Student>{
/**
* How to sort list of class objects
* @author www.instanceofjava.com
*/
@Override
public int compare(Student obj1, Student obj2) {
return ((Float)obj1.getMarks()).compareTo((Float)obj2.getMarks());
}
}

SortListObjects:

Take a test class
Create arraylist object and add Student objects with different values into list.
Using Collections.Sort(List,FiledComparator) pass corresponding comparator class in order to sort multiple fields of a class.

package com.sortobjects;
mport java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* How to sort list of class objects
* @author www.instanceofjava.com
*/
public class SortListObjects {
public static void main(String[] args){
List<Student> studentlst= new ArrayList<Student>();
studentlst.add(new Student("Saisesh",1,80));
studentlst.add(new Student("Vinod",2,90));
studentlst.add(new Student("Ajay",3,95));
System.out.println("** Before sorting **:");
for (Student student : studentlst) {
System.out.println(student);
}
Collections.sort(studentlst,new NameComparator());
System.out.println("** After sorting **");
for (Student student : studentlst) {
System.out.println(student);
}
}
}

Output:

Like this we can compare list of objects by Rollno, and marks aslo. Please practice this example by sorting rollno and marks and check output. if you have any doubts then leave a comment.

Chained comparator:

We can use chained comparator to sort list of class objects by multiple fields by passing multiple comparators.
java collections sort multiple comparators
The below program is example of chained comparator java

package com.sortobjects;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class StudentChainedComparator implements Comparator<Student> {
private List<Comparator<Student>> listComparators;
public StudentChainedComparator(Comparator<Student>... comparators) {
this.listComparators = Arrays.asList(comparators);
}
@Override
public int compare(Student student1, Student student2) {
for (Comparator<Student> comparator : listComparators) {
int result = comparator.compare(student1, student2);
if (result != 0) {
return result;
}
}
return 0;
}
}

Java comparator multiple fields example:

Lets see an example of java comparatorchain in java

Deep copy in java example program

Posted by: Instanceofjava Posted date: 6:20 PM / comment : 0 java Collections interview Questions , java programming interview questions

Creating a copy of the object can be done in two ways
Shallow copy and deep copy. we have already discussed about shallow copy
Shallow copy in java example program
In shallow copy of object only object reference will be copied and if we change any data inside object changes will reflect in cloned object also this means both are referring to same object.

Deep copy / Deep cloning in Java

In deep copy completely a new object will be created with same data.
If we change the data inside original object wont reflect in deeply cloned object.

Program #1: Java example program to demonstrate deep copy / deep cloning

Sample :

package com.shallowcopyvsdeppcopy;
public class Sample {
int a;
int b;
Sample (int a, int b){
this.a=a;
this.b=b;
}
}

Empclone :

package com.shallowcopyvsdeppcopy;
public class empclone implements Cloneable {
Sample s;
int a;
empclone(int a, Sample s){
this.a=a;
this.s=s;
}
public Object clone()throws CloneNotSupportedException{
return new empclone(this.a, new Sample(this.s.a,this.s.a));
}
public static void main(String[] args) {
empclone a= new empclone(2, new Sample(3,3));
empclone b=null;
try {
b=(empclone)a.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(a.s.a);
System.out.println(b.s.a);
a.s.a=12;
System.out.println(a.s.a);
System.out.println(b.s.a);
}
}

OutPut:

What is the difference between shallow copy and deep copy:

When we create a shallow copy of the object only reference will be copied
When we create deep copy of the object totally new object with same data will be created.
Shallow copy and deep copy will be done by using Cloneable interface in java.

Difference between Collections and Collection in java with example program

Posted by: Instanceofjava Posted date: 9:37 PM / comment : 0 Core java Interview Questions , java Collections interview Questions

In Java, "Collection" refers to the interface that defines the basic properties and behaviors of a collection, while "Collections" is a utility class that provides static methods for working with collections.

The Collection interface is part of the Java Collections Framework and it is a root interface for all the collections. It defines the basic properties and behaviors that all collections should have, such as adding and removing elements, checking the size of the collection, and so on.

It includes List, Set and Queue interfaces.

On the other hand, the Collections class is a utility class that provides various static methods for working with collections, such as sorting, reversing, and searching. It also provides methods for creating unmodifiable collections, which are collections that cannot be modified after they are created.

Here are some examples of how we can use the Collections class:

To sort a List:

List<Integer> myList = new ArrayList<>();

myList.add(3);

myList.add(1);

myList.add(2);

Collections.sort(myList);

To reverse an array:

Collections.reverse(myList);

To create an unmodifiable collection:

List<Integer> unmodifiableList = Collections.unmodifiableList(myList);

It's worth noting that, the Collections class only provides static methods, it does not provide any instance methods. So, you can't create an object of the Collections class.

Famous java interview question: difference between collections and collection in java
Major difference between Collection and Collections is Collection is an interface and Collections is a class.
Both are belongs to java.util package
Collection is base interface for list set and queue.
Collections is a class and it is called utility class.
Collections utility class contains some predefined methods so that we can use while working with Collection type of classes(treeset, arraylist, linkedlist etc.)
Collection is base interface for List , Set and Queue.

Collection vs Collections

public interface Collection<E>
extends Iterable<E>

public class Collections
extends Object

difference between collections and collection in java

Collections utility class contains static utility methods so that we can use those methods by using class name without creating object of Collections class object
Lest see some methods of Collections class.

addAll: public static <T> boolean addAll(Collection<? super T> c,T... elements)
reverseOrder: public static <T> Comparator<T> reverseOrder()
shuffle: public static void shuffle(List<?> list)
sort:public static <T extends Comparable<? super T>> void sort(List<T> list)

How to Relate Collection and Collections

ArrayList is a Collection type of class means it is implementing Collection interface internally
Now lets see a java example program to sort ArrayList of elements using Collections.sort() method.

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

1.Basic Java example program to sort arraylist of integers using Collections.sort() method

package com.javasortarraylistofobjects;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class SortArrayListExample{
public static void main(String[] args) {
//create an ArrayList object
ArrayList<Integer> arrayList = new ArrayList<Integer>();
//Add elements to Arraylist
arrayList.add(10);
arrayList.add(7);
arrayList.add(11);
arrayList.add(4);
arrayList.add(9);
arrayList.add(6);
arrayList.add(2);
arrayList.add(8);
arrayList.add(5);
arrayList.add(1);
System.out.println("Before sorting ArrayList ...");
Iterator itr=arrayList.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
/*
To sort an ArrayList object, use Collection.sort method. This is a
static method. It sorts an ArrayList object's elements into ascending order.
*/
Collections.sort(arrayList);
System.out.println("After sorting ArrayList ...");
Iterator itr1=arrayList.iterator();
while (itr1.hasNext()) {
System.out.println(itr1.next());
}
}
}

Output:

Before sorting ArrayList ...
10
7
11
4
9
6
2
8
5
1
After sorting ArrayList ...
1
2
4
5
6
7
8
9
10
11

Subscribe to: Posts ( Atom )