A: Sometimes Vector is better; sometimes ArrayList is better; sometimes you don’t want to use either. I hope you weren’t looking for an easy answer because the answer depends upon what you are doing. There are four factors to consider:

* API
* Synchronization
* Data growth
* Usage patterns

Let’s explore each in turn.
API

In The Java Programming Language (Addison-Wesley, June 2000) Ken Arnold, James Gosling, and David Holmes describe the Vector as an analog to the ArrayList. So, from an API perspective, the two classes are very similar. However, there are still some major differences between the two classes.
Synchronization

Vectors are synchronized. Any method that touches the Vector’s contents is thread safe. ArrayList, on the other hand, is unsynchronized, making them, therefore, not thread safe. With that difference in mind, using synchronization will incur a performance hit. So if you don’t need a thread-safe collection, use the ArrayList. Why pay the price of synchronization unnecessarily?
Data growth

Internally, both the ArrayList and Vector hold onto their contents using an Array. You need to keep this fact in mind while using either in your programs. When you insert an element into an ArrayList or a Vector, the object will need to expand its internal array if it runs out of room. A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent. Depending on how you use these classes, you could end up taking a large performance hit while adding new elements. It’s always best to set the object’s initial capacity to the largest capacity that your program will need. By carefully setting the capacity, you can avoid paying the penalty needed to resize the internal array later. If you don’t know how much data you’ll have, but you do know the rate at which it grows, Vector does possess a slight advantage since you can set the increment value.
Usage patterns

Both the ArrayList and Vector are good for retrieving elements from a specific position in the container or for adding and removing elements from the end of the container. All of these operations can be performed in constant time — O(1). However, adding and removing elements from any other position proves more expensive — linear to be exact: O(n-i), where n is the number of elements and i is the index of the element added or removed. These operations are more expensive because you have to shift all elements at index i and higher over by one element. So what does this all mean?

It means that if you want to index elements or add and remove elements at the end of the array, use either a Vector or an ArrayList. If you want to do anything else to the contents, go find yourself another container class. For example, the LinkedList can add or remove an element at any position in constant time — O(1).O(i) where i is the index of the element. Traversing an ArrayList is also easier since you can simply use an index instead of having to create an iterator. The LinkedList also creates an internal object for each element inserted. So you have to be aware of the extra garbage being created. However, indexing an element is a bit slower –
Finally, in “PRAXIS 41″ from Practical Java (Addison-Wesley, Feb. 2000) Peter Haggar suggests that you use a plain old array in place of either Vector or ArrayList — especially for performance-critical code. By using an array you can avoid synchronization, extra method calls, and suboptimal resizing. You just pay the cost of extra development time.

We’re told that the future of applications relies on app servers and rich, graphical clients. But will market share or common sense determine which method of building RIAs that developers choose most?

All the major rich Internet applications platforms that are in active use today are leveraged upon some existing, already well-deployed component. Adobe’s AIR relies on the ubiquity of Flash video and the underlying language constructs that have supported Flash in the past, such as Flex. Microsoft’s Silverlight is a vehicle for extending a part of the .NET Framework and Common Language Runtime — and thus with them, a little bit more of Windows — into everyone’s computing environment; and once Microsoft secures that open pipeline, it may be able to push C# and other technologies through it.

Up to now, Google has been the one with the RIA platform that has tried to leverage Java, along with JavaScript (which is related in style but not in architecture, and which is essentially a product of Mozilla). Google Web Toolkit uses Java tools as a staging ground for Asynchronous JavaScript (AJAX) applications. Mozilla has been testing the waters for some time with its own RIA platform experiment called XULRunner; and Curl has had the wherewithal to go it alone, with both a development environment and a runtime that rely on no single pre-existing platform. (Some dispute whether AJAX truly qualifies as RIA, but I tend to say that if an application can run outside the browser with full graphical resplendence, as though it had been installed on the user’s computer directly, then it’s an RIA.)

To this mix of players, enter Sun Microsystems. Its JavaFX platform formally exited beta on Monday, and its objective is to further extend the Java 6 runtime platform onto more systems. Rich graphical applications built with JavaFX, like other Java apps since the 1990s, can run outside of the Web browser though maintain their links to servers through HTTP.

But JavaFX Script — the programming language for this new platform — is not Java, and it’s not JavaScript. While it’s not exactly a foreign language, especially for Web developers who find themselves learning new ones practically every month, it is — like Flex for Adobe — its own beast.

