Java Programming Forum - Learn Java Programming - Blogs - Java Array

Sorting Arrays

Java Array — Sun, 04 Mar 2012 09:26:42 GMT

To sort arrays, static methods are provided by the class java.util.Arrays. Kinds of arrays that are supported by it are as following:

i. Arrays of object types
ii. Arrays of primitive types

It is possible to apply the sorting method to range of arrays or some particular part. It is also applicable to the whole array.

For object type array comparators shall be provided so that to define it to such kind of sorting. Few Array methods are explained here along with their description:

Arrays.sort(pa): Primitive type array�s elements are sorted to ascending order. This is usually done by the help of natural ordering.
Arrays.sort(pa, from, to): Object type array elements are sorted to an ascending order. This is done by that order usage which is defined usually by the help of comparable interface. Ultimately the method thecompareTo is defined by it. It shall be noted that number of Java classes like BigInteger, String or Double etc would be implementing Comparable.
Arrays.sort(oa, from, to): Array elements are sorted to an ascending order in range (from-to) of object type.
Arrays.sort(oa, comp): Object type array�s elements are sorted to an ascending order. This is done by the help of Comparator comp.
Arrays.sort(oa, from, to, comp): Array elements are sorted in ascending order, in range (from..to) of object type. This is also done by the help of Comparator comp.

Multidimensional arrays

Java Array — Sun, 04 Mar 2012 09:24:58 GMT

Array of arrays also consists of multi dimensional arrays. Multi-dimensional variables could be declared by specifying the every extra index. This is done by using square bracket set.
Java Code:
For example: 
int myArray[ ][ ] = new int[5][6] ;
In case of a multi-dimensional array, memory is allocated by specifying memory for leftmost (1st) dimension.

Rest of the dimensions can be allocated separately.

In multi-dimensional array, every array�s length is in one�s control.

Multi-dimensional array�s declarations will be better explained by the given example:
Java Code:
int myArray[][] = new int[4][];
myArray [0] = new int[5];
myArray [1] = new int[6];
myArray [2] = new int[7];
myArray [3] = new int[8];

Two-Dimensional Arrays

Java Array — Sun, 04 Mar 2012 09:23:25 GMT

2 dimensional arrays are known to be the array of arrays. Number of array types is present, for example:

Array of Strings
Array of ints
Array of Objects

Array of int consists of type int[]. Two dimensional array will have int[][]. It might also be known as array of arrays of the ints. Such type of arrays are known as 2D arrays.

Command:
int[][] array = new int[5][6];
Array or variable of type int[][] gets declared. Variable is initialized so that to refer it for a new object created.
Int [5][6], it has been indicated that five arrays of ints are present, in �array�. Six ints are present in every array present.
2D arrays are processed by the nested loops. �Nested� loops are the loops which are present in any loop. Array�s processing is explained by the given code.
Java Code:
int[][] a2 = new int[10][5];
 // print array in rectangular form
 for (int i=0; i
	

arrays are passed by reference

Java Array — Sun, 04 Mar 2012 09:20:44 GMT

By reference, array is passed to functions. Or it is passed to original as a pointer. This shows that anything which happens to an array in a function would be affecting the original.

For understanding an array is passed by reference

Step 1) In editor, code shall be copied
Java Code:
class ArrayDemo {
  
   public static void passByReference(String a[]);
     a[1] = "Changed";
   }
  
   public static void main(String args[]){
      String []b={"Apple","Mango","Orange"};
      System.out.println("Before Function Call    "+b[0]);
      ArrayDemo.passByReference(b);
      System.out.println("After Function Call    "+b[0]);
   }
}
Step 2) Save, Compile & run the code. Observe output.

Array Store Exception

Java Array — Sun, 04 Mar 2012 09:18:47 GMT

If array variable v consists of type A[] (where A is a reference type) then v might hold a reference to any array type B[] instance.( provided that B could be assigned to A).

Example:
Java Code:
class Point { int x, y; }
class ColoredPoint extends Point { int color; }
class Test {
	public static void main(String[] args) {
		ColoredPoint[] cpa = new ColoredPoint[10];
		Point[] pa = cpa;
		System.out.println(pa[1] == null);
		try {
			pa[0] = new Point();
		} catch (ArrayStoreException e) {
			System.out.println(e);
		}
	}
}
produces the output:
true
java.lang.ArrayStoreException

Variable pa has type Point[].Variable cpa has its value a reference, to an object of type ColoredPoint[]. To a point, a ColoredPoint could be assigned; hence to pa, the value of cpa can be assigned.

Class Objects for Arrays

Java Array — Sun, 04 Mar 2012 09:17:12 GMT

An associated class object is present for every array that is shared to other arrays along with similar component type.An array�s direct superclass is Object. Interfaces java.io.Serializable and Cloneable are implemented by every array type.

