[JAVA] array met dynamische lengte

[Verwijderd]

Ik heb in de JavaDocs en in het boek van Deitel & Deitel gezocht maar ik kon er niets over vinden, kan ik een dergelijke constructie.

Ik heb de volgende functie gemaakt:

code:

private void splitUp(String input, String output[], String arg)
//
//   pre:   - input bevat een string
//      - output is gedeclareerd als een array van string
//      - arg bevat de tekens die gebruikt worden voor de 
//      scheiding van de input string
//   post:  - output bevat de inhoud van de string input 
//      in elementen die gescheiden zijn middels de tekens
//      die in arg waren meegegeven
//      
//
{
   StringTokenizer tokens;
   int counter;
        
   tokens = new StringTokenizer(input,arg);
   counter = 0;
   
   while ( tokens.hasMoreTokens() and counter < output.length() )
   {
    output[counter] = tokens.nextToken();
    counter++;
   }
}

Het probleem is nu dat de lengte van het array output[] vast staat, ik wil nu hetzelfde bereiken als in deze functie maar dat ik dan op de een of andere manier een array terugkrijg die net zo lang is als het aantal elementen waarin ik hem ga scheiden

Hoe kan ik dit zo eenvoudig mogelijk voor elkaar krijgen?

[Verwijderd]

Met een ArrayList is waarschijnlijk de makkelijkste oplossing:

code:

public Object[] split(String input, String arg)
{
   StringTokenizer tokens;
   java.util.ArrayList list = new java.util.ArrayList();        
   tokens = new StringTokenizer(input,arg);
   
   while ( tokens.hasMoreTokens() )
   {
    list.add(tokens.nextToken());
   }

   return list.toArray();
}

[edit]
typos, en ik snap niet waarom je zo'n wazige (c-achtige?) constructie gebruik om de output van je functie in een van te voren gealloceerde array te stoppen. Misschien heb je het nodig, maar ik denk dat de bovenstaande functie meer is wat je zoekt.

[Canard]

ik zou trouwens de array output teruggeven als return-waarde en niet als parameter...

Dus:

code:

private String[] splitUp(String input, String arg)
{
   ...
}

Het aantal elementen kun je van te voren ophalen met countTokens() van je StringTokenizer, hiermee kun je dan je array dynamisch declareren...

simpeler als de oplossing hierboven...

[Canard]

Let op: Je retourneert een array van Object, moet je dus nog casten....

code:

output[counter] = tokens.nextToken();

wordt dan:

code:

output[counter] = (String)tokens.nextToken();

[GiLuX]

eerst een vector maken en dan vullen en als klaar naar array?

[Canard]

vooruit dan

code:

private String[] splitUp(String input, String arg)
{
   StringTokenizer tokens = new StringTokenizer(input,arg);
   int counter = 0;
   String output[] = new String[tokens.countTokens()];
         
   while (tokens.hasMoreTokens())
   {
    output[counter] = (String)tokens.nextToken();
    counter++;
   }

   return output;
}

[Verwijderd]

die c-achtige constructie komt omdat ik meer ervaring in c dan in java heb en dan ben je altijd geneigd om in c-stijl te programmeren.

[Bobco]

Op vrijdag 19 juli 2002 10:39 schreef KlukKluk het volgende:
die c-achtige constructie komt omdat ik meer ervaring in c dan in java heb en dan ben je altijd geneigd om in c-stijl te programmeren.

Een eerste liefde vergeet je nooit Maar het is wel handig om eens wat JavaDoc door te lezen over de interfaces en classes in java.util. Daar zitten namelijk hele handige dingetjes tussen en je hoeft je al snel niet meer druk te maken over dit soort low-level achtige activiteiten.