Are You Recruiter/Hiring Manager?
Cloud-based Candidate Screening | Online Tests
PMP 1600 Questions
PMP 1600 Questions
1600 PMP mock questions 1400 CAPM mock questions 800 SCJP 6 mock questions 600 OCAJP 7 mock questions 590 OCPJP 7 mock questions 556 SCWCD 5 mock questions 500 OCEJWCD 6 mock questions pdfDownload (java,struts, hibernet etc)

Tutorial Home

Hibernate

  • Advantage of Hibernate over JDBC
  • Hibernate Setup with an web Application
  • First Hibernate Application
  • Hibernate mapping with Database TABLE
  • Hibernate Data Type-Java Data Type - SQL Data Type mapping
  • One to Many Relation in Hibernate
  • One to Many Relation in Hibernate bi-directional
  • Many to Many Relation in Hibernate
  • HQL: The Hibernate Query Language
  • Criteria Queries
  • Criteria Queries : Equal (eq), Not Equal(ne), Less than (le), greater than (gt),greater than or equal(ge) and Ordering the results
  • Criteria Queries: And OR conditions
  • Hibernate generator to generate id (primary key)
  • prevent concurrent update in Hibernate,slate object updatation in Hibernate,version checking in Hibernate

    Struts


  • Model View Controller (MVC)
  • Model View Controller (MVC)
  • Struts Flow-How Struts Works?
  • Struts Tutorial - Struts Setup- First Struts Action class setup
  • Message Resources
  • Validation Framework
  • Validation Framework-client side
  • ForwardAction
  • IncludeAction
  • DispatchAction
  • LookupDispatchAction
  • DynaActionForm
  • DynaActionForm
  • Struts Tutorial - Mutli-click prevention using struts tokens-Prevent Duplicate Submission
  • Logic Iterate Map and List

    JSP


  • JSP Tutorial
  • Introduction to JSP
  • JSP Comments
  • JSP Syntax
  • JSP Scripting Elements :Scriptlet, expression, declaration
  • JSP Directives
  • implicit objects in JSP
  • JSP Actions
  • Introduction to JSP
  • jsp:useBean
  • The jsp:setProperty Action
  • The jsp:getProperty Action
  • Introduction to JSP

    Spring


  • Spring Tutorial
  • Introduction to Spring
  • Benefits of Using Spring Framework
  • Inversion of Control in Spring
  • Introduction to BeanFactory
  • Dependency Injection in Spring
  • Collections Setter Injection
  • Bean Scopes in Spring
  • Spring IOC Setup Step by Step
  • Bean Lifecycle in Spring
  • ApplicationContext
  • MessageSources in Spring
  • Web Spring MVC framework
  • Developing Your First Spring Web Application
  • Developing Your Second Spring Web Application with Spring Form
  • Developing Your First Spring Web Application with Spring Validation Framework with Code Example
  • Spring integration with Hibernate
  • SCJP : enhanced for loop (for-each)

    SCJP 1.5/1.6 Exam Kit

    Develop code that implements all forms of loops and iterators, including the use of for, the enhanced for loop (for-each), do, while, labels, break, and continue; and explain the values taken by loop counter variables during and after loop execution.

    An enhanced "for" loop

    The current for statement is quite powerful and can be used to iterate over arrays or collections. However, it is not optimized for collection iteration, simply because the iterator serves no other purpose than getting elements out of the collection. The new enhanced for construct lets you iterate over collections and arrays without using iterators or index variables.

    The new form of the for statement has the following syntax:

    for ( Type Identifier : Expression ) Statement					
    					

    Note that Expression MUST be an array or an instance of a new interface called java.lang.Iterable, which is meant to ease the task of enabling a type for use with the enhanced for statement. This means that the java.util.Collection now extends the Iterable interface that has the following signature:

    package java.lang;
    
    public interface Iterable<E> {
      /**     
       * Returns an iterator over the elements in this collection.     
       * There are no guarantees concerning the order in which the elements     
       * are returned (unless this collection is an instance of some class     
       * that provides such a guarantee).     
       *      
       * @return an iterator over the elements in this collection     
       */    
    
       Iterator<E> iterator();
    }
    					

    As an example, consider the following method that uses the conventional for statement to iterate over a collection:

    // Assume we have an instance of StringBuffer "sb"
    public void oldFor(Collection c) {
    	for(Iterator i = c.iterator(); i.hasNtext(); ) {
    		String str = (String) i.next();
    		sb.append(str);
    	}
    }
    					

    With the addition of generics, the above segment of code can be rewritten using the enhanced for statement as follows:

    // Assume we have an instance of StringBuffer "sb"
    public void newFor(Collection<String> c) {
    	for(String str : c) {
    		sb.append(str);
    	}
    }
    					

    The enhanced for statement can be used to iterate over an array. Consider the following segment of code for a method that calculates the sum of the elements in an array:

    public int sumArray(int array[]) {
    	int sum = 0;
    	for(int i=0; i<array.length; i++) {
    		sum += array[i];
    	}
    	return sum;
    }
    					

    Using the enhanced for statement, this can be rewritten as:

    public int sumArray(int array[]) {
    	int sum = 0;
    	for(int i : array) {
    		sum += i;
    	}
    	return sum;
    }
    					

    The for(:) loop is designed for iteration over collections and arrays.

    Iterating over arrays:

    // for(;;) loop
    int[] ageInfo = {12, 30, 45, 55};
    int sumAge = 0;
    for (int i = 0; i < ageInfo.length; i++) {
    	sumAge += ageInfo[i];
    }	
    					
    // for(:) loop
    int[] ageInfo = {12, 30, 45, 55};
    int sumAge = 0;
    for (int element : ageInfo) {
    	sumAge += element;
    }	
    					

    NOTE, that an array element of a primitive value CANNOT be modified in the for(:) loop.

    Iterating over non-generic Collection:

    // for(;;) loop
    Collection nameList = new ArrayList();
    nameList.add("Mikalai");
    nameList.add("Michael");
    nameList.add("Craig");
    for (Iterator it = nameList.iterator(); it.hasNext(); ) {
    	Object element = it.next();
    	if (element instanceof String) {
    		String name = (String) element;
    		...		
    	}
    }
    					
    // for(:) loop
    Collection nameList = new ArrayList();
    nameList.add("Mikalai");
    nameList.add("Michael");
    nameList.add("Craig");
    for (Object element : nameList) {
    	if (element instanceof String) {
    		String name = (String) element;
    		...
    	}
    }					
    					

    Iterating over generic Collection:

    
    // for(;;) loop
    Collection<String> nameList = new ArrayList<String>();
    nameList.add("Mikalai");
    nameList.add("Michael");
    nameList.add("Craig");
    for (Iterator<String> it = nameList.iterator(); it.hasNext();) {
    	String name = it.next();
    	...
    }
    
    					
    
    // for(:) loop
    Collection<String> nameList = new ArrayList<String>();
    nameList.add("Mikalai");
    nameList.add("Michael");
    nameList.add("Craig");
    for (String name : nameList) {
    	...
    }
    
    					

    The syntax of the for(:) loop does not use an iterator for the collection.

    NOTE, the for(:) loop DOES NOT allow elements to be removed from the collection.

    for (Type FormalParameter : Expression) Statement
    					

    The FormalParameter must be declared in the for(:) loop.

    The Expression is evaluated only once.

    The type of Expression is java.lang.Iterable or an array. The java.util.Collection interface is retrofitted to extend the java.lang.Iterable interface which has the method prototype Iterator<T> iterator().

    When Expression is an array: the type of the array element MUST be assignable to the Type of the FormalParameter.

    When Expression is an instance of a raw type java.lang.Iterable: the Type of the FormalParameter MUST be Object.

    When Expression is an instance of a parameterized type java.lang.Iterable<T>: the type parameter T MUST be assignable to the Type of the FormalParameter.

    Restrictions on the enhanced for loop:

    • CANNOT be used to remove elements from a collection. The 'for-each' loop hides the iterator, so you CANNOT call remove(). Therefore, the 'for-each' loop is not usable for filtering:

      
      // This is NOT possible with 'for-each' loop !!!
      // Removes the 4-letter words from c
      static void expurgate(Collection<String> c) {
      	for (Iterator<String> i = c.iterator(); i.hasNext(); ) {
      		if (i.next().length() == 4) {
      			i.remove();
      		}	
      	}       
      }
      								
      								

    • CANNOT be used to modify the current slot in a collection or an array. It is not usable for loops where you need to replace elements in a list or array as you traverse it.

      
      Collection<String> nameList = new ArrayList<String>();
      nameList.add("Mikalai");
      nameList.add("Michael");
      nameList.add("Craig");
      for (String name : nameList) {
      	name = "Nicholas"; // WRONG ! Can not modify collection
      }
      System.out.println(nameList);
      								
      								
      The output:
      [Mikalai, Michael, Craig]
      								
      					
      int[] numArray = new int[] {1,2,3,4,5};
      for (int i : numArray) {
      	i = 0; // WRONG ! Can not modify array !
      }
      System.out.println(Arrays.toString(numArray));
      								
      The output:
      [1, 2, 3, 4, 5]								
      								

      However, we CAN modify object itself:

      
      Collection<StringBuffer> bufferList = new ArrayList<StringBuffer>();
      bufferList.add(new StringBuffer("Mikalai"));
      bufferList.add(new StringBuffer("Michael"));
      bufferList.add(new StringBuffer("Craig"));
      for (StringBuffer name : bufferList) {
      	name.reverse(); // CORRECT ! Can modify object itself
      }
      System.out.println(bufferList);
      								
      								
      The output:
      [ialakiM, leahciM, giarC]
      								

    • CANNOT be used to simultaneously iterate over multiple collections or arrays in parallel.

    The information you are posting should be related to java and ORACLE technology. Not political.