Wow you guys put some thought into that 
Edit:Could someone please tell me how to put code snippets in my posts, i tried some html tags (code, pre), but none worked 
I want my posts to look cleaner.
[quote]There is nothing wrong with recursion in itself, it can be a quite elegant solution to many problems. However, the issue with recursion is that for each recursive call, some things get stored on the stack (a piece of memory where local variables are stored). So if you do many recursive calls (e.g. because you are parsing a large tiled grid using this approach) you may run out of stack memory and get exceptions.
So if you want to use recursion, you should be aware of this and ensure that there is an acceptable maximum “depth” of recursion. This means that the size of electricity networks must be limited somehow.
[/quote]
I heard of the stack issue but never thought that i would be an actual issue, as i thought it would be very hard to actually run out of memory. Do you know some numbers, or a way to check how much is possible?
Also, a node tree is of what i understood, An object (parent), that contains (one, two, or more) children, and the children have children again etc.
To me it seems like composition of objects.
So if i had an interface which every electric component implements, let’s say with the method impulse(): To run through the components i just had to call =>
Battery-> impulse child -> impulse child -> and so on, it would be the same method name, but not really recursion(it would be the implemented method of another object), since in fact i would just run through the objects in a direct manner, and the method in the Battery component would not be calling itself again.
In this case, this seems like the most optimal way to ‘flood-fill’ the circuit. There would be basically no wasted method calls at all, depending on how it is done.
And this way I could easily implement an internal mapping/rules, of where the impulse should flow to, based on states etc.
So it would be easy to add new features, and even a bit more complex stuff like ‘internal circuits’(ic’s);
Is there any issue with the stack memory then? (Like in the next example)
Edit: I read a little about heap,stack etc: If there are no local variables (which I avoid 99.999% in methods), there would/should be no problem in in recursive methods, even if they run thousands of times. Or am i wrong?(Memory, is still totally alien for me
)
(Please excuse my pseudo code)
Update circuit => Battery.emitImpulse() -> Battery.cableNode.impulse() -> Cable.switchNode.impulse() -> Switch.ConsumerNode.impulse() -> etc
I dont know how it could be more efficient, plus, it could easily be saved until the next iteration, and only had to be overwritten while passing impulses around.(if desired)
I like the idea of all your methods, (and btw thank you for sharing it and beeing patient ^^), especially that you keep track of the differrent objects in different arrays.
I will also implement a method to acces/save different object/component types in different arrays, because i will eventually need to order them by type.
And what i havent understood, or simply didnt see it in all your answers(excuse me if that is the case), how do you actually iterate your components, as you said a flood-fill, since you would use array, are you connecting it via meta-objects(like nodes) or by index or something ? 
In this case i though a tilemap would make it easier, but as it seems, for once, a tile map actually makes it harder
(At least for me)
Thank you guys again very, very much for the help and suggestions! <3
(Including answering some of my noob questions => going to read up some java memory/stack stuff)