1. Vergelijkingen
Programmeurs moeten voortdurend verschillende variabelen met elkaar vergelijken. Maar zoals je al hebt gezien, is alles niet zo eenvoudig.
Integers zijn heel gemakkelijk te vergelijken - u hoeft ze alleen maar te gebruiken ==
en u bent klaar. Om reële getallen te vergelijken , moet je hun verschil (of beter gezegd de absolute waarde van het verschil) vergelijken met een heel klein getal.
Strings vergelijken is nog moeilijker. Dit komt vooral omdat strings objecten zijn. Bovendien willen programmeurs vaak dat de stringvergelijking een beetje anders verloopt, afhankelijk van de situatie.
2. Hoe strings in het geheugen zijn gerangschikt
Zoals je al hebt gezien, worden strings anders in het geheugen opgeslagen dan gehele getallen en reële getallen:
Twee geheugenblokken worden gebruikt om strings op te slaan: het ene blok slaat de tekst zelf op (de grootte hangt af van de grootte van de tekst) terwijl het tweede blok (4 bytes) het adres van het eerste blok opslaat.
Hoewel een ervaren programmeur iets zou zeggen als "de String
str
variabele slaat een verwijzing naar een String
object op.
3. Referenties toekennen aan een string
De voordelen van deze benadering worden duidelijk wanneer u een tekenreeksvariabele moet toewijzen aan een andere tekenreeksvariabele. Voorbeeld:
String text = "This is a very important message";
String message = text;
En dit is wat het geheugen als resultaat zal bevatten:

Na dit type toewijzingsbewerking blijft het object waar het was en wordt alleen het adres (een verwijzing naar het object) naar de variabele String
gekopieerd .message
4. Werken met referenties en objecten
Maar als u besluit een tekenreeks om te zetten in hoofdletters (hoofdletters), doet de Java-machine alles goed: u krijgt uiteindelijk twee String
objecten en de variabelen text
en message
slaan verwijzingen op, elk naar zijn eigen object.
Voorbeeld:
String text = "This is a very important message";
String message = text.toUpperCase();
En dit is wat het geheugen als resultaat zal bevatten:
Houd er rekening mee dat de toUpperCase()
methode de string waarop deze wordt aangeroepen niet verandert . In plaats daarvan wordt een nieuwe string (nieuw object) gemaakt en wordt er een verwijzing naar geretourneerd.
Wat dacht je van een nog interessanter voorbeeld. Stel dat u besluit een tekenreeks door te geven aan een Scanner
object (zodat het waarden uit de tekenreeks leest).
Voorbeeld:
String text = "10 20 40 80";
Scanner console = new Scanner(text);
int a = console.nextInt();
int b = console.nextInt();
Je kunt hier meer leren over hoe de Scanner
klas werkt .
Dit is hoe het allemaal in het geheugen wordt opgeslagen:
In dit geval blijft een enkel String
object in het geheugen zoals het was - alleen verwijzingen ernaar worden doorgegeven en opgeslagen in variabelen.
5. Verwijzingen naar String
objecten vergelijken
En tot slot hebben we het leuke gedeelte bereikt: snaarvergelijking.
Er zijn twee operatoren die u kunt gebruiken om tekenreeksvariabelen te vergelijken: ==
(gelijk aan) en !=
(niet gelijk). U kunt de operatoren "groter dan", "kleiner dan" of "groter dan of gelijk aan" niet gebruiken - de compiler staat dit niet toe.
Maar er is hier een interessante nuance: wat wordt er eigenlijk opgeslagen in stringvariabelen? Dat klopt: adressen (referenties) naar objecten. En het zijn deze adressen die worden vergeleken:
String text = "Hi";
String message = text;
String s1 = text.toUpperCase();
String s2 = text.toUpperCase();
Dit is wat er in het geheugen zal zijn:
De variabelen message
en text
verwijzen naar (sla het adres op van) hetzelfde object. Maar de variabelen s1
en s2
slaan verwijzingen op naar objecten die erg op elkaar lijken maar verschillend zijn.
En als je deze 4 variabelen in de code vergelijkt, krijg je het volgende resultaat:
Code | Console-uitvoer |
---|---|
|
|
GO TO FULL VERSION