Creating
Arrays
An
array is a single data variable that can store multiple pieces of data that are
each of the same data type.
To
declare an array, you use the square brackets after the data type when you
declare the
variable.
The basic format of an array declaration is as shown here:
datatype[] name;
datatype
is the type for the information you will store. The square brackets indicate
that you are declaring an array, and the name is the name of the array
variable. The following definition sets up an array variable called num that
can hold integer values:
int[] num;
This
declaration creates the variable and prepares it to be capable of holding
integer values;
however,
it doesn’t actually set aside the area to hold the variables. To do that, you
need to do the same thing you do to create other objects, which is to
initialize the variable using the new keyword. When you instantiate the array,
you must indicate how many values will be stored. One way to indicate this
number is to include the number of elements in square brackets when you do the
initialization:
num = new int[10];
You
also can do this initialization at the same time that you define the variable:
int[] num = new
int[10];
As
you can see, the format for initializing is as follows:
new
datatype[nbr_of_elements]
datatype
is the same data type of the array, and nbr_of_elements is a numeric value that
indicates the number of items to be stored in the array. In the case of the num
variable, you can see that 10 integers values can be stored.
Simple
program to implement an array-
using System;
class Program
{
public static void Main()
{
int[]
num = new int[10];
Console.WriteLine("Enter the integer numbers");
for
(int i = 0; i < 10; i++)
{
num[i] = int.Parse(Console.ReadLine());
}
Console.WriteLine("Numbers you have entered are");
for
(int i = 0; i < 10; i++)
{
Console.WriteLine(num[i]);
}
}
}
Initializing
Array Elements
You
can initialize the values of the individual array elements at the same time
that you declare and initialize the array. You can do this by declaring the
values after the array declaration. The values are enclosed in a block and are
separated by a comma.
char[] name = new
char[6] { 'A', 'd', 'i', 't', 'y', 'a' };
It is interesting to note that if you initialize the values
in this manner, you do not have to include the array size in the brackets. The
following statement is equivalent to the previousstatement:
char[] name = new
char[] { 'A',
'd', 'i', 't', 'y', 'a' };
or
char[] name = { 'A', 'd', 'i', 't', 'y', 'a' };
The compiler automatically defines this array
as 6 elements because that is the number of items being initialized. The
following program creates and initializes a character array.
using System;
class Program
{
public static void Main()
{
char[] name = new char[] {'A','d','i','t','y','a', (char) 0 };
Console.WriteLine("Display content of name array...");
int
i = 0;
while (name[i]
!= 0)
{
Console.Write("{0}", name[i]);
i++;
}
Console.WriteLine("\nDone.....");
}
}
Working
with Multidimensional Arrays
A multidimensional array is an array of arrays. You can even have an array
of arrays of arrays. The number of levels can quickly add up. This starts
getting complicated, so I recommend that you don’t store more than three levels
(or three dimensions) of arrays.
An array of arrays is often referred to as a two-dimensional array because
it can be represented
in two dimensions. To declare a two-dimensional array, you expand on what
you do with a regular (or one-dimensional) array:
byte[,] scores = new byte[15,30];
A comma is added to the first part of the declaration, and two numbers
separated by a command are used in the second part. This declaration creates a
two-dimensional array that has 15 elements, each containing an array of 30
elements. In total, the scores array holds 450 values of the data type byte. To
declare a simple multidimensional array that stores a few characters, you enter
the following:
char[,] letters = new char[2,3]; // without initializing values
This declaration
creates a two-dimensional array called letters, which contains two elements
that are each arrays that have three character elements. You can initialize the
elements within the letters array at declaration time:
char[,] letters
= new char[,] { {‘a’,’b’,’c’},{‘X’,’Y’,’Z’} };
Or, you can
initialize each element individually. To access the elements of a
multidimensional array, you again use the indexes. The first element of the
letters array is letters[0,0]. Remember, the indexes start at offset 0, not 1.
letters[0,1] is the second element, which contains the letter ‘b’. The letter
‘X’ is letter[1,0] because it is in the second array (offset 1) and is the
first element (offset 0). To initialize the letters array outside the
declaration, you could do the following:
letters[0,0] =
‘a’;
letters[0,1] = ‘b’;
letters[0,2] =
‘c’;
letters[1,0] =
‘X’;
letters[1,1] =
‘Y’;
letters[1,2] =
‘Z’;
Creating an
Array Containing Different-Size Arrays
In the previous
section, an assumption was made that in a two-dimensional array, all the subarrays
are the same size. This would make the arrays rectangular. What happens if you
want to store arrays that are not the same size? Consider the following:
char[][] myname
= new char[3][];
myname[0] = new
char[] { ‘A’, ‘d’, ‘i’, ‘t’, ‘y’, ‘a’,};
myname[1] = new
char[] { ‘K’, ‘.’ };
myname[2] = new
char[] { ‘T’, ‘y’, ‘a’, ‘g’, ‘i’ };
The myname array
is an array of arrays. It contains three character arrays that are each a different
length. Because they are different lengths, you work with their elements
differently from the rectangular arrays that you saw before.
Instead
of addressing each element by using index values separated by commas, you instead
separate the elements into their own square brackets. For example, the
following line of code uses the WriteLine method to print the array elements
that would be my initials:
System.Console.WriteLine(“{0}{1}{2}”,
myname[0][0], myname[1][0], myname[2][0]);
It would be
wrong to address these as myname[0,0], myname[1,0], and myname[2,0]. In fact,
you’ll get an
error if you try to access the elements this way.
What happens if
you want to declare the myname array without initializing it, as was done previously?
You know there are three parts to the name, so the first dimension is 3;
however,
what should the
second dimension be? Because of the variable sizes, you must make multiple
instantiations to set up the full array. First, you declare the outside array that
will hold the arrays:
char[][] myname
= new char[3][];
This declares
the myname variable as an array with three elements, each holding a character
array. After
you’ve done this declaration, you must initialize each of the individual arrays
that will be stored in myname[].
myname[0] = new
char[6]; // first array of six elements
myname[1] = new
char[2]; // second array of two elements
myname[2] = new
char[5]; // third array of five elements
Using a Jagged Two-Dimensional
Array:
using System;
public class Names
{
public static void Main()
{
char[][] name
= new char[3][];
name[0] = new char[6] {'A', 'd', 'i', 't', 'y', 'a'};
name[1] = new char[2] {'K', '.'};
name[2] = new char[5] {'T', 'y', 'a', 'g', 'i'};
Console.WriteLine("Display the sizes of the arrays...\n");
Console.WriteLine("Length of name array {0}", name.Length);
for( int ctr = 0; ctr < name.Length; ctr++)
Console.WriteLine("Length of name[{0}] is {1}",ctr,
name[ctr].Length);
//---------------------------------------------------------------------
Console.WriteLine("\nDisplaying the content of the name array...");
for( int ctr = 0; ctr < name.Length; ctr++)
{
Console.Write("\n"); // new
line
for( int ctr2 = 0; ctr2 < name[ctr].Length; ctr2++ )
{
Console.Write("{0}", name[ctr][ctr2]);
}
}
Console.WriteLine("\n...Done displaying");
}
}
A
multidimensional array that contains subarrays of the same size is referred to
as rectangular. A
multidimensional array that has variable-size subarrays stored is referred to
as “jagged.”
The System.Array
Class
In
C# every array we create is automatically derived from the System.Array class.
This class defines a number of methods and properties that can be used to
manipulate arrays more efficiently. The following table lists some of the
commonly used methods and their purpose.
Method/Property
|
Description
|
Clear()
CopyTo()
GetLength()
GetValue()
Length
SetValue()
Reverse()
Sort()
|
Sets a Range of Elements to empty
values
Copies elements from the source array
into the destination array
Gives the number of elements in a
given dimension of the array
Gets the value for a given index in
the array
Gives the length of an array
Sets the value for a given index in
the array
Reverse the contents of one
dimensional array
Sorts the elements in one dimensional
array
|
Using
GetLength()
int[] num = new
int[] { 1, 2, 3, 4, 5, 6, 7 };
int
dim= num.GetLength(0);//GetLength(int dimension)
Console.WriteLine(dim);//output
will be 7
int[,] num1 = new
int[2, 3];
Console.WriteLine(
num1.GetLength(0));//output will be 2
Console.WriteLine(
num1.GetLength(1));//output will be 3
Using
GetValue()
int[] num = new
int[] { 1, 2, 3, 4, 5, 6, 7 };
int val = (int)num.GetValue(3);//GetValue(int index)
Console.WriteLine(val);//output will be 4
Using
SetValue()
int[] num = new
int[] { 1, 2, 3, 4, 5, 6, 7 };
num.SetValue(12, 4);//SetValue(object value,int index)
Console.WriteLine(num[4]);//output
will be 12
Using
Sort()
int[] num = new int[]
{ 4, 2, 6, 3, 5, 1, 9 };
Array.Sort(num);
for (int
i = 0; i < num.Length; i++)
{
Console.Write(num[i]);
}
Output will be 1234569
Using
Reverse()
int[] num = new
int[] { 1, 2, 3, 4, 5, 6, 7 };
Array.Reverse(num);
for (int
i = 0; i < num.Length; i++)
{
Console.Write(num[i]);
}
Output will be 7654321
Using
Clear()
int[] num = new int[] { 1, 2, 3,
4, 5, 6, 7 };
Array.Clear(num, 0, 3);//Clear(Array
array,Int index,int length)
for (int i = 0; i < num.Length; i++)
{
Console.Write(num[i]);
}
Output will be 0004567
