Am mai vorbit despre array-uri înainte, într-un întreg capitol. Array-urile sunt colecții cu număr fix de elemente de anumit tip (șiruri, numere întregi, etc.) în care elementele își păstrează ordinea inițială. Fiecare element poate fi accesat prin indexul său numeric, care începe la 0.
Array-urile sunt zone de memorie care au o dimensiune predefinită. De aceea, adăugarea unui element nou într-un array este o operație lentă (iar prin asta, mă refer la adăugarea unui nou element atunci când toate pozițiile array-ului sunt umplute, deci, când trebuie de fapt să mărim dimensiunea array-ului). Pentru această operație trebuie mai întâi să alocăm o memorie de aceeași dimensiune plus unu, și să copiem toate datele din array-ul original în cel nou.
Căutarea într-o matrice necesită timp deoarece trebuie să comparăm fiecare element cu valoarea căutată. Este nevoie de N/2 comparații, în medie.
Eliminarea unui element dintr-un array este, de asemenea, o operație lentă. Ca și mai sus, trebuie să alocăm o memorie de aceeași mărime minus unu și să copiem toate elementele vechi, cu excepția celui eliminat.
Accesarea elementelor prin index este directă și, prin urmare, o operație rapidă.
Array-urile ar trebui utilizate numai atunci când trebuie să procesăm un număr fix de elemente, pentru care avem nevoie de un acces rapid prin index. De exemplu, dacă trebuie să sortăm niște numere, putem să le păstrăm într-un array și apoi să aplicăm unii dintre algoritmii de sortare. Dacă trebuie să modificăm numărul elementelor, array-ul nu este structura corectă de date pe care ar trebui să o folosim. Utilizați array-uri atunci când trebuie să procesați un număr fix de elemente la care aveți nevoie de acces prin index.
Un array este definit astfel:|
1
|
[tip obiect][] arrayulMeu = new [tip obiect][numar de elemente]
|
Exemplu:
|
1
2
|
int[] arrayulMeu = new int[5];
int[] arrayulMeu2 = new { 0, 1, 2, 3, 4 };
|
Array-urile au o mulțime de metode, dintre care următoarele sunt cele mai utile:
Array.AsReadOnly() - face posibilă restricționarea accesului la array din codul clientului, astfel încât elementele arra-ului pot fi folosite ca și o colecție doar-citire (read-only). Exemplu:|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
using
System;
using
System.Collections.ObjectModel;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[] array = { 1, 5, 3 };
ReadOnlyCollection<int> rezultat = Array.AsReadOnly(array);
Console.WriteLine("Count: " + rezultat.Count);
for (int i = 0; i < rezultat.Count; i++)
{
// Nu putem modifica nimic
Console.WriteLine(rezultat[i]);
}
Console.ReadLine();
}
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Array sursa care este sortat ascendent
string[] array = { "a", "e", "m", "n", "x", "z" };
// Apeleaza diferite versiuni ale metodei BinarySearch
int index1 = Array.BinarySearch(array, "m");
int index2 = Array.BinarySearch<string>(array, "x");
int index2 = Array.BinarySearch<string>(array, "E", StringComparer.OrdinalIgnoreCase);
// Afiseaza rezultatele
Console.WriteLine(index1);
Console.WriteLine(index2);
Console.WriteLine(index3);
Console.ReadLine();
}
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
string[] arrayNumereIntregi = { 4, 6, 8, 1, 3 };
// Afiseaza array-ul
Console.WriteLine("--- Array de numere inainte de Clear ---");
foreach (int valoare in arrayNumereIntregi);
Console.WriteLine(valoare);
// Sterge toate elementele din array
Array.Clear(arrayNumereIntregi, 0, arrayNumereIntregi.Length);
// Afiseaza array-ul
Console.WriteLine("--- Array de numere intregi dupa Clear ---");
foreach (int valoare in arrayNumereIntregi);
Console.WriteLine(valoare);
Console.ReadLine();
}
}
}
|
Array.ConvertAll() - vă permite să convertiți declarativ un array întreg, într-o singură instrucțiune. Convertește toate elementele dintr-un array într-un alt tip. Implică anumite pierderi de performanță, dar poate simplifica înțelegerea codului, în special în programele în care au loc multe conversii diferite. Folosește expresii lambda, despre care nu am scris încă. Folosirea sa este descurajată în favoarea proiecțiilor LINQ. Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Array de numere intregi cu trei valori
int[] array1 = new int[3];
array1[0] = 4;
array1[1] = 5;
array1[2] = 6;
// Folosește ConvertAll pentru a converti array-ul de numere intregi intr-un array de string-uri
string[] array2 = Array.ConvertAll(array1, element => element.ToString());
// Afiseaza array-ul de string-uri
Console.WriteLine(string.Join(",", array2));
Console.ReadLine();
}
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Instantiaza array-ul sursa
int[] sursa = new int[5];
sursa[0] = 1;
sursa[1] = 2;
sursa[2] = 3;
sursa[3] = 4;
sursa[4] = 5;
// Instantiaza si alocheaza array-ul destinatie
int[] destinatie = new int[5];
// Copiaza din sursa in destinatie
Array.Copy(sursa, destinatie, 5);
// Afiseaza array-ul destinatie
Console.WriteLine("--- Array Destinatie ---");
foreach (int valoare in destinatie);
Console.WriteLine(valoare);
Console.ReadLine();
}
}
}
|
Array.Exists() - oferă o modalitate la îndemână de a testa un element care corespunde unei anumite condiții predicat. Aceasta implică unele dezavantaje generale și de performanță. Folosește expresii lambda, discutate într-o lecție viitoare. Folosirea sa este descurajată în favoarea metodei LINQ Any(). Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
string[] array = { "pisica", "caine", "perle" };
// Foloseste Array.Exists in diferite moduri
bool a = Array.Exists(array, element => element == "perle");
bool b = Array.Exists(array, element => element == "piton");
bool c = Array.Exists(array, element => element.StartsWith("d"));
bool d = Array.Exists(array, element => element.StartsWith("x"));
// Afiseaza rezultatele boolene
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
Console.WriteLine(d);
Console.ReadLine();
}
}
}
|
Array.Find() - caută într-un array (cu sintaxă declarativă). Specificăm o instanță de tip predicat pentru a determina ce logică utilizează căutarea. Folosește expresii lambda, discutate într-o lecție viitoare. Folosirea sa este descurajată în favoarea metodei LINQ Where(). Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Declara si initializeaza un array de tip string
string[] array1 = { "pisica", "caine", "morcov", "pasare" };
// Gaseste primul element care incepe cu subsirul specificat
string valoare1 = Array.Find(array1, element => element.StartsWith("pisica", StringComparison.Ordinal));
// Gaseste primul element cu o lungime de trei caractere
string[] valoare2 = Array.Find(array1, element => element.Length == 3);
// Gaseste toate elementele nu mai lungi de 4 caractere
string[] array2 = Array.FindAll(array1, element => element.Length <= 4);
Console.WriteLine(valoare1);
Console.WriteLine(valoare2);
string[] array3 = { "mie", "tie", "voua" };
// Gaseste ultimul element cu lungime 3
string rezultat = Array.FindLast(array3, element => element.Length == 3);
Console.WriteLine(rezultat);
// Declara un alt array
int[] array4 = { 5, 6, 7, 8 };
// Foloseste metoda FindIndex cu predicat
int[] index1 = Array.FindIndex(array4, element => element == 6);
// Foloseste metoda LastFindIndex cu predicat
int[] index2 = Array.FindLastIndex(array4, element => element == 6);
// Afiseaza rezultatele
Console.WriteLine("{0} = {1}", index1, index4[index1]);
Console.WriteLine("{0} = {1}", index2, index4[index2]);
Console.ReadLine();
}
}
}
|
Array.ForEach() - ciclează peste fiecare element dintr-un array și apelează o metodă pe fiecare din elemente. Este o formă de sintaxă declarativă, și nu este necesară utilizarea unei bucle. Folosește expresii lambda, discutate într-o lecție viitoare. Folosirea sa este descurajată în favoarea metodei LINQ ForEach(). Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[] elemente = { 10, 100, 1000 };
// Afiseaza elementele cu ForEach
Array.ForEach(elemente, element => Console.WriteLine("Elementul este " + element));
Console.ReadLine();
}
}
}
|
Array.IndexOf() - caută indexul numeric al unui element într-un array. Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Declara un array de tip string
string[] array = new string[6];
array[0] = null;
array[1] = "morcov";
array[2] = "sobolan";
array[3] = "";
array[4] = "morcov";
array[5] = "mar";
// Gaseste un string cu aceasta valoare, incepand de la indexul 2
int index1 = Array.IndexOf(array, "morcov", 2, 3);
// Gaseste un string inexistent
int index2 = Array.IndexOf(array, "banana");
// Afiseaza rezultatul
Console.WriteLine(index1);
Console.WriteLine(index2);
Console.ReadLine();
}
}
}
|
Array.LastIndexOf() - găsește ultimul index numeric al unui element dintr-un array, care se potrivește termenului căutat. Caută de la sfârșitul array-ului. Exemple:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
string[] array = { 2, 4, 6, 8, 6, 2 };
int rezultat1 = Array.IndexOf(array, 6);
Console.WriteLine(rezultat1);
int rezultat2 = Array.LastIndexOf(array, 6);
Console.WriteLine(rezultat2);
int rezultat3 = Array.LastIndexOf(array, 100);
Console.WriteLine(rezultat3);
Console.ReadLine();
}
}
}
|
Array.Resize() - alocă un nou array și copiază apoi valorile elementelor existente în noul array. Această logică este necesară atunci când mărimea array-ului este inadecvată. Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Initializeaza array
char[] array = new char[4];
array[0] = 't';
array[1] = 'e';
array[2] = 's';
array[3] = 't';
// Afiseaza array-ul
for (int i = 0; i < array.Length; i++);
Console.WriteLine(array[i]);
Console.WriteLine();
// Redimensioneaza array-ul de la 4 la 2 elemente
Array.Resize(ref array, 2);
// Afiseaza array-ul care a fost redimensionat
for (int i = 0; i < array.Length; i++);
Console.WriteLine(array[i]);
Console.WriteLine();
Console.ReadLine();
}
}
}
|
Array.Reverse() - inversează ordonarea elementelor într-un array. Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Declara si initializeaza un array
int[] array = { 1, 2, 3 };
// Afiseaza array-ul
foreach (int valoare in array)
Console.WriteLine(valoare);
Console.WriteLine();
// Inverseaza elementele array-ului
Array.Reverse(array);
// Afiseaza array-ul
foreach (int valoare in array)
Console.WriteLine(valoare);
Console.WriteLine();
// Inverseaza elementele din nou
Array.Reverse(array);
// Afiseaza elementele array-ului
foreach (int valoare in array)
Console.WriteLine(valoare);
Console.ReadLine();
}
}
}
|
Array.Sort() - ordonează elemente dintr-un array. Funcționează cu diferite tipuri de elemente, inclusiv șiruri de caractere și numere întregi. Folosirea sa este descurajată în favoarea metodelor LINQ OrderBy() și OrderByDescending(). Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Declara un array
int[] valori = { 4, 7, 2, 0 };
Array.Reverse(valori);
// Print
foreach (int valoare in valori)
Console.WriteLine(valoare);
Console.ReadLine();
}
}
}
|
Array.TrueForAll() - oferă o modalitate declarativă de a testa fiecare element din array după o anumită condiție, utilizând un predicat. Folosirea sa este descurajată în favoarea metodei LINQ All(). Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[] valori1 = { 1, 3, 5, 7 };
bool rezultat1 = Array.TrueForAll(valori1, element => element % 2 == 1);
Console.WriteLine(rezultat1);
int[] valori2 = { 2, 5, 8 };
bool rezultat2 = Array.TrueForAll(valori2, element => element % 2 == 1);
Console.WriteLine(rezultat2);
Console.ReadLine();
}
}
}
|
Cea mai importantă proprietate a array-urilor este:
Length - un array are o lungime – aceasta este mărimea sa (numărul de elemente). Returnează un int cu valoarea 0 sau mai mare; nu se efectuează nici o iterație (se utilizează o memorie cache). Exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
// Exemplu lungime array simplu
int[] arrayA = new int[5];
int lungimeA = arrayA.Length;
Console.WriteLine(lungimeA); // Afiseaza 5
// Exemplu lungime long
long lungimeLong = arrayA.lungimeLong;
Console.WriteLine(lungimeLong); // Afiseaza 5
// Exemplu array cu lungime 0
int[] zero = new int[0];
int lungimeZero = zero.Length;
Console.WriteLine(lungimeZero); // Afiseaza 0
// Exceptie lungime array nul
// int[] exceptie = null;
// Console.WriteLine(exceptie.Length);
// Exemplu GetLength 0
int lungimeE = arrayA.GetLength(0);
Console.WriteLine(lungimeE); // Afiseaza 5
// Exemplu exceptie GetLength 1
// int lungimeF = arrayA.GetLength(1);
// Console.WriteLine(lungimeF);
// Exemplu GetLength bidimensional
int[,] doi = new int[5, 10];
Console.WriteLine(doi.GetLength(0)); // Afiseaza 5
Console.WriteLine(doi.GetLength(1)); // Afiseaza 10
// Exemplu Length bi-dimensional
Console.WriteLine(doi.Length); // Afiseaza 50
Console.ReadLine();
}
}
}
|