[JAVA] string replacen

[Zynth]

Ik heb een hele tijd gezocht (API, internet, etc...),
maar ik kan geen methode vinden die een
string in een string kan replacen.
oftewel iets van:

code:

public String replace(String de_tekst, String verander_dit, String in_dit){
  //veranderen!!!!
  return de_aangepaste_tekst;
}

bestaat zoiets?
(mag trouwens ook wel voor een char[])

[mbravenboer]

In 1.4.0 zijn er methoden toegevoegd in java.lang.String die je daarvoor kunt gebruiken. Hierbij kan je opgeven wat je wilt vervangen met een reguliere expressie.

In 1.4.0 kan het zo: String.replaceAll("Bla", "Boeh"). Hiermee vervang je uiteraard alle Blas door Boehs.

Als je 1.4.0 niet kan gebruiken werkt dit ook (geen extreme optimaliseer poging gedaan). Als je meerdere Strings moet vervangen kan je het beste de StringBuffer variant gebruiken en de grootte van de buffer goed instellen.

edit: deze code bevat nogal wat gebreken die het erg traag maken, zie verder in de thread voor betere oplossingen .

code:

public static String replaceString(String source, String firstString, String newString)
{
    return replaceStringInBuffer(new StringBuffer(source), firstString, newString).toString();
}

public static StringBuffer replaceStringInBuffer(StringBuffer source,  String firstString, String newString)
{
    int firstStringLength = firstString.length();

    for(int i=0;i<source.length();i++)
    {
        if(source.substring(i, i + firstStringLength).equals(firstString))
        {
            source.replace(i, i + firstStringLength, newString);
        }
    }

    return source;
}

[mbravenboer]

btw, een echt goede methode zou niet iedere keer substrings van de StringBuffer nemen. Beter kan je elke char los checken . Maar goed, ben af en toe beetje lui .

[.oisyn]

dan kun je nog beter gaan zoeken met String.indexOf (), vervolgens dat veranderen en verder gaan met indexOf () waar je gebleven was, dan wordt er ook nix dubbel gecontroleerd

^{PS. hier sprak een C++ coder}


.edit: heej ik verveel me, okee?!

code:

