Arrays
In this part of the C# programming tutorial, we will cover arrays. We will initiate arrays and read data from them.Arrays are collections of data. A variable can hold only one item at a time. Arrays can hold multiple items. These items are called elements of the array. Arrays store data of the same data type. Each element can be referred to by an index. Arrays are zero based. The index of the first element is zero. Arrays are reference types.
Collections serve the similar purpose. They are are more powerful than arrays. They will be described later.
Arrays are used to store data of our applications. We declare arrays to be of a certain data type. We specify their length. And we initialize arrays with data. We have several methods for working with arrays. We can modify the elements, sort them, copy them or search them.
Initializing arrays
There are several ways, how we can initialize an array in C#.using System;We declare and initialize a numerical array. The contents of the array are printed to the console.
public class CSharpApp
{
static void Main()
{
int[] array = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;
for (int i = 0; i < array.Length; i++)
{
Console.WriteLine(array[i]);
}
}
}
int[] array = new int[5];Here we declare an array which contains five elements. All elements are integers.
array[0] = 1;We initialize the array with some data. This is assignment initialization. The indexes are in the square brackets. Number 3 is going to be the first element of the array, 2 the second.
array[1] = 2;
...
for (int i = 0; i < array.Length; i++)We go through the array and print its elements. An array has a
{
Console.WriteLine(array[i]);
}
Length property, which gives the number of elements in the array. Since arrays are zero based, the indexes are 0..length-1. We can declare and initialize an array in one statement.
using System;This is a modified version of the previous program.
public class CSharpApp
{
static void Main()
{
int[] array = new int[] {2, 4, 5, 6, 7, 3, 2 };
foreach (int i in array)
{
Console.WriteLine(i);
}
}
}
int[] array = new int[] {2, 4, 5, 6, 7, 3, 2 };
An array is declared and initialized in one step. The elements are specified in the curly brackets. We did not specify the length of the array. The compiler will do it for us. foreach (int i in array)We use the
{
Console.WriteLine(i);
}
foreach keyword to traverse the array and print its contents. Array dimensions
So far, we have worked with one dimensional arrays. The number of indexes needed to specify an element is called the dimension, or rank of the array.We will work with two dimensional array.
using System;If we need two indexes to access an element in an array, than we have a two dimensional array.
public class CSharpApp
{
static void Main()
{
int[,] twodim = new int[,] { {1, 2, 3}, {1, 2, 3} };
int d1 = twodim.GetLength(0);
int d2 = twodim.GetLength(1);
for (int i=0; i<d1; i++)
{
for (int j=0; j<d2; j++)
{
Console.WriteLine(twodim[i, j]);
}
}
}
}
int[,] twodim = new int[,] { {1, 2, 3}, {1, 2, 3} };
We declare and initialize a two dimensional array in one statement. Note the comma inside the square brackets. int d1 = twodim.GetLength(0);We get the dimensions of the array. The
int d2 = twodim.GetLength(1);
GetLength() gets the number of elements in the specified dimension of the array. for (int i=0; i<d1; i++)We use two
{
for (int j=0; j<d2; j++)
{
Console.WriteLine(twodim[i, j]);
}
}
for loops to go through all the elements of a two dimensional array. Note that a specific array element is obtained using two indexes, separated by a comma character. $ ./twodim.exeOutput of the code example.
1
2
3
1
2
3
Next we will work with a three dimensional array.
using System;We have a numerical three dimensional array. Again, we initialize the array with numbers and print them to the terminal.
public class CSharpApp
{
static void Main()
{
int[,,] n3 = {
{{12, 2, 8}},
{{14, 5, 2}},
{{3, 26, 9}},
{{4, 11, 2}}
};
int d1 = n3.GetLength(0);
int d2 = n3.GetLength(1);
int d3 = n3.GetLength(2);
for (int i=0; i<d1; i++)
{
for (int j=0; j<d2; j++)
{
for (int k=0; k<d3; k++)
{
Console.Write(n3[i, j, k] + " ");
}
}
}
Console.Write('\n');
}
}
int[,,] n3 = {
{{12, 2, 8}},
{{14, 5, 2}},
{{3, 26, 9}},
{{4, 11, 2}}
};
There is another comma between the square brackets on the left side and additional curly brackets on the right side. for (int k=0; k<d3; k++)This loop goes through the third dimension. We use three indexes to retrieve the value from the array.
{
Console.Write(n3[i, j, k] + " ");
}
$ ./threedim.exeWe print the contents of the three dimensional array to the console.
12 2 8 14 5 2 3 26 9 4 11 2
There is a
Rank property, which gives the number of dimensions of an array. using System;We have three arrays. We use the
public class CSharpApp
{
static void Main()
{
int[] a1 = {1, 2};
int[,] a2 = { { 1 }, { 2 } };
int[,,] a3 = { { { 1, 2 }, { 2, 1 } } };
Console.WriteLine(a1.Rank);
Console.WriteLine(a2.Rank);
Console.WriteLine(a3.Rank);
}
}
Rank property to get the number of dimensions for each of them. Console.WriteLine(a1.Rank);Here we get the rank for the first array.
$ ./rank.exeOutput of the program.
1
2
3
Jagged arrays
Arrays that have elements of the same size are called rectangular arrays. In contrast, arrays which have elements of different size are called jagged arrays. Jagged arrays are declared and initialized differently.using System;This is an example of a jagged array.
public class CSharpApp {
static void Main()
{
int[][] jagged = new int[][]
{
new int[] { 1, 2 },
new int[] { 1, 2, 3 },
new int[] { 1, 2, 3, 4 }
};
foreach (int[] array in jagged) {
foreach (int e in array) {
Console.Write(e + " ");
}
}
Console.Write('\n');
}
}
int[][] jagged = new int[][]This is a declaration and initialization of a jagged array. Note that this time, we use two pairs of square brackets. We have an array of arrays. More specifically, we have declared an array to have three arrays of int data type. Each of the arrays has different number of elements.
{
new int[] { 1, 2 },
new int[] { 1, 2, 3 },
new int[] { 1, 2, 3, 4 }
};
foreach (int[] array in jagged) {
foreach (int e in array) {
Console.Write(e + " ");
}
}
We use two foreach loops to traverse the jagged array. In the first loop, we get the array. In the second loop, we get the elements of the obtained array. Array methods
There are various methods for working with arrays. These methods can be used for retrieving, modifying, sorting, copying, searching data. These methods that we use are static methods of the Array class or member methods of the array objects.using System;In this example, we sort the data.
public class CSharpApp {
static void Main()
{
string[] names = {"Jane", "Frank", "Alice", "Tom" };
Array.Sort(names);
foreach(string el in names)
{
Console.Write(el + " ");
}
Console.Write('\n');
Array.Reverse(names);
foreach(string el in names)
{
Console.Write(el + " ");
}
Console.Write('\n');
}
}
string[] names = {"Jane", "Frank", "Alice", "Tom" };
We have an array of strings. Array.Sort(names);The static
Sort() method sorts the data alphabetically. Array.Reverse(names);The
Reverse() method reverses the sequence of the elements in the entire one-dimensional array. $ ./sorting.exeWe have ordered the names in ascending and descending order.
Alice Frank Jane Tom
Tom Jane Frank Alice
The following example uses
SeValue(), GetValue(), IndexOf(), Copy() and Clear() methods. using System;This example introduces additional methods.
public class CSharpApp {
static void Main()
{
string[] names = {"Jane", "Frank", "Alice", "Tom"};
string[] girls = new string[5];
names.SetValue("Beky", 1);
names.SetValue("Erzebeth", 3);
Console.WriteLine(names.GetValue(1));
Console.WriteLine(names.GetValue(3));
Console.WriteLine(Array.IndexOf(names, "Erzebeth"));
Array.Copy(names, girls, names.Length);
foreach(string girl in girls)
{
Console.Write(girl + " ");
}
Console.Write('\n');
Array.Clear(names, 0, 2);
foreach(string name in names)
{
Console.Write(name + " ");
}
Console.Write('\n');
}
}
names.SetValue("Beky", 1);
names.SetValue("Erzebeth", 3);
The SetValue() sets a value for a specific index in the array. Console.WriteLine(names.GetValue(1));We retrieve the values from the array with the
Console.WriteLine(names.GetValue(3));
GetValue() method. Console.WriteLine(Array.IndexOf(names, "Erzebeth"));The
IndexOf() method returns an index for the first occurrence of a specific value. Array.Copy(names, girls, names.Length);The
Copy() method copies values from the source array to the destination array. The first parameter is the source array, the second is the destination array. The third parameter is the length; it specifies the number of elements to copy. Array.Clear(names, 0, 2);The
Clear() method clears elements from the array. It takes three parameters, the array, the start index and the number of elements from the index to clear. $ ./arraymethods.exeOutput.
Beky
Erzebeth
3
Jane Beky Alice Erzebeth
Alice Erzebeth
In this part of the C# tutorial, we worked with arrays. We described various types of arrays and methods to work with them.
0 comments:
Post a Comment