OLD [G_PRO] Programmeren en OO programmeren
experimental-merge3
experimental-merge3
  • Welkom
  • Inleiding
    • Benodigdheden
    • Afspraken code
    • Afspraken oefeningen
    • Nuttige extras
    • Dankwoord
    • Mee helpen?
  • Semester 1: Programming Principles
    • H0: Werken met Visual Studio
      • Introductie tot C#
      • Werken met Visual Studio
      • Je eerste programma
      • Input verwerken met ReadLine
      • Fouten in je code
      • Kleuren in Console
      • Oefeningen
    • H1: Variabelen en datatypes
      • De essentie van C#
      • Datatypes
      • Variabelen
      • Expressies en operators
      • Oefeningen
    • H2: Tekst in code
      • Strings en chars
      • Strings samenvoegen
      • Unicode tonen
      • Oefeningen
      • Uitbreidingsoefeningen
    • H3: Werken met data
      • Casting, conversie en parsing
      • Input verwerken en omzetten
      • Math-library en berekeningen
      • Random
      • Debuggen
      • Oefeningen
    • H4: Beslissingen
      • Beslissingen intro
      • Booleanse logica en operators
      • If
      • Scope van variabelen
      • enum
      • Switch
      • Oefeningen
    • H5: Loops
      • Loops intro
      • While en Do While
      • For
      • Nesting
      • Programma flow analyse
      • Oefeningen deel 1
      • Oefeningen deel 2
      • Oefeningen deel 3
    • H6: Methoden
      • Methoden intro
      • Bibliotheken
      • Geavanceerde methoden
      • Oefeningen
      • Uitbreidingsoefeningen
    • H7: Arrays
      • Array principes
      • Werken met arrays
      • Arrays en methoden
      • N-dimensionale arrays
      • Oefeningen deel 1
      • Oefeningen deel 2
  • Semester 2 : OOP
    • H8: Klassen en objecten
      • OOP Intro
      • Klassen en objecten in C#
      • Methoden en access modifiers
      • Properties
      • DateTime: leren werken met objecten
      • (Klassikale!) smaakmaker OOP
      • Oefeningen
    • H9: Geheugenmanagement bij klassen
      • Objecten en methoden
      • Stack en Heap
      • Null en NullReferenceException
      • Oefeningen
    • H10: Advanced klassen en objecten
      • Constructors
      • Static
      • Spelen met strings
      • Oefeningen
    • H11: Arrays en klassen
      • Arrays van objecten
      • Foreach en var
      • List
      • Oefeningen
    • H12: Overerving
      • Overerving intro
      • Base keyword
      • Constructors bij overerving
      • Virtual en override
      • Oefeningen
    • H13: Advanced overerving
      • System.Object
      • Abstract
      • Oefeningen
    • H14: Compositie
      • Compositie
      • Oefeningen
    • H15: Polymorfisme
      • Polymorfisme
      • Is en As keywords
      • Objecten vergekijken: alles komt samen
      • Oefeningen
    • H16: Interfaces
      • Interface intro
      • Interfaces in de praktijk
      • Polymorfisme en interfaces
      • Oefeningen
  • Appendix
    • Ea-ict coding guidelines
    • Oefeningen kerkhof
  • Semester 1 appendix
    • Nice to know stuff
      • Out en Ref parameters
      • Jagged arrays
    • All-In-Projecten
      • Overzicht
      • Console Matrix
      • Ascii filmpjes maken met loops
      • Ascii filmpjes maken met methoden
      • Fun with methods: een verhaalgenerator
      • Tekst-gebaseerd Maze game
      • Conway game of life
  • Semester 2 appendix
    • Nice to know stuff
      • Operator overloading
      • Expression bodied members
    • All-In-Projecten
      • Overzicht
      • OO Textbased Game
      • War Simulator
      • Map Maker
      • Magic The Gathering API
  • Pro (geen leerstof en/of in opbouw)
    • Bitwise operators
    • Generics en collections
      • Generics methoden en types
      • Generic classes en constraints
      • Collections
      • Labo-oefeningen
    • Exception handling
      • Werken met exceptions
      • Waar exceptions plaatsen
      • Zelf uitzonderingen maken
    • Events
      • Events
      • Chat server
