What is the difference between Array and ArrayList is the quite common question for the Java interview and for the beginners who are learning Java programming. I have started writing the Java best practices series, this is one of the post for clearing the air on misconception about popular Java classes Array and ArrayList.

1. Flexible Storage

One of the major difference between Array and ArrayList is that, Array has the fixed length and it can not be extended once it is initialized. Here is the simple construct for initializing the arrays which I have taken from Java Arrays Example:

[code lang=”java”]
int weight[ ]= new int[5];
weight[0]=36;
weight[1]=42;
weight[2]=24;
weight[3]=10;
weight[4]=50;
[/code]

If you look at the above example, array variable weight is initialized with the length 5, it can not accommodate more than 5 elements.
Whereas ArrayList can dynamically increase the size when new elements are added. Look at the following code:

[code lang=”java”]
ArrayList<String> list = new ArrayList<String>();
[/code]

When you create the above object, the default size of 10 is internally assigned for storing the values. However, when you add the eleventh element, the ArrayList size will be extended to another 10 elements. This impacts the performance of your programming if it has to increase multiple times for accommodating more elements.

2. Generics

Arrays can not use the Generics programming introduced in Java 5. Array knows the type which it can hold, otherwise it will throw the ArrayStoreException when you try to store the wrong data type.

Whereas one of the great advantages of the collections programming is to use the generics for specifying the type of the objects an ArrayList can store. This provides the type-safety for your code at compile time itself.

3. Length / Size

Arrays provide the method length for accessing the size of an array. Even though you have not stored any elements in the array, this method will always returns the capacity of the array.

ArrayList or any other collections APIs that implements List interface defines the method size accessing the size of the object. Note that size method of ArrayList returns only the number of elements currently stored, to know the maximum elements that can be stored in the ArrayList can be accessed using the method capacity.

4. Primitives and Objects

Arrays can be created for either primitives or objects. It can store primitive types as well as objects.

ArrayList can hold only the objects using the add method. Since the Java 5 version, though you store the primitive types to an ArrayList, it silently converts (autoboxing in Java 5) the primitive value to corresponding wrapper class and stores it. All the collection APIs support only storing of the objects and not the primitive values.

5. Iterator

One of the greatest advantage of storing the objects in the collections API is use of iterator for iterating the elements. But, this feature is not available with the Arrays, we have to do the manual iteration using for loop or while loop constructs.

6. Performance

There is no difference in terms of performance between Array and ArrayList classes. They both offer the similar performance for storing and retrieving the objects. If you are storing the thousands of objects in your application, you can measure the performance difference between Array and ArrayList. ArrayList internally uses the Array for storing the objects.

If you are performing the resize() operation or automatic resizing of the ArrayList, the it will impact the performance.

Best Practice

The recommendation is only my opinion and not to be taken as universal best practice for the use of Array vs ArrayList in your projects. I would recommend using the ArrayList every where because it offers the lot of flexibility for storing the objects. If you want thread safety, choose Vector instead of ArrayList.

If you are a Java programmer, then one of the common question comes into mind is How do I compile for compatibility with older versions of Java?. When you run your Java  program with an older version of the Java runtime environment, you may get the following Java exception if you have not compiled with the right version of Java language:

[code]
Exception in thread "main" java.lang.UnsupportedClassVersionError: Bad version number in .class file
[/code]

In one of my previous example, I have explained about how to check the version number of the Java from the class file. In this tutorial I am going to explain the two parameters, target and source which are used for cross compilation and runtime requirements of your Java application.

If you want to ensure the application has to support the minimum runtim environment, then you have to fully understand how to use the source and target parameter for javac.  Java compiler javac have the option to set the target runtime environment supported for your application by using the command line arguments target while compiling the source code.

Javac Source and Target Parameters

Source parameter tells the compiler that the source code will be compiled with the specific version. The official documentation says the source parameter provides source compatibility with specified release. If you are compiling the source code with Java 1.6, but if the code is having some specific features in the Java 7, then compilation fails. In that case you have to set the source parameter as the Java 1.7.

The following are the accepted parameter value for the release:

• 1.3 – The compiler does not support assertions, generics, or other language features introduced after JDK 1.3.
• 1.4 – The compiler accepts code containing assertions, which were introduced in JDK 1.4.
• 1.5 – The compiler accepts code containing generics and other language features introduced in JDK 5.
• 5 – Synonym for 1.5.
• 1.6 – This is the default value if you are compiling with JDK 6. No language changes were introduced in Java SE 6. However, encoding errors in source files are now reported as errors, instead of warnings, as previously.
• 6 – Synonym for 1.6.
• 1.7 – This is the default value. The compiler accepts code with features introduced in Java SE 7.
• 7 – Synonym for 1.7.

Target parameter tells the compiler that what is the minimum targeted JVM that can run the class files. If you pass the target parameter as 1.5, then the class files compatible to run 1.5 and above version of JVM. But, it can not run below 1.5 JVM.

The default for -target depends on the value of -source:

• If -source is not specified, the value of -target is 1.6
• If -source is 1.2, the value of -target is 1.4
• If -source is 1.3, the value of -target is 1.4
• For all other values of -source, the value of -target is the value of -source.

Let’s look at the below example command:

[code]
% javac -source 1.6 -target 1.5
[/code]

The above code conveys the message that, the code base will be compiled with the Java 1.6 version, but the targeted minimum environment support is Java 1.5. In other words, converted class files are compatible to with 1.6 JVM.

Ant – Source and Target

How to use the source and target parameter of javac can be used in the apache ant script?. Let’s look at the below code snippet of ant script:

[code lang=”xml”]
<target name="compile">
<javac source="1.5" target="1.5" srcdir=…/>
</target>
[/code]

Maven – Source and Target

This section provides the sample code snippet for using the source and target parameters of javac in the maven’s pom.xml file.

[code lang=”xml”]
<project>
[…]
<build>
[…]
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
[…]
</build>
[…]
</project>
[/code]

Removing Support for the older versions

There is a JEP 182 which talks about retiring the old version from the support to reduce the cost to maintain multiple versions.

Oracle wants reduce the maintenance costs of javac, so the new JEP 182 defines a policy for retiring old -source and -target options. From JDK 8, use of a source or target of 1.5 or earlier is deprecated and in JDK 9, support for a source or target of 1.5 or earlier will be completely removed.

From JDK 9 and going forward, javac will use a “one + three back” policy of supported source and target options. Under this policy, javac will still be able to recognize and process class files of all previous JDKs, going back to version 45.3 class files generated by JDK 1.0.2, which first shipped in 1996.

One of the basic Java interview question is what is the difference between abstract class and interface. If you are a beginner in Java, you can not avoid this question in any Java interview to test your knowledge on Java OOPs concepts. In this short tutorial I will write down the difference between abstract class and interface in Java. Also there is few simple examples for abstract class and interface.

The below table presents the key differences:

Abstract Class Example

[code lang=”java”]
public abstract class AbstractClass{
public int i = 10;
public void abstract abstractMethod();
public void methodImpl(){
System.out.println("Default Method Implementation");
}
}

class ClassImpl extends AbstractClass{
public void abstractMethod(){
System.out.println("Method Implementation in Sub Class");
}
}
[/code]

Interface Example

[code lang=”java”]
public class InterfaceExample{
public static final i = 10; //public, static, final keywords are optional.
public void abstractMethod(); //This method is implicitly abstract
public void methodImpl(){ // This method is not legal. Method implementation not allowed in interfaces.

}
}
[/code]