Lijsten, arrays en strings in Java

Een ArrayList bewaart waarden op volgorde. De lijst groeit als je een element toevoegt en krimpt als je er een verwijdert. Elk element heeft een index, die begint bij 0. Importeer de klasse voordat je die gebruikt: import java.util.ArrayList;.

Maak een lijst met een type

ArrayList<String> drinks = new ArrayList<>();
drinks.add("tea");
drinks.add("milk");

Het type in <String> geeft aan wat de lijst opslaat. Met de diamantoperator <> rechts kan Java hetzelfde type afleiden. De lijst begint leeg, met grootte 0; na deze twee aanroepen bevat die [tea, milk] en heeft die grootte 2. Als je de lijst direct afdrukt, zie je de elementen: System.out.println(drinks);.

Het elementtype van een lijst moet een klassetype zijn. Gebruik voor getallen een wrapperklasse: Integer voor int, Double voor double, Boolean voor boolean of Character voor char. ArrayList<int> compileert niet. Met ArrayList<Integer> numbers = new ArrayList<>(); werkt numbers.add(5) omdat Java de int via autoboxing omzet naar een Integer. Als je de waarde leest met int n = numbers.get(0);, past Java unboxing toe.

Volg elke indexwijziging

String old = drinks.set(0, "coffee");
drinks.add(1, "water");
String last = drinks.get(2);

set(0, "coffee") vervangt het eerste element en geeft de oude waarde terug, dus old is "tea". De grootte blijft 2. Als je "water" op index 1 invoegt, schuift "milk" naar rechts. De lijst is nu [coffee, water, milk]; last is "milk" en de grootte is 3.

De extra toegestane invoegindex is de positie direct na het huidige laatste element. Bij deze lijst voegt add(3, "juice") achteraan toe, maar get(3) zou vóór die invoeging falen. Een ongeldige index veroorzaakt een IndexOutOfBoundsException. Gebruik get(size() - 1) voor het laatste element, nadat je hebt gecontroleerd dat de lijst niet leeg is.

Begin met gegevens of verzamel invoer

Met import java.util.List; maakt new ArrayList<>(List.of("red", "green", "blue")) een wijzigbare lijst met die waarden. List.of(...) alleen maakt een niet-wijzigbare lijst: add, set en remove werpen een UnsupportedOperationException op. Je zult ook List<String> names = new ArrayList<>(); zien; de algemene List-variabele ondersteunt deze lijstmethoden nog steeds.

Gebruik een Scanner met de naam scanner en een lege lijst met de naam lines om regels te verzamelen tot aan een lege regel:

while (true) {
    String line = scanner.nextLine();
    if (line.isEmpty()) {
        break;
    }
    lines.add(line);
}

De stopregel wordt vóór het toevoegen gecontroleerd en dus niet opgeslagen. lines.size() telt de opgeslagen regels. lines.isEmpty() test of er geen zijn en lines.clear() verwijdert ze allemaal wanneer je de lijst opnieuw wilt gebruiken.

Als je een element verwijdert, veranderen zowel de grootte als de indexen van latere elementen. Een zoekactie vertelt je of een waarde bestaat of waar die nu staat. Houd het verschil tussen een waarde en de positie ervan duidelijk, vooral in een lijst met gehele getallen.

Twee betekenissen van remove

Bij [coffee, water, milk] geeft remove(0) de waarde "coffee" terug en blijft [water, milk] over. De oude index 2 voor "milk" is nu ongeldig; die waarde is naar index 1 verschoven. Een opgeslagen index is alleen bruikbaar zolang bewerkingen de posities die de index aanduidt niet hebben veranderd.

Verwijderen op waarde betekent niet dat alle overeenkomsten worden verwijderd. Als je begint met [a, b, a], laat remove("a") de lijst [b, a] over. Een tweede aanroep verwijdert de resterende "a". Een ontbrekende waarde verwijderen geeft false terug en laat de lijst ongewijzigd, zodat je het resultaat direct kunt gebruiken:

boolean removed = names.remove("Lena");
if (removed) {
    System.out.println("Name removed");
}

De valkuil van de methodevarianten bij gehele getallen

Een int-argument selecteert de vorm met een index, ook als de lijst gehele getallen bevat:

ArrayList<Integer> numbers = new ArrayList<>(List.of(10, 20, 30));
int removed = numbers.remove(1);
boolean found = numbers.remove(Integer.valueOf(10));

De eerste aanroep verwijdert het element op index 1, dus removed is 20 en de lijst wordt [10, 30]. De tweede aanroep geeft expliciet een Integer-object mee. Die verwijdert de waarde 10, maakt found waar en laat [30] over. Een aanroep van remove(10) op de oorspronkelijke lijst met drie elementen zou index 10 proberen en een IndexOutOfBoundsException opwerpen.

Kies een zoekresultaat

Voor colors = [red, green, blue, green] is contains("green") gelijk aan true, indexOf("green") aan 1 en lastIndexOf("green") aan 3. contains geeft een ja-of-neeantwoord. De twee indexmethoden geven de eerste of laatste positie die overeenkomt. Een ontbrekende waarde levert respectievelijk false of -1 op.

Deze methoden gebruiken equals om elementen te vergelijken. De inhoud van strings moet exact overeenkomen, inclusief hoofdletters en kleine letters: indexOf("Green") is -1 voor deze lijst. Voor een hoofdletterongevoelige zoekactie kan een lus elke naam vergelijken met equalsIgnoreCase.

Een overeenkomst op index 0 is ook een overeenkomst. Met de test indexOf(x) > 0 mis je die. Als je de positie nodig hebt, test dan expliciet op de waarde die aangeeft dat er niets is gevonden:

int index = colors.indexOf("red");
if (index != -1) {
    colors.remove(index);
}

