Iterator:

Using Iterator we can iterate only in forward direction and you cannot add elements while iterating and Here cursor always points to specific index.

Example:

 
public class Example {

  public static void main(String[] args) {

    ArrayList aList = new ArrayList();

    aList.add("1");
    aList.add("2");
    aList.add("3");
    aList.add("4");
    aList.add("5");

    Iterator itr = aList.iterator();

    while(itr.hasNext())
      System.out.println(itr.next());

  }
}

ListIterator:

Allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator’s current position in the list. A ListIterator has no current element; its cursor position always lies between the element that would be returned by a call to previous() and the element that would be returned by a call to next().

Example:

public class sample {

  public static void main(String[] args) {
    //create an object of ArrayList
    ArrayList aList = new ArrayList();

    //Add elements to ArrayList object
    aList.add("1");
    aList.add("2");
    aList.add("3");
    aList.add("4");
    aList.add("5");

    //Get an object of ListIterator using listIterator() method
    ListIterator listIterator = aList.listIterator();

    System.out.println(" forward direction using ListIterator");
    while(listIterator.hasNext())
      System.out.println(listIterator.next());

    System.out.println("reverse direction using ListIterator");
    while(listIterator.hasPrevious())
      System.out.println(listIterator.previous());

  }
}

try the above code and get back to me :)

• Counting down (i.e. for (int i=n; i>0; i–)) is twice as fast as counting up: my machine can count down to 144 million in a second, but up to only 72 million.

• Calling Math.max(a,b) is 7 times slower than (a > b) ? a : b. This is the cost of a method call.

• Arrays are 15 to 30 times faster than Vectors. Hashtables are 2/3 as fast as Vectors.
• Use System.arraycopy(firstArray, 0, secondArray, 0, firstArray.length) method instead of iterating the first array and copying into second array.
• Use compound assignment operators (+=, -=, *=, and /=) instead of using normal operators.
• Ex: a = a+b takes longer time to execute when compared to a += b. In fact, these cause different Java byte codes to be generated.
• Eliminate unnecessary code in the loops and you should avoid declaring variables unnecessarily within loops.
• Use int instead of other primitive types because operations performed on int primitives generally execute faster than for any other primitive type supported by Java, so you should use int values whenever possible; char and short values are promoted to int automatically before arithmetic operations.

• Use notify() instead of notifyAll(), notify will execute faster than notifyAll().

• When joining couple of Stings use StringBuffer instead of String.

• Don’t try to convert Strings to upper or lower case for String comparison.
• In the String Class prefer charAt() method instead of startsWith() method. From performance perspective, startWith() makes quite a few comparisons preparing itself to compare it’s prefix with another string.

• Don’ t initialize the public instance variable in constructor if they already initialized outside the constructor. Because all public initialized instance variables are again initialized in constructor by default.

• Vector provides the following methods to insert elements.
  addElementAt( e, index)
  addElement (e)
  add(e)
  add(index, e)

• Out of these try to avoid using methods, addElementAt( e, index) and add(index, e). The way these methods work is , all the elements are moved down between the insertion point and the end of the vector, making space for the new Element. The same works for deleting element at a Particular index. If possible, if these features are required, then try to use a different Data Structure if possible.

• If the approximate size of the Vector is know initially then use it. Instead of declaring Vector as,

Vector v = newVector();
declare it as,Vector v = new Vector(40);
or  Vector v = new Vector(40,25) ;

• This method indicates initial capacity of Vector is 40 and increment by 25 elements per expansion.The way the Vector is expanded is, a new Vector of double the size of currentVector is created, all the Elements in the old Vector is copied to the new Vector and then the old Vector is discarded. (During GC). This has major effect on performance.

1

Class C {

public static void main(String[] args) {

int[]a1[]=new int[3][3]; //3

int a2[4]={3,4,5,6}; //4

int a2[5]; //5

}}

5.None of the above

What is the result of attempting to compile and run the program ?.

1.compiletime error at lines 3,4,5

2.compiltime error at line 4,5

3.compiletime error at line 3

4.Runtime Exception

Ans: 2

Explanation:

no value shoud be specified in the rightsidebrackets when constructing an array