Java Programming Resources from Sun

General Java Resorces

• Sun’s main Java homepage.

• Sun’s Java FAQ’s. Collection of Frequently Asked Questions on various Java-related topics.

• Sun’s top-level Java documentation page.

• Index of Sun’s Java-related products and API’s.

• The JavaOne Conferences.

• Java application success stories.

• The Java Community Process. How to be involved in the Java specification development.

• Sun’s Java training courses (US). (If Sun’s courses seem a bit steep, or you want something on-site, or prefer an instructor with more hands-on Java development experience, also see these courses.)

• Java Certification. Although it is highly controversial if certification actually proves anything about your Java skills, in many cases certification is useful in getting a new or better job.

Specific Java Products & Technologies

• J2SE

• J2EE

• J2ME

• Java Servlets. (Also see this servlet programming resources page.)

• JavaServer Pages (JSP). (Also see this JSP programming resources page.)

• JavaServer Faces (JSF) (Also see this JSF tutorial.)

• Java and XML

• Java Foundation Classes (Swing).

• JDBC.

• JavaBeans.

• JavaHelp.

• JavaMail.

• Enterprise JavaBeans.

• Java IDL.

• Java Media and Advanced Imaging.

• Java 3D.

• Jini and JavaSpaces.

Section 1:
************

Section 7:
***********
Fundamentals
Given a code example and a scenario, write code that uses the appropriate access modifiers, package declarations, and import statements to interact with (through access or inheritance) the code in the example.
Given an example of a class and a command-line, determine the expected runtime behavior.
Determine the effect upon object references and primitive values when they are passed into methods that perform assignments or other modifying operations on the parameters.
Given a code example, recognize the point at which an object becomes eligible for garbage collection, determine what is and is not guaranteed by the garbage collection system, and recognize the behaviors of the Object.finalize() method.
Given the fully-qualified name of a class that is deployed inside and/or outside a JAR file, construct the appropriate directory structure for that class. Given a code example and a classpath, determine whether the classpath will allow the code to compile successfully.
Write code that correctly applies the appropriate operators including assignment operators (limited to: =, +=, -=), arithmetic operators (limited to: +, -, *, /, %, ++, –), relational operators (limited to: < , <=, >, >=, ==, !=), the instanceof operator, logical operators (limited to: &, |, ^, !, &&, ||), and the conditional operator ( ? : ), to produce a desired result. Write code that determines the equality of two objects or two primitives

Chapter 1: Overview: The Mental Landscape

Chapter 2: Programming in the Small I: Names and Things

Chapter 3: Programming in the Small II: Control

Chapter 4: Programming in the Large I: Subroutines

Chapter 5: Programming in the Large II: Objects and Classes

Chapter 6: Applets, HTML, and GUI’s

Chapter 7: Advanced GUI Programming

Chapter 8: Arrays

Chapter 9: Correctness and Robustness

Chapter 10: Advanced Input/Output

Chapter 11: Linked Data Structures and Recursion

- Java’s Official Site

- Java’s Official Forum

- J2SE SDK Download

- J2EE SDK Download

- Open JDK

- Netbeans Download

DaniWeb IT Discussion Community

Check version of JCC Driver

$ java com.ibm.db2.jcc.DB2Jcc -version

Simple nonsense solution to use JCC Tracing

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;

String ts = “”;
while (rs.next()) {
ts = rs.getString(1);
System.out.println(“Timestamp: ” + ts);
}
rs.close();
stmt.close();
}
}

The trick here is to add connection properties in the connection string and this is what probably most of your search results will show.

String url = “jdbc:db2://localhost:50000/SAMPLE:traceFile=c:/jdbc4.log;TraceLevel=TRACE_ALL;”;

Simple no-nonsense solution to use Tracing using property file

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.util.Properties;

rs.close();
stmt.close();
}
}

If you look at above program, you notice that there is no trace information in the connection URL. But, the trace information is kept in a property file that JDBC driver uses at the runtime.

db2.jcc.override.traceFile=C:/temp/jdbc.trace
db2.jcc.override.traceFileAppend=true
db2.jcc.override.TraceLevel=TRACE_ALL
db2.jcc.override.currentSchema=VIKRAM

The name of the property file is DB2JccConfiguration.properties and it should be on your class path or in a JAR which should also be on your classpath.