Hier geeft de zoekactie 0 terug, slaagt de test en blijft na verwijdering op index 0 de lijst [green, blue, green] over. Controleer vóór het toevoegen om dubbele namen te voorkomen: if (!names.contains(name)) { names.add(name); }. Om alle voorkomens te verwijderen, kun je de verwijdering herhalen zolang contains waar is of een veilige achterwaartse lus gebruiken. Een voorwaartse lus die na een verwijdering altijd de index verhoogt, kan een verschoven element overslaan.

Een lijstvariabele bevat een referentie naar een object. De variabele zelf bevat niet alle elementen. Dit verklaart waarom een lijst wijzigen via de ene naam invloed kan hebben op een andere naam en waarom een parameter een waarde toewijzen een ander effect heeft dan de elementen bewerken.

Volg de referenties

ArrayList<String> original = new ArrayList<>(List.of("tea"));
ArrayList<String> alias = original;
ArrayList<String> copy = new ArrayList<>(original);
alias.add("milk");
copy.add("juice");

original en alias verwijzen naar één lijst. Na de toevoeging via alias tonen beide [tea, milk]. De kopie is een afzonderlijke lijst, die vóór die toevoeging is gemaakt, en bevat dus [tea, juice]. Twee namen voor één object heten aliassen. Een toewijzing kopieert een referentie; de kopieerconstructor maakt een nieuwe lijst en kopieert de elementen daarin.

De gekopieerde lijst bevat referenties naar dezelfde elementobjecten. Bij strings en wrapperwaarden kunnen die elementobjecten niet veranderen, dus als je een plaats in de ene lijst vervangt, verandert de plaats in de andere lijst niet. Een lijst kopiëren is voldoende om deze twee lijsten onafhankelijk te laten toevoegen, verwijderen en vervangen.

Een methode krijgt een kopie van de referentie

Java geeft argumenten door op waarde. Voor een lijst is die waarde een referentie. De variabele van de aanroeper en de parameter verwijzen aanvankelijk naar dezelfde lijst:

static void addBonus(ArrayList<Integer> scores, int bonus) {
    for (int i = 0; i < scores.size(); i++) {
        scores.set(i, scores.get(i) + bonus);
    }
}

Als je addBonus(scores, 5) aanroept op [70, 85], verandert de lijst van de aanroeper in [75, 90]. De methode hoeft geen lijst terug te geven omdat die het gedeelde object bewerkt. Maar als je binnen de methode scores = new ArrayList<>(); toewijst, laat je alleen de lokale parameter naar een andere lijst verwijzen. De variabele van de aanroeper verwijst nog steeds naar de oude lijst.

Een int-parameter ontvangt een gekopieerd getal. Als je die parameter wijzigt, kan de int-variabele van de aanroeper niet veranderen. In beide gevallen is de parameter lokaal; het verschil is of de waarde ervan naar een gedeeld veranderlijk object leidt.

Geef nieuwe gegevens terug als dat de taak is

static ArrayList<String> longWords(ArrayList<String> words, int minLength) {
    ArrayList<String> result = new ArrayList<>();
    for (String word : words) {
        if (word.length() >= minLength) {
            result.add(word);
        }
    }
    return result;
}

De methode leest words en schrijft alleen naar result, dus de invoer blijft ongewijzigd. Een methode die een argument wijzigt, moet dat gedrag duidelijk maken, zoals addBonus doet. Een methode die nieuwe gegevens teruggeeft, maakt het gemakkelijker om de uitvoer afzonderlijk van de invoer te controleren.

Vergelijk inhoud en handel ontbrekende resultaten af

a == b test of twee lijstreferenties naar hetzelfde object verwijzen. a.equals(b) test of de lijsten even groot zijn en gelijke elementen in dezelfde volgorde hebben. Twee afzonderlijk opgebouwde lijsten [1, 2] hebben gelijke inhoud maar een verschillende identiteit; [2, 1] heeft geen gelijke inhoud in de volgorde van de lijst.

Een lege lijst is een echt object met grootte 0. Een lus daarover wordt nul keer uitgevoerd, maar get(0) faalt omdat er geen elementindexen zijn. null betekent dat er geen lijstobject is; zelfs size() werpt dan een NullPointerException op. Een methode zonder overeenkomsten kan een lege resultatenlijst teruggeven, zodat de aanroeper het resultaat normaal kan doorlopen.

Een array bewaart een vast aantal elementen van één type. Je kiest de lengte wanneer je de array maakt. Elementen kunnen veranderen, maar het aantal plaatsen in die array niet. Arrays kunnen primitieve waarden direct opslaan.

Maak en vul plaatsen

int[] scores = new int[5];
scores[0] = 90;
int first = scores[0];
int[] primes = {2, 3, 5, 7, 11};

new int[5] maakt vijf plaatsen. Hun indexen zijn 0, 1, 2, 3 en 4. Met vierkante haken lees en schrijf je een plaats, dus first wordt 90. De initialisator voor primes maakt en vult vijf plaatsen. Wanneer je een gevulde array als expressie nodig hebt, bijvoorbeeld als methodeargument, gebruik je new int[] {2, 3, 5}.

De lengte is een veld: scores.length, zonder haakjes. Het telt alle plaatsen, ook de plaatsen waaraan je zelf nog geen waarde hebt toegewezen. Als je een waarde op plaats 0 zet, verandert de lengte niet van 5 in 1.

Deze namen zijn niet onderling uitwisselbaar. Een array heeft geen methode size() en een string heeft haakjes nodig na length.

Ken de beginwaarden

Nieuwe plaatsen in een array krijgen standaardwaarden. Numerieke primitieve arrays beginnen met nul: 0 voor int, 0,0 voor double. Een boolean[] begint met false; een char[] begint met het teken waarvan de code nul is, geschreven als '\u0000'. Arrays van klassetypen, waaronder String[], beginnen met null-referenties.

String[] words = new String[3];
words[0] = "sun";
System.out.println(words[0].length());

