[Java] Explode()

[Verwijderd]

ik ben aan het beginnen met java (mbv een boek ), ik probeer op het moment mijn eigen overhoorprogramma te maken. nou verwacht ik dat ik vaak een explode zal gebruiken zoals die in PHP is, maar ik krijg nu wat foutmeldingen:

Java:

public class Tools {
    static public String replace(String fS, String fF, String fR) //deze functie gaat het niet om
    {
        if (fS == null) return fS;
        if (fF == null) return fS;
        if (fR == null) fR = "";
        
        int index01 = fS.indexOf(fF);
        while (index01 != -1)
        {
            fS = fS.substring(0,index01) + fR + fS.substring(index01+fF.length());
            index01 += fR.length();
            index01 = fS.indexOf( fF, index01 );
        }
        return fS;
    }
    
    static public String[] explode(String fSplitter, String fString)
    {
        String[] result;
        
        int index = fString.indexOf(fSplitter), lastStop = 0, fSplitterLength = fSplitter.length();
        do
        {
            result[result.length] = fString.substring(lastStop, (lastStop + fSplitterLength));
            lastStop = lastStop + fSplitterLength;
            index = (new String(fString.substring(index, (fString.length()-1)))).indexOf(fSplitter);
        }
        while (index != -1);
        
        return result;
    }
}

foutmelding:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
The local variable result may not have been initialized
The local variable result may not have been initialized
The local variable result may not have been initialized

at Tools.explode(Tools.java:26)
at Dictionary.<init>(Dictionary.java:23)
at Program.main(Program.java:6)

nou werken die dictionary en program klassen prima, dus daar zal het probleem niet zitten.
maar wat bedoelen ze met die foutmelding en hoe los ik die op?

[ Voor 32% gewijzigd door Verwijderd op 10-02-2006 21:19 ]

[NMe]

Zo op het eerste gezicht: je declareert een arary van strings, maar je initialiseert ze niet. Ik neem dus aan, als niet-Java-kenner, dat je nog een constructor aan moet roepen.

[MNeMoNiCS]

Indien de do-loop niet wordt uitgevoerd is er nog geen waarde aan result toegekend.

[ Voor 28% gewijzigd door MNeMoNiCS op 10-02-2006 21:21 ]

[Varienaja]

Je zit nu de split() methode van het String-object na te bouwen.

Gewoon dit gebruiken dus:

code:

String[] lijstje = "a,b,c,d,e,f".split(",");

Ook voor replace-functies is in Java voorzien:

code:

String aap = "noot".replace("noot","aap");

[ Voor 32% gewijzigd door Varienaja op 10-02-2006 21:22 ]

[Verwijderd]

-NMe- schreef op vrijdag 10 februari 2006 @ 21:12:
Zo op het eerste gezicht: je declareert een arary van strings, maar je initialiseert ze niet. Ik neem dus aan, als niet-Java-kenner, dat je nog een constructor aan moet roepen.

maar in de do_while loop wordt er toch minimaal 1 keer een nieuwe input uitgevoerd? of herkent java dat niet?

ik zal het proberen met een minder mooie oplossing

[Verwijderd]

MNeMoNiCS schreef op vrijdag 10 februari 2006 @ 21:20:
Indien de do-loop niet wordt uitgevoerd is er nog geen waarde aan result toegekend.

ah! ik zie nu dat length de fout geeft. als er geen enkele input is kan die natuurlijk nooit een waarde hebben

Varienaja schreef op vrijdag 10 februari 2006 @ 21:21:
Je zit nu de split() methode van het String-object na te bouwen.

Gewoon dit gebruiken dus:

code:

String[] lijstje = "a,b,c,d,e,f".split(",");

hihi.
domme ik

[flowerp]

Verwijderd schreef op vrijdag 10 februari 2006 @ 21:08:
ik ben aan het beginnen met java (mbv een boek ), ik probeer op het moment mijn eigen overhoorprogramma te maken. nou verwacht ik dat ik vaak een explode zal gebruiken zoals die in PHP is, maar ik krijg nu wat foutmeldingen:

Java:

    
    String[] result;        
    int index = fString.indexOf(fSplitter), lastStop = 0, fSplitterLength = fSplitter.length();
    do {
        result[result.length] = fString.substring(lastStop, (lastStop + fSplitterLength));

Los van het feit dat dit een overbodige functie is (zoals al gezegd ), zit de fout hem erin dat je geen array aanmaakt. String[[] result zelf is geen array maar alleen een pointer (reference) erna. Als je geen daarwerkelijk array aanmaakt wijst deze helemaal nergens heen.

Voor locale variabelen is het nog erger, want behalve dat ie nergens naar wijst is ie ook nog eens niet geinitialiseert op 'nix'. Je krijgt dus nu een compiler fout voor het niet initialiseren, maar wel uitlezen. Of de loop nu 1 of 1000 maal wordt doorlopen is hier irrelavant. Je alloceert nergens een array.

Dit doe je eenvoudig door:

Java:

String[] result = new String[someSize];

Als result een instance variable was geweest (dwz, gedeclareert buiten een method body) dan zou ie WEL geinitialiseert zijn, maar op null. Je had dan echter een null pointer exception gekregen ipv een compiler fout.

[Verwijderd]

flowerp schreef op vrijdag 10 februari 2006 @ 22:43:
[...]


Los van het feit dat dit een overbodige functie is (zoals al gezegd ), zit de fout hem erin dat je geen array aanmaakt. String[[] result zelf is geen array maar alleen een pointer (reference) erna. Als je geen daarwerkelijk array aanmaakt wijst deze helemaal nergens heen.

Voor locale variabelen is het nog erger, want behalve dat ie nergens naar wijst is ie ook nog eens niet geinitialiseert op 'nix'. Je krijgt dus nu een compiler fout voor het niet initialiseren, maar wel uitlezen. Of de loop nu 1 of 1000 maal wordt doorlopen is hier irrelavant. Je alloceert nergens een array.

Dit doe je eenvoudig door:

Java:

String[] result = new String[someSize];

Als result een instance variable was geweest (dwz, gedeclareert buiten een method body) dan zou ie WEL geinitialiseert zijn, maar op null. Je had dan echter een null pointer exception gekregen ipv een compiler fout.

en als ik nou een theoretisch oneindig lange (of iig onbepaald lange) array wil maken? new String[] geeft een foutmelding hiero.

[BestTested!]

Verwijderd schreef op zaterdag 11 februari 2006 @ 10:28:
[...]

en als ik nou een theoretisch oneindig lange (of iig onbepaald lange) array wil maken? new String[] geeft een foutmelding hiero.

Dan zal je gebruik moeten maken van een of andere functie die je array copieert naar een grotere array als hij vol raakt (Tip: System.arrayCopy)
Of je maakt gebruik van een zogenaamde Vector (java.util.Vector) die bevat een dergelijke functionaliteit al.

[flowerp]

Verwijderd schreef op zaterdag 11 februari 2006 @ 10:28:
[...]

en als ik nou een theoretisch oneindig lange (of iig onbepaald lange) array wil maken? new String[] geeft een foutmelding hiero.

Je kunt een array niet alloceren zonder een size op te geven. String[] myArray = new String[]; gaat dus niet werken. Er zijn wel een groot aantal collection types in Java die precies doen wat jij wilt. Vector wordt hierboven al genoemd, maar dit is eigenlijk een oud type die een beetje retro-fitted is voor de nieuwe wereld.

Het standaard type om in de situatie te gebruiken is ArrayList. ->

ArrayList<String> myArray = new ArrayList<String>();

Als je wilt kun je de initiele grote opgeven:

ArrayList<String> myArray = new ArrayList<String>(100);

Maar het array groeit automatisch mee als het groter wordt dan de opgegeven grote. Wegens stugheid van de Java desingers mag je hier helaas niet de vierkante haken gebruiken, maar doe je het met method cals:

myArray.put( "test" ); // of myArray.put( 0, "test" );
String test = myArray.get(0);

[ Voor 4% gewijzigd door flowerp op 11-02-2006 11:17 ]

[Daos]

In plaats van de explode zelf maken kan je ook de standaard Java dingen gebruiken.

Tegenwoordig gaat dat met (String-object).Split(..). Je hebt hierbij een patroontje nodig.

Je kan ook de java.util.Stringtokenizer gebruiken. Dit ding werkt veel makkelijker, maar Sun wil niet dat je deze gebruikt in nieuwe code.

[Robtimus]

flowerp schreef op zaterdag 11 februari 2006 @ 11:15:
Het standaard type om in de situatie te gebruiken is ArrayList. ->

ArrayList<String> myArray = new ArrayList<String>();

Als je wilt kun je de initiele grote opgeven:

ArrayList<String> myArray = new ArrayList<String>(100);

* Robtimus slaps flowerp
Doe dat nooit meer, ok? Declareren als implementatie als de interface genoeg is...


Dus:

Java:

List<String> myList = new ArrayList<String>();
// fill list
return myList.toArray();

Die laatste regel is alleen nodig als je echt een array terug wilt hebben. Anders kun je gewoon de List returnen.


Oh en het is myList.set(0, "test") om element 0 te veranderen in "test". Voor toevoegen gebruik je myList.add("test") om aan het einde toe te voegen of myList.add(5, "test") om op een specifieke index toe te voegen.
put is van Maps.

[ Voor 20% gewijzigd door Robtimus op 11-02-2006 19:06 ]

[flowerp]

IceManX schreef op zaterdag 11 februari 2006 @ 19:04:
[...]
* flowerp slaps flowerp
Doe dat nooit meer, ok? Declareren als implementatie als de interface genoeg is...

*lach* Ja, daar heb je helemaal gelijk in. Ik doe dit eigenlijk veels te weinig in mijn code, maar het is wel beter ja.

put is van Maps.

Nu gebruik ik de ArrayList (List ) zo'n 100x per dag en schrijf ik het nog verkeerd op hier.

Wat ik hierboven ook al onduidelijk uitlegde is dat je add met een index erbij niet zomaar kan gebruiken om elementen toe te voegen maar eigenlijk alleen om elementen te veranderen. Zelfs als je new ArrayList<type>(X) , X > 0 gebruikt, dan is de lengte van de ArrayList nog niet X maar alleen z'n capaciteit.

De oude Vector had een setSize function waarna je daarna wel de index vorm kon gebruiken. Dit is handig als je elementen random binnenkrijgt en op nummer in een array wilt stoppen. Met de ArrayList moet je dan eerst een loopje met add(null) doorlopen.

[Verwijderd]

De oude Vector had een setSize function waarna je daarna wel de index vorm kon gebruiken. Dit is handig als je elementen random binnenkrijgt en op nummer in een array wilt stoppen. Met de ArrayList moet je dan eerst een loopje met add(null) doorlopen.

Ik denk dat je beter een Map gebruikt als je key van betekenis is en niet opvolgend is. Anders kan je met een enorm groot array uitkomen in je ArrayList dat maar hier en daar opgevuld is ipv een kleiner array op hashcode

[flowerp]

Verwijderd schreef op zondag 12 februari 2006 @ 12:12:
[...]

Ik denk dat je beter een Map gebruikt als je key van betekenis is en niet opvolgend is. Anders kan je met een enorm groot array uitkomen in je ArrayList dat maar hier en daar opgevuld is ipv een kleiner array op hashcode

Agreed. Echter de 'key' was wel degelijk opvolgend; het ging in mijn geval om de diepte van een walk in een tree. Die levels van de tree kwamen random binnen, maar waren wel duidelijk opvolgend en de maximale diepte was van te voren bekend.

Een beetje offtopic hier, maar je kunt natuurlijk inderdaad ook wel een Map gebruiken, waarbij je dan na het ding gevuld te hebben de keys sorteerd en copieert naar een List.

[momania]

flowerp schreef op zaterdag 11 februari 2006 @ 19:36:
[...]
De oude Vector had een setSize function waarna je daarna wel de index vorm kon gebruiken. Dit is handig als je elementen random binnenkrijgt en op nummer in een array wilt stoppen. Met de ArrayList moet je dan eerst een loopje met add(null) doorlopen.

uuuhmm: http://java.sun.com/j2se/...yList.html#ArrayList(int)

Dat kan in het collection framework ook allemaal gewoon nog hoor Niks geen loopjes met add(null) voor nodig

[Kama]

<mierenneukmodus>
Je functie heeft multiple exit points... niet echt netjes... zorg voor 1x "return" in je functies, anders zoek je je nog es een ongeluk naar de plekken... Vul liever een variable en return die op 't eind.
</mierrenneukmodus>

[ Voor 48% gewijzigd door Kama op 12-02-2006 23:41 ]

[kenneth]

Kama, waarom niet? Zoals Fowler het aangeeft kan het juist duidelijker zijn dan vele malen nesten.

[Verwijderd]

IceManX schreef op zaterdag 11 februari 2006 @ 19:04:
/me slaps flowerp
Doe dat nooit meer, ok? Declareren als implementatie als de interface genoeg is...

Als je het over een return type van een methode had gehad gaf ik je misschien gelijk. In dit geval logischerwijs niet, simpelweg omdat je het niet als regel kunt stellen. Er is geen enkele nuttige reden te verzinnen om direct te gaan generaliseren. Ik vraag me af waarom je dan in dit geval kiest voor List ipv bijvoorbeeld Collection?

Initieel juist altijd het concrete type declareren en pas gaan generaliseren als dat daadwerkelijk nodig is (method scope).

[Verwijderd]

Ik mis toch ook met mijn weinige kennis van java, een constructor
Of hoe word dit hier toegepast?

[Verwijderd]

Verwijderd schreef op maandag 13 februari 2006 @ 09:36:
Ik mis toch ook met mijn weinige kennis van java, een constructor
Of hoe word dit hier toegepast?

Het niet definieren van een constructor impliceert een default constructor (constructor zonder argumenten).

[Verwijderd]

Verwijderd schreef op maandag 13 februari 2006 @ 09:43:
[...]

Het niet definieren van een constructor impliceert een default constructor (constructor zonder argumenten).

Thx voor de uitleg, waar wat geleerd