Java Data Structures - Contents
A D V E R T I S E M E N T
One of the most basic data structures, is an array.
An array is just a number of items, of same type, stored in linear order, one after
another. Arrays have a set limit on their size, they can't grow beyond that limit. Arrays
usually tend to be easier to work with and generally more efficient than other structural
approaches to organizing data; way better than a no formal structure approach.
For example, lets say you wanted to have 100
numbers. You can always resort to having 100 different variables, but that would be a
pain. Instead, you can use the clean notation of an array to create, and later manipulate
those 100 numbers. For example, to create an array to hold 100 numbers you would do
something like this:
int[] myArray;
myArray = new int[100];
or
int[] myArray = new int[100];
or
int myArray[] = new int[100];
The three notations above do exactly the same thing.
The first declares an array, and then it creates an array by doing a new. The
second example shows that it can all be one in one line. And the third example shows that
Java holds the backwards compatibility with C++, where the array declaration is: int
myArray[]; instead of int[] myArray;. To us, these notations are
exactly the same. I do however prefer to use the Java one.
Working with arrays is also simple, think of them as
just a line of variables, we can address the 5th element (counting from 0, so, it's
actually the 6th element) by simply doing:
int i = myArray[5];
The code above will set integer 'i' to
the value of the 5th (counting from 0) element of the array. Similarly, we can set an
array value. For example, to set the 50th element (counting from 0), to the value of 'i'
we'd do something like:
myArray[50] = i;
As you can see, arrays are fairly simple. The best
and most convenient way to manipulate arrays is using loops. For example, lets say we
wanted to make an array from 1 to 100, to hold numbers from 1 to 100 respectively, and
later add seven to every element inside that array. This can be done very easily using two
loops. (actually, it can be done in one loop, but I am trying to separate the problem into
two)
int i;
for(i=0;i<100;i++)
myArray[i] = i;
for(i=0;i<100;i++)
myArray[i] = myArray[i] + 7;
In Java, we don't need to remember the size of the
array as in C/C++. Here, we have the length variable in every array, and we can check it's
length whenever we need it. So to print out any array named: myArray, we'd do
something like:
for(int i = 0;i<myArray.length;i++)
System.out.println(myArray[i]);
This will work, given the objects inside the myArray
are printable, (have a corresponding toString() method), or are of primitive
type.
One of the major limitations on arrays is that
they're fixed in size. They can't grow or shrink according to need. If you have an array
of 100 max elements, it will not be able to store 101 elements. Similarly, if you have
less elements, then the unused space is being wasted (doing nothing).
Java API provides data storage classes, which
implement an array for their storage. As an example, take the java.util.Vector
class (JDK 1.2), it can grow, shrink, and do some quite useful things. The way it does it
is by reallocating a new array every time you want to do some of these operations, and
later copying the old array into the new array. It can be quite fast for small sizes, but
when you're talking about several megabyte arrays, and every time you'd like to add one
more number (or object) you might need to reallocate the entire array; that can get quite
slow. Later, we will look at other data structures where we won't be overly concerned with
the amount of the data and how often we need to resize.
Even in simplest situations, arrays are powerful
storage constructs. Sometimes, however, we'd like to have more than just a plain vanilla
array.
Back to Table of Contents
A D V E R T I S E M E N T
|
Subscribe to SourceCodesWorld - Techies Talk |
|
Add to Favorites
Make Home Page