Dit drukt 3 af omdat plaats 0 nu naar "sun" verwijst. Plaatsen 1 en 2 bevatten nog steeds null. De aanroep words[1].length() werpt een NullPointerException op: er staat daar nog geen string. Een plaats met de standaardwaarde null is iets anders dan een lege string "", een object met lengte 0.

Lees uitvoer en blijf binnen de array

Importeer java.util.Arrays en gebruik System.out.println(Arrays.toString(scores)); om [90, 0, 0, 0, 0] af te drukken. Als je scores direct afdrukt, zie je een type- en identiteitscode zoals [I@1b6d3586, niet de elementen. De identiteitscode geeft geen bruikbaar overzicht van de opgeslagen getallen.

Voor één week met temperaturen in graden Celsius:

double[] temps = {12.5, 14.0, 9.5, 11.0, 15.5, 13.0, 10.5};
temps[2] = 10.0;

De meting van de derde dag verandert van 9,5 in 10,0. De eerste meting is temps[0]; de laatste is temps[6], of temps[temps.length - 1]. temps[7] ligt buiten de array. Java werpt een ArrayIndexOutOfBoundsException op bij een ongeldige arrayindex. Gebruik in een lus met index i < temps.length: i <= temps.length probeert één extra plaats na de laatste geldige plaats. Een array met lengte nul heeft helemaal geen geldige elementindexen.

Een arrayvariabele bevat een referentie, net als een lijstvariabele. Als je die referentie toewijst, maak je een andere naam voor dezelfde array. Voor een afzonderlijke kopie is een nieuw arrayobject nodig en om de inhoud te vergelijken is een methode nodig die de plaatsen controleert.

Toewijzen en kopiëren

int[] a = {4, 9, 2};
int[] alias = a;
int[] copy = Arrays.copyOf(a, a.length);
alias[0] = 99;

Nu tonen a en alias allebei [99, 9, 2]; copy toont nog steeds [4, 9, 2]. Arrays.copyOf(a, a.length) maakt een nieuwe array met dezelfde lengte. Ook met a.clone() kun je de array kopiëren. Importeer java.util.Arrays voor de hulpmethoden.

Een andere gevraagde lengte verandert de nieuwe array, niet de oude. Arrays.copyOf(new int[] {2, 3, 5}, 4) levert [2, 3, 5, 0] op. Extra plaatsen krijgen standaardwaarden. Om een variabele naar een grotere array te laten verwijzen, wijs je de teruggegeven kopie aan die variabele toe. Een alias van het origineel verwijst nog steeds naar de oude array.

Methodeaanroepen delen het object

static void doubleAll(int[] values) {
    for (int i = 0; i < values.length; i++) {
        values[i] = values[i] * 2;
    }
}

De parameter ontvangt een kopie van de referentie. De methode verandert daardoor de plaatsen in de array van de aanroeper. Als je values opnieuw aan een nieuwe array zou toewijzen, zou alleen de parameter veranderen. Een methode kan ook een nieuwe array teruggeven: return new int[] {values[0], values[values.length - 1]}; levert [4, 2] op voor invoer {4, 9, 2}. Die expressie vereist niet-lege invoer omdat die twee indexen leest.

Inhoudelijke gelijkheid werkt anders bij arrays

Voor afzonderlijk gemaakte arrays a = {1, 2} en b = {1, 2} zijn zowel a == b als a.equals(b) onwaar: equals bij arrays controleert identiteit. Arrays.equals(a, b) is waar omdat de overeenkomstige elementen gelijk zijn. Dit verschilt van een ArrayList, waarvan equals de inhoud in volgorde vergelijkt.

Bewaar een waarde voordat je die overschrijft

Om twee posities te verwisselen, bewaar je één oude waarde in een tijdelijke variabele:

int temp = a[0];
a[0] = a[2];
a[2] = temp;

Als je begint met {4, 9, 2}, bewaart de eerste regel 4. De tweede levert [2, 9, 2] op. De derde zet de opgeslagen 4 terug op index 2 en voltooit zo [2, 9, 4]. Zonder temp zou de toewijzing a[2] = a[0] na de tweede regel opnieuw 2 kopiëren en zou de oorspronkelijke 4 verloren gaan.

Kies een structuur die bij de gegevens past

Arrays komen ook voor in main(String[] args) en als resultaat van String.split. Voor een String[] words maakt new ArrayList<>(Arrays.asList(words)) een lijst die kan groeien. Maak voor een int[] een ArrayList<Integer> en voeg elk geheel getal toe in een lus. Arrays.asList behandelt de volledige primitieve array als één element en maakt dus geen lijst van de afzonderlijke getallen.

Met een lus kan één stuk code elk element verwerken. De keuze hangt af van wat de lusbody nodig heeft: alleen een waarde, de positie ervan of een manier om naar de collectie terug te schrijven. Zowel arrays als ArrayLists ondersteunen lussen met index en for-each-lussen.

Bezoek waarden op volgorde

for (String task : tasks) {
    System.out.println(task);
}

Lees dit als “voor elke taak in tasks”. Bij [shop, cook, clean] drukt de lus de drie strings in die volgorde af. De lusvariabele heeft het elementtype. Gebruik bij ArrayList<Integer> het type int om op elke waarde unboxing toe te passen of Integer om de wrapperreferentie te behouden. Voor tekens van een string bezoekt for (char c : word.toCharArray()) de char-waarden.

Een for-each-lus biedt geen index. Gebruik een lus met index als je genummerde regels nodig hebt:

for (int i = 0; i < tasks.size(); i++) {
    System.out.println((i + 1) + ". " + tasks.get(i));
}

De index begint bij 0, maar het weergegeven regelnummer begint bij 1. Door de haakjes is i + 1 een optelling voordat het resultaat deel van de tekst wordt. Voor een array verander je de voorwaarde in i < tasks.length en lees je tasks[i]. Een while-lus kan hetzelfde doen door vóór de lus een teller te initialiseren en die in de lusbody te verhogen.

Schrijf terug via een positie

int[] nums = {4, 9, 2};
for (int n : nums) {
    n = n * 2;
}

Dit laat de array ongewijzigd. Elke iteratie zet een kopie van één primitieve waarde in n; een waarde toewijzen aan die lokale variabele schrijft niet naar de oorspronkelijke plaats. Om de array te wijzigen:

for (int i = 0; i < nums.length; i++) {
    nums[i] = nums[i] * 2;
}

Het resultaat is [8, 18, 4]. Voor een lijst met gehele getallen is de overeenkomstige bijwerking list.set(i, list.get(i) * 2). De index vertelt Java welk opgeslagen element moet worden vervangen.

Laat de grenzen bij de lusbody passen

Om een lijst achterwaarts te doorlopen, begin je bij tasks.size() - 1, ga je door zolang i >= 0 en gebruik je i--. Dit bezoekt achtereenvolgens clean, cook en shop. Om elk tweede element te nemen, kun je i += 2 in een voorwaartse lus gebruiken.

Vergelijkingen met een buur hebben een korter bereik nodig. Als de lusbody zowel list.get(i) als list.get(i + 1) leest, is de voorwaarde i < list.size() - 1. De laatste geldige beginpositie is het voorlaatste element. Met de gebruikelijke voorwaarde voor het volledig doorlopen zou de lus na het laatste element een niet-bestaande buur proberen te lezen.

Als je twee even lange lijsten samen verwerkt, gebruik je één index om beide te benaderen. Zo duiden names.get(i) en scores.get(i) de overeenkomstige elementen aan. Een for-each-lus is eenvoudiger als de positie geen rol speelt, bijvoorbeeld als je elke naam afdrukt of elke waarde bij een totaal optelt.

Als je bij 1 begint, sla je ongemerkt het eerste element over. Met <= size() of <= length probeer je één extra ongeldige index. Een lege lijst of array heeft geen speciale regel voor het doorlopen nodig: de beginvoorwaarde is onwaar, dus de lusbody wordt nul keer uitgevoerd. Latere code die door het aantal deelt of een element leest, moet het lege geval zelf afhandelen.

Een accumulator houdt een resultaat bij dat tijdens de iteraties van een lus wordt opgebouwd. Initialiseer de accumulator vóór de lus, werk die daarbinnen bij en gebruik die daarna. De beginwaarde hangt af van de taak: een som of telling begint bij 0, terwijl een maximum een werkelijk element nodig heeft.

Totalen en gemiddelden

int sum = 0;
for (int value : numbers) {
    sum += value;
}
if (!numbers.isEmpty()) {
    double average = (double) sum / numbers.size();
    System.out.println(average);
}

Voor [4, 7, 8] verandert sum van 0 naar 4, dan 11 en dan 19. Beide operanden in sum / numbers.size() zouden gehele getallen zijn, wat 6 oplevert. Als je sum vóór de deling expliciet converteert, krijg je ongeveer 6,33. Als je het al berekende quotiënt converteert, zet je alleen de afgekaptе waarde 6 om in 6,0.

Een lege collectie heeft geen gewoon gemiddelde. Geheeltallige deling door nul werpt een ArithmeticException op; de zwevendekommagetallendeling 0.0 / 0 geeft NaN. Bepaal vóór het delen wat het lege geval voor het programma betekent, bijvoorbeeld de melding “Geen metingen” weergeven. Voor kommagetalafstanden [5.0, 7.5, 10.0] km is een double-totaal 22,5 km en het gemiddelde 7,5 km.

Tel alleen overeenkomsten

Een voorwaardelijke telling begint bij 0 en neemt alleen toe als de test slaagt. Voor temperaturen {22, 27, 31, 24, 26} graden Celsius levert if (t > 25) { count++; } de waarde 3 op. Zet de initialisatie buiten de lus; als je count bij elke iteratie opnieuw instelt, gaan eerdere overeenkomsten verloren.

Zoek een extremum en de positie ervan

Begin bij een niet-lege array met int max = values[0];. Vervang max telkens als een bezochte waarde groter is. Beginnen bij 0 gaat fout bij {-5, -2, -9}: het resultaat is dan 0, hoewel geen element die waarde heeft. Als je begint met -5, kan de lus het juiste maximum -2 vinden. Een minimum gebruikt hetzelfde patroon met <.

Als de positie ertoe doet, houd je de beste index bij:

int best = 0;
for (int i = 1; i < numbers.size(); i++) {
    if (numbers.get(i) > numbers.get(best)) {
        best = i;
    }
}

Voor [4, 7, 8] eindigt best op 2 en is numbers.get(best) gelijk aan 8. De lus begint bij 1 omdat index 0 al de eerste kandidaat is. Met > vervangt een gelijke waarde de huidige kandidaat niet, zodat het eerste maximum behouden blijft. Met >= vervangt elke gelijke waarde de kandidaat, zodat het laatste maximum behouden blijft. Controleer of de collectie leeg is voordat je een kandidaat op index 0 kiest.

Verzamel overeenkomende waarden

Bij filteren gebruik je een lege resultatenlijst als accumulator. Bezoek elk woord, voeg het toe als word.length() > 4 en geef het resultaat terug. Voor [sun, planet, moon, galaxy] is het resultaat [planet, galaxy]. Als je de invoer leest en aan een afzonderlijke lijst toevoegt, blijft de invoer ongewijzigd.

Voor twee Integer-elementen vergelijkt == de objectidentiteit. Kleine waarden die worden hergebruikt kunnen deze fout verbergen; gelijke grotere waarden kunnen verschillende objecten zijn. Vergelijk met equals of pas eerst unboxing toe naar int-variabelen. De numerieke operatoren <, >, <= en >= passen unboxing toe op wrapperwaarden, dus de code voor de beste index vergelijkt hun getallen.

Een lineaire zoekactie controleert elementen één voor één. Die werkt op gegevens in elke volgorde. Een succesvolle zoekactie naar de eerste overeenkomst kan vroeg stoppen; een zoekactie zonder resultaat moet het einde bereiken voordat vaststaat dat geen element overeenkomt.

Geef de eerste overeenkomende index terug

static int indexOfName(ArrayList<String> names, String target) {
    for (int i = 0; i < names.size(); i++) {
        if (names.get(i).equals(target)) {
            return i;
        }
    }
    return -1;
}

Als de eerste overeenkomende naam op index 2 staat, controleert de methode indexen 0, 1 en 2 en geeft dan direct 2 terug. De return -1 staat na de lus omdat pas na een volledige doorloop vaststaat dat er geen overeenkomst is. Als je else { return -1; } binnen de lus zet, stopt de methode bij het eerste element dat niet overeenkomt en negeert die alle latere kandidaten.

De waarde -1 die aangeeft dat iets ontbreekt, kan geen geldige index zijn. De aanroeper moet die controleren voordat het resultaat wordt gelezen:

int index = indexOfName(names, "Ahmed");
if (index != -1) {
    System.out.println(names.get(index));
}

De test index > 0 zou een geldige overeenkomst op index 0 missen. Als je -1 direct in get gebruikt, wordt een exceptie opgeworpen. Bij een lege lijst wordt de lusbody nooit uitgevoerd en geeft de methode terecht -1 terug.

Pas de vergelijking aan de taak aan

Voor exacte waarden in een lijst voeren contains en indexOf al een lineaire zoekactie uit. Schrijf een lus voor een array of een voorwaarde zoals “begint met L”. Gebruik equals of equalsIgnoreCase voor strings, == voor primitieve waarden en equals voor twee Integer-objecten. Een identiteitstest voor strings kan gelijke tekst missen.

Test voor String[] cities = {"Oslo", "Lima", "Lagos", "Pune"} de voorwaarde cities[i].startsWith("L"). Index 0 voldoet niet; index 1 voldoet wel, dus het resultaat voor de eerste overeenkomst is 1. Als de taak om alle overeenkomsten vraagt, keer je daar niet terug. Voeg overeenkomende indexen toe aan een resultatenlijst en voltooi de doorloop; dat geeft [1, 2]. Om overeenkomsten te tellen, verhoog je een teller in plaats van posities op te slaan.

Kies de vorm van het antwoord

Een ja-of-neezoekactie kan beginnen met boolean found = false;. Zet de waarde bij een overeenkomst op waar en verlaat de lus met break. Zonder die break blijft het eindantwoord waar, maar controleert het programma waarden die het niet meer nodig heeft. Een zoekmethode kan ook direct true teruggeven en na de lus false teruggeven.

Als je een element teruggeeft, is een afzonderlijk resultaat voor “niets gevonden” nodig. Voor een String is dit vaak null; de aanroeper moet daarop controleren voordat die een String-methode aanroept. Als je een index met -1 teruggeeft, is het ontbrekende geval zichtbaar zonder te stellen dat een lege string ontbrekende gegevens zijn.

Tel het werk dat de zoekactie werkelijk doet

Een doelwaarde op de eerste positie vereist één vergelijking. Een doelwaarde op de derde positie vereist er drie. Een ontbrekende doelwaarde in 10.000 namen vereist alle 10.000 vergelijkingen. De eerste mislukte vergelijking kan niet vaststellen dat de doelwaarde ook op de resterende posities ontbreekt. Een zoekactie naar alle overeenkomsten controleert eveneens elk element, ook na een vroege overeenkomst, omdat latere waarden ook kunnen overeenkomen.

Als je elementen uit een ArrayList verwijdert, veranderen de posities die een lus probeert te bezoeken. Het veilige patroon hangt af van de vraag of je de oorspronkelijke lijst wilt wijzigen of een afzonderlijk resultaat wilt opbouwen. Waarden vervangen is eenvoudiger omdat de posities daarbij gelijk blijven.

Bekijk hoe een voorwaartse lus een waarde overslaat

Stel dat een lus even getallen uit [3, 8, 8, 5] verwijdert en i altijd verhoogt. Op index 1 verwijdert de lus de eerste 8. De tweede 8 schuift naar index 1, maar de volgende iteratie gebruikt index 2. Het resultaat is [3, 8, 5], met één even getal over. De voorwaarde was correct; het ging mis door de verschuiving na de verwijdering.

Ook in een for-each-lus over een ArrayList mag je niet via de lijst toevoegen of verwijderen. De lus gebruikt een iterator waarvan de voortgang niet meer overeenkomt met de bewerkte lijst. Java meldt meestal een ConcurrentModificationException. Sommige bewerkingen kunnen de lus in plaats daarvan stilzwijgend beëindigen, waardoor een element niet wordt bezocht. Het ontbreken van een exceptie maakt die bewerking niet veilig.

Verwijder achterwaarts om ongecontroleerde posities stabiel te houden

for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 0) {
        numbers.remove(i);
    }
}