public void replace (String deText, String van, String naar)
{
    StringBuffer buffer = new StringBuffer ();
    int i1, i2;
    int len = van.length ();

    buffer.ensureCapacity (512); // scheelt een hoop mem-allocs :)

    i1 = 0;
    i2 = deText.indexOf (van);
    while (i2 >= 0)
    {
      if (i1 < i2)
        buffer.append (deText.substring (i1, i2);
      buffer.append (naar);
      i1 = i2 + len;
      i2 = deText.indexOf (van, i1);
    }
    if (i1 < deText.length ())
      buffer.append (deText.substring (i1));

    return buffer.toString ();
}

niet getest uiteraard, maar als ie werkt is ie sneller dan die van mbravenboer

[Alarmnummer]

Ik ben nog niet klaar met mijn lib ander zette ik hem wel online. (ok.. niet erg nuttig )

[mbravenboer]

OiSyN: dan kun je nog beter gaan zoeken met String.indexOf (), vervolgens dat veranderen en verder gaan met indexOf () waar je gebleven was, dan wordt er ook nix dubbel gecontroleerd

Hum, in theorie hoef je met mijn methode (maar dan wel op een veel betere manier geimplementeerd ) nooit nieuwe Strings te maken. Een String is een Object, dus das duur. Je kan zelfs al de grootte van de StringBuffer naar schatting goed instellen zodat de interne opslag niet verdubbeld hoeft te worden. In principe kan je in mijn methode ook nog de index optelling verbeteren. Dan wordt hier ook helemaal niets dubbel gecontroleerd .

Misschien moet ik maar ff een betere maken .

[Nappa]

[compleet offtopic]
Vind het wel cool dat mbravenboer zelfs om 01:27 nog voor je klaar staat als je Java vragen hebt!!
/edit zelfs om 2:17 nog
[/compleet offtopic]

[mbravenboer]

Ik zal het zaakje ff bench-marken (deze code, nieuwe code, index-of code) .

[mbravenboer]

Nappa: Vind het wel cool dat mbravenboer zelfs om 01:27 nog voor je klaar staat als je Java vragen hebt!!
/edit zelfs om 2:17 nog

Ik ben een gespleten persoonlijkheid: als de ene slaapt, is de andere paraat om Java vragen te beantwoorden .

[Alarmnummer]

probeer deze anders ff..

code:

public static void replace(StringBuffer source,String findString, String replaceString, int startPos, int stopPos)
    {
        if(source == null)
            throw new NullPointerException("source can`t be null");
        
        if(findString == null)
            throw new NullPointerException("findString can`t be null.");
        
        if(findString.length()==0)
            throw new NullPointerException("findString.length() must be greater than 0");
        
        if(replaceString == null)
            throw new NullPointerException("replaceString can`t be null.");
        
        if(stopPos<0)
            throw new IndexOutOfBoundsException("stopPos must be greater or equal to zero, stopPos = "+stopPos);
        
        if(stopPos>source.length())
            stopPos = source.length();
        
        if(startPos<0)
            throw new IndexOutOfBoundsException("startPos can`t be smaller than 0");
        
        if(startPos>=stopPos)
            throw new IndexOutOfBoundsException("startPos must be smaller than stopPos, startPos="+startPos+" stopPos="+stopPos);
        
        
        startPos = source.indexOf(findString,startPos);
        while(startPos>-1&&startPos<=stopPos)
        {
            source.replace(startPos,startPos+findString.length(),replaceString);
            startPos = startPos+replaceString.length();
            startPos = source.indexOf(findString,startPos);
        }
    }

[Nappa]

Op vrijdag 14 december 2001 02:20 schreef mbravenboer het volgende:

[..]

Ik ben een gespleten persoonlijkheid: als de ene slaapt, is de andere paraat om Java vragen te beantwoorden .

Ahhh, juist. Je slaapt? Maar je antwoordt tegelijkertijd. Is dit de digitale versie van slaapwandelen??

Ach, laat ook maar. Ik ga maar slapen, voordat een modje mijn onzin ziet .

[.oisyn]

ik heb mijn post dus geedit hierboven, kijk er even naar (tijdens het editten had er verder nog niemand gepost)

[mbravenboer]

Ik neem hem mee in de bench-mark .

[.oisyn]

wat ik me afvraag... (ik ken de interne java-werking verder niet)

als je van je StringBuffer een substring opvraagt, dan wordt er toch gewoon een nieuwe String gemaakt? (met de nodige overhead die dat met zich meebrengt)


.edit: let trouwens op die while (i2 >= 0), daar stond eerst i2 > 0, moet dus >= zijn

[Alarmnummer]

yep wat jij wil is een textsegment.

[mbravenboer]

Ja inderdaad, dat was dus ook het punt wat ik noemde...

Ik ben een leuke bench-mark aan het maken. Ik doe nu mijn oude versie tegen die van jullie, daarna zal ik nog ff de mijnes aanpassen en mogen jullie ook nog veranderen .

[.oisyn]

oh wacht

Hum, in theorie hoef je met mijn methode (maar dan wel op een veel betere manier geimplementeerd ) nooit nieuwe Strings te maken

ik had over dat deel tussen de haakjes heen gelezen

[Alarmnummer]

ik zou een dikke optimalisatie kunnen krijgen door de de stringbuffer on gesysnchroniseerde methodes te geven (dus ff knippen en plakken ) En er kan nog wat met de variable berekeningen gerommeld worden. (dus niet 2 keer dezelfde waarde uitrekenen), maar volgens mij valt er dan niet veel meer te optimaliseren (misschien als ik ontwerp radicaal ga veranderen)

[mbravenboer]

Ze zijn in ieder geval allemaal correct met mijn test-case . ff een output maken.

[Alarmnummer]

als je gaat testen met lange zoekstringen dan ligt jouw algoritme denk ik achteraan. Want je hebt een ongelovelijk hoge object creatie.

if(source.substring(i, i + firstStringLength).equals(firstString)) en dit in een lus..

het gaat dus om de substring methode.

[.oisyn]

ja dat is ook precies waar ik op doelde

[mbravenboer]

Whow, ik weet niet of ik dit durf te publiceren .

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer: 490
OiSyn:   715
mbravenboer: 1821
Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 489
OiSyn:   694
mbravenboer: 1981

Ikke ga ff de genoemde aanpassing doorvoeren in mijn code . Als jullie nog wat willen aanpassen, ga je gang .

[.oisyn]

hahaha, eat that javahova whitness!

nieuwe versie coming up...

[Alarmnummer]

als je zelf even een equals routine erin zet, zonder substring dus, maar met een offset dan gaat het een stuk sneller..

[Alarmnummer]

dit is een van de char array (nog niet getest)
maar copieer het controleer stuk maar..
dan gaat ie van jou een stuk rapper..

code:

public static int indexOfIgnoreCase(char[] charArray, char[] findCharArray, int startOffset, int stopOffset)
    {
        if(charArray == null)
            throw new NullPointerException("charArray can`t be null");
        
        if(findCharArray == null)
            throw new NullPointerException("findString can`t be null");
        
        if(findCharArray.length==0)
            return 0;
        
        if(startOffset<0)
            throw new StringIndexOutOfBoundsException("startOffset must be greater or equal than 0, startOffset="+startOffset);
        
        //stopOffset zit na het einde van de array
        if(stopOffset>charArray.length)
            stopOffset = charArray.length;
        
        if(stopOffset<0)
            throw new IndexOutOfBoundsException("stopPos must be greater or equal to zero, stopPos = "+stopOffset);
            
        //stopOffset zit voor de startOffset
        if(startOffset>=stopOffset)
            throw new StringIndexOutOfBoundsException("startOffset must be smaller than stopOffset, startOffset="+startOffset+", stopOffset="+stopOffset);
        
        int sourceIndex = startOffset;
        int findIndexInSource = -1;
        int findIndex = 0;
        boolean found = false;
        while(sourceIndex<stopOffset)
        {
            char charSource = charArray[sourceIndex];
            char charFind = findCharArray[findIndex];

            if(Character.toLowerCase(charSource)==Character.toLowerCase(charFind))
            {
                if(findIndexInSource == -1)
                {
                    //1e goeie karakter ben je tegen gekomen.
                    findIndexInSource = sourceIndex;
                }

                findIndex++;

                if(findIndex == findCharArray.length)
                {
                    //je hebt de hele string gevonden
                    sourceIndex = stopOffset;
                    found = true;
                }
            }
            else
            {
                findIndexInSource = -1;
                findIndex = 0;
            }
            sourceIndex++;
        }

        if(found)
            return findIndexInSource;
        else
            return -1;
    }

[mbravenboer]

Ik schaam me inderdaad diep .

Alarmnummer: als je zelf even een equals routine erin zet, zonder substring dus, maar met een offset dan gaat het een stuk sneller..

Inderdaad + heb nog wat slimme truckjes bedacht .

[.oisyn]

geen idee hoe dit uit gaat pakken hoor... misschien zijn er tegenwoordig snellere manieren om met arrays te werken (heb het niet zo bijgehouden, wat snelheid betreft ben ik bekend met jdk 1.1.4 ofzo )

code:

public void replace (String deText, String van, String naar)
{
    char buffer[] = new char[65536];
    char chText[] = deText.toCharArray ();
    char chVan[] = van.toCharArray ();
    char chNaar[] = naar.toCharArray ();
    int tlen = chText.length;
    int vlen = chVan.length;
    int nlen = chNaar.length;

    int bufpos = 0, tpos = 0, vpos = 0;
    while (tpos < tlen)
    {
      char t = chText[tpos++];

      if (t != chVan[vpos])
      {
        if (vpos > 0)
        {
            System.arrayCopy (chVan, vpos, buffer, bufpos, vpos);
            bufpos += vpos;
            vpos = 0;
        }
        else
            buffer[bufpos++] = t;
      }
      else if (++vpos == vlen)
      {
        System.arrayCopy (chNaar, 0, buffer, bufpos, nlen);
        bufpos += nlen;
        vpos = 0;
      }
    }

    return new String (buffer, 0, bufpos);
}

nadelen:
je krijgt een ArrayIndexOutOfBoundsException als de totale string langer wordt dan 64k chars (wanneer gebeurt dat nou? )

[mbravenboer]

Ok, ik heb de zaak een beetje opgeleukt . Veel succes .

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer: 489
OiSyn:   705
mbravenboer: 338

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 476
OiSyn:   688
mbravenboer: 491

Waarom Alarmnummers oplossing met meer tekens sneller is (in tegenstelling tot bij zelfde lengte), is mij eigenlijk onduidelijk...

[Alarmnummer]

waarom maak je van de array (van 65k) geen stringbuffer? dan heb je helemaal geen beperkingen. (ok.. tis wel iets langzamer). Misschien is het een idee om een ongesynchroniseerde versie van de stringbuffer te maken. hmm.. ga ik morgen maar eens even doen

[mbravenboer]

OiSyn: in je oplossing zit een fout... Zal ff kijken wat er mis is. Hij is bovendien ERG langzaam .

[.oisyn]

ja heej ik kan m ook wel implementeren als native hoor, moet je kijken wie er wint

[.oisyn]

Op vrijdag 14 december 2001 03:13 schreef mbravenboer het volgende:
OiSyn: in je oplossing zit een fout... Zal ff kijken wat er mis is. Hij is bovendien ERG langzaam .

hmmmz waarom verbaast me dat niet (dat ie langzaam is dan he)

.edit: ik zie nu waarom ie fout is, er moet ergens nog een vpos++ tussen... zal m effe editten <-- onzin, staat er wel

[Alarmnummer]

betere versie

code:

int stopPos;
int findStringLength = findString.length();
int replaceStringLength = replaceString.length();
startPos = source.indexOf(findString,startPos);
while(startPos>-1&&startPos<=stopPos)
{
   stopPos = startPos+length;
   source.replace(startPos,stopPos,replaceString);
   startPos = startPos+replaceStringLength;
   startPos = source.indexOf(findString,startPos);
}

volgens mij is ie nu wel een stuk sneller

[mbravenboer]

Hum, hij vervangt helemaal niets in jouw laatste oplossing OiSyn .

Hier is mijn code (sorry voor de truck ). Op sommige details zal het zeker nog wel beter kunnen.

code:

    public static String replaceUltraSnel(String source, String firstString, String newString)
    {
        return replaceUltraSnel(new StringBuffer(source), firstString, newString).toString();
    }

    public static StringBuffer replaceUltraSnel(StringBuffer source,  String firstString, String newString)
    {
        final int firstStringLength = firstString.length();
        final int newStringLength = firstString.length();
        final char[] firstChars = firstString.toCharArray();
        final char[] newChars = newString.toCharArray();

        if(firstString.length() == newString.length())
        {
            int max = source.length() - firstStringLength;
            boolean equals = false;

            for(int i=0; i < max; i++)
            {
                equals = true;

                for(int j=0;j < firstStringLength; j++)
                {
                    if(source.charAt(i + j) != firstChars[j])
                    {
                        equals = false;
                        break;
                    }
                }

                if(equals)
                {
                    for(int j=0;j < firstStringLength; j++)
                    {
                        source.setCharAt(i + j, newChars[j]);
                    }
                    i += firstStringLength - 1;
                }
            }
        }
        else
        {
            int max = source.length() - firstStringLength;
            int dif = newString.length() - firstStringLength;
            boolean equals = false;

            for(int i=0; i < max; i++)
            {
                equals = true;
                for(int j=0;j < firstStringLength; j++)
                {
                    if(source.charAt(i + j) != firstChars[j])
                    {
                        equals = false;
                        break;
                    }
                }

                if(equals)
                {
                    source.replace(i, i + firstStringLength, newString);
                    i += newStringLength - 1;
                    max += dif;
                }
            }
        }

        return source;
    }

[.oisyn]

aargh natuurlijk

stom koppiepeestfoutje: char chNaar[] = van.toCharArray ();

moet natuurlijk zijn char chNaar[] = naar.toCharArray ();

[mbravenboer]

Alarmnummer: waar komt length hier vandaan? :
stopPos = startPos+length;

[.oisyn]

alarmnummer gebruikt waarschijnlijk een compiler met fuzzy logic, die probeert te raden wat de domme user nou eigenlijk bedoelt

[Alarmnummer]

stopPos = startPos+findStringLength;

[Alarmnummer]

Op vrijdag 14 december 2001 03:20 schreef OiSyN het volgende:
alarmnummer gebruikt waarschijnlijk een compiler met fuzzy logic, die probeert te raden wat de domme user nou eigenlijk bedoelt

he..maar windows is wel het meest gebruike os hoor!

[Alarmnummer]

sorry.. foute code.. (slaat echt nergens op..komt door windows)

code:

int findStringLength = findString.lenght();
int replaceStringLength = replaceString.length();

startPos = source.indexOf(findString,startPos);
while(startPos>-1&&startPos<=stopPos)
{
    source.replace(startPos,startPos+findStringLength,replaceString);
    startPos = startPos+replaceStringLength;
    startPos = source.indexOf(findString,startPos);
}

[mbravenboer]

Roffel.... daar komtie ...

[mbravenboer]

Sorry, ik moet ff wachten tot de oplossing van OiSyn klaar is

[mbravenboer]

Whow, verrassende resultaten .

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer: 950
OiSyn:   47871
mbravenboer: 355

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 502
OiSyn:   42950
mbravenboer: 480

Het is er dus niet echt beter op geworden Alarmnummer... Laat ik maar niets over OiSyn zeggen . De test wordt trouwens 100.000 keer uitgevoerd en de resultaten zijn uiteraard milli-seconden.

[Alarmnummer]

het lijkt me stug dat mijn code langzamer is geworden.

Alarmnummer: 489
OiSyn: 705
mbravenboer: 338

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 476
OiSyn: 688
mbravenboer: 491

of de test is veranderd..

[mbravenboer]

Alarmnummer: het lijkt me stug dat mijn code langzamer is geworden.

Hum tja... ik zal OiSyn er even tussen-uit halen, jij komt namelijk daarna en hij gooit nogal met arrays...

Moment

[mbravenboer]

Test is hetzelfde gebleven... Ik heb OiSyn uitgezet en toen kreeg ik dit:

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer: 493
OiSyn:   1
mbravenboer: 339
Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 488
OiSyn:   0
mbravenboer: 477

Echt sneller is hij dus niet geworden... Die 900 zal wel met het opruimen van de zooi van OiSyn te maken hebben .

Ik zal ons tweeen nog even omdraaien.

[Alarmnummer]

[mbravenboer]

Hum ik heb jou nu eerste gezet (ipv mij) maar daar heb je niet echt voordeel van...

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer: 536
OiSyn:   0
mbravenboer: 300
Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 483
OiSyn:   0
mbravenboer: 494

[Alarmnummer]

ok.. jouw code is sneller maar je hebt gebruik gemaakt van dat algoritme waar laatst naar verwezen werd in mijn topic: String(Buffer) en char[] lib maken?

[mbravenboer]

M'n zelfde lengte truck werkt wel erg goed .

Komt OiSyn nog met een nieuwe kandidaat?

[mbravenboer]

Alarmnummer: ok.. jouw code is sneller maar je hebt gebruik gemaakt van dat algoritme waar laatst naar verwezen werd in mijn topic: String(Buffer) en char[] lib maken?

Zou wel kunnen, maar niet bewust. Waar doel je op? Overigens is jouw code voor het 'normale geval' iets sneller...

[Alarmnummer]

ik kan hem nog wel een stuk sneller krijgen door mijn eigen indexof in elkaar te zetten. Maar die post ik morgen wel, ik ga nu op bed moet om 9 uur weer op mijn werk zijn

[mbravenboer]

Oeps . trusten .

[mbravenboer]

Interessant: Ik heb voor de gein even een bench-mark toegevoegd voor de reguliere expressie String.replaceAll().

Ik heb hierbij (1) niet gebruik gemaakt van caching van de gecompileerde regex (2) gebruik gemaakt van de gecompileerde regex (3) gebruik gemaakt van de Matcher.

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer:           554
OiSyn:             0
mbravenboer:           310
regex:             1506
regex (met Pattern cache): 1231
regex (met Matcher cache): 1149

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer:           494
OiSyn:             0
mbravenboer:           464
regex:             1444
regex (met Pattern cache): 1258
regex (met Matcher cache): 1171

De resultaten van de Matcher vielen mij eigenlijk wel een beetje tegen.

[Alarmnummer]

deze is weer een stuk beter (hopelijk )

code:

char[] findCharArray = findString.toArray();??
int findStringLength = findCHarArray.length;
int replaceStringLength = replaceString.length();

startPos = indexOf(source,findCharArray,startPos);
while(startPos>-1&&startPos<=stopPos)
{
    source.replace    (startPos,startPos+findStringLength,replaceString);
    startPos = startPos+replaceStringLength;
    startPos = indexOf(source,findCharArray,startPos);
}

    public static int indexOf(StringBuffer source, char[] findCharArray, int startOffset)
    {
        int sourceIndex = startOffset;
        int findIndexInSource = -1;
        int findIndex = 0;
        boolean found = false;
        int stopOffset = source.length();
        
        while(sourceIndex<stopOffset)
        {
            char charSource = source.charAt(sourceIndex);
            char charFind = findCharArray[findIndex];

            if(charSource==charFind)
            {
                if(findIndexInSource == -1)
                {
                    //1e goeie karakter ben je tegen gekomen.
                    findIndexInSource = sourceIndex;
                }

                findIndex++;

                if(findIndex == findCharArray.length)
                {
                    //je hebt de hele string gevonden
                    sourceIndex = stopOffset;
                    found = true;
                }
            }
            else
            {
                findIndexInSource = -1;
                findIndex = 0;
            }
            sourceIndex++;
        }

        if(found)
            return findIndexInSource;
        else
            return -1;  
    }

[mbravenboer]

Hum vreemd Alarmnummer: bij een vervanging waarbij de String groter wordt is hij inderdaad een stukje sneller, bij dezelfde lengte niet...

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer:           541
OiSyn:             0
mbravenboer:           298
regex:             1520
regex (met Pattern cache): 1270
regex (met Matcher cache): 1143

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer:           459
OiSyn:             0
mbravenboer:           476
regex:             1459
regex (met Pattern cache): 1253
regex (met Matcher cache): 1177

[mbravenboer]

Oh wacht, als je niet wordt lastig gevallen door een opstartende VM gaat het iets beter:

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer:           496
OiSyn:             0
mbravenboer:           308
regex:             1512
regex (met Pattern cache): 1232
regex (met Matcher cache): 1119

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer:           467
OiSyn:             0
mbravenboer:           476
regex:             1417
regex (met Pattern cache): 1259
regex (met Matcher cache): 1153

Zou onze topic-starter ondertussen geholpen zijn? .

[Alarmnummer]

ok.. ben 1 1/2 uur te laat op mijn werk en volgens mij is hij wel geholpen

[Alarmnummer]

Als je trouwens wilt zien wat nu precies de methodes zijn die alles verstoppen moet je even een profiler ophalen (loop je nu iets te verkondigen wat je al lang weet). Onder win2k gebruikte ik JProbe (is er volgens mij ook voor linux). Je kunt zelfs met taart diagrammen zien hoeveel % van de tijd je in een methode zit Bottlenecks zijn zo gevonden.

[Alarmnummer]

En probeer het maar eens met een html pagina erin. En dan verschillende strings gaan vervangen en dan kun je echt zien hoe snel de test in real life zijn. <b> in <bb> en </b> in <> en <p> in <m> ofzo. Dan heb je alle soorten vervangenen. Met lange lengte, kortere en gelijke. Beter dan een syntetische benchmark

[wasigh]

ik heb ook ooit een stringreplacer geschreven maar durf deze niet te posten

[Alarmnummer]

Ik ben er mee bezig, als ik hem klaar heb dan plaats ik hem wel online. Hoop dat jullie dan de fouten (die er vast en zeker nog inzitten) eruit halen en misschien alles nog iets sneller kunnen krijgen.

[mbravenboer]

Alarmnummer: profiler

Profiler zou hier inderdaad wel makkelijk zijn, maar ik denk niet dat we nog fundamenteel iets kunnen verbeteren in Java. De oplossing met de StringBuffer moet het snelste zijn en je ziet ook dat onze twee oplossingen ongeveer gelijk preseteren.

Alarmnummer: html pagina

Goed idee, wellicht zal ik vanavond ff een test draaien .

Lullig voor je dat je te laat was .

[.oisyn]

Op vrijdag 14 december 2001 03:44 schreef mbravenboer het volgende:
Hum ik heb jou nu eerste gezet (ipv mij) maar daar heb je niet echt voordeel van...

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer: 536
OiSyn:   0
mbravenboer: 300
Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer: 483
OiSyn:   0
mbravenboer: 494

yeah ik ben het snelst!!!

[Alarmnummer]

[.oisyn]

maar waarom is werken met char arrays nou zo ongelooflijk langzaam

ik bedoel, StringBuffer werkt intern toch ook met char arrays? of is dat native geimplementeerd? Of heb ik ergens een gigantische fout zitten waarom het gewoon niet goed loopt?

Enlighten me please

[Alarmnummer]

jij gaat in je lus arrays copieren..

jouw code

code:

while (tpos < tlen)
    {
        char t = chText[tpos++];
        if (t != chVan[vpos])
        {
            if (vpos > 0)
            {
                System.arrayCopy (chVan, vpos, buffer, bufpos, vpos);<==hier een..
                bufpos += vpos;
                vpos = 0;
            }
            else
                buffer[bufpos++] = t;
        }
        else if (++vpos == vlen)
        {
            System.arrayCopy (chNaar, 0, buffer, bufpos, nlen);<=weer een!

[.oisyn]

uhm ja maar dat doet StringBuffer dus ook neem ik aan

ik ging ervan uit dat System.arrayCopy sneller was dan zelf die arrays doorlopen, waarom zou die feature er anders in zitten

ik kan ze wel zelf gaan kopieren mbv een for-lusje, maar volgens mij wordt het er niet echt bepaald sneller op

[Alarmnummer]

ik heb net nog even goed gekeken (regeltje commentaar erbij zou geen kwaad kunnen en het ziet er toch heel goed uit. Die mem copies zijn inderdaad nodig, en die zouden heel efficient moeten zijn. (Was even iets te voorbarig). Maar misschien dat hij die initialisatie procedure (al die string naar arrays conversies) niet zo leuk vind? Ik vind het er eigelijk goed uitzien..

[Alarmnummer]

Ik heb ook nog een idee om het geheel wat sneller te krijgen. Je gaat eerst de source string doorlopen en maakt een lijst met alle indexen waar je je zoekstring hebt gevonden. Dan maak je een nieuwe buffer waarvan je de lengte nu heel eenvoudig kan bepalen

newLengte=oudLengte+lijst.size()*(replaceString.length-findString.length());

en dan ga je alles in de nieuwe stringbuffer/array plaatsen.

maarja..of je door al dat gecopieer er nou op vooruit gaat?

[Alarmnummer]

voor de liefhebbers... als jullie er nog fouten in ontdekken dan natuurlijk even melden En die 'gekke' code komt uit String.java van sun zelf

code:

/**
 * CharArrayUtilities.java
 *
 * @author Peter Veentjer
 */

package com.jph.string;

public class CharArrayUtilities
{
    
    public static int indexOfIgnoreCase(char[] source,char[] target)
    {
        return indexOfIgnoreCase(source,target,0,source.length);
    }
    
    public static int indexOfIgnoreCase(char[] source,char[] target, int fromIndex)
    {
        return indexOfIgnoreCase(source,target,fromIndex,source.length);
    }
    
    public static int indexOfIgnoreCase(char[] source,char[] target, int fromIndex, int stopOffset)
    {
        return indexOfIgnoreCase(source,0,stopOffset,target,0,target.length,fromIndex);
    }
    
    public static int indexOf(char[] source,char[] target)
    {
        return indexOf(source,target,0,source.length);
    }
    
    public static int indexOf(char[] source,char[] target, int fromIndex)
    {
        return indexOf(source,target,fromIndex,source.length);
    }
    
    public static int indexOf(char[] source,char[] target, int fromIndex, int stopIndex)
    {
        return indexOf(source,0,stopIndex,target,0,target.length,fromIndex);
    }
    
    public static int lastIndexOf(char[] source,char[] target)
    {
        return lastIndexOf(source,target,source.length-1,0);
    }
    
    public static int lastIndexOf(char[] source,char[] target, int fromIndex)
    {
        return lastIndexOf(source,target,fromIndex,0);
    }
    
    public static int lastIndexOf(char[] source,char[] target, int fromIndex, int stopIndex)
    {
        return lastIndexOf(source,stopIndex,source.length-stopIndex,target,0,target.length,fromIndex);
    }
    
    public static int lastIndexOfIgnoreCase(char[] source,char[] target)
    {
        return lastIndexOfIgnoreCase(source,target,source.length-1,0);
    }
    
    public static int lastIndexOfIgnoreCase(char[] source,char[] target, int fromIndex)
    {
        return lastIndexOfIgnoreCase(source,target,fromIndex,0);
    }
    
    public static int lastIndexOfIgnoreCase(char[] source,char[] target, int fromIndex, int stopIndex)
    {
        return lastIndexOfIgnoreCase(source,stopIndex,source.length-stopIndex,target,0,target.length,fromIndex);
    }

    
    /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source   the characters being searched.
     *
     * @param   sourceOffset offset of the source string.
     *
     * @param   sourceCount  count of the source string.
     *
     * @param   target   the characters being searched for.
     *
     * @param   targetOffset offset of the target string.
     *
     * @param   targetCount  count of the target string.
     *
     * @param   fromIndex    the index to begin searching from.
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
                              char[] target, int targetOffset, int targetCount,
                              int fromIndex)
    {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        
        if (targetCount == 0) {
            return fromIndex;
        }
        
        char first  = target[targetOffset];
        
        //de huidige karakter positie
        int i = sourceOffset + fromIndex;
        
        //de maximale offset.
        int max = sourceOffset + (sourceCount - targetCount);
        
        startSearchForFirstChar:
        while (true) {
            /* Look for first character. */
            while (i <= max && source[i] != first) {
                i++;
            }
            
            if (i > max) {
                return -1;
            }
            
            /* Found first character, now look at the rest of v2 */
            int j = i + 1;
            int end = j + targetCount - 1;
            int k = targetOffset + 1;
            while (j < end) {
                if (source[j++] != target[k++]) {
                    i++;
                    /* Look for str's first char again. */
                    continue startSearchForFirstChar;
                }
            }
            return i - sourceOffset;    /* Found whole string. */
        }
    }
    
    static int indexOfIgnoreCase(char[] source, int sourceOffset, int sourceCount,
                                        char[] target, int targetOffset, int targetCount,
                                        int fromIndex)
    {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        
        if (targetCount == 0) {
            return fromIndex;
        }
        //converteer target naar lower case.
        char[] lowerCaseTarget = new char[target.length];
        for(int k=0;k<target.length;k++)
            lowerCaseTarget[k]=Character.toLowerCase(target[k]);
        
        char first  = lowerCaseTarget[targetOffset];
        
        //de huidige karakter positie
        int i = sourceOffset + fromIndex;
        
        //de maximale offset.
        int max = sourceOffset + (sourceCount - targetCount);
        
        startSearchForFirstChar:
        while (true) {
            /* Look for first character. */
            while (i <= max && Character.toLowerCase(source[i]) != first) {
                i++;
            }
            
            if (i > max) {
                return -1;
            }
            
            /* Found first character, now look at the rest of v2 */
            int j = i + 1;
            int end = j + targetCount - 1;
            int k = targetOffset + 1;
            while (j < end) {
                if (Character.toLowerCase(source[j++]) != target[k++]) {
                    i++;
                    /* Look for str's first char again. */
                    continue startSearchForFirstChar;
                }
            }
            return i - sourceOffset;    /* Found whole string. */
        }
    }
    
    
    
    /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source   the characters being searched.
     * @param   sourceOffset offset of the source string.
     * @param   sourceCount  count of the source string.
     * @param   target   the characters being searched for.
     * @param   targetOffset offset of the target string.
     * @param   targetCount  count of the target string.
     * @param   fromIndex    the index to begin searching from.
     */
    static int lastIndexOfIgnoreCase(char[] source, int sourceOffset, int sourceCount,
                           char[] target, int targetOffset, int targetCount,
                           int fromIndex) {
        /*
         * Check arguments; return immediately where possible. For
         * consistency, don't check for null str.
         */
        int rightIndex = sourceCount - targetCount;
        if (fromIndex < 0) {
            return -1;
        }
        if (fromIndex > rightIndex) {
            fromIndex = rightIndex;
        }
        /* Empty string always matches. */
        if (targetCount == 0) {
            return fromIndex;
        }
        
         //converteer target naar lower case.
        char[] lowerCaseTarget = new char[target.length];
        for(int k=0;k<target.length;k++)
            lowerCaseTarget[k]=Character.toLowerCase(target[k]);
    
                               
        int strLastIndex = targetOffset + targetCount - 1;
        char strLastChar = lowerCaseTarget[strLastIndex];
        int min = sourceOffset + targetCount - 1;
        int i = min + fromIndex;
        
        startSearchForLastChar:
        while (true) {
            while (i >= min && Character.toLowerCase(source[i]) != strLastChar) {
                i--;
            }
            if (i < min) {
                return -1;
            }
            int j = i - 1;
            int start = j - (targetCount - 1);
            int k = strLastIndex - 1;
            
            while (j > start) {
                if (Character.toLowerCase(source[j--]) != lowerCaseTarget[k--]) {
                    i--;
                    continue startSearchForLastChar;
                }
            }
            return start - sourceOffset + 1;
        }
    }
    
      static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
                           char[] target, int targetOffset, int targetCount,
                           int fromIndex) {
        /*
         * Check arguments; return immediately where possible. For
         * consistency, don't check for null str.
         */
        int rightIndex = sourceCount - targetCount;
        if (fromIndex < 0) {
            return -1;
        }
        if (fromIndex > rightIndex) {
            fromIndex = rightIndex;
        }
        /* Empty string always matches. */
        if (targetCount == 0) {
            return fromIndex;
        }
        
        int strLastIndex = targetOffset + targetCount - 1;
        char strLastChar = target[strLastIndex];
        int min = sourceOffset + targetCount - 1;
        int i = min + fromIndex;
        
        startSearchForLastChar:
        while (true) {
            while (i >= min && source[i] != strLastChar) {
                i--;
            }
            if (i < min) {
                return -1;
            }
            int j = i - 1;
            int start = j - (targetCount - 1);
            int k = strLastIndex - 1;
            
            while (j > start) {
                if (source[j--] != target[k--]) {
                    i--;
                    continue startSearchForLastChar;
                }
            }
            return start - sourceOffset + 1;
        }
    }
    
    public static void main(String[] args)
    {
        String source = "peter";
        String target = "e";
        int indexOf = lastIndexOf(source.toCharArray(),target.toCharArray(),10);
        System.out.println("indexOf:"+indexOf);
    }
}

[mbravenboer]

Wel ja, vervang jij ff een String in 2 pagina's code .

Ik zal hem vanavond ff bench-marken

OiSyn: ik vermoed dat de slechte performance komt door de grote char[] .... maar dat is nogal een gok .

[Alarmnummer]

is utilities class voor char arrays, niet voor String en StringBuffers.. alhoewel je ook die er ook in kan stoppen

[.oisyn]

ik denk idd ook dat het door het aanmaken van die arrays komt

als je de buffer nou eens static maakt (is ie wel niet thread-safe, maar het is alleen maar om te testen ), en voor het aanmaken van toCharArray () moet ook wel een andere oplossing zijn... ik neem aan dat String en StringBuffer regelrecht in de chararray kan neuzen... als je ze nou in de package java.lang zet, kun je er dan ook niet bij?

[Alarmnummer]

haha of de access modifier van die array van string en stringbuffer aanpasen zodat je buiten de package er ook bij kan..

jdk1.4beta3fast(crash)

[Alarmnummer]

ok.. probeer deze maar eens.. volgens mij is ie wel redelijk snel

code:

/**
 * Test.java
 *
 * @author Created by Peter Veentjer
 */

package com.jph.string;

import java.util.*;

public class Test
{
        /**
     * Vervangt in source alle voorkomens van findString door replaceString.
     *
     * @param source                 de StringBuffer waarin vervangen moet worden.
     * @param findString             de te zoeken String.
     * @param replaceString      de te vervangen String.
     * @param startPos               de positie vanaf waar je begint te vervangen.
     * @param stopPos                de eerste positie die niet vervangen meer mag worden
     */
    public static void replaceFast(StringBuffer source,String findString, String replaceString, int startPos, int stopPos)
    {
        if(findString.length()==0)
            throw new NullPointerException("findString.length() must be greater than 0");
        
        if(stopPos<0)
            throw new IndexOutOfBoundsException("stopPos must be greater or equal to zero, stopPos = "+stopPos);
        
        if(stopPos>source.length())
            stopPos = source.length();
        
        if(startPos<0)
            throw new IndexOutOfBoundsException("startPos can`t be smaller than 0");
        
        if(startPos>=stopPos)
            throw new IndexOutOfBoundsException("startPos must be smaller than stopPos, startPos="+startPos+" stopPos="+stopPos);
        
        char[] replaceCharArray = replaceString.toCharArray();
        int replaceCharArrayLength = replaceString.length();
        
        
        //converteer de findstring naar array
        char[] findCharArray = findString.toCharArray();
        int findCharArrayLength =findCharArray.length;
        
        //copieer de stringbuffer naar string.
        char[] sourceCharArray = new char[source.length()];
        source.getChars(0,source.length(),sourceCharArray,0);
        
        //hierin komen alle startpos van find string te staan.
        ArrayList list = new ArrayList();
        
        //vul de list met alle startPosities posities
        startPos = indexOf(sourceCharArray,0,source.length(),findCharArray,0,findCharArrayLength,0);
        while(startPos>-1&&startPos<=stopPos)
        {
            list.add(new Integer(startPos));
            startPos = indexOf(sourceCharArray,0,source.length(),findCharArray,0,findCharArrayLength,startPos+findCharArrayLength);
        }
        
        
        //controleer of er iets gevonden is.
        if(list.size()==0)
            return;
        
        //bereken de nieuwe buffer lengte.
        int newBufferLengte = source.length()+list.size()*(replaceCharArrayLength-findCharArrayLength);
        
        //maak buffer aan met nieuwe lengte
        char[] destCharArray = new char[newBufferLengte];
        
        int listSize = list.size();
        int destCharIndex = 0;
        int sourceCharIndex = 0;
        for(int k=0;k<listSize;k++)
        {
            startPos = ((Integer)list.get(k)).intValue();
            
            int copyLengte = startPos - sourceCharIndex;
            
            System.arraycopy(sourceCharArray,sourceCharIndex,destCharArray, destCharIndex,copyLengte);
            
            sourceCharIndex = startPos +findCharArrayLength;
            
            destCharIndex = destCharIndex + copyLengte;
            
            System.arraycopy(replaceCharArray,0,destCharArray,destCharIndex,replaceCharArrayLength);
            
            destCharIndex = destCharIndex + replaceCharArrayLength;
        }
        
        System.arraycopy(sourceCharArray,sourceCharIndex,destCharArray,destCharIndex,sourceCharArray.length-sourceCharIndex);
        source.delete(0,source.length());
        source.append(destCharArray);
    }
    
        /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source   the characters being searched.
     *
     * @param   sourceOffset offset of the source string.
     *
     * @param   sourceCount  count of the source string.
     *
     * @param   target   the characters being searched for.
     *
     * @param   targetOffset offset of the target string.
     *
     * @param   targetCount  count of the target string.
     *
     * @param   fromIndex    the index to begin searching from.
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
                              char[] target, int targetOffset, int targetCount,
                              int fromIndex)
    {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        
        if (targetCount == 0) {
            return fromIndex;
        }
        
        char first  = target[targetOffset];
        
        //de huidige karakter positie
        int i = sourceOffset + fromIndex;
        
        //de maximale offset.
        int max = sourceOffset + (sourceCount - targetCount);
        
        startSearchForFirstChar:
        while (true) {
            /* Look for first character. */
            while (i <= max && source[i] != first) {
                i++;
            }
            
            if (i > max) {
                return -1;
            }
            
            /* Found first character, now look at the rest of v2 */
            int j = i + 1;
            int end = j + targetCount - 1;
            int k = targetOffset + 1;
            while (j < end) {
                if (source[j++] != target[k++]) {
                    i++;
                    /* Look for str's first char again. */
                    continue startSearchForFirstChar;
                }
            }
            return i - sourceOffset;    /* Found whole string. */
        }
    }
    
    public static void main(String[] args)
    {
        StringBuffer stringBuffer = new StringBuffer("peter");
        String zoekString = "e";
        replaceFast(stringBuffer,"e","aa",0,stringBuffer.length());
        System.out.println("result:");
        System.out.println(stringBuffer.toString());
    }
}

[mbravenboer]

In mijn oude test wordt het er niet echt sneller op:

code:

Resultaten bij een vervanging met zelfde lengte:
Alarmnummer:           585
mbravenboer:           297
regex:             1497
regex (met Pattern cache): 1226
regex (met Matcher cache): 1397

Resultaten bij een vervanging met 1 teken meer (en enkele voorkomens) :
Alarmnummer:           613
mbravenboer:           462
regex:             1426
regex (met Pattern cache): 1275
regex (met Matcher cache): 1190

Ikke ben nu dus duidelijk sneller .

[mbravenboer]

Omdat ik een beetje verbaasd was over de baggere performance in een Matcher ben ik eens in die code gedoken. Wat een zooi. De interne werking is wel leuk ontworpen, maar omdat die intern is, is dat IMHO absoluut niet relevant. StringBuffers wordt niet op de goede grootte ingesteld, Strings worden om de haverklap aangemaakt... zooi dus. Dit zou echt supersnel kunnen... Kijk maar eens in de source code.

[Alarmnummer]

Als je een stringbuffer hebt en je gaat er text aan toevoegen dan en de stringbuffer zijn interne array is niet groot genoeg om dat te kunnen herbergen dan word een copie van de array gemaakt (langzaam dus) en dan word toegevoegd. Als je veel gaat toevoegen dan word er dus steeds gecopieerd en dat hoopte ik hiermee te verhinderen. Ik snap ook niet dat het zo langzaam is, misschien dat het string copieren toch heel snel gaat. Weet je zeker dat je mijn 'Test' object ook hebt getest?

[mbravenboer]

Ik begrijp inderdaad wat je probeert te voorkomen.

Ik heb je laatste Test code genomen. De slechte prestatie kan natuurlijk door de test komen, maar uiteraard zou de oplossing het op alle punten beter moeten doen.

Je hebt ook best kan dat de mindere performance door de ArrayList wordt veroorzaakt?

[Alarmnummer]

yep... dat zou kunnen, alhoewel mij het vrij onwaarschijnlijkt lijkt (er gebeuren zoveel dingen dat zoiets bijna niet mee kan tellen). Maar kun je er anders een andere lijst structuur inzetten? Om mij part een array van max 100 ofzo.

[mbravenboer]

Ik heb even gekeken naar de performance:

De ArrayList aanmaken en de while loop erna = indexen
Alles daarna = vervangen

code:

Indexen Alarmnummer:     799
Vervangen Alarmnummer:     1107

De oorzaak lijkt mij dus wel voor een deel bij de ArrayList liggen, maar je moet denk ik ook niet verwachten mega-performance te krijgen als je alleen dat oplost...

[Alarmnummer]

Had verwacht door mijn minimaal gecopieer heel snel te zijn, maar dat valt vies tegen In ieder geval weer een hoop geleerd van de stringbuffer. Zou je misschien het integer object er ook kunnen uithalen en dan gewoon een array van int s maken met een int counter.. (lastige klant speaking )

[mbravenboer]

Zeker . Uiteindelijk was jouw recursieve StringBuffer oplossing dus wel het best: goede performance en weinig code (mijn code was een beetje teveel).

[.oisyn]

nou ik vond mijn 2e char-array oplossing anders ook wel elite

[mbravenboer]

OiSyN: nou ik vond mijn 2e char-array oplossing anders ook wel elite

Zekers .

[Alarmnummer]

heb je al een nieuwe benchmark klaar?

[mbravenboer]

Alarmnummer: heb je al een nieuwe benchmark klaar?

Nope nog niets met HTML gedaan. Als ik m'n compiler ff zat ben zal ik het even tussendoor doen...

[roelio]

En de topicstarter heeft na zijn topicpost niet eens meer gereageerd
't is op een strijd tussen javahova's en een java-wannabe-c++er uitgedraaid

[.oisyn]

euhm... ik een java-wannabe?

ja hoor, droom maar lekker verder (tip: ga eens in dat oude gamesdesign topic kijken, daar staat geloof ik nog een hoop java-geflame van mij, geheel onderbouwd )

[roelio]

ik droom niet, ik maak gewoon een grapje no offence

[.oisyn]

no offense

ONE TAKEN!
en ga nu je excuses aanbieden aan mij

[Zynth]

ik heb inderdaad niet gereageerd neej...
ik keek vanmiddag even of er al "een" antwoord zou zijn op mijn vraag; 87 replies! whaah
volgens mij heb ik hier een beetje een programmeerwedstrijd georganiseerd ofzow
in ieder geval zijn de antwoorden héél bruikbaar;
thnx 4 that!!

[Zynth]

ik gebruik nu de code die mbravenboer heeft gepost om 3:16,
maar volgens mij zitten er fouten in.

als ik namelijk de volgende string heb in messageField (is een tekstvak)

code:

dit is een<I><U><B><I></I></B></U></I></I> markup</U>

en ik laat er dan dit op los:

code:

String[] markuplist ={"<B>","</B>","<U>","</U>","<I>","</I>"};
String text = messageField.getText();
        for(int i=0;i<Array.getLength(markuplist);i++){
             text = MiscFunctions.replaceUltraSnel(text,markuplist[i],"");
        }
        messageField.setText(text);

dan vervangt hij niet correct:

code:

ouput:
dit is een<I></I> markup</U>

over het algemeen werkt de code goed,
maar als ik veeeeel verschillende tags tegen elkaar aanzet in de tekst, mist hij er een paar! (niet altijd de <I> hoor, ook anderen...)
de laatste pakt hij sowieso nooit...

[Alarmnummer]

heb je mijn Test object (laatste classe van mij) al gebruikt?

[Zynth]

Dit heb ik ervan gemaakt
(het makkelijkst is voor mij namelijk:

public static String replaceFast(String text,String zoek, String vervang){}.
dan is het het makkelijkst toepasbaar vanuit elke klasse.

code:

import java.util.*;

public class MiscFunctions{
 public MiscFunctions(){}


public static void replaceFast(String Source, String findString, String replaceString)
         {
        StringBuffer source = new StringBuffer(Source);
        int stopPos = source.length();
        int startPos = 0;


        if(findString.length()==0)
            throw new NullPointerException("findString.length() must be greater than 0");

        if(stopPos<0)
            throw new IndexOutOfBoundsException("stopPos must be greater or equal to zero, stopPos = "+stopPos);

        if(stopPos>source.length())
            stopPos = source.length();

        if(startPos<0)
            throw new IndexOutOfBoundsException("startPos can`t be smaller than 0");

        if(startPos>=stopPos)
            throw new IndexOutOfBoundsException("startPos must be smaller than stopPos, startPos="+startPos+" stopPos="+stopPos);

        char[] replaceCharArray = replaceString.toCharArray();
        int replaceCharArrayLength = replaceString.length();


        //converteer de findstring naar array
        char[] findCharArray = findString.toCharArray();
        int findCharArrayLength =findCharArray.length;
        
        //copieer de stringbuffer naar string.
        char[] sourceCharArray = new char[source.length()];
        source.getChars(0,source.length(),sourceCharArray,0);
        
        //hierin komen alle startpos van find string te staan.
        ArrayList list = new ArrayList();
        
        //vul de list met alle startPosities posities
        startPos = indexOf(sourceCharArray,0,source.length(),findCharArray,0,findCharArrayLength,0);
        while(startPos>-1&&startPos<=stopPos)
        {
            list.add(new Integer(startPos));
            startPos = indexOf(sourceCharArray,0,source.length(),findCharArray,0,findCharArrayLength,startPos+findCharArrayLength);
        }
        

        //controleer of er iets gevonden is.
        if(list.size()==0)
            return;
        
        //bereken de nieuwe buffer lengte.
        int newBufferLengte = source.length()+list.size()*(replaceCharArrayLength-findCharArrayLength);

        //maak buffer aan met nieuwe lengte
        char[] destCharArray = new char[newBufferLengte];

        int listSize = list.size();
        int destCharIndex = 0;
        int sourceCharIndex = 0;
        for(int k=0;k<listSize;k++)
        {
            startPos = ((Integer)list.get(k)).intValue();
            
            int copyLengte = startPos - sourceCharIndex;
            
            System.arraycopy(sourceCharArray,sourceCharIndex,destCharArray, destCharIndex,copyLengte);

            sourceCharIndex = startPos +findCharArrayLength;
            
            destCharIndex = destCharIndex + copyLengte;
            
            System.arraycopy(replaceCharArray,0,destCharArray,destCharIndex,replaceCharArrayLength);
            
            destCharIndex = destCharIndex + replaceCharArrayLength;
        }
        
        System.arraycopy(sourceCharArray,sourceCharIndex,destCharArray,destCharIndex,sourceCharArray.length-sourceCharIndex);
        source.delete(0,source.length());
        source.append(destCharArray);
    }

        /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source   the characters being searched.
     *
     * @param   sourceOffset offset of the source string.
     *
     * @param   sourceCount  count of the source string.
     *
     * @param   target   the characters being searched for.
     *
     * @param   targetOffset offset of the target string.
     *
     * @param   targetCount  count of the target string.
     *
     * @param   fromIndex    the index to begin searching from.
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
                              char[] target, int targetOffset, int targetCount,
                              int fromIndex)
    {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        
        if (targetCount == 0) {
            return fromIndex;
        }

        char first  = target[targetOffset];

        //de huidige karakter positie
        int i = sourceOffset + fromIndex;
        
        //de maximale offset.
        int max = sourceOffset + (sourceCount - targetCount);
        
        startSearchForFirstChar:
        while (true) {
            /* Look for first character. */
            while (i <= max && source[i] != first) {
                i++;
            }
            
            if (i > max) {
                return -1;
            }
            
            /* Found first character, now look at the rest of v2 */
            int j = i + 1;
            int end = j + targetCount - 1;
            int k = targetOffset + 1;
            while (j < end) {
                if (source[j++] != target[k++]) {
                    i++;
                    /* Look for str's first char again. */
                    continue startSearchForFirstChar;
                }
            }
            return i - sourceOffset;    /* Found whole string. */
        }
    }
}

het moet dus wel een String returnen, en geen void zijn.
Dat is uitermate lstig als je van buiten de klasse zo'n vervang-functie wil aanroepen.

[Alarmnummer]

Dit moet je er ook niet van maken grapjurk string zijn imutable (dus overanderbaar) aangezien bij de .. replaceFast(van mij dus) geen return type heeft kun je nu ook onmogelijk iets veranderen Je moet het return type dan maar even een string van maken en dan een String terug sturen op basis van die char[] source. Dit kan geloof ik wel met return new String(source); En dan ben je klaar

[Alarmnummer]

het moet dus wel een String returnen, en geen void zijn.
Dat is uitermate lstig als je van buiten de klasse zo'n vervang-functie wil aanroepen.

Dat is het van binnen ook hoor

[Zynth]

ehm...
..dit newbietje weet niet precies waar hij dat:
return new String(source);
moet neerzetten

als ik het namelijk bij dat if-statement zet:

code:

    //controleer of er iets gevonden is.
        if(list.size()==0)
            return new String(source);

dan zegt de compiler dat er geen waarde wordt gereturnd.
(omdat het binnen een if-lus zit, weet java nooit zeker of hij ooit wel iets returned)

---EDIT----
I got it!
in de volgende post staatie!
(btw, deze werkt perfect

[Zynth]

het uiteindelijke resultaat

code:

/**
 * Test.java
 *
 * @author Created by Peter Veentjer
 */

public static String replaceFast(String Source, String findString, String replaceString)
         {
        StringBuffer source = new StringBuffer(Source);
        int stopPos = source.length();
        int startPos = 0;


        if(findString.length()==0)
            throw new NullPointerException("findString.length() must be greater than 0");

        if(stopPos<0)
            throw new IndexOutOfBoundsException("stopPos must be greater or equal to zero, stopPos = "+stopPos);

        if(stopPos>source.length())
            stopPos = source.length();

        if(startPos<0)
            throw new IndexOutOfBoundsException("startPos can`t be smaller than 0");

        if(startPos>=stopPos)
            throw new IndexOutOfBoundsException("startPos must be smaller than stopPos, startPos="+startPos+" stopPos="+stopPos);

        char[] replaceCharArray = replaceString.toCharArray();
        int replaceCharArrayLength = replaceString.length();


        //converteer de findstring naar array
        char[] findCharArray = findString.toCharArray();
        int findCharArrayLength =findCharArray.length;
        
        //copieer de stringbuffer naar string.
        char[] sourceCharArray = new char[source.length()];
        source.getChars(0,source.length(),sourceCharArray,0);

        //hierin komen alle startpos van find string te staan.
        ArrayList list = new ArrayList();

        //vul de list met alle startPosities posities
        startPos = indexOf(sourceCharArray,0,source.length(),findCharArray,0,findCharArrayLength,0);
        while(startPos>-1&&startPos<=stopPos)
        {
            list.add(new Integer(startPos));
            startPos = indexOf(sourceCharArray,0,source.length(),findCharArray,0,findCharArrayLength,startPos+findCharArrayLength);
        }


        //controleer of er iets gevonden is.
        if(list.size()==0)
            return Source;


        //bereken de nieuwe buffer lengte.
        int newBufferLengte = source.length()+list.size()*(replaceCharArrayLength-findCharArrayLength);

        //maak buffer aan met nieuwe lengte
        char[] destCharArray = new char[newBufferLengte];

        int listSize = list.size();
        int destCharIndex = 0;
        int sourceCharIndex = 0;
        for(int k=0;k<listSize;k++)
        {
            startPos = ((Integer)list.get(k)).intValue();

            int copyLengte = startPos - sourceCharIndex;

            System.arraycopy(sourceCharArray,sourceCharIndex,destCharArray, destCharIndex,copyLengte);

            sourceCharIndex = startPos +findCharArrayLength;

            destCharIndex = destCharIndex + copyLengte;

            System.arraycopy(replaceCharArray,0,destCharArray,destCharIndex,replaceCharArrayLength);

            destCharIndex = destCharIndex + replaceCharArrayLength;
        }

        System.arraycopy(sourceCharArray,sourceCharIndex,destCharArray,destCharIndex,sourceCharArray.length-sourceCharIndex);
        source.delete(0,source.length());
        source.append(destCharArray);
        return new String(source); 

    }

        /**
     * Code shared by String and StringBuffer to do searches. The
     * source is the character array being searched, and the target
     * is the string being searched for.
     *
     * @param   source   the characters being searched.
     *
     * @param   sourceOffset offset of the source string.
     *
     * @param   sourceCount  count of the source string.
     *
     * @param   target   the characters being searched for.
     *
     * @param   targetOffset offset of the target string.
     *
     * @param   targetCount  count of the target string.
     *
     * @param   fromIndex    the index to begin searching from.
     */
    static int indexOf(char[] source, int sourceOffset, int sourceCount,
                              char[] target, int targetOffset, int targetCount,
                              int fromIndex)
    {
        if (fromIndex >= sourceCount) {
            return (targetCount == 0 ? sourceCount : -1);
        }
        
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        
        if (targetCount == 0) {
            return fromIndex;
        }

        char first  = target[targetOffset];

        //de huidige karakter positie
        int i = sourceOffset + fromIndex;
        
        //de maximale offset.
        int max = sourceOffset + (sourceCount - targetCount);
        
        startSearchForFirstChar:
        while (true) {
            /* Look for first character. */
            while (i <= max && source[i] != first) {
                i++;
            }
            
            if (i > max) {
                return -1;
            }
            
            /* Found first character, now look at the rest of v2 */
            int j = i + 1;
            int end = j + targetCount - 1;
            int k = targetOffset + 1;
            while (j < end) {
                if (source[j++] != target[k++]) {
                    i++;
                    /* Look for str's first char again. */
                    continue startSearchForFirstChar;
                }
            }
            return i - sourceOffset;    /* Found whole string. */
        }
    }

hij werkt snel zat voor mijn doeleinde in ieder geval
thnx!!

btw, deze zouden ze standaard in de String library moeten opnemen vind ik. is een errug handig methodetje