An array is
a collection of variables of the same type. For instance, an array of int is
a collection of variables of the type int. The variables in the array are
ordered and each have an index. You will see how to index into an array later
in this text. Here is an illustration of Java arrays:
Declaring an Array
Variable in Java
A Java array variable
is declared just like you would declare a variable of the desired type, except
you add[] after the type. Here is a simple Java array declaration example:
int[] intArray;
You can use a Java
array as a field, static field, a local variable, or parameter, just like any
other variable. An array is simply a variation of the data type. Instead of
being a single variable of that type, it is a collection of variables of that
type.
Here are a few more
Java array declaration examples:
String[] stringArray;
MyClass[] myClassArray;
The first line declares
an array of String references. The second line declares an array of
references to objects of the class MyClass, which symbolizes a class you
have created yourself.
You actually have a
choice about where to place the square brackets [] when you declare an array in
Java. The first location you have already seen. That is behind the name of the
data type (e.g. String[]). The second location is after the variable name.
The following Java array declarations are actually all valid:
int[] intArray;
int intArray[];
String[] stringArray;
String stringArray[];
MyClass[] myClassArray;
MyClass myClassArray[];
Personally I prefer to
locate the square brackets [] after the data type (e.g. String[]) and not
after the variable name. After all, an array is a special kind of data type, so
I feel it is easier to read the code when the square brackets are placed right
after the data type in the array declaration.
Instantiating
an Array in Java
When you declare a Java
array variable you only declare the variable (reference) to the array itself.
The declaration does not actually create an array. You create an array like
this:
int[] intArray;
intArray = new int[10];
This example creates an
array of type int with space for 10 int variables inside.
Once an array has been
created its size cannot be changed. In some languages arrays can change their
size after creation, but in Java an array cannot change its size once it is
created. If you need an array-like data structure that can change its size, you
should use a List.
The previous Java array
example created an array of int which is a primitive data type. You
can also create an array of object references. For instance:
String[] stringArray =
new String[10];
Java allows you to
create an array of references to any type of object (to instances of any
class).
The Java programming
language contains a shortcut for instantiating arrays of primitive types and
strings. If you already know what values to insert into the array, you can use
an array literal. Here is how how an array literal looks in Java code:
int[] ints2 = new int[]{ 1,2,3,4,5,6,7,8,9,10 };
Notice how the values
to be inserted into the array are listed inside the { ... } block.
The length of this list also determines the length of the created array.
Actually, you don't
have to write the new int[] part in the latest versions of Java. You
can just write:
int[] ints2 = { 1,2,3,4,5,6,7,8,9,10 };
It is the part inside
the curly brackets that is called an array literal.
This style works for
arrays of all primitive types, as well as arrays of strings. Here is a string
array example:
String[] strings = {"one",
"two", "three"};
Accessing Java Array
Elements
Each variable in an
Java array is also called an "element". Thus, the example shown
earlier created an array with space for 10 elements, and each element is a
variable of type int.
Each element in the
array has an index (a number). You can access each element in the array via its
index. Here is an example:
intArray[0] = 0;
int firstInt =
intArray[0];
This example first sets
the value of the element (int) with index 0, and second it reads the value of
the element with index 0 into an int variable.
You can use the
elements in a Java array just like if they were ordinary variables. You can
read their value, assign values to them, use the elements in calculations and
pass specific elements as parameters to method calls.
The indexes of elements
in a Java array always start with 0 and continue to the number 1 below the size
of the array. Thus, in the example above with an array with 10 elements the
indexes go from 0 to 9.
You can access the
length of an array via its length field. Here is an example:
int[] intArray = new
int[10];
int arrayLength = intArray.length;
In this example the
variable named arrayLength will contain the value 10 after the second
line of code has been executed.
You can loop through
all the elements of an array using the.java for loop Here is an example of
iterating an array with a for loop in Java:
String[] stringArray =
new String[10];
for(int i=0; i <
stringArray.length; i++) {
stringArray[i] = "String no " +
i;
}
for(int i=0; i <
stringArray.length; i++) {
System.out.println( stringArray[i] );
}
This example first
creates an array of String references. When you first create an array
of object references, each of the cells in the array points to null -
no object.
The first of the two for loops
iterate through the String array, creates a String and
makes the cell reference that String.
The second of the two for loops
iterate through the String array and prints out all of the strings
that the cells reference.
If this had been an
array of int (primitive values), it could have looked like this:
int[] intArray = new
int[10];
for(int i=0; i <
intArray.length; i++) {
intArray[i] = i;
}
for(int i=0; i <
intArray.length; i++) {
System.out.println( intArray[i] );
}
The variable i is
initialized to 0 and runs up until the length of the array minus 1. In this
case, i takes the values 0 through 9, each time repeating the code
inside the for loop one time, and for each iteration i has
a different value.
You can also iterate an
array using the "for-each" loop in Java. Here is how that looks:
int[] intArray = new
int[10];
for(int theInt :
intArray) {
System.out.println(theInt);
}
The for-each loop gives
you access to each element in the array, one at a time, but gives you no
information about the index of each element. Additionally, you only have access
to the value. You cannot change the value of the element at that position. If
you need that, use a normal for-loop as shown earlier.
For for-each loop also
works with arrays of objects. Here is an example showing you how to iterate an
array of String objects:
String[] stringArray =
{"one", "two", "three"};
for(String theString :
stringArray) {
System.out.println(theString);
}
Multidimensional Java
Arrays
The examples shown
above all created arrays with a single dimension, meaning elements with indexes
going from 0 and up. It is, however, possible to create arrays where each
element has two or more indexes which identify (locate) it in the array.
You create a
multidimensional array in Java by appending one set of square brackets ([]) per
dimension you want to add. Here is an example that creates a two-dimensional
array:
int[][] intArray = new
int[10][20];
This example creates a
two-dimensional array of int elements. The array contains 10 elements
in the first dimension, and 20 elements in the second dimension. In other
words, this examples creates an array of arrays of int elements. The
array of arrays has space for 10 int arrays, and each int array
has space for 20 int elements.
You access the elements
in a multidimensional array with one index per dimension. In the example above
you would have to use two indexes. Here is an example:
int[][] intArray = new
int[10][20];
intArray[0][2] = 129;
int oneInt = intArray[0][2];
The variable named oneInt will
contain the value 129 after the last line of Java code has executed.
Iterating
Multidimensional Arrays
When you iterate a
multidimensional array in Java you need to iterate each dimension of the array
separately. Here is is how iterating a multidimensional looks in Java:
int[][] intArray = new
int[10][20];
for(int i=0; i <
intArrays.length; i++){
for(int j=0; j < intArrays[i].length;
j++){
System.out.println("i: " + i
+ ", j: " + j);
}
}
Inserting Elements Into
an Array
Sometimes you need to
insert elements into a Java array somewhere. Here is how you insert a new value
into an array in Java:
int[] ints = new int[20];
int insertIndex = 10;
int newValue = 123;
//move elements below insertion
point.
for(int
i=ints.length-1; i > insertIndex; i--){
ints[i] = ints[i-1];
}
//insert new value
ints[insertIndex] =
newValue;
System.out.println(Arrays.toString(ints));
The example first
creates an array. Then it defines an insert index and a new value to insert.
Then all elements from the insertion index and to the end of the array are
shifted one index down in the array. Note that this will shift the last value
in the array out of the array (it will simply be deleted).
The above array insertion
code could be embedded in a Java method. Here is how that could look:
public void
insertIntoArray(
int[] array, int insertIndex, int
newValue){
//move elements below insertion point.
for(int i=array.length-1; i >
insertIndex; i--){
array[i] = array[i-1];
}
//insert new value
array[insertIndex] = newValue;
}
This method takes an int[] array
as parameter as well as the index to insert the new value, and the new value.
You can insert elements into an array by calling this method like this:
int[] ints = new int[20];
insertIntoArray(ints,
0, 10);
insertIntoArray(ints,
1, 23);
insertIntoArray(ints,
9, 67);
Of course, if the insertIntoArray() method
is located in a different class than the above code, you would need an object
of that class in order to be able to call the method. Or, if the insertIntoArray() method
was static, you would need to put the class name and a dot in front of the
method name.
Removing Elements From
an Array
Sometimes you have want
to remove an element from a Java array. Here is the code for removing an
element from an array in Java:
int[] ints = new int[20];
ints[10] = 123;
int removeIndex = 10;
for(int i =
removeIndex; i < ints.length -1; i++){
ints[i] = ints[i + 1];
}
This example first
creates an int array. Then it sets the value of the element with
index 10 to 123. Then the example removes the element with index 10. It removes
the element by shifting all elements below index 10 one position up in the
array. After the removal, the last element in the array will exist twice. Both
in the last and second last element.
The above code could be
embedded in a Java method. Here is how such an array removal Java method could
look:
public void removeFromArray(
int[] array, int removeIndex){
for(int i = removeIndex; i <
array.length -1; i++){
array[i] = array[i + 1];
}
}
This removeFromArray() method
takes two parameters: The array to remove the element from, and the index of
the element to remove.
Of course, if the removeFromArray() method
is located in a different class than the above code, you would need an object
of that class in order to be able to call the method. Or, if the removeFromArray() method
was static, you would need to put the class name and a dot in front of the
method name.
Finding Min and Max
Value in Arrays
Sometimes you may need
to find the minimum or maximum value in a Java array. Java does not have any
built-in functions for finding minimum and maximum value, so I will show you
how to code that yourself.
Here is first how you
find the minimum value in an array:
int[] ints =
{0,2,4,6,8,10};
int minVal =
Integer.MAX_VALUE;
for(int i=0; i <
ints.length; i++){
if(ints[i] < minVal){
minVal = ints[i];
}
}
System.out.println("minVal
= " + minVal);
The example first sets
the minVal to Integer.MAX_VALUE which is the highest
possible value an int can take. This is done to make sure that the
initial value is not by accident smaller than the smallest value in the array.
Second, the example
iterates through the array and compares each value to minValue. If the
element in the array is smaller than minVal then minVal is
set to the value of the element.
Finally the minimum
value found in the array is printed out. In the example above the minimum value
is 0.
Here is how you find
the maximum value in an array. It is pretty similar to finding the minimum
value.
int[] ints =
{0,2,4,6,8,10};
int maxVal =
Integer.MIN_VALUE;
for(int i=0; i <
ints.length; i++){
if(ints[i] > maxVal){
maxVal = ints[i];
}
}
System.out.println("maxVal
= " + maxVal);
This example will print
out the value 10.
The major differences
to finding the minimum value is the initialization of maxVal and the
comparison ofmaxVal to the elements in the array.
Java contains a special
utility class that makes it easier for you to perform many often used array
operations like copying and sorting arrays, filling in data, searching in
arrays etc. The utility class is calledArrays and is located in the
standard Java package java.util. Thus, the fully qualified name of the
class is:
java.util.Arrays
I will cover a few of
the methods found in this class in the following sections. Remember, in order
to usejava.util.Arrays in your Java classes you must import it. Here is
how importing java.util.Arrays could look in a Java class of your
own:
package myjavaapp;
import
java.util.Arrays;
public class MyClass{
public static void main(String[] args) {
}
}
Notice the import
java.util.Arrays; statement in bold. It is this statement that imports the
classjava.util.Arrays into your Java class.
You can copy an array
into another array in Java in several ways.
Copying an Array
by Iterating the Array
The first way to copy
an array in Java is to iterate through the array and copy each value of the
source array into the destination array. Here is how copying an array looks
using that method:
int[] source = new
int[10];
int[] dest = new int[10];
for(int i=0; i <
source.length; i++) {
source[i] = i;
}
for(int i=0; i <
source.length; i++) {
dest[i] = source[i];
}
First two int arrays
are created. Second, the source array is initialized with values from 0 to 9 (0
to the length of the array minus 1). Third, each element in the source array is
copied into the destination array.
Copying an Array Using
Arrays.copyOf()
The second method to
copy a Java array is to use the Arrays.copyOf() method. Here is how
copying an array using Arrays.copyOf() looks:
int[] source = new
int[10];
for(int i=0; i <
source.length; i++) {
source[i] = i;
}
int[] dest =
Arrays.copyOf(source, source.length);
The Arrays.copyOf() method
takes 2 parameters. The first parameter is the array to copy. The second
parameter is the length of the new array. This parameter can be used to specify
how many elements from the source array to copy.
Copying an Array
Using Arrays.copyOfRange()
The third method to
copy a Java array is to use the Arrays.copyOfRange() method. TheArrays.copyOfRange() method
copies a range of an array, not necessarily the full array. Here is how copying
a full array using Arrays.copyOfRange() in Java looks:
int[] source = new
int[10];
for(int i=0; i <
source.length; i++) {
source[i] = i;
}
int[] dest =
Arrays.copyOfRange(source, 0, source.length);
The Arrays.copyOfRange() method
takes 3 parameters. The first parameter is the array to copy. The second
parameter is the first index in the source array to include in the copy. The
third parameter is the last index in the source array to include in the copy
(excluded - so passing 10 will copy until and including index 9).
Converting
Arrays to Strings With Arrays.toString()
You can convert an Java
array of primitive types to a String using the Arrays.toString() method.
Here is an example of how to convert an array of int to a String using Arrays.toString():
int[] ints = new int[10];
for(int i=0; i <
ints.length; i++){
ints[i] = 10 - i;
}
System.out.println(java.util.Arrays.toString(ints));
The first line creates
an array of int with 10 elements. The for loop initializes
the array with the values from 10 to 1. The last line prints out the value
returned from Arrays.toString(). The returned String(which is
printed) looks like this:
[10, 9, 8, 7, 6, 5, 4,
3, 2, 1]
You can sort the
elements of an array using the Arrays.sort() method. Sorting the
elements of an array rearranges the order of the elements according to their
sort order. Here is an Arrays.sort() example:
int[] ints = new int[10];
for(int i=0; i <
ints.length; i++){
ints[i] = 10 - i;
}
System.out.println(java.util.Arrays.toString(ints));
java.util.Arrays.sort(ints);
System.out.println(java.util.Arrays.toString(ints));
The first line declares
and instantiates an array of int with a length of 10;
The for loop
iterates over the array and inserts values into each element. The values
inserted will go from 10 to 1 in descending order.
After the for loop
the array is converted to a String using Arrays.toString() and
printed out to the console (command line). At this point the output written to
the console (the String version of the array) looks like this:
[10, 9, 8, 7, 6, 5, 4,
3, 2, 1]
The array is then
sorted using Arrays.sort(). The elements will now be ordered in ascending
order.
After sorting the
array, it is again converted into a String and printed to the
console. The output printed this time looks like this:
[1, 2, 3, 4, 5, 6, 7,
8, 9, 10]
Sorting
Arrays of Objects
The Arrays.sort() example
shown earlier only works for Java arrays of primitive data types. Java's
primitive data types have a natural ordering, either their numeric order, or
the order of the characters in the ASCII table (the binary number representing
the character).
If you want to sort an
array of objects you need to use a different method. Objects may not have any
natural sort order, so you need to provide another object which is capable of
determining the order of your objects. Such an object is called a Comparator.
Hello, my name is Jack Sparrow. I'm a 50 year old self-employed Pirate from the Caribbean. 