Why does JComponent have add() and remove() methods but Component does not
because JComponent is a subclass of Container, and can contain other components and jcomponents. How can I implement a thread-safe JSP page? – You can make your JSPs thread-safe by having them implement the SingleThreadModel interface. This is done by adding the directive <%@ page isThreadSafe=”false” % > within your JSP page
Performance of Map interface implementations
Hashtable
An instance of Hashtable has two parameters that affect its performance: initial capacity and load factor. The capacity is the number of buckets in the hash table, and the initial capacity is simply the capacity at the time the hash table is created. Note that the hash table is open: in the case of a “hash collision”, a single bucket stores multiple entries, which must be searched sequentially. The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased. The initial capacity and load factor parameters are merely hints to the implementation. The exact details as to when and whether the rehash method is invoked are implementation-dependent.
HashMap
This implementation provides constant-time [ Big O Notation is O(1) ] performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets. Iteration over collection views requires time proportional to the “capacity” of the HashMap instance (the number of buckets) plus its size (the number of key-value mappings). Thus, it’s very important not to set the initial capacity too high (or the load factor too low) if iteration performance is important.
TreeMap
The TreeMap implementation provides guaranteed log(n) [ Big O Notation is O(log N) ] time cost for the containsKey, get, put and remove operations.
LinkedHashMap
A linked hash map has two parameters that affect its performance: initial capacity and load factor. They are defined precisely as for HashMap. Note, however, that the penalty for choosing an excessively high value for initial capacity is less severe for this class than for HashMap, as iteration times for this class are unaffected by capacity.
Explain about session interface
This represents hibernate session which perform the manipulation on the database entities. Some of the activities performed by session interface are as follows they are managing the persistence state, fetching persisted ones and management of the transaction demarcation.
What is java.util.concurrent BlockingQueue? How it can be used
Java has implementation of BlockingQueue available since Java 1.5. Blocking Queue interface extends collection interface, which provides you power of collections inside a queue. Blocking Queue is a type of Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element. A typical usage example would be based on a producer-consumer scenario. Note that a BlockingQueue can safely be used with multiple producers and multiple consumers. An ArrayBlockingQueue is a implementation of blocking queue with an array used to store the queued objects. The head of the queue is that element that has been on the queue the longest time. The tail of the queue is that element that has been on the queue the shortest time. New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue. ArrayBlockingQueue requires you to specify the capacity of queue at the object construction time itself. Once created, the capacity cannot be increased. This is a classic “bounded buffer” (fixed size buffer), in which a fixed-sized array holds elements inserted by producers and extracted by consumers. Attempts to put an element to a full queue will result in the put operation blocking; attempts to retrieve an element from an empty queue will be blocked.
What is the role of JSP in MVC Model
JSP is mostly used to develop the user interface, It plays are role of View in the MVC Model.
Why Java Vector class is considered obsolete or unofficially deprecated? or Why should I always use ArrayList over Vector
You should use ArrayList over Vector because you should default to non-synchronized access. Vector synchronizes each individual method. That’s almost never what you want to do. Generally you want to synchronize a whole sequence of operations. Synchronizing individual operations is both less safe (if you iterate over a Vector, for instance, you still need to take out a lock to avoid anyone else changing the collection at the same time) but also slower (why take out a lock repeatedly when once will be enough)? Of course, it also has the overhead of locking even when you don’t need to. It’s a very flawed approach to have synchronized access as default. You can always decorate a collection using Collections.synchronizedList – the fact that Vector combines both the “resized array” collection implementation with the “synchronize every operation” bit is another example of poor design; the decoration approach gives cleaner separation of concerns. Vector also has a few legacy methods around enumeration and element retrieval which are different than the List interface, and developers (especially those who learned Java before 1.2) can tend to use them if they are in the code. Although Enumerations are faster, they don’t check if the collection was modified during iteration, which can cause issues, and given that Vector might be chosen for its syncronization – with the attendant access from multiple threads, this makes it a particularly pernicious problem. Usage of these methods also couples a lot of code to Vector, such that it won’t be easy to replace it with a different List implementation. Despite all above reasons Sun may never officially deprecate Vector class.
What is Java Collections API
Java Collections framework API is a unified architecture for representing and manipulating collections. The API contains Interfaces, Implementations & Algorithm to help java programmer in everyday programming. In nutshell, this API does 6 things at high level
- Reduces programming efforts. – Increases program speed and quality.
- Allows interoperability among unrelated APIs.
- Reduces effort to learn and to use new APIs.
- Reduces effort to design new APIs.
- Encourages & Fosters software reuse.
To be specific, There are six collection java interfaces. The most basic interface is Collection. Three interfaces extend Collection: Set, List, and SortedSet. The other two collection interfaces, Map and SortedMap, do not extend Collection, as they represent mappings rather than true collections.
What are the ways to speed up Object Serialization? How to improve Serialization performance
The default Java Serialization mechanism is really useful, however it can have a really bad performance based on your application and business requirements. The serialization process performance heavily depends on the number and size of attributes you are going to serialize for an object. Below are some tips you can use for speeding up the marshaling and un-marshaling of objects during Java serialization process.
- Mark the unwanted or non Serializable attributes as transient. This is a straight forward benefit since your attributes for serialization are clearly marked and can be easily achieved using Serialzable interface itself.
- Save only the state of the object, not the derived attributes. Some times we keep the derived attributes as part of the object however serializing them can be costly. Therefore consider calcualting them during de-serialization process.
- Serialize attributes only with NON-default values. For examples, serializing a int variable with value zero is just going to take extra space however, choosing not to serialize it would save you a lot of performance. This approach can avoid some types of attributes taking unwanted space. This will require use of Externalizable interface since attribute serialization is determined at runtime based on the value of each attribute.
- Use Externalizable interface and implement the readObject and writeObject methods to dynamically identify the attributes to be serialized. Some times there can be a custom logic used for serialization of various attributes.
What are the pros and cons of an Observer design pattern
PROS:
- Loose coupling between Subject and Observer: The subject knows only a list of observers, that implementthe Observer interface, it does no know the concrete implementation of the Observer.
- Broadcast communication: An eventnotification is broadcast to observers irrespective of the number of Observers
CONS:
- If not used carefullythe observer pattern can add unnecessary complexity.
- The order of Observer notifications is undependable. Simply registering the observers in a particular order will not enforce their order ofnotification. You don’t necessarily know if the first registered listener is notified first or last. If you need to have cascading notifications, where object X must be notified first, followed by object Y, you must introduce an intermediary object to enforce the ordering.
- The possibility of a memory leak: A reference tothe Observer is maintained by the Subject. Until the Subject releases the reference, the Observer cannot be removed by the garbage collector.
What is the benefit of having JdbcRowSet implementation? Why do we need a JdbcRowSet like wrapper around ResultSet
The JdbcRowSet implementation is a wrapper around a ResultSet object that has following advantages over ResultSet
- This implementation makes it possible to use the ResultSet object as a JavaBeans component. A JdbcRowSet can be used as a JavaBeans component in a visual Bean development environment, can be created and configured at design time and executed at run time.
- It can be used to make a ResultSet object scrollable and updatable. All RowSet objects are by default scrollable and updatable. If the driver and database being used do not support scrolling and/or updating of result sets, an application can populate a JdbcRowSet object with the data of a ResultSet object and then operate on the JdbcRowSet object as if it were the ResultSet object.
CallableStatement Example in Java
The JDBC CallableStatement interface extends PreparedStatement and provides support for output and input/output parameters. The CallableStatement interface also has support for input parameters that is provided by the PreparedStatement interface.
The CallableStatement interface allows the use of SQL statements to call stored procedures. Stored procedures are programs that have a database interface. These programs possess the following:
- They can have input and output parameters, or parameters that are both input and output.
- They can have a return value.
- They have the ability to return multiple ResultSets.
CREATE PROCEDURE GetImmediateManager
@employeeID INT,
@managerID INT OUTPUT
AS
BEGIN
SELECT @managerID = ManagerID
FROM HumanResources.Employee
WHERE EmployeeID = @employeeID
END
Conceptually in JDBC, a stored procedure call is a single call to the database, but the program associated with the stored procedure may process hundreds of database requests. The stored procedure program may also perform a number of other programmatic tasks not typically done with SQL statements.
public static void executeStoredProcedure(
Connection con) {
try {
CallableStatement cstmt = con.prepareCall(“{call dbo.GetImmediateManager(?, ?)}”);
cstmt.setInt(1, 5);
cstmt.registerOutParameter(2, java.sql.Types.INTEGER);
cstmt.execute();
System.out.println(“MANAGER ID: ” + cstmt.getInt(2));
}
catch (Exception e) {
e.printStackTrace();
}
}
package com.Javastuff.jdbc;
import java.sql.*;
import java.util.*;
import java.io.*;
public class GetEmployeeDetails {
public static void main(String s[]) throws Exception {
Driver d= (Driver) ( Class.forName(
“oracle.jdbc.driver.OracleDriver”).newInstance());
Properties p=new Properties ();
p.put(“user”,”scott”);
p.put(“password”,”tiger”);
Connection con=d.connect(
“jdbc:oracle:thin:@mysys:1521:javastuff”,p);
Statement st=con.createStatement();
ResultSet rs=st.executeQuery( “select profile from empprofiles where empno=”+s[0]);
while (rs.next()) {
Reader r=rs.getCharacterStream(1);
FileWriter fw=new FileWriter(“ProfileOf”+s[0]+”.doc”);
int i=r.read();
while (i!=-1){
fw.write(i);
i=r.read();
}//while
}//while
System.out.println(“Profile retrived”);
con.close();
}//main
}//class
How to convert blob to byte array in java
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
InputStream in = blob.getBinaryStream();
int n = 0;
while ((n=in.read(buf))>=0)
{
baos.write(buf, 0, n);
}
in.close();
byte[] bytes = baos.toByteArray();
The JDBC drivers that support JDBC 2.0 and above support batch updates. Batch updates is a option given by the JDBC in which application developers can submit a set of SQL update statements as batch to the database.
The following methods used for creating, executing, and removing a batch of SQL updates:
- addBatch
- executeBatch
- clearBatch
package com.javstuff.jdbc;
import java.sql.*;
import java.util.*;
import java.io.*;
public class BatchUpdateExample {
public static void main(String s[]) throws Exception {
Driver d= (Driver) ( Class.forName(
“oracle.jdbc.driver.OracleDriver”).newInstance());
Properties p=new Properties ();
p.put(“user”,”scott”);
p.put(“password”,”tiger”);
Connection con=d.connect(“jdbc:oracle:thin:@mysys:1521:javastuff”,p);
Statement st=con.createStatement();
//statement1
st.addBatch(“insert into emp(empno,sal,deptno) values(“+s[0]+”,1000,10)”);
//statement2
st.addBatch(“update emp set sal=2000 where empno=”+s[0]);
//statement3
st.addBatch(“insert into emp(empno,sal,deptno) values(202,1000,10)”);
//statement4
st.addBatch(“insert into emp(empno,sal,deptno) values(203,1000,10)”);
try {
int[] counts=st.executeBatch();
System.out.println(“Batch Executed Successfully”);
for (int i=0;i<counts.length;i++){
System.out.println(“Number of records effected by statement”+(i+1)+”: “+counts[i]);
}//for
}//try
catch(BatchUpdateException e){
System.out.println(“Batch terminated with an abnormal condition”);
int[] counts=e.getUpdateCounts();
System.out.println(“Batch terminated at statement”+ (counts.length+1));
for (int i=0;i<counts.length;i++) {
System.out.println(“Number of records effected by the statement”+ (i+1)+”: “+counts[i]);
}//for
}//catch
con.close();
}//main
}//class
Array, one of the SQL 99 datatypes. offers you the facility to include an ordered list of values within the column. The java.sql.Array interface to store the values of the array types. To store the Array first we need to create a User-Defined-Type Array. this can be done by creating a UDT as array in database.
package com.Javastuff.jdbc;
import java.sql.*;
import java.util.*;
import oracle.sql.*;
public class InsertEmpPassportDetails {
public static void main(String s[]) throws Exception {
Driver d= (Driver) ( Class.forName(
“oracle.jdbc.driver.OracleDriver”).newInstance());
Properties p=new Properties ();
p.put(“user”,”scott”);
p.put(“password”,”tiger”);
Connection con=d.connect(
“jdbc:oracle:thin:@Javastuff:1521:sandb”,p);
PreparedStatement ps=con.prepareStatement(“insert into emppassportDetails values(?,?,?)”);
ps.setInt(1,7934);
ps.setString(2,”12345A134″);
String s1[]={“v1″,”v2″,”v3″,”v4″,”v5”};
ArrayDescriptor ad=ArrayDescriptor.createDescriptor(“VISA_NOS”,con);
ARRAY a=new ARRAY(ad,con,s1);
ps.setArray(3,a);
int i=ps.executeUpdate();
System.out.println(“Row Inserted, count : “+i);
con.close();
}//main
}//class
The DatabaseMetaData class is used to determine the capabilities of a JDBC driver and it database during runtime. If a given method of this interface is not supported by the JDBC driver, the method will either throw an SQLException, or in the case of a method that returns a result set, it may return null. Some of the methods take search patterns as its arguments. The pattern values used can be the SQL wildcard characters % and _. Other search arguments accept an empty set (“”) when the argument is not applicable, or null to drop the argument from the search criteria.
This interface is implemented by driver vendors to let users know the capabilities of a Database Management System (DBMS) in combination with the driver based on JDBC driver that is used with it. Different relational DBMSs often support different features, implement features in different ways, and use different data types. In addition, a driver may implement a feature on top of what the DBMS offers. Information returned by methods in this interface applies to the capabilities of a particular driver and a particular DBMS working together.
The JDBC API enables you to uncover metadata about a database using the DatabaseMetaData interfaces. The DatabaseMetaData interface enables you to obtain information about your database’s attributes and make runtime decisions based around that information.
package com.javastuff.jdbc;
import java.sql.*;
import java.util.*;
import java.io.*;
public class DataBaseMetaDataExample {
public static void main(String s[]) throws Exception {
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
Connection con =
DriverManager.getConnection(“jdbc:odbc:javastuff”, “scott”,”tiger”);
DatabaseMetaData db= con.getMetaData();
System.out.println(“Database name : “+db.getDatabaseProductName());
System.out.println(“Database version : “+db.getDatabaseProductVersion());
System.out.println(“nDriver Name : “+ db.getDriverName());
System.out.println(“Driver Version : “+ db.getDriverVersion());
con.close();
}//main
}//class