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ă. 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[] arrayulMeu = { 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 matrice din codul clientului. Exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
using System; using System.Collections.ObjectModel; class Program { static void Main() { int[] array = { 1, 5, 3 }; ReadOnlyCollection<int> rezultat = Array.AsReadOnly(array); Console.WriteLine("Numar: " + rezultat.Count); for (int i = 0; i < rezultat.Count; i++) { // Nu putem modifica nimic Console.WriteLine(rezultat[i]); } } } |
Array.BinarySearch() – Această metodă identifică rapid și precis locația unui element în matrice. I se poate spune cum să compare elementele. Funcționează corect numai pe o matrice presortată. Exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
using System; class Program { static void Main() { // 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 index3 = Array.BinarySearch<string>(array, "E", StringComparer.OrdinalIgnoreCase); // Afiseaza rezultatele Console.WriteLine(index1); Console.WriteLine(index2); Console.WriteLine(index3); } } |
Array.Clear() – elimină toate elementele dintr-un array. Aceasta oferă o modalitate unică, fiabilă și ușor de înțeles de a goli sau șterge array-ul. Funcționează cu array-uri de orice tip, inclusiv numere, booleani, structuri și instanțe de clasă. 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; class Program { static void Main() { int[] arrayNumereIntregi = new int[] { 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); } } } |
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 codul, în special în programele în care au loc multe conversii diferite. Exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
using System; class Program { static void Main() { // 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)); } } |
Array.Copy() – copiază elementele dintr-un array în altul. Are unele complexități. Această operațiune poate duce la anumite excepții. Tipul de elemente – atât în array-ul țintă, cât și în cel sursă – este important. Aceasta este o metodă statică. 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 |
using System; class Program { static void Main() { // 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); } } } |
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ță. Dar poate fi util pentru anumite programe. Exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
using System; class Program { static void Main() { string[] array = { "pisica", "perle", "caine" }; // 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); } } |
Array.Find() – Această metodă caută într-un array (cu sintaxă declarativă). Specificăm o instanță de tip predicat pentru a determina ce logică utilizează căutarea. 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 |
using System; class Program { static void Main() { // Declara si initializeaza un array de tip string. string[] array1 = { "pisica", "morcov", "caine", "pasare" }; // Gaseste primul element care incepe cu subsirul specificat. string valoare1 = Array.Find(valoare1, element => element.StartsWith("masina", 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, s => s.Length == 3); Console.WriteLine(rezultat); // Declara un alt array. int[] array4 = { 5, 6, 7, 6 }; // Foloseste metoda FindIndex cu predicat. int index1 = Array.FindIndex(array4, item => item == 6); // Foloseste metoda LastFindIndex cu predicat. int index2 = Array.FindLastIndex(array4, item => item == 6); // Afiseaza rezultatele Console.WriteLine("{0} = {1}", index1, array4[index1]); Console.WriteLine("{0} = {1}", index2, array4[index2]); } } |
Array.ForEach() – ciclează peste fiecare element dintr-un array. Apelează o metodă pe fiecare element dintr-un array. Este o formă de sintaxă declarativă. Simplifică anumite tipare de cod. Nu este necesară utilizarea unei bucle. Exemple:
|
1 2 3 4 5 6 7 8 9 10 11 |
using System; class Program { static void Main() { int[] itemi = { 10, 100, 1000 }; // Afiseaza elementele cu ForEach. Array.ForEach(itemi, element => Console.WriteLine("Elementul este " + element)); } } |
Array.IndexOf() – caută într-un array. Acționează pe orice tip de array. Localizează indexul valorii specificate. Metoda IndexOf, atât în forma sa generică, cât și în forma LastIndexOf, este utilă în multe contexte ale programului. 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; class Program { static void Main() { // Declara un array de tip string. string[] array = new string[6]; array[0] = null; array[1] = "morcov"; array[2] = "soarece"; 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); } } |
Array.LastIndexOf() – găsește ultimul element dintr-un array, care se potrivește termenului căutat. Caută de la sfârșitul array-ului. Aceasta returnează indexul elementului care conține valoarea specificată. Are limitări – poate avea o valoare limitată. Exemple:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
using System; class Program { static void Main() { int[] 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); } } |
Array.Resize() alocă un nou array. Se copiază apoi valorile elementelor existente în noul array. Această logică este necesară atunci când mărimea array-ului este inadecvată. Itaă modul în care Resize realocă și copiază elementele:
|
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; class Program { static void Main() { // Initializeaza array. char[] array = new char[4]; array[0] = 'p'; array[1] = 'e'; array[2] = 'r'; array[3] = 'l'; // afiseaza array for (int i = 0; i < array.Length; i++) Console.Write(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.Write(array[i]); Console.WriteLine(); } } |
Array.Reverse() – inversează ordonarea elementelor într-un array. Această sarcină ar putea fi realizată cu o buclă. Dar metoda Array.Reverse() este mai convenabilă – și, de asemenea, mai ușor de citit. 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 |
using System; class Program { static void Main() { // 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); } } |
Array.Sort() – Această metodă ordonează elemente dintr-un array. Funcționează cu diferite tipuri de elemente, inclusiv șiruri de caractere și numere întregi. Exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
using System; class Program { static void Main() { // Apel simplu de sortare. int[] valori = { 4, 7, 2, 0 }; Array.Sort(valori); foreach (int valoare in valori) { Console.Write(valoare); Console.Write(' '); } Console.WriteLine(); } } |
Array.TrueForAll() – o metodă de array statică. Vă oferă o modalitate declarativă de a testa fiecare element din array-ul vostru, după o anumită condiție, utilizând un predicat. Scanează array-ul și returnează adevărat sau fals. Exemplu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
using System; class Program { static void Main() { int[] valori1 = { 1, 3, 5, 7 }; bool rezultat1 = Array.TrueForAll(valori1, y => y % 2 == 1); Console.WriteLine(rezultat1); int[] valori2 = { 2, 5, 8 }; bool rezultat2 = Array.TrueForAll(valori2, y => y % 2 == 1); Console.WriteLine(rezultat2); } } |
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 număr întreg cu valoarea 0 sau mai mult; 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 |
using System; class Program { static void Main() { // Exemplu lungime array simplu. int[] arrayA = new int[5]; int lungimeA = arrayA.Length; Console.WriteLine(lungimeA); // afiseaza 5 // Exemplu lungime long. long lungimeLong = arrayA.LongLength; 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 } } |
Tags: accesarea elementelor unui array, array-uri multidimensionale, arrays, iterarea elementelor unui array, structuri de date