Alternatively, you can specify the name of your file by supplying a switch to JVM at the runtime as shown below:

-Ddb2.jcc.propertiesFile=C:/Test/DB2JccConfiguration.properties

This approach is elegant as you are not touching the code to set the trace and you control it through a property file that you can change anytime.

JCC Tracing in multi-threaded applications

If you use traceFile option in DB2JccConfiguration.properties file, you will collect trace information for all threads in a single file if you are running a multi-threaded application. In that case, you should use traceDirectory property so that JCC driver creates a separate file for each thread.

db2.jcc.override.traceDirectory=C:/temp/jdbc/
db2.jcc.override.traceFile=trace.log
db2.jcc.override.traceFileAppend=true
db2.jcc.override.TraceLevel=TRACE_ALL

Suppose your java program creates two connections in 2 separate threads. When the program completes, the following files contain the trace data:

C:/temp/jdbc/trace.log_global_0
C:/temp/jdbc/trace.log_global_1

Some very important properties least understood

I also use few properties in this simple program and some of them are very useful and important.

For example:

• deferPrepares This property is true by default and that may lead to some problems occasionally. The prepare is deferred until execution time to save few network hops to describe the query from the database rather than to use java specific mappings. This parameter is true for performance but if there is a problem in correct mapping between java data types and DB2, JCC driver will recover from those errors automatically at execution time and you will see lots of SQL errors in your trace file which should not have been there. To avoid those errors, set this param to false and again see the trace.

  If you want to check very quickly how deferPrepares works, set this value to true in above code and make a mistake in your SQL statement. For example, you can set the SQL as “VALUES CURRENT TIMESTAMP2″. This SQL will fail at runtime.

  If deferPrepares=true, you will see the exception at line where you have ResultSet rs = stmt.executeQuery(); but if you set this to false, you will see exception at line where you have java.sql.PreparedStatement stmt = con.prepareStatement(sql);

  This should explain the importance of deferPrepares. The value of true gives a better performance but it can bog you down if there are differences in data type matching between java and DB2 and some problems related to dates or numbers or decimals.

• clientWorkstation You set this value to identify client workstation and this is an ideal property to set to the IP address from your web response if you are writing a web application. This will allow db2 audit to catch IP addresses of the web client. A very unknown feature not used by Java application developers.
• jdbcCollection This is another very powerful property that affects the execution of your SQL statements if you are using parameter markers in your application. Please read this article for details on this property at this link
• driverType This is the type of driver you choose to use. There used to be a separate JDBC driver for Type-2 connections but that has been deprecated and both the drivers are merged in a single db2jcc.jar file. If you set driverType=2, you are using Type-2 driver of DB2 which is using CLI calls under the cover to the database. Which one should you use?

  If you set driverType=4, you really do not need a DB2 client on your machine to connect to DB2 but you will need a DB2 client of you set driverType=2. If you are connecting remotely to db2, you will get a better performance by using Type-4 driver and if you are connecting locally to DB2, you will get a better performance by using Type-2 driver.

• retrieveMessagesFromServerOnGetMessage This is another property that gives a formatted SQLException output.

  Did you notice that we specified default schema in the external property file and that is very useful if you want to change default schema at run time rather than to hard code in URL of the connection string.

  Did you, by any chance, notice the use of @Sql in above java code and an import of com.ibm.pdq.annotation.Sql. This is a way to check the syntax of SQL at design time if your SQL is right or not and allows you to use context sensitive help by pressing ctrl-space. If this sounds exciting, download free Data Studio from this link.

• One may ask if there is a way to specify all those properties in a single file and not have to hard code these ones in the code.

  conProperties.put(“user”, “pdqpot”);
  conProperties.put(“password”, “pdqpot123″);
  conProperties.put(“portNumber”, “50000″);
  conProperties.put(“deferPrepares”, “false”);
  conProperties.put(“retrieveMessagesFromServerOnGetMessage”, “true”);
  conProperties.put(“emulateParameterMetaDataForZCalls”, “1″);
  conProperties.put(“clientApplicationInformation”, “T4Driver”);
  conProperties.put(“clientWorkstation”, “192.168.10.125″);
  conProperties.put(“defaultIsolationLevel”, java.sql.Connection.TRANSACTION_READ_COMMITTED);
  conProperties.put(“jdbcCollection”, “NULLIDR1″);
  conProperties.put(“driverType”, “4″);
  

  In the property file DB2JccConfiguration.properties, you can only specify few properties that JCC driver will actually use. So, if you specify deferPrepares in this file, JCC driver is not going to use it. But, you can do one thing – Take all of the above properties and put them in same property file and load it at run time in your program. This way, JCC driver will also use same property file and your program is also using same property file. Some may like it and some may not. Choice is yours.

