dannyboy
wzl-lid
Sinds 31/5/2005
T: 108
R: 883
|
15/11/2008 -
22:02u
| Quote
|
Hoi hoi,
ik programeer graag in java en wil vragen welk van de 2 principes hier onder ik het best kan gebruiken.
String test;
while (blabla) {
test = "telkensietsanders";
doeIetsMetTest(test);
}
of
while (blabla) {
String test = "telkensietsanders";
doeIetsMetTest(test);
}
met andere woorden: is het beter om voor een loop de variabele aan te maken en die dan te herbruiken tijdens elke loop, of is het beter om in de loop gewoon telkens de variabele aan te maken (of zijn de 2 voorbeelden hetzelfde). Ik bedoel beter in termen van sneller, minder belastend voor geheugen, ...
|
Quagmire
wzl-lid
Sinds 18/11/2003
T:62 -
R:1458
|
16/11/2008 -
1:11u
| Quote
|
De eerste versie is in principe beter denk ik....
Alhoewel het zeer de vraag is of het in de praktijk iets uitmaakt aangezien ge (denk ik) toch wel moogt veronderstellen dat moderne compilers zelf zo'n dingen detecteren en optimaliseren....
Laatst aangepast door
Quagmire
op 16/11/2008 1:12:04u
(1x aangepast)
|
lordfragger
[mod], gewoon [mod]
Sinds 28/6/2004
T:15 -
R:3135
|
16/11/2008 -
15:50u
| Quote
|
|
Het heeft alletwee eigenlijk een andere werkign ook eh. In het eerste geval is uwe variabele buiten uwe loop beschikbaar, in het 2de geval alleen binnen de loop. Het hangt er dus in feite vanaf waarvoor ge em nodig hebt.
|
dannyboy
wzl-lid
Sinds 31/5/2005
T:108 -
R:883
|
16/11/2008 -
21:41u
| Quote
|
lordfragger schreef:
Het heeft alletwee eigenlijk een andere werkign ook eh. In het eerste geval is uwe variabele buiten uwe loop beschikbaar, in het 2de geval alleen binnen de loop. Het hangt er dus in feite vanaf waarvoor ge em nodig hebt.
dat weet ik, maar stel dat ik alleen binnen de loop de variabele nodig heb. Ik zou dan de string ook rechtstreeks als argument meegeven aan de method, zoals hier:
while (blabla) {
doeIetsMetTest("telkensietsanders" ;
}
maar als het dan een tijdrovend proces is om aan die string te geraken en ik deze meerdere malen nodig heb binnen de loop. Welk van deze 2 kan ik dan best gebruiken
String test;
while (blabla) {
test = klasse.ditDuurtHeelLang();
doeIetsMetTest(test);
doeNogIetsMetTest(test);
doeEenDerdeDingMetTest(test);
}
of
while (blabla) {
String test = klasse.ditDuurtHeelLang();
doeIetsMetTest(test);
doeNogIetsMetTest(test);
doeEenDerdeDingMetTest(test);
}
Ik denk niet dat er veel verschil is tussen deze 2, maar ik ben een perfectionist en wil de snelste en/of minst belastende manier gebruiken
|
ka0z
wzl-lid
Sinds 30/9/2004
T:8 -
R:60
|
17/11/2008 -
0:39u
| Quote
|
dannyboy schreef:
lordfragger schreef:
Het heeft alletwee eigenlijk een andere werkign ook eh. In het eerste geval is uwe variabele buiten uwe loop beschikbaar, in het 2de geval alleen binnen de loop. Het hangt er dus in feite vanaf waarvoor ge em nodig hebt.
dat weet ik, maar stel dat ik alleen binnen de loop de variabele nodig heb. Ik zou dan de string ook rechtstreeks als argument meegeven aan de method, zoals hier:
while (blabla) {
doeIetsMetTest("telkensietsanders";
}
maar als het dan een tijdrovend proces is om aan die string te geraken en ik deze meerdere malen nodig heb binnen de loop. Welk van deze 2 kan ik dan best gebruiken
String test;
while (blabla) {
test = klasse.ditDuurtHeelLang();
doeIetsMetTest(test);
doeNogIetsMetTest(test);
doeEenDerdeDingMetTest(test);
}
of
while (blabla) {
String test = klasse.ditDuurtHeelLang();
doeIetsMetTest(test);
doeNogIetsMetTest(test);
doeEenDerdeDingMetTest(test);
}
Ik denk niet dat er veel verschil is tussen deze 2, maar ik ben een perfectionist en wil de snelste en/of minst belastende manier gebruiken
ben geen specialist maar ik gok da et 1ste beter is (string test; buiten loop)
|
m0rPh3uS
WZL-lid
Sinds 13/1/2003
T:1 -
R:38
|
17/11/2008 -
13:40u
| Quote
|
Verschil is dat in versie 2 van je code telkens opnieuw een stukje geheugen wordt gealloceerd om de waarde van 'String test' in bij te houden. Bij versie 1 is dat niet zo; je alloceert één keer een stukje geheugen (bij de declaratie van de variabele) en gaat telkens een andere waarde in deze plaats steken. Vergeet ook niet dat 'String' een speciaal datatype is dat men 'immutable' noemt (meer info).
Maar ik denk dat het op zich niet veel gaat uitmaken als je een lus 10, 100 of zelfs 1000 keer uitvoert. 't Is pas bij een veelvuldig gebruik dat dit iets gaat uitmaken.
Hope this helps.
|
dannyboy
wzl-lid
Sinds 31/5/2005
T:108 -
R:883
|
17/11/2008 -
20:04u
| Quote
|
m0rPh3uS schreef:
Verschil is dat in versie 2 van je code telkens opnieuw een stukje geheugen wordt gealloceerd om de waarde van 'String test' in bij te houden. Bij versie 1 is dat niet zo; je alloceert één keer een stukje geheugen (bij de declaratie van de variabele) en gaat telkens een andere waarde in deze plaats steken. Vergeet ook niet dat 'String' een speciaal datatype is dat men 'immutable' noemt (meer info).
Maar ik denk dat het op zich niet veel gaat uitmaken als je een lus 10, 100 of zelfs 1000 keer uitvoert. 't Is pas bij een veelvuldig gebruik dat dit iets gaat uitmaken.
Hope this helps.
Ok, dit help al een beetje, maar persoonlijk vind ik het belachelijk en onoverzichtig om een object, dat ik alleen in de lus ga gebruiken, voor de loop ga declareren. Zorgt java er niet automatisch voor dat het stukje gealloceerd geheugen terug vrijgegeven wordt, als ik in de volgende doorloop van de lus terug een string aanmaak met dezelfde naam als de vorige keer? of moet ik effectief zeggen test = null; op het einde van elke doorloop van de lus? Of is dit zelfs niet genoeg om het stukje geheugen terug vrij te geven?
Laatst aangepast door
dannyboy
op 17/11/2008 20:06:02u
(1x aangepast)
|
Quagmire
wzl-lid
Sinds 18/11/2003
T:62 -
R:1458
|
17/11/2008 -
20:29u
| Quote
|
of moet ik effectief zeggen test = null; op het einde van elke doorloop van de lus? Of is dit zelfs niet genoeg om het stukje geheugen terug vrij te geven?
Als ge uw variabele declareert binnen de lus heeft het sowieso geen zin om die op null te zetten omdat uwe stack dan toch "ge-popped" wordt, dus wat ge daarvoor zelf nog doet met die variabele zal niet veel uitmaken....
Sowieso, als gij een variabele op "null" instelt dan wordt het geheugen daarom niet per definitie vrijgegeven... Dit gebeurt pas wanneer de garbage collector in gang schiet en dat is iets waar gij als programmeur in de regel weinig of geen controle over hebt aangezien de hele bedoeling van dat systeem is dat gij u niks meer moet aantrekken van het vrijgeven van geheugen....
Ge kunt in principe wel zelf ne collect forceren, maar dat kost meer resources dan ge daar ooit mee gaat uitsparen....
En zoals ik eerder al zei..... volgens mij gaat de java compiler echt wel zelf de optimalisatie doorvoeren om uw variabele buiten de lus te brengen bij het compileren.
|
dannyboy
wzl-lid
Sinds 31/5/2005
T:108 -
R:883
|
17/11/2008 -
20:38u
| Quote
|
Quagmire schreef:
of moet ik effectief zeggen test = null; op het einde van elke doorloop van de lus? Of is dit zelfs niet genoeg om het stukje geheugen terug vrij te geven?
Als ge uw variabele declareert binnen de lus heeft het sowieso geen zin om die op null te zetten omdat uwe stack dan toch "ge-popped" wordt, dus wat ge daarvoor zelf nog doet met die variabele zal niet veel uitmaken....
Sowieso, als gij een variabele op "null" instelt dan wordt het geheugen daarom niet per definitie vrijgegeven... Dit gebeurt pas wanneer de garbage collector in gang schiet en dat is iets waar gij als programmeur in de regel weinig of geen controle over hebt aangezien de hele bedoeling van dat systeem is dat gij u niks meer moet aantrekken van het vrijgeven van geheugen....
Ge kunt in principe wel zelf ne collect forceren, maar dat kost meer resources dan ge daar ooit mee gaat uitsparen....
En zoals ik eerder al zei..... volgens mij gaat de java compiler echt wel zelf de optimalisatie doorvoeren om uw variabele buiten de lus te brengen bij het compileren.
Dit was hulpvol, bedankt  Ik ga nog wel kijken of er nog een second opinion hier wordt gecomment. Niks persoonlijk, gewoon verificatie van het door u gestelde principe.
|
Quagmire
wzl-lid
Sinds 18/11/2003
T:62 -
R:1458
|
17/11/2008 -
23:14u
| Quote
|
Niks persoonlijk, gewoon verificatie van het door u gestelde principe.
mja..... ik ben ook eens benieuwd of iemand anders kan bevestigen wat ik er allemaal uitflap 
|
Zubzub
wzl-lid
Sinds 30/7/2005
T:2 -
R:176
|
18/11/2008 -
1:22u
| Quote
|
m0rPh3uS schreef:
Verschil is dat in versie 2 van je code telkens opnieuw een stukje geheugen wordt gealloceerd om de waarde van 'String test' in bij te houden. Bij versie 1 is dat niet zo; je alloceert één keer een stukje geheugen (bij de declaratie van de variabele) en gaat telkens een andere waarde in deze plaats steken. Vergeet ook niet dat 'String' een speciaal datatype is dat men 'immutable' noemt (meer info).
Maar ik denk dat het op zich niet veel gaat uitmaken als je een lus 10, 100 of zelfs 1000 keer uitvoert. 't Is pas bij een veelvuldig gebruik dat dit iets gaat uitmaken.
Hope this helps.
Ja en nee
eigenlijk zijn beide voorbeelden hetzelfde qua performance ik zou dus persoonlijk voor het 2de gaan (variabelen die alleen in de lus nodig zijn worden alleen in de lus gedeclareerd). Wat er eigenlijk gebeurt is dit:
String test alloceert een string pointer met waarde null. in de lus wordt deze pointer telkens "opgevuld" met een waarde en behoud de string test de laatste waarde die er aan gegeven is na de loop. Maw je moet expliciet test = null zette opdat de garbage collecter hem zou kunnen opruimen nadat de lus is beeindigd.
Bij het tweede wordt er telkens een nieuw pointer met waarde "telkensietsanders" aangemaakt maar wordt deze pointer inc waarde ook telkens weer verwijderd. Een loop van een lus wordt immers uitgevoerd in een apart stuk geheugen (stack) en telkens gereset bij het begin van een nieuw lus.
Ik zou dus persoonlijk voor het tweede gaan.
Laatst aangepast door
Zubzub
op 18/11/2008 1:23:40u
(2x aangepast)
|
dannyboy
wzl-lid
Sinds 31/5/2005
T:108 -
R:883
|
18/11/2008 -
8:58u
| Quote
|
Zubzub schreef:
m0rPh3uS schreef:
Verschil is dat in versie 2 van je code telkens opnieuw een stukje geheugen wordt gealloceerd om de waarde van 'String test' in bij te houden. Bij versie 1 is dat niet zo; je alloceert één keer een stukje geheugen (bij de declaratie van de variabele) en gaat telkens een andere waarde in deze plaats steken. Vergeet ook niet dat 'String' een speciaal datatype is dat men 'immutable' noemt (meer info).
Maar ik denk dat het op zich niet veel gaat uitmaken als je een lus 10, 100 of zelfs 1000 keer uitvoert. 't Is pas bij een veelvuldig gebruik dat dit iets gaat uitmaken.
Hope this helps.
Ja en nee
eigenlijk zijn beide voorbeelden hetzelfde qua performance ik zou dus persoonlijk voor het 2de gaan (variabelen die alleen in de lus nodig zijn worden alleen in de lus gedeclareerd). Wat er eigenlijk gebeurt is dit:
String test alloceert een string pointer met waarde null. in de lus wordt deze pointer telkens "opgevuld" met een waarde en behoud de string test de laatste waarde die er aan gegeven is na de loop. Maw je moet expliciet test = null zette opdat de garbage collecter hem zou kunnen opruimen nadat de lus is beeindigd.
Bij het tweede wordt er telkens een nieuw pointer met waarde "telkensietsanders" aangemaakt maar wordt deze pointer inc waarde ook telkens weer verwijderd. Een loop van een lus wordt immers uitgevoerd in een apart stuk geheugen (stack) en telkens gereset bij het begin van een nieuw lus.
Ik zou dus persoonlijk voor het tweede gaan.
OK, nu ben ik volledig overtuigd. Ik ga het 2de principe gebruiken.
Merci iedereen voor de hulp 
|
m0rPh3uS
WZL-lid
Sinds 13/1/2003
T:1 -
R:38
|
19/11/2008 -
16:08u
| Quote
|
Zubzub schreef:
m0rPh3uS schreef:
...
Ja en nee
eigenlijk zijn beide voorbeelden hetzelfde qua performance ik zou dus persoonlijk voor het 2de gaan (variabelen die alleen in de lus nodig zijn worden alleen in de lus gedeclareerd). Wat er eigenlijk gebeurt is dit:
String test alloceert een string pointer met waarde null. in de lus wordt deze pointer telkens "opgevuld" met een waarde en behoud de string test de laatste waarde die er aan gegeven is na de loop. Maw je moet expliciet test = null zette opdat de garbage collecter hem zou kunnen opruimen nadat de lus is beeindigd.
Bij het tweede wordt er telkens een nieuw pointer met waarde "telkensietsanders" aangemaakt maar wordt deze pointer inc waarde ook telkens weer verwijderd. Een loop van een lus wordt immers uitgevoerd in een apart stuk geheugen (stack) en telkens gereset bij het begin van een nieuw lus.
Ik zou dus persoonlijk voor het tweede gaan.
Ok, maar het gaat hier wel over performantie. Volgens mij is het nog altijd sneller om één stukje geheugen éénmaal te alloceren en daar telkens een nieuwe waarde in te droppen, dan elke keer een dat stukje geheugen te alloceren en terug vrij te geven. Ok, deze waarden worden wel sneller opgeruimd door de GC, maar het proces is toch intensiever volgens mij.
Daarentegen vind ik optie 2 ook overzichtelijker; zoals je zegt: variabelen die je enkel in een lus nodig hebt, ook daar declareren. Maar vanuit een performantiestandpunt lijkt mij optie 1 toch beter.
Regards.
|
Zubzub
wzl-lid
Sinds 30/7/2005
T:2 -
R:176
|
8/12/2008 -
17:03u
| Quote
|
m0rPh3uS schreef:
Zubzub schreef:
m0rPh3uS schreef:
...
Ja en nee
eigenlijk zijn beide voorbeelden hetzelfde qua performance ik zou dus persoonlijk voor het 2de gaan (variabelen die alleen in de lus nodig zijn worden alleen in de lus gedeclareerd). Wat er eigenlijk gebeurt is dit:
String test alloceert een string pointer met waarde null. in de lus wordt deze pointer telkens "opgevuld" met een waarde en behoud de string test de laatste waarde die er aan gegeven is na de loop. Maw je moet expliciet test = null zette opdat de garbage collecter hem zou kunnen opruimen nadat de lus is beeindigd.
Bij het tweede wordt er telkens een nieuw pointer met waarde "telkensietsanders" aangemaakt maar wordt deze pointer inc waarde ook telkens weer verwijderd. Een loop van een lus wordt immers uitgevoerd in een apart stuk geheugen (stack) en telkens gereset bij het begin van een nieuw lus.
Ik zou dus persoonlijk voor het tweede gaan.
Ok, maar het gaat hier wel over performantie. Volgens mij is het nog altijd sneller om één stukje geheugen éénmaal te alloceren en daar telkens een nieuwe waarde in te droppen, dan elke keer een dat stukje geheugen te alloceren en terug vrij te geven. Ok, deze waarden worden wel sneller opgeruimd door de GC, maar het proces is toch intensiever volgens mij.
Daarentegen vind ik optie 2 ook overzichtelijker; zoals je zegt: variabelen die je enkel in een lus nodig hebt, ook daar declareren. Maar vanuit een performantiestandpunt lijkt mij optie 1 toch beter.
Regards.
Om nog ff te muggenziften
in het eerste voorbeeld is test een pointer zonder geheugenverwijzing (een nullpointer), je gaat dus ook geen geheugen alloceren maw een lege 32/64 bit geheugenverwijzing (geheugen alloceren voor een object gebeurt pas bij de constructor). In de lus wordt de waarde van test een geheugenplaats waar de waarde "telkensietsanders" zich bevindt. Maar, nu komt het , String is een immutable java object. Dit wil zegge dat als ik een nieuwe waarde aan test geef ik ook telkens nieuw geheugen reserveer en het oude geheugen dus niet overschrijf en het opruimen overlaat aan de garbage collector. In het 2de geval gebeurt dit ook maar moet ik gewoon na het beindigen van de lus de variabele test niet op null zette want ik zit al buiten mijn lus (wat in het eerste voorbeeld dus wel moet wil ik het geheugen vrijgeven). Beide zijn dus even performant. Als je toch perse aan performantere string manipulatie wil doen gebruik dan een StringBuffer.
|
Berrepoot
wzl-lid
Sinds 2/7/2008
T:0 -
R:6
|
16/12/2008 -
14:46u
| Quote
|
Ik zie deze post nu pas dus sorry voor de late reactie, maar Zubzub heeft wel degelijk gelijk.
Als de variabele buiten de loop gedeclareerd wordt wil dit absoluut niet zeggen dat deze waarde telkens wordt overschreven in het geheugen. Het enige wat er overschreven wordt is de pointer naar het geheugen! En dit is dus in feite net hetzelfde als de 2e manier!
Wat wel verschilt is (zoals Zubzub) zegt, dat je bij de 1e manier zelf je variabele op "null" moet zetten. Vandaar dat ik zou zeggen dat de 2e manier de beste is. Niet zozeer voor de performantie maar deze is gewoon "properder".
|