Bij [3, 8, 8, 5] bevat index 3 de waarde 5 en die blijft staan. Index 2 bevat 8 en wordt verwijderd. Index 1 bevat nog steeds de andere 8 en die wordt daarna verwijderd. Index 0 bevat 3 en die blijft staan. Het resultaat is [3, 5]. Een verwijdering verschuift elementen rechts van de huidige index, die deze achterwaartse lus al heeft gecontroleerd.

Bouw een lijst op met de waarden die je wilt behouden

Als het origineel ongewijzigd moet blijven, maak je een nieuwe lijst:

ArrayList<Integer> odds = new ArrayList<>();
for (int value : numbers) {
    if (value % 2 != 0) {
        odds.add(value);
    }
}

Deze for-each-lus is veilig omdat die numbers leest en aan een andere lijst toevoegt. Met [3, 8, 8, 5] als invoer bevat odds de waarden [3, 5] en bevat de invoer nog steeds alle vier waarden. Ook een array kan niet krimpen; om de waarden daarvan te filteren is eveneens een nieuwe array of lijst nodig.

Laat een iterator zelf verwijderen

Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) {
        it.remove();
    }
}

Importeer java.util.Iterator. next() levert het volgende element en it.remove() verwijdert het zojuist teruggegeven element terwijl de positie van de iterator consistent blijft. Gebruik in deze lus niet numbers.remove(...) in plaats daarvan.