JCC Tracing made really simple with connection properties

What if, you want all properties put in a single file and also control JCC tracing at run time. The following code example actually does that and all of your settings are in one file but you control JCC tracing through one -D switch specified through command line.

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.util.Enumeration;
import java.util.Properties;

rs.close();
stmt.close();
}
}

Some of the points to remember:

• All properties are placed in a single file including tracing and connection related.
• This property file can be placed in current directory assuming that the current directory is not on classpath
• If you do not specify this property file through -D switch, no tracing will happen.
• The Java program actually reads this file and uses as a connection property.
• If you specify this file as command line argument -Ddb2.jcc.propertiesFile=C:/Test/DB2JccConfiguration.properties, you will start tracing.
• If you have this file in a JAR file or in classpath, you do not need to specify it using -D switch. However, you will have to delete JCC tracing parameters from this file to stop tracing.
• Use any of the method that suits your best needs.
• DB2JccConfiguration.properties file having JCC tracing and connection properties
  

  #### JCC Driver reads these properties automatically
  db2.jcc.override.traceFile=C:/temp/jdbc.trace
  db2.jcc.override.traceFileAppend=true
  db2.jcc.override.TraceLevel=TRACE_ALL
  db2.jcc.override.currentSchema=VIKRAM

  #### Extra connection properties used at the time of opening connections.
  #### Java program reads this propety file

  user=pdqpot
  password=pdqpot123
  portNumber=50000
  deferPrepares=false
  retrieveMessagesFromServerOnGetMessage=true
  emulateParameterMetaDataForZCalls=1
  clientApplicationInformation=T4Driver
  clientWorkstation=192.168.10.125
  defaultIsolationLevel=2
  jdbcCollection=NULLIDR1
  driverType=4

Whenever my colleagues and I discuss our career plans and the job market, someone always asks me whether to learn programming language X, or operating system Y, or framework Z. But I like to point out that time spent learning some new skill is also time not spent honing the skills you already have. And in my opinion, it is both more lucrative and more enjoyable to be a master of one craft, than to be mediocre at several of them.

This is because I’ve noticed that those who are the best in their chosen fields are always fully employed and highly compensated. Especially during an economic downturn, employers become more selective about who they hire. So when they go looking for a candidate with a particular set of skills, they want to choose the person who is strongest with those skills — not the person who has the most different skills. And employers are usually willing to pay a premium for top-notch talent, if they can find it.

I’ve been on the hiring side of the interview table enough times to know this. When a job candidate shows me they have mastered one technology, it also demonstrates to me that they have the potential to master others. But having partial expertise in many technologies may only prove that they own a lot of O’Reilly books. Truly mastering any technology requires a great deal of patience and dedication, and those traits are far more valuable to the team than being able to write code in 16 different languages.

Having said all that, I do acknowledge there is a real tradeoff between the depth and breadth of one’s technical skills. Not all job candidates are created equal, and it just isn’t possible for everyone to be the “best” in something. I’m sure there is a sweet spot where you can optimize your employability, and this doesn’t mean that you should completely ignore other technologies. The industry is constantly evolving so you must stay up-to-date, and learning a little bit about other technologies can give you a fantastic new perspective on the those you already know well. And of course, this all assumes that you actually enjoy the technologies you’re working with. If you don’t enjoy them, then by all means, go learn some new skills.

But if you do enjoy the technologies you work with, then I urge you to consider mastering those technologies before going off to learn some new bag-of-tricks. To be sure, the road to mastery is long and difficult. It is fraught with frustration and can be boring at times. But it is also challenging, exciting, and deeply rewarding. In the end, I believe it will lead you to a much happier and more prosperous career.

I’d rather be the first-pick candidate for just one position than the second-pick for several.

Jeff Thalhammer has been specializing in Perl software development for over 10 years. He is the senior engineer and chief janitor at Imaginative Software Systems, a small software consultancy based in San Francisco. Jeff is also the creator of Perl-Critic, the leading static analysis tool for Perl.