Following example code could better explain this:
Java Code:
class Test {
	public static void main(String[] args) {
		int[] ia = new int[3];
		System.out.println(ia.getClass());
		System.out.println(ia.getClass().getSuperclass());
	}
}
which prints:
class [I
class java.lang.Object
here the string "[I" is the �run-time type� signature, for the class object that is "array with component type int".

Array Initializers

Java Array — Sun, 04 Mar 2012 09:14:46 GMT

In a declaration, an array initialize might be specified. It also might be specified as an array creation expression part, that gives certain initial values and creates an array.

ArrayInitializer:
{ VariableInitializersopt ,opt }

VariableInitializers:
VariableInitializer
VariableInitializers , VariableInitializer

To make it further clear:

VariableInitializer:
Expression
ArrayInitializer

For writing array initialize, list of expressions are separated by commas and enclosed by "{" and "}".
The constructed array length would be equal to the no. of expressions.

An array initializer�s expressions get executed starting from left towards right, in textual order which occurs in source code. Value of n-1st array component is specified by the nth variable initializer. With component type of an array, every expression shall be assignment compatible. In case component type is array type itself then array initializers might be nested. After array initializer�s last expression, a trailing comma might come which is ignored.
Java Code:
For example: 
class Test {
	public static void main(String[] args) {
		int ia[][] = { {1, 2}, null };
		for (int i = 0; i < 2; i++)
			for (int j = 0; j < 2; j++)
				System.out.println(ia[i][j]);
	}
}
prints:
1
2

Array Variables

Java Array — Sun, 04 Mar 2012 09:12:33 GMT

Reference to object is being held by the array type variable. Declaration of a variable of array type doesn�t allocate space for the array components or create the array object. But, declarator�s initializer part may make an array and a reference which will become variable�s initial value.

Array length is not considered as a part of its type therefore an array type�s single variable might possess reference to other array of varying length.

Given below are few examples regarding those declarations (of array variables) which don�t create array:
Java Code:
int[] ai;		// array of int
short[][] as;		// array of array of short
Object[]    ao,		// array of Object
otherAo;	// array of Object
short	s,		// scalar short 
aas[][];	// array of array of short
Here you can see few examples of declarations (of array variables) which are involved in creating the array objects:
Java Code:
Exception ae[] = new Exception[3]; 
Object aao[][] = new Exception[2][3];
int[] factorial = { 1, 1, 2, 6, 24, 120, 720, 5040 };
char ac[] = { 'n', 'o', 't', ' ', 'a', ' ', 'S', 't', 'r', 'i', 'n', 'g' }; 
String[] aas = { "array", "of", "String", };
The [] might seem for a particular variable to be a part of declaration or type in beginning of declaration, or both as it is given in this example
Java Code:
byte[] rowvector, colvector, matrix[];
This declaration is equivalent to:
Java Code:
byte rowvector[], colvector[], matrix[][];
Length of an array object never gets changed once it has been created

Array Types

Java Array — Sun, 04 Mar 2012 09:10:21 GMT

To write an array type use element type name with few empty square bracket pairs[]. Depth of array nesting is indicated by the no. of bracket pairs. Length of array is not its type part.

An array�s element type might be any type whether reference or primitive. Particularly,

Arrays along with an interface type, as the component type are allowed. Such array�s elements might use null reference as their value or any type instances which implements interface.
Arrays with an abstract class type, as the component type are allowed. Such array�s elements might use null reference as their value or any subclass�s instance, of some abstract class which is not abstract itself.

Array types are used in cast expressions and declarations.

Copying Arrays

Java Array — Sun, 04 Mar 2012 09:08:37 GMT

An arraycopy method is used by the system class which can efficiently be used to copy one array�s data to other:
Java Code:
public static void arraycopy(Object src,
                       int srcPos,
                       Object dest,
                       int destPos,
                       int length)
The array to copyfrom or the array to copyto is specified by the two object arguments. Three int arguments are used for the specification of the number of array elements to copy, starting position in the destination array and the starting position in the source array.

Given program named as ArrayCopyDemo is used to make the declaration of the array of char elements by spelling �decaffeinated�. For copying array component subsequence to another array, arraycopy is used.
Java Code:
class ArrayCopyDemo {
    public static void main(String[] args) {
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
			    'i', 'n', 'a', 't', 'e', 'd' };
        char[] copyTo = new char[7];

        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        System.out.println(new String(copyTo));
    }
}
This program�s output is:

caffein

Creating, Initializing, and Accessing an Array

Java Array — Sun, 04 Mar 2012 09:05:46 GMT

One can create an array by the help of the new operator. In ArrayDemo program, next statement allocates the array along with quite enough memory. This is done for 10 integer elements so that to assign array to anArray variable.
Java Code:
// create an array of integers
anArray = new int[10];
In case if the given statement is missing, an error like this would be printed by compiler and also the compilation would fail.

To array�s each element, values will be assigned by the next few lines:
Java Code:
// initialize first element
anArray[0] = 100;
// initialize second element
anArray[1] = 200;
// etc.
anArray[2] = 300;
Numerical index is used to access each element:
Java Code:
System.out.println("Element 1 at index 0: "
                   + anArray[0]);
System.out.println("Element 2 at index 1: "
                   + anArray[1]);
System.out.println("Element 3 at index 2: "
                   + anArray[2]);
To initialize and create an array, shortcut syntax may be used:
Java Code:
int[] anArray = { 
    100, 200, 300,
    400, 500, 600, 
    700, 800, 900, 1000
};

Declaring a Variable to Refer to an Array

Java Array — Sun, 04 Mar 2012 09:02:43 GMT

Array is declared in the above program along with this line of code.
Java Code:
// declares an array of integers
int[] anArray;
Array declaration also consists of 2 components, just like other declarations for other types of variables. They are

Array�s name
Array�s type

Array�s type is written as type[].

An array�s name could be anything that you may want provided it follows the conventions. Just like other type variables, array is not actually created by the declaration- this shows that variables would be holding specified type array.

In same way, the other types array could be declared.
Java Code:
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

Java Array

Java Array — Sun, 04 Mar 2012 09:00:33 GMT

Array is that container object which consists of fixed value numbers of one single type. When array is created, establishment of the length of an array takes place. Length is fixed after creation of an array. In Hello world application�s main method, example of array has already been given. Here detailed array section will be given.

An array of ten elements

Every item present in array is known as an element. Numerical index is used to access each element. Numbering starts with zero, as it has been given in above illustration. At index 8, the 9th element would be accessed.