Een voorwaartse while-lus kan ook werken door de index alleen te verhogen als er niets is verwijderd. Na een verwijdering moet de lus dezelfde index opnieuw controleren, waar het volgende element terecht is gekomen. Dit vereist meer aandacht dan een achterwaartse lus of een nieuwe resultatenlijst.

Vervangen en toevoegen hebben verschillende effecten

set(i, value) is veilig in een lus met index omdat de grootte en posities niet veranderen. Als je bij elke iteratie toevoegt terwijl je i < list.size() test, kan het einde steeds verder opschuiven en kan de lus oneindig doorgaan. Sla int originalSize = list.size(); op en laat de lus alleen tot die grens lopen wanneer elk oorspronkelijk element tot één toegevoegde waarde moet leiden.

Een String bewaart tekst als een reeks char-waarden. Indexen beginnen bij 0, net als bij arrays en lijsten. Een String-object kan na het maken niet veranderen, dus methoden die gewijzigde tekst opleveren geven een resultaat terug dat je moet bewaren.

Een teken verschilt van een string

"Hello".length() is 5. "Hello".charAt(0) is 'H' en charAt(4) is 'o'. Een char gebruikt enkele aanhalingstekens en bevat één UTF-16-code-eenheid; een String gebruikt dubbele aanhalingstekens en kan nul, één of veel van die eenheden bevatten. "Java".charAt(0) == 'J' vergelijkt twee primitieve tekens. Die char vergelijken met "J" compileert niet omdat de typen verschillen.

