Ennen ensimmäistä kutsua tilanne on seuraava:
pala jono ++ +-------------------------------------+ || | |V|o|l|v|o| ||| | |1|2|3|0|0| ||| |1| ++ +-------------------------------------+ 0 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
Ensimmäisessä kutsussa erota-funktio löytää etsittävän | -merkin paikasta 7. Merkit 0-6 kopioidaan funktion paluuarvoksi ja sitten jonosta tuhotaan merkit 0-7. Funktion paluuarvo sijoitetaan muuttujaan pala:
pala jono +-------------+ +---------------------+ | |V|o|l|v|o| | | | |1|2|3|0|0| ||| |1| +-------------+ +---------------------+ 0 1 2 3 4 5 6 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
Seuraavalla kutsulla (kerta 2) |-merkki löytyy jonosta paikasta 8. Nyt merkit jonon merkit 0-7 kopioidaan funktion paluuarvoon ja merkki 8 tuhotaan. Kutsun jälkeen tilanne on:
pala jono +---------------+ +---+ | | |1|2|3|0|0| | | |1| +---------------+ +---+ 0 1 2 3 4 5 6 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
Kolmannessa kutsussa merkkiä | ei enää löydy jonosta. Tämä ilmenee siitä, että find-metodi palauttaa arvon string::npos ( no position ), eli ei paikkaa. Näin koko jono kopioidaan funktion paluuarvoksi ja kutsun jälkeen tilanne on:
pala jono +---+ ++ | |1| || +---+ ++ 0 1 2 3 4 5 6 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
Vastaava toistuu neljännessä kutsussa, eli koko jono sitten kopioidaan paluuarvoksi ja tilanne on neljännen kutsun jälkeen:
pala jono ++ ++ || || ++ ++ 0 1 2 3 4 5 6 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
Tämän jälkeen tilanne pysyy samana vaikka erota-funktiota kutsuttaisiin kuinka monta kertaa tahansa. Tästä saadaan se etu, että erota-funktiota voidaan turvallisesti kutsua kuinka monta kertaa tahansa, vaikkei jonosta enää palasia saataisikaan. Jos kutsua tehdään silmukassa, voidaan silmukan lopetusehdoksi kirjoittaa
while ( !jono.equals("") ) {
pala = erota(jono,'|');
System.out.println(pala);
}