InstanceOfJava: java Collections interview Questions

java Collections interview Questions

Java program to reverse ArrayList elements

Posted by: Instanceofjava Posted date: February 07, 2018 / 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: February 07, 2018 / 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: February 03, 2018 / 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: May 07, 2017 / 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: April 23, 2017 / 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: August 14, 2016 / 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: June 18, 2016 / 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

Remove duplicates from arraylist without using collections

Posted by: Instanceofjava Posted date: April 21, 2016 / comment : 1 java Collections interview Questions

1.Write a Java program to remove duplicate elements from an arraylist without using collections (without using set)

package arrayListRemoveduplicateElements;
import java.util.ArrayList;
public class RemoveDuplicates {
public static void main(String[] args){
ArrayList<Object> al = new ArrayList<Object>();
al.add("java");
al.add('a');
al.add('b');
al.add('a');
al.add("java");
al.add(10.3);
al.add('c');
al.add(14);
al.add("java");
al.add(12);
System.out.println("Before Remove Duplicate elements:"+al);
for(int i=0;i<al.size();i++){
for(int j=i+1;j<al.size();j++){
if(al.get(i).equals(al.get(j))){
al.remove(j);
j--;
}
}
}
System.out.println("After Removing duplicate elements:"+al);
}
}

Output:

Before Remove Duplicate elements:[java, a, b, a, java, 10.3, c, 14, java, 12]
After Removing duplicate elements:[java, a, b, 10.3, c, 14, 12]

2. Write a Java program to remove duplicate elements from an array using Collections (Linkedhashset)

package arrayListRemoveduplicateElements;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
public class RemoveDuplicates {
public static void main(String[] args){
List<String> arraylist = new ArrayList<String>();
arraylist.add("instanceofjava");
arraylist.add("Interview Questions");
arraylist.add("Interview Programs");
arraylist.add("java");
arraylist.add("Collections Interview Questions");
arraylist.add("instanceofjava");
arraylist.add("Java Experience Interview Questions");
System.out.println("Before Removing duplicate elements:"+arraylist);
HashSet<String> hashset = new HashSet<String>();
/* Adding ArrayList elements to the HashSet
* in order to remove the duplicate elements and
* to preserve the insertion order.
*/
hashset.addAll(arraylist);
// Removing ArrayList elements
arraylist.clear();
// Adding LinkedHashSet elements to the ArrayList
arraylist.addAll(hashset );
System.out.println("After Removing duplicate elements:"+arraylist);
}
}

Output:

Before Removing duplicate elements:[instanceofjava, Interview Questions, Interview
Programs, java, Collections Interview Questions, instanceofjava, Java Experience Interview
Questions]
After Removing duplicate elements:[java, Collections Interview Questions, Java Experience
Interview Questions, Interview Questions, instanceofjava, Interview Programs]

Iterator and Custom Iterator in java with example programs

Posted by: Instanceofjava Posted date: April 19, 2016 / comment : 5 java Collections interview Questions

Java Iterator

Iterator is an interface which is made for Collection objects like List, Set. It comes inside java.util package and it was introduced in java 1.2 as public interface Iterator. To generate successive elements from a Collection, we can use java iterator. It contains three methods: those are,

boolean hasNext(): this method returns true if this Iterator has more element to iterate.
remove(): method remove the last element return by the iterator this method only calls once per call to next().
Object next() : Returns the next element in the iteration.

Every collection classes provides an iterator() method that returns an iterator to the beginning of the collection. By using this iterator object, we can access each element in the collection, one element at a time. In general, to use an iterator to traverse through the contents of a collection follow these steps:

Obtain Iterator object by calling Collections’s iterator() method
Make a loop to decide the next element availability by calling hasNext() method.
Get each element from the collection by using next() method.

Java Program which explains how to use iterator in java

Here is an example demonstrating Iterator. It uses an ArrayList object, You can apply to any type of collection.

import java.util.ArrayList;
import java.util.Iterator;
public class IteratorExample {
public static void main(String args[]) {
// create an array list. But, you can use any collection
ArrayList<String> arraylist = new ArrayList<String>();
// add elements to the array list
arraylist .add("Raja");
arraylist .add("Rani");
arraylist .add("Shankar");
arraylist .add("Uday");
arraylist .add("Philips");
arraylist .add("Sachin");
// use iterator to display contents of arraylist
System.out.println("Original contents of arraylist : ");
Iterator<String> itr = arraylist .iterator();
while (itr.hasNext()) {
Object obj = itr.next();
System.out.print(obj + "\n");
}
}
}

Output:

Original contents of arraylist :
Raja
Rani
Shankar
Uday
Philips
Sachin

Iterator is the best choice if you have to iterate the objects from a Collection. But, Iterator having some limitations.

Those are,

Iterator is not index based
If you need to update the collection object being iterated, normally you are not allowed to because of the way the iterator stores its position. And it will throw ConcurrentModificationException.
It does not allow to traverse to bi directions.

To overcome these on other side, we have For-each loop. It was introduced in Java 1.5
Advantages of For each loop :

Index Based
Internally the for-each loop creates an Iterator to iterate through the collection.
If you want to replace items in your collection objects, use for-each loop

Consider the following code snippet, to understand the difference between how to use Iterator and for-each loop.

Iterator<String> itr = aList.iterator();
while (itr.hasNext()) {
Object obj = itr.next();
System.out.print(obj + "\n");
}
Is same as,
For (String str : aList){
System.out.println(str);
}

Same code has been rewritten using enhanced for-loops which looks more readable. But enhanced for-loops can’t be used automatically in Collection objects that we implement. Then what do we do? This is where Iterable interface comes in to picture. Only, if our Collection implemented Iterable interface, we can iterate using enhanced for-loops. The advantage of implementing Iterable interface So, we should implement Java Iterable interface in order to make our code more elegant.
Here I am going to write a best Practice to develop a custom iterator. Following is the Syntax.

public class MyCollection<E> implements Iterable<E>{
public Iterator<E> iterator() {
return new MyIterator<E>();
}
public class MyIterator <T> implements Iterator<T> {
public boolean hasNext() {
//implement...
}
public T next() {
//implement...;
}
public void remove() {
//implement... if supported.
}
public static void main(String[] args) {
MyCollection<String> stringCollection = new MyCollection<String>();
for(String string : stringCollection){
}
}
}
}

package com.instanceofjava.customIterator;
public class Book {
String name;
String author;
long isbn;
float price;
public Book(String name, String author, long isbn, float price) {
this.name = name;
this.author = author;
this.isbn = isbn;
this.price = price;
}
public String toString() {
return name + "\t" + author + "\t" + isbn + "\t" + ": Rs" + price;
}
}

package com.instanceofjava.customIterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import com.pamu.test.Book;
import java.lang.Iterable;
public class BookShop implements Iterable<Book> {
List<Book> avail_books;
public BookShop() {
avail_books = new ArrayList<Book>();
}
public void addBook(Book book) {
avail_books.add(book);
}
public Iterator<Book> iterator() {
return (Iterator<Book>) new BookShopIterator();
}
class BookShopIterator implements Iterator<Book> {
int currentIndex = 0;
@Override
public boolean hasNext() {
if (currentIndex >= avail_books.size()) {
return false;
} else {
return true;
}
}
@Override
public Book next() {
return avail_books.get(currentIndex++);
}
@Override
public void remove() {
avail_books.remove(--currentIndex);
}
}
//main method
public static void main(String[] args) {
Book book1 = new Book("Java", "JamesGosling", 123456, 1000.0f);
Book book2 = new Book("Spring", "RodJohnson", 789123, 1500.0f);
Book book3 = new Book("Struts", "Apache", 456789, 800.0f);
BookShop avail_books = new BookShop();
avail_books.addBook(book1);
avail_books.addBook(book2);
avail_books.addBook(book3);
System.out.println("Displaying Books:");
for(Book total_books : avail_books){
System.out.println(total_books);
}
}
}

Here, we created a BookShop class which contains books. This class able to use for-each loop only if it implements Iterable interface.Here, we have to provide the implementation for iterator method. we define my BookShopIterator as inner class.
Inner classes will provide more security, So that your class is able to access with in the Outer class and this will achieve data encapsulation.
The best reusable option is to implement the interface Iterable and override the method iterator().The main advantage of Iterable is, when you implement Iterable then those object gets support for for:each loop syntax.
Execute above program and check output. Practice makes perfect.

Get collection values from hashtable example

Posted by: Instanceofjava Posted date: March 17, 2016 / comment : 0 Hashtable , java Collections interview Questions

1.Basic java collection framework example program to get Value collection from hashtable

Collection values() This method used to get collection of values
Important note is that if any value is removed from set the original hashtable key also removed

package com.setviewHashtable;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Set;
public class HashtableExample{
public static void main(String[] args) {
//create Hashtable object
Hashtable<String,String> hashtable = new Hashtable<String,String>();
//add key value pairs to Hashtable
hashtable.put("1","Java Interview Questions");
hashtable.put("2","Java Interview Programs");
hashtable.put("3","Concept and example program");
hashtable.put("4","Concept and interview Questions");
hashtable.put("5","Java Quiz");
hashtable.put("6","Real time examples");
Collection c = hashtable.values();
System.out.println("Values of Collection created from Hashtable are :");
//iterate through the Set of keys
Iterator itr = c.iterator();
while(itr.hasNext())
System.out.println(itr.next());
c.remove("Java Quiz");
System.out.println("Elements in hash table");
Enumeration e=hashtable.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}

Output:

Values of Collection created from Hashtable are :
Real time examples
Java Quiz
Concept and interview Questions
Concept and example program
Java Interview Programs
Java Interview Questions
Elements in hash table
Real time examples
Concept and interview Questions
Concept and example program
Java Interview Programs
Java Interview Questions

Java Collections example program Get Set view of Keys from Hashtable example

Posted by: Instanceofjava Posted date: March 17, 2016 / comment : 0 Hashtable , java Collections interview Questions

1.Basic java collection framework example program to get set view from hashtable

Set keySet() This method used to get set view of the keys of hashtable
Important note is that if any key is removed from set the original hashtable key also removed

package com.setviewHashtable;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Set;
public class HashtableExample{
public static void main(String[] args) {
//create Hashtable object
Hashtable<String,String> hashtable = new Hashtable<String,String>();
//add key value pairs to Hashtable
hashtable.put("1","Java Interview Questions");
hashtable.put("2","Java Interview Programs");
hashtable.put("3","Concept and example program");
hashtable.put("4","Concept and interview Questions");
hashtable.put("5","Java Quiz");
hashtable.put("6","Real time examples");
Set st = hashtable.keySet();
System.out.println("Set created from Hashtable Keys contains :");
//iterate through the Set of keys
Iterator itr = st.iterator();
while(itr.hasNext())
System.out.println(itr.next());
st.remove("1");
System.out.println("Elements in hash table");
Enumeration e=hashtable.keys();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
}

Output:

Set created from Hashtable Keys contains :
6
5
4
3
2
1
Elements in hash table
6
5
4
3
2

Subscribe to: Comments ( Atom )

Java Iterator

Output:

Iterator is the best choice if you have to iterate the objects from a Collection. But, Iterator having some limitations.