charAt(length()) ligt voorbij het einde en werpt een StringIndexOutOfBoundsException op. Zelfs charAt(0) faalt bij "". Controleer isEmpty() voordat je het eerste teken van invoer leest.

length() telt UTF-16-char-waarden, die niet altijd volledige weergegeven symbolen zijn. "café".length() is 4; "Hi 👋".length() is 5 omdat de zwaaiende hand als emoji twee char-posities inneemt. Gebruik dat aantal wanneer je de indexen van deze methoden bepaalt.

Bezoek en test de tekens

String text = "Programming in Java".toLowerCase();
int vowels = 0;
for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);
    if ("aeiou".indexOf(c) >= 0) {
        vowels++;
    }
}

Door de omzetting naar kleine letters herkent dezelfde lidmaatschapstest zowel hoofdletters als kleine letters onder de klinkers. Elke indexOf(c) is niet-negatief als het teken in "aeiou" voorkomt. De telling komt uit op 6: o, a, i, i, a, a. Met for (char c : text.toCharArray()) kun je dezelfde waarden zonder index bezoeken.

De klasse Character biedt tests zoals isLetter, isDigit, isWhitespace en isUpperCase. Character.isDigit('7') is waar, terwijl Character.isLetter('7') onwaar is. Character.toUpperCase(c) en toLowerCase(c) geven geconverteerde char-waarden terug.

Tekens hebben ook getalcodes. 'a' + 1 levert de int 98 op; (char) ('a' + 1) zet die code om naar 'b'. Bij een ASCII-cijferteken geeft aftrekken van '0' de waarde: '7' - '0' is 7. De code voor nul aftrekken werkt omdat die cijfercodes opeenvolgend zijn.

Lees concatenatie van links naar rechts

Zodra de linkerkant van + tekst is, wordt het volgende getal als tekst samengevoegd. Haakjes dwingen de numerieke optelling vóór het samenvoegen af. Enkele samenvoegingen in één expressie zijn een duidelijke toepassing van +.

Sla de teruggegeven tekst op

String name = "Lena";
name.toUpperCase();
System.out.println(name);
name = name.toUpperCase();

De afdruk toont nog steeds "Lena": de weggegooide aanroep heeft het object niet veranderd. Door de toewijzing verwijst name daarna naar "LENA". Onveranderlijkheid van strings betekent dat de oude tekst ongewijzigd blijft, ook als andere variabelen ernaar verwijzen. Het resultaat bewaren en het oorspronkelijke object veranderen zijn verschillende bewerkingen.

Tekstverwerking volgt vaak een korte reeks stappen: zoek een markering, controleer of die bestaat en haal daarna het benodigde deel eruit. Opschoonbewerkingen kunnen de tekst voorbereiden op een zoekactie of vergelijking. Elke String-bewerking geeft een resultaat terug zonder het oorspronkelijke object te veranderen.

Zoek posities of stel een ja-of-neevraag

Voor "banana" geeft indexOf('a') de waarde 1 terug, indexOf("a", 2) de waarde 3 en lastIndexOf('a') de waarde 5. Het tweede argument bepaalt waar de voorwaartse zoekactie begint. Een zoekactie zonder resultaat geeft -1, zoals in indexOf("x").

Gebruik contains(text) als je alleen hoeft te weten of tekst voorkomt. startsWith(prefix) controleert het begin en endsWith(suffix) het einde. "report.pdf".endsWith(".pdf") is waar. Deze zoekacties zijn hoofdlettergevoelig: "Hello".contains("hello") is onwaar. De indexmethoden accepteren een char of een String; contains neemt tekst als argument.

Een deelstring eindigt vlak vóór de eindindex

String word = "programming";
String middle = word.substring(3, 7);
String tail = word.substring(3);

middle is "gram" en gebruikt de posities 3, 4, 5 en 6. De lengte is 7 - 3, oftewel 4. tail is "gramming", omdat de methode tot het einde van de string loopt als je het eindargument weglaat. De beginindex moet niet-negatief zijn en mag niet groter zijn dan de eindindex; de eindindex mag niet groter zijn dan length(). Ongeldige grenzen werpen een StringIndexOutOfBoundsException op.