Powered by GitBook
On this page
  • Nuttige array methoden
  • System.Array
  • Sort: Arrays sorteren
  • Reverse: Arrays omkeren
  • Clear: Arrays leegmaken
  • BinarySeach: Zoeken in arrays
  • Copy : Array kopieren
  • Manueel zoeken in arrays
  • String en arrays
  • String naar char array
  • Char array naar string

Was this helpful?

Export as PDF
  1. Semester 1: Programming Principles
  2. H7: Arrays

Werken met arrays

PreviousArray principesNextArrays en methoden

Last updated 5 years ago

Was this helpful?

Nuttige array methoden

Net zoals we hebben gezien dat de Math-klasse een heleboel nuttige methoden in zich heeft, zo heeft ook iedere array een aantal methoden waar handig gebruik van gemaakt kan worden.

Om deze methoden te kunnen gebruiken moet je bovenaan je file de volgende lijn toevoegen: using System.Linq;:

using System;
namespace methodmovie
{
   class Program
    {
        public static void Main()
        {
            int[] getallen = new int[101];

            //..
            Console.WriteLine(getallen.Sum());
        }
    }
}

Wanneer je een array hebt gemaakt kan je met de IntelliSense van Visual Studio bekijken wat je allemaal kan doen met de array:

Al deze methoden hier beschrijven zal ons te ver nemen. De volgende methoden zijn echter zeer handig om te gebruiken:

Max(), Min(), Sum() en Average().

Volgende code geeft bijvoorbeeld het grootste getal terug uit een array genaamd "leeftijden":

int oudsteleeftijd = leeftijden.Max();

System.Array

Alle C# arrays erven over van de System.Array klasse (klasse en overerving zien we later), hierdoor kan je zaken zoals Length gebruiken op je array. De System.Array klasse heeft echter ook nog een hoop andere nuttige methoden zoals de BinarySearch(), Sort() en Reverse() methoden. Het gebruik hiervan is steeds dezelfde zoals volgende voorbeelden tonen:

Sort: Arrays sorteren

Om arrays te sorteren roep je de Sort()-methode op als volgt, als parameter geef je de array mee die gesorteerd moet worden.

Volgende voorbeeld toont hier het gebruik van:

string[] myColors = {"red", "green", "yellow", "orange", "blue"};
//Sorteer
Array.Sort(myColors);

//Toon resultaat van sorteren
for (int i = 0; i < myColors.Length; i++)
{
    Console.WriteLine(myColors[i]);
}

Wanneer je de Sort-methode toepast op een array van strings dan zullen de elementen alfabetisch gerangschikt worden.

Reverse: Arrays omkeren

Met de Array.Reverse()-methode kunnen we dan weer de elementen van de array omkeren (dus het laatste element vooraan zetten en zo verder:

Array.Reverse(myColors);

Clear: Arrays leegmaken

Een array volledig leegmaken (alle elementen op ‘null’ zetten) doe je met de Array.Clear-methode, als volgt:

Array.Clear(myColors);

BinarySeach: Zoeken in arrays

De BinarySearch-methode maakt het mogelijk om te zoeken naar de index van een gegeven element in een index. Deze methode werkt enkel indien de elementen in de array gesorteerd staan! Je geeft aan de methode 2 parameters mee, enerzijds de array in kwestie en anderzijds het element dat we zoeken. Als resultaat wordt de index van het gevonden element teruggegeven. Indien niets wordt gevonden zal het resultaat -1 zijn.

Volgende code zal bijvoorbeeld de index teruggeven van de kleur "red" indien deze in de array myColors staat:

Array.BinarySearch(myColors, "red");

Volgend voorbeeld toont het gebruik van deze methode:

int[] rank = {224, 34, 156, 1023, -6};
Array.Sort(rank);

Console.WriteLine("What rank do you need?");
int userchoice = Convert.ToInt32(Console.ReadLine());

int index = Array.BinarySearch(rank, userchoice);
if(index >= 0)
    Console.WriteLine($"{userchoice} found at index {index}");
else
    Console.WriteLine("Not found");

Copy : Array kopieren

In het vorige hoofdstuk vertelden we reeds over het venijn van arrays kopiëren, daar deze 'by reference' worden bewaard. Lijn 2 in deze code creëert dus enkel een alias naar dezelfde array en geen kopie:

int[] arrayA = {1, 2, 3};
int[] arrayB = arrayA; //Sure?!

Willen we een kopie dan moet dit dus zoals in vorige hoofdstuk manueel gebeuren, of je maakt gebruikt van de Array.Copy() methode, als volgt:

int[] ar = {1, 2, 3};
int[] bar = new int[ar.Length];
Array.Copy(ar, bar, ar.Length);

De methode Array.Copy vereist minimaal 3 parameters, waaronder de originele array, de doel array (die reeds moet aangemaakt zijn!) alsook hoeveel elementen je uit de originele array wenst te kopieren. Bekijk zeker ook de overloaded versies die deze methode heeft. Zo kan je ook een bepaald stuk van een array kopieren en ook bepalen waar in de doel array dit stuk moet komen.

Manueel zoeken in arrays

Het zoeken in arrays kan met behulp van while of for-loops tamelijk snel. Volgend programmatje gaat zoeken of het getal 12 aanwezig is in de array. Indien ja dan wordt de index bewaard van de positie in de array waar het getal staat:

int teZoekenGetal = 12;

int[] getallen = {5, 10, 12, 25, 16};

bool gevonden = false;
int index = -1;

for (int i = 0; i < getallen.Length; i++)
{
    if (getallen[i] == teZoekenGetal)
    {
        gevonden = true;
        index = i;
    }
}

Voorgaande stukje code is de meest naïeve oplossing. Bedenk echter wat er gebeurt indien het getal dat we zoeken 2 of meerdere keren in de array staat. Index zal dan de positie bevatten van de laatst gevonden 12 in de array.

Het is zéér belangrijk dat je vlot dit soort algoritmen kan schrijven, zoals:

  • Zoeken van elementpositie in array

  • Tellen hoe vaak een element in een array voorkomt

  • Elementen in een array 1 of meerdere plaatsen opschuiven

Manueel zoeken met for en while

We tonen nu twee voorbeelden van hoe je kan zoeken in een array wanneer we bijvoorbeeld 2 arrays hebben die 'synchroon' zijn. Daarmee bedoel ik: de eerste array bevat producten, de tweede array bevat de prijs van ieder product. De prijs van de producten staat steeds op dezelfde index in de andere array:

string[] products = {"apples", "pears", "melons"};
double[] prices = {3.3, 6.2, 2.9};

We vragen nu aan de gebruiker van welk product de prijs getoond moet worden:

Console.WriteLine("Which price do you need?");
string userchoice = Console.ReadLine();

We tonen nu hoe we met for eerst het juiste product zoeken en dan vervolgens die index bewaren en gebruiken om de prijs te tonen:

bool found = false;
int productIndex = -1;

int counter = 0;
while (counter < products.Length && userchoice != products[counter])
{
    counter++;
}

if (counter != products.Length) //product found!
{
    found = true;
    productIndex = counter;
}


if (found == true)
{
    Console.WriteLine($"Price for {userchoice} is {prices[productIndex]}");
}
else
{
    Console.WriteLine("Not found");
}

Een nadeel van deze oplossing is dat we steeds de hele for doorlopen (we gebruiken geen break vanwege een allergie hiervoor bij de auteur). Bij heel lange arrays is dit dus niet erg performant.

Volgende oplossing met een while toont een performantere oplossing:

bool found = false;
int productIndex = -1;

int counter = 0;
while (counter < products.Length && userchoice != products[counter])
{
    counter++;
}

if (counter != products.Length) //product found!
{
    found = true;
    productIndex = counter;
}

if (found == true)
{
    Console.WriteLine($"Price for {userchoice} is {prices[productIndex]}");
}
else
{
    Console.WriteLine("Not found");
}

String en arrays

String naar char array

Het type string is niet meer dan een arrays van karakters, char[]. Om een string per karakter te bewerken is het aanbevolen om deze naar een char-array om te zetten en nadien terug naar een string. Dit kan gebruikmakend van .ToCharArray() als volgt:

string origineleZin = "Ik ben Tom";
char[] karakters = origineleZin.ToCharArray();
karakters[8] = 'i';
string nieuweZin = new string(karakters);
Console.WriteLine(nieuweZin);

De uitvoer zal worden:Ik ben Tim.

Char array naar string

Ook de omgekeerde weg is mogelijk. De werking is iets anders, let vooral op hoe we de char array doorgeven als argument bij het aanmaken van een nieuwe string in lijn 3:

char[] arrayOfLetters = {'h', 'a', 'l', 'l', 'o'};
arrayOfLetters[2] = 'x';
string word = new string(arrayOfLetters);
Console.WriteLine(word);

De uitvoer van deze code zal zijn: haxlo.