Top 25 Java Quiz Questions – A Small Test to Build Your Knowledge

What will be the output of the following code
import java.util.Arrays;
import java.util.Comparator;
public class ComparatorTest {
public static void main(String args[])
{
String[] ar= {“c”,”d”,”b”,”a”,”e”};
InnerClass in=new InnerClass();
Arrays.parallelSort(ar, in);
for(String str : ar)
System.out.println(str +””);
System.out.println(Arrays.binarySearch(ar, “b”));
}
static class InnerClass implements Comparator<String>
{
public int compare(String s1, String s2)
{
return s2.compareTo(s1);
}
}
}

What will be the output of the following code
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetTest {
public static void main (String args[])
{
Set s=new LinkedHashSet();
s.add(“1”);
s.add(1);
s.add(3);
s.add(2);
System.out.println(s);
}
}

What will be the output of the following code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class Employee implements Comparator{
String name;
String id;
public Employee()
{}
public Employee(String name, String id)
{
this.name=name;
this.id=id;
}
@Override
public int compare(Employee obj1, Employee obj2) {
return obj2.name.compareTo(obj1.name);
}
@Override
public String toString() {
return “{“+”name “+name+”, id ” + id+’}’;
}
}
public class ComparatorUsage {
public static void main(String args[])
{
Employee emp1=new Employee(“sam”,”4″);
Employee emp2=new Employee(“amy”,”2″);
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(emp1);
list.add(emp2);
Collections.sort(list,new Employee());
System.out.println(list);
}

}

What will be the output of the following code
import java.util.ArrayList;
import java.util.List;
public class ListDemo {

public static void main (String args[])
{
List<Integer> list=new ArrayList<Integer>();
list.add(2);
list.add(3);
m(list);
public static void m(List<Number> list) {
System.out.println(list);
}
}

}

Which of those doesn’t have an index based structure?

java.util.Collections is a:

Methods such as reverse, shuffle are offered in:

Which of those allows duplicate elements?

Which allows the storage of a null key and null values?

What will be the output of the following code
import java.util.HashMap;
import java.util.Map;
public class HashMapTest {
public static void main(String args[])
{
Map<Integer,String> hashMap=new HashMap<Integer,String>();
hashMap.put(11,”animesh”);
hashMap.put(2,”ayushi”);
hashMap.put(7,”renuka”);
hashMap.put(9,”shivashish”);
hashMap.put(null,”null”);
System.out.println(hashMap.size());
System.out.println(hashMap);
}

}

What will be the output of the following code
import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
public static void main(String args[])
{
Vector<String> vector= new Vector<String>();
vector.add(“1”);
vector.add(“2”);

Iterator<String> iterator=vector.iterator();
while(iterator.hasNext())
{

System.out.println(iterator.next());
}
}
}

What will be the output of the following code
import java.util.ArrayList;
import java.util.List;

public class MyClass {
public static void main (String args[])
{
//Insert Here
List<String> list=new ArrayList<String>();
list.add(“a”);
list.add(“b”);
l.add(list);

}
}

What will be the output of the following code
import java.util.ArrayList;
import java.util.List;

public class ArrayListTest {
public static void main(String args[])
{
List<String> arrayList=new ArrayList<String>();

arrayList.add(“a”);
arrayList.add(“b”);
arrayList.add(“c”);

System.out.println();
arrayList.add(1,”d”);
System.out.println(arrayList);
}

}

What will be the output of the following code
import java.util.List;

public class ArrayListTest {
public static void main(String args[])
{
List<String> arrayList=new ArrayList<String>();

arrayList.add(“a”);
arrayList.add(“a”);
arrayList.clear();
arrayList.add(“b”);
arrayList.add(“b”);

System.out.println(arrayList.size());
}

}

What will be the output of the following code
import java.util.Map;
import java.util.TreeMap;

public class TreeMapTest {

public static void main (String args[])
{
Map<Integer,String> m= new TreeMap<Integer,String>();
m.put(11, “audi”);
m.put(null, null);
m.put(11,”bmw”);
m.put(null,”fer”);

System.out.println(m.size());
System.out.println(m);
}
}

What will be the output of the following code
class PrintValue
{
<t> void display(t obj[])
{
for(t i:obj)
{
System.out.println(i+” “);
}
}
}
public class MyClass {
public static void main(String…args)
{
Abc obj1=new Abc();

Integer i[]= {1,2};
obj1.display(i);

Double d[]= {1.1,2.2};
obj1.display(d);
}
}

What will be the output of the following code
import java.util.ArrayList;
import java.util.List;

public class MyClass {
public static void main (String args[])
{
List<Integer> list=new ArrayList<Integer>();
list.add(2);
list.add(3);
System.out.println(sum(list));

}
public static double sum(List<? extends Number> list)
{
double sum=0;
for(Number num:list)
{
sum+=num.doubleValue();
}
return sum;
}
}

What will be the output of the following code
import java.util.Comparator;

public class SortSet {
public static void main(String…a)
{
Set<Integer> treeSet=new TreeSet(new Comparator<Integer>()
{
public int compareTo(Integer o1,Integer o2)
{
return o2.compareTo(o1);
}
});
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet);

}

}

What will be the output of the following code
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SortSet {
public static void main(String…a)
{
Collection<Integer> collection = new HashSet<Integer>();
collection.add(3);
collection.add(1);
collection.add(2); {

Set<Integer> treeSet=new TreeSet<Integer>(collection);
System.out.println(treeSet);

}
}
}

Which interface should be implemented for sorting on basis of many criteria’s?

What will be the output of the following code
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class SortMap {

public static void main(String…a)
{
Map<Integer,Integer> treeMap = new TreeMap<Integer,Integer>(new Comparator<Integer>()
{
public int compare(Integer o1,Integer o2)
{
return o2.compareTo(o1);
}
});
treeMap.put(4,1);
treeMap.put(2,1);
treeMap.put(3,1);{

System.out.println(treeMap);

}
}
}

What will be the output of the following code
import java.util.List;
import java.util.ArrayList;

public class MyClass {

public static void main(String…a)
{
List<Integer> l = new ArrayList<Integer>();
l.add(2);
m(1);
}
static void m(List<? super Double> l)
{
System.out.println(l.get(0));
System.out.println(l.get(1));
}
}

In ConcurrentHashMap – once thread locks one segment for updation it doesn’t allow the other thread to perform updations in the same segment till lock isn’t released on the segment