Zoek bij een e-mailadres het scheidingsteken voordat je de delen eruit haalt:

String email = "lena.ito@example.com";
int at = email.indexOf("@");
if (at != -1) {
    String user = email.substring(0, at);
    String domain = email.substring(at + 1);
}

Het scheidingsteken staat op index 8. Het eerste deel eindigt ervoor en geeft "lena.ito"; het tweede begint erna en geeft "example.com". Als de markering ontbreekt, is at gelijk aan -1. Een aanroep van substring(0, at) zonder de controle zou falen. Als je het tweede deel bij at zou laten beginnen, zou de @ in het domein blijven staan.

Schoon alleen op waarop de bewerking gericht is

" hello ".trim() geeft "hello"; spaties binnen de tekst blijven staan. strip() verwerkt extra Unicode-witruimte, zoals een em-spatie. De methode gebruikt de Java-definitie van witruimte, die niet elk teken omvat dat op een spatie lijkt. "banana".replace('a', 'o') geeft "bonono". "ab".repeat(3) geeft "ababab".

Leeg en alleen witruimte zijn verschillend

isEmpty() test op lengte 0. isBlank() accepteert ook tekst die alleen uit Java-witruimte bestaat. Voor " " is de eerste onwaar en de tweede waar. Gebruik de test die bij de invoerregel past. Om een antwoord zoals " Yes " op te schonen, geeft answer.trim().toLowerCase() de waarde "yes" terug. Sla die teruggegeven tekst op als de variabele de opgeschoonde waarde moet bewaren; een losse answer.trim(); gooit die weg.

Een gegevensregel kan meerdere waarden bevatten die door een komma of een andere markering zijn gescheiden. Splitsen levert een array met strings op; parsen zet daarna geselecteerde velden om naar getallen. Controleer de vorm van de gegevens voordat je posities gebruikt.

Splits naar een array

String[] fields = "Ada,36,London".split(",");

Er zijn drie velden: "Ada", "36" en "London". De komma’s blijven niet behouden. fields.length is 3 en fields[1] is nog steeds tekst, geen getal.

Het scheidingsteken dat aan split wordt doorgegeven, is een reguliere expressie, een patroon dat niet altijd letterlijke tekst is. Een komma betekent zichzelf, maar ., |, *, + en ? hebben een speciale betekenis. Gebruik "1.5.2".split("\\.") om een versiestring bij letterlijke punten te splitsen. Twee backslashes in de Java-string leveren de ene backslash in het patroon op die de punt letterlijk maakt. split(".") komt daarentegen overeen met afzonderlijke tekens en levert voor dit voorbeeld een lege array op.

Handel spaties en lege delen af

Als je "a b" splitst bij " ", krijg je drie delen: "a", "" en "b". Elk scheidingsteken is één spatie, dus opeenvolgende spaties laten een leeg deel ertussen over. Gebruik voor reeksen witruimte:

String[] words = "  red   green blue ".trim().split("\\s+");

Het resultaat is [red, green, blue]. Door eerst trim te gebruiken, voorkom je een leeg eerste deel door een scheidingsteken aan het begin. Standaard laat split lege delen aan het einde weg: "a,b,,".split(",") levert alleen "a" en "b" op. Tel de werkelijke resulterende velden voordat je ze met een index benadert.

Parse elk veld naar het bedoelde type

Integer.parseInt("42") geeft de primitieve int 42 terug. Integer.valueOf("-7") geeft een Integer-object terug. Double.parseDouble("5.2") geeft 5,2 terug en gebruikt een punt als decimaalteken, ongeacht de landinstellingen van de computer. Bij het parsen van gehele getallen moet de tekst een geheel getal zonder decimaalpunt bevatten. Integer.parseInt("4.5") faalt in plaats van af te ronden.

Gebruik trim op velden voordat je ze parset, vooral bij tekst met gehele getallen: Integer.parseInt(" 42") werpt een NumberFormatException op. Splitsen bij komma’s verwijdert geen spaties rond de velden. Een correct aantal velden garandeert ook niet dat een veld een geldig getal bevat.

Lees een volledig record

String line = "Amira,10.5,63";
String[] parts = line.split(",");
if (parts.length == 3) {
    String name = parts[0].trim();
    double distanceKm = Double.parseDouble(parts[1].trim());
    int minutes = Integer.parseInt(parts[2].trim());
    double pace = minutes / distanceKm;
    System.out.println(name + ": " + pace + " min/km");
}

De afstand is 10,5 km, de tijd is 63 minuten en het tempo is 6,0 min/km. De onvolledige regel "Amira,10.5" heeft slechts twee velden; zonder controle van het aantal zou parts[2] een ArrayIndexOutOfBoundsException opwerpen. Een programma kan dat onvolledige record overslaan of melden voordat het een ontbrekende positie gebruikt.

Zet weer om naar tekst of voeg tekst samen

String.valueOf(42) en Integer.toString(42) geven beide "42". String.join(", ", List.of("Oslo", "Lima", "Pune")) geeft "Oslo, Lima, Pune" en voegt alleen tussen de delen scheidingstekens in. De methode accepteert een lijst, een array of afzonderlijke stringargumenten. Samenvoegen parset of berekent niets: het combineert de aangeleverde strings.

Twee variabelen kunnen tekst met dezelfde tekens bevatten zonder naar hetzelfde String-object te verwijzen. Kies een vergelijking op basis van de vraag: gelijke inhoud, gelijke inhoud zonder onderscheid tussen hoofdletters en kleine letters, of welke tekst eerst komt in de volgorde van Java.

Gebruik equals voor inhoud

String answer = new String("yes");
System.out.println(answer == "yes");
System.out.println(answer.equals("yes"));

