Question

• Describe the operation of the enhanced for loop and explain why it’s especially useful with arrays.
• Explain when you need to implement the Comparable interface in a class you create.
• Describe the difference between a rectangular array and a jagged array, and explain the difference in how you create them.
• Describe the similarities and differences between arrays and collections.
• Name the two main types of collections defined by the collection framework and explain how they differ.

Answer 1

1. Enhanced For Loop:

The main advantage of the for-each loop is that it eliminates the possibility of bugs and makes the code more readable. It is known as the for-each loop because it traverses each element one by one.

Syntax:

for(data_type variable : array | collection){  

//body of for-each loop  

}  

Example:

class ForEachExam{  

public static void main(String args[]) {  

int arr[]={1,3,14,4};  

for(int i:arr){  

System.out.println(i);  

}   }  }  

2. Comparable Interface:

Java Comparable interface is used to order the objects of the custom-defined class. This interface is found in java.lang package and contains only one method named compareTo(Object). It provides a single sorting sequence only, i.e., you can sort the elements on the basis of single data member only.

Lists (and arrays) of objects that implement Comparable interface can be sorted automatically by Collections.sort (and Arrays.sort).

Using Comparable interface, we can sort the elements of:

1. String objects
2. Wrapper class objects, for example Integer, Long etc
3. User defined custom objects

Syntax:

public interface Comparable<T>

{

    public int compareTo(T o);

}

Example:

Student.java

class Student implements Comparable<Student>{
int rollno;
String name;
int age;
  
Student(int rollno,String name,int age){
this.rollno=rollno;
this.name=name;
this.age=age;
}
  
public int compareTo(Student st){
if(age==st.age)
return 0;
else if(age>st.age)
return 1;
else
return -1;
}
}

Main Class to test:

TestSort1.java

import java.util.*;

public class TestSort1 {
public static void main(String args[]){
ArrayList<Student> al=new ArrayList<Student>();
al.add(new Student(101,"Vijay",23));
al.add(new Student(106,"Ajay",27));
al.add(new Student(105,"Jai",21));
  
Collections.sort(al);

for(Student st:al){
System.out.println(st.rollno+" "+st.name+" "+st.age);
}
}
}

4. Differences between arrays and collections

1. Arrays are fixed in size but Collections are dynamic in size.
2. With respect to memory arrays are not good to use but with respect to memory Collections are better to use.
3. With respect to performance its better to use arrays but with respect to performance collection are not good to use.
4. Arrays can hold only homogeneous elements but collections can hold both homogeneous and heterogeneous elements
5. Arrays don't have ready made methods but collections have ready made data structures and methods.
6. Arrays can hold both primitives and wrapper objects but collections can hold only objects.

5. Collection Framework

Main Types are:

1. List

Lists represents an ordered collection of elements. Using lists, we can access elements by their integer index (position in the list), and search for elements in the list. index start with 0, just like an array.

Some useful classes which implement List interface are – ArrayList, CopyOnWriteArrayList, LinkedList, Stack and Vector.

2. Set

Sets represents a collection of sorted elements. Sets do not allow the duplicate elements. Set interface does not provides no guarantee to return the elements in any predictable order; though some Set implementations store elements in their natural ordering and guarantee this order.

Some useful classes which implement Set interface are – ConcurrentSkipListSet, CopyOnWriteArraySet, HashSet, LinkedHashSet and TreeSet.

3. Map

The Map interface enable us to store data in key-value pairs (keys should be immutable). A map cannot contain duplicate keys; each key can map to at most one value.

The Map interface provides three collection views, which allow a map’s contents to be viewed as a set of keys, collection of values, or set of key-value mappings. Some map implementations, like the TreeMap class, make specific guarantees as to their order; others, like the HashMap class, do not.

Some useful classes which implement Map interface are – ConcurrentHashMap, ConcurrentSkipListMap, EnumMap, HashMap, Hashtable, IdentityHashMap, LinkedHashMap, Properties, TreeMap