Het eerste resultaat is onwaar: het afzonderlijk gemaakte object is niet het object van de literal. Het tweede is waar omdat de tekens overeenkomen. Identieke literals zoals "yes" == "yes" delen een object en kunnen een identiteitsvergelijking betrouwbaar laten lijken. Tekst die tijdens de uitvoering ontstaat, kan nieuwe of bestaande objecten gebruiken, dus identiteit is geen test om te bepalen of invoer overeenkomt.

equalsIgnoreCase negeert het verschil tussen hoofdletters en kleine letters: "YES".equalsIgnoreCase("yes") is waar. De methode verwijdert geen spaties. Om ook spaties rondom te accepteren, schoon je de invoer vóór het vergelijken op.

Roep bij een variabele die null kan zijn de methode aan op een bekende literal die niet null is: "yes".equals(answer) geeft onwaar terug bij null. answer.equals("yes") werpt een NullPointerException op als answer null is, omdat er geen object is dat de aanroep ontvangt.

Een opdrachtlus kan !command.equals("quit") testen. De ! ontkent de inhoudelijke gelijkheid. command != "quit" test daarentegen referenties en kan een lus laten doorgaan, zelfs als de getypte tekens “quit” vormen.

Interpreteer het teken van compareTo

a.compareTo(b) vergelijkt UTF-16-charwaarden één voor één. De methode geeft een negatief getal terug als a vóór b komt, nul als ze gelijk zijn en een positief getal als de eerste erna komt. Alleen het teken is van belang voor de volgorde; een resultaat hoeft niet precies -1 of 1 te zijn.

Getallen die als tekst zijn opgeslagen, volgen dus niet de numerieke volgorde. Parse ze als de taak numeriek is. Engelse hoofdletters zonder accent komen vóór kleine letters zonder accent, dus "Zebra" komt vóór "apple". In deze volgorde komt "Émile" met accent na "Zoe". compareToIgnoreCase negeert hoofdletters en kleine letters; voor woordenboekvolgorde volgens een specifieke taal is java.text.Collator nodig.

Gebruik het minimumpatroon opnieuw voor namen

Voor een niet-lege lijst [Mia, Ahmed, Lucia]:

String first = names.get(0);
for (String name : names) {
    if (name.compareTo(first) < 0) {
        first = name;
    }
}

"Mia" is de eerste kandidaat. "Ahmed" komt daarvoor en wordt de kandidaat; "Lucia" vervangt die niet. Het resultaat is "Ahmed". Controleer of de lijst leeg is voordat je het eerste element leest.

Een afzonderlijke char is primitief, dus word.charAt(0) == 'A' is een correcte tekenvergelijking zodra vaststaat dat het woord niet leeg is. Het probleem met == betreft objectidentiteit, niet elke vergelijking met tekst.

Een StringBuilder bevat veranderlijke tekst. Die is handig als een lus veel delen toevoegt of als tekens ter plaatse moeten worden bewerkt. Als je enkele delen in één expressie samenvoegt, is + duidelijk, maar als je een groeiende String steeds opnieuw opbouwt, kan de opgebouwde inhoud vaak worden gekopieerd.

Voeg delen achteraan toe en sluit af met een String

StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        sb.append(", ");
    }
    sb.append(i);
}
String result = sb.toString();

Er is geen import nodig. append voegt strings, chars, getallen of booleaanse waarden achteraan toe. De eerste iteratie voegt alleen 1 toe; de tweede voegt ", " en daarna 2 toe. Het resultaat is "1, 2, 3, 4, 5". Een scheidingsteken na elk getal zetten zou een ongewenst scheidingsteken aan het einde achterlaten. Voor een bestaande lijst met strings regelt String.join(", ", list) de scheidingstekens direct.

Herhaaldelijk text += piece gebruiken in een lus vormt nieuwe onveranderlijke String-resultaten. Het opgebouwde begindeel moet elke keer worden opgenomen, dus de hoeveelheid die wordt gekopieerd kan kwadratisch groeien naarmate een lang resultaat groeit. Een StringBuilder houdt een veranderlijke buffer bij en voegt daaraan toe zonder bij elke iteratie het hele begindeel opnieuw op te bouwen.

Bewerk posities en bereiken

length() en charAt(i) lezen de StringBuilder zoals ze een String lezen. Indexen beschrijven de huidige toestand; een invoeging of verwijdering kan latere posities veranderen.

Begin met new StringBuilder("Jva"). insert(1, 'a') levert "Java" op; setCharAt(0, 'j') geeft daarna "java". Bij "2026-10-22" verwijdert delete(4, 7) de posities 4, 5 en 6, zodat "2026-22" overblijft. Als je posities 7 tot en met 9 in "I like tea" vervangt door "coffee", krijg je "I like coffee".

Keten alleen methoden die de StringBuilder teruggeven

new StringBuilder().append("a").append(1).append('b').toString() geeft "a1b". De append-aanroepen geven dezelfde StringBuilder terug, waardoor een volgende aanroep mogelijk is. De bewerkingsmethoden hier geven ook de StringBuilder terug, behalve setCharAt, dat void teruggeeft en een afzonderlijke instructie nodig heeft.

reverse() verandert de ontvanger. Als sb de tekst "stressed" bevat, laat String r = sb.reverse().toString(); zowel r als de tekst van de StringBuilder achter als "desserts". Om de oorspronkelijke StringBuilder te behouden, keer je een nieuwe StringBuilder om die je van de tekst maakt.

Vergelijk de voltooide inhoud

Voeg voor een palindroomcontrole de kleine lettervorm van elke letter in "Was it a car or a cat I saw" toe. De opgeschoonde tekst is "wasitacaroracatisaw". Keer een nieuwe StringBuilder met die tekst om, zet die om naar een String en vergelijk met clean.equals(reversed). De vergelijking is waar.

StringBuilder overschrijft equals niet om de inhoud te vergelijken. Afzonderlijke StringBuilders met "abc" zijn volgens die methode niet gelijk en een StringBuilder is niet gelijk aan een String. Zet eerst om: sb1.toString().equals(sb2.toString()) vergelijkt de werkelijke tekst.