If I understood correctly, you would like to create a class that has an array of some length and the instances of that class may have different lengths of their arrays. This is valid in Processing, here is an example:

thank you, that's an answer I hoped for. But as like in all examples that I've studied - because most of them run just through once - there's still some blank space in my brains left:
(sticking to asimes example-script above)

if I create 3 examples[]-instances like that:

q1. How can I remove instance examples[1] while examples[0] and examples[2] stay present? 

just like this: 

examples[1] = examples[2];
examples[2] = null;

or another way?

q2. Can I add examples[3,4,5...] later or does line 5 ( examples = new MyClass[3]; )  set the number of instances fixed to 3 until program has ended?  

q3. How (if possible) can I change the count of elements in examples[ any].classArray[] after creation?
(So the line println(examples[ any ].classArray.length); prints out something else)

Or do I have to create a new instance of examples[] with the desired length of classArray and copy the memory to the new instance?  Then I need an answer to question q1.

It would be much easier to use an ArrayList of type MyClass. This would solve questions 1 and 2 fairly easily as you would just have to use add or remove to do them.

hi,

"...you'll have to either set its length to be the maximum number of instances you expect to have or manually expand its size when needed..."

So I assume it's allowed to resize an array somehow? But how: it's not a "new" array though.
Like this 

int[] numbers = new int[3];

there are 3 elements now...
but if I want to resize it later to 6 elements can I just use "new" again and write some lines later:

int[] numbers = new int[6];

or do I have to leave it blank in the first place? Like this:

int[] numbers = new int[];

My problem is: all examples that I've found about arrays just show how to set them up once.
But I want to know how to enlarge or reduce them in size (array.lenght) after setup.

And the other thing:
It might be a solution to combine it like suggested and to use objects stored in an arrayList since there are not that many and I could setup them limited to maybe 256 and due to the large differences in amount of vertices per object it drives me to use common arrays to store them. Until I've learned how to arrange and handle my data I can't start porting one of my basic-projects to Processing.  

there lies the hound buried: I just find the help pages and the shipped examples. The only mentioned thing of that kind is "array.length" and that just because of the remark to not confuse it with "string.lenght()". This doc: http://processing.org/reference/Array.html gives just raw basic information and also http://processing.org/reference/arrayCopy_.html (which I only found in the alphabetical list because it starts with "array" too) doesn't tell more about these functions.
The only way is to click there at the "related"-Link - but the "Array"-page has none. I don't like to browse and read a dozen different help pages and click "related" if available until I stumble by accident across the desired information.
 Especially I do not like them remarks "For further information please read the Java Reference Description" which is written that confusing: I do not find any useful information there to fill the blank lines in my brains.
That's why I'm asking in this forum.

So please could anyone link me to a list of these functions?

Sorry me not good english - I amusing spell correction ;)

 

Heyya Return_True_Or_False!

As you've already noticed, Java offers other types of arrays besides the ordinary ones!

When you know beforehand the amount of elements an array gonna need, use the native ones.
It's faster and easier to deal with!

Now, if you intend to keep resizing an array in the middle of your program
or not so sure how big you need it, use class ArrayList<>!
It's more practical! You can add/remove an element, and that class resizes itself!

Although Java also offers ordinary array resizing; in my opinion it's not worth it!

Here's a code that has a class named Bullet.
Since we don't know how many bullets a player is gonna fire, it's not very practical to have a fixed-size array.

Although we coulda created an array w/ an estimated highest size of how many bullets can exist in a given moment,
still it's more logical not to worry about and keep managing these issues.

Study how an ArrayList is created.
So you'll be able to use it when it's more appropriate than a normal array:

P.S.: the part that adds an element is at the end of function -> addBullet().
and elements are removed at the loop within function draw().

/**
 * Multiple Bullets (v2.72)
 * by Ammon.Owed (2013/Jan)
 * tweaked by GoToLoop
 *
 * http://forum.processing.org/topic/shoot-multiple-bullets
 *
 * http://forum.processing.org/topic/array-usage-objects-in-general
 *
 * http://forum.processing.org/topic/
 * arraylist-confusion-changing-the-variables-of-an-extracted-object-with-get
 */

final static List
               
                <Bullet> bullets = 
                new 
                ArrayList(50);


                final 
                static 
                PVector playerPos = 
                new 
                PVector(); 

                final 
                static 
                PVector playerSpd = 
                new 
                PVector();

                final 
                static 
                PVector bulletSpd = 
                new 
                PVector();


                final 
                static 
                byte    playerVel  = 3, bulletVel = 5, fps = 60;

                final 
                static 
                byte    playerSize = 20, holeSize = playerSize>>1;

                final 
                static 
                byte    aimSize = 5, bulletSize = 4, bulletGap = 3;


                final 
                static 
                color   aimColor = 0, bg = 255;

                final 
                static 
                color   playerColor = #FF0000, bulletColor = #0000FF;


                boolean toCrossScreen = 
                true;


                void 
                setup() {
  
                size(600, 600);
  
                smooth();
  
                noStroke();
  
                noCursor();
  
                ellipseMode(
                CENTER);
  
                frameRate(fps);

  playerPos.
                set(
                width>>1, 
                height>>1, 0);
}


                void 
                draw() {
  
                background(bg);

  updatePlayer();
  checkPlayer();
  displayPlayer();
  displayAim();

  
                if (
                mousePressed && 
                frameCount % bulletGap == 0)
    addBullet();

  
                fill(bulletColor);

  
                //for (Bullet b: bullets) b.run(); //unremovable bullets!

  
                for ( 
                int b = bullets.
                size(); b != 0; )
    
                if ( bullets.
                get(--b).run() )   bullets.remove(b);

  
                print(bullets.
                size() + 
                "\t");
}


                void updatePlayer() {
  playerPos.
                add(playerSpd);
}


                void checkPlayer() {
  
                if (toCrossScreen) {
    
                if (playerPos.x > 
                width)    playerPos.x = 0;
    
                else 
                if (playerPos.x < 0)   playerPos.x = 
                width;

    
                if (playerPos.y > 
                height)   playerPos.y = 0;
    
                else 
                if (playerPos.y < 0)   playerPos.y = 
                height;
  }

  
                else {
    
                if (playerPos.x > 
                width  - holeSize)  playerPos.x = 
                width-holeSize;
    
                else 
                if (playerPos.x < holeSize)      playerPos.x = holeSize;

    
                if (playerPos.y > 
                height - holeSize)  playerPos.y = 
                height-holeSize;
    
                else 
                if (playerPos.y < holeSize)      playerPos.y = holeSize;
  }
}


                void displayPlayer() {
  
                fill(playerColor);
  
                ellipse(playerPos.x, playerPos.y, playerSize, playerSize);

  
                fill(bg);
  
                ellipse(playerPos.x, playerPos.y, holeSize, holeSize);
}


                void displayAim() {
  
                fill(aimColor);
  
                ellipse(
                mouseX, 
                mouseY, aimSize, aimSize);
}


                void addBullet() {
  bulletSpd.
                set(
                mouseX, 
                mouseY, 0);

  bulletSpd.
                sub(playerPos);
  bulletSpd.
                normalize();
  bulletSpd.
                mult(bulletVel);

  bullets.
                add( 
                new Bullet(playerPos, bulletSpd) );
}


                void 
                keyPressed() {
  
                final 
                int k = 
                keyCode;

  
                if (     k == 
                LEFT  |  k == 
                'A')
    playerSpd.x = -playerVel;
  
                else 
                if (k == 
                RIGHT |  k == 
                'D')
    playerSpd.x = playerVel;
  
                else 
                if (k == 
                UP    |  k == 
                'W') 
    playerSpd.y = -playerVel;
  
                else 
                if (k == 
                DOWN  |  k == 
                'S')
    playerSpd.y = playerVel;
  
                else 
                if (k == 
                ENTER |  k == 
                RETURN | k == 
                ' ')
    toCrossScreen = !toCrossScreen;
}


                void 
                keyReleased() {
  
                final 
                int k = 
                keyCode;

  
                if ( k == 
                LEFT    |  k == 
                'A'  &&  playerSpd.x < 0 
    || k == 
                RIGHT   |  k == 
                'D'  &&  playerSpd.x > 0 )
    playerSpd.x = 0;

  
                else 
                if ( k == 
                UP |  k == 
                'W'  &&  playerSpd.y < 0 
    || k == 
                DOWN    |  k == 
                'S'  &&  playerSpd.y > 0 )
    playerSpd.y = 0;
}


                class Bullet 
                extends 
                PVector {
  
                PVector vel;

  Bullet(
                PVector loc, 
                PVector vel) {
    
                super(loc.x, loc.y);
    
                this.vel = vel.
                get();
  }

  
                void display() {
    
                ellipse(x, y, bulletSize, bulletSize);
  }

  
                void update() {
    
                add(vel);
  }

  
                boolean check() {
    
                return x > 
                width | x < 0 | y > 
                height | y < 0;
  }

  
                boolean run() {
    display();
    update();
    
                return check();
  }
}

               

Thanx for your reply.

OK, for the objects its the best way to use arrayLists I think. I can limit them to 256. Done.

But there will be a couple of hundred faces per object and I've read arrayLists can not handle large arrays since they slow down and eventually crash the program due an unstuffed memory leak that also makes Processing to run slower and slower with every new execution of a script. So I'm afraid of using them since the user might not have the possibility to save his works in my program and deletes it finally because of frustration.

Usage of ArrayLists is explained pretty well now and I can always refer this page.

Still open questions:

How to "kill" an objects instance?
.remove() like in the code above does not work in my Processing Version 2.0b7
- so I think it's some arrayList-specific method
do these instances have to stay in memory until program ends like the unused array-elements?
How to "ReDim" an array? Ain't possible eh?



names:
my name is return_true_if_false but Return True Or False would be a nice function-result :lol:
there is a user called GoToLoop in MS Smallbasic-Forum too that uses the same user-image, what a coincidence.
Or should I say: what a small world....

Well, I still use current stable version 1.5.1 exclusively.
But I find it very strange that method remove() doesn't work in 2.0bx series!  

get(), add(), remove(), size(), etc. are internal methods which belong to interface List.

And ArrayList is derived from it, as many other similar classes!
If ArrayList is valid in 2.0b7, it should also include all its internal methods AFAIK!

When statement new is used, memory is allocated to accommodate an object instance.
But I don't know whether Java has any statement/method to explicitly free/kill/release allocated memory
from object instances as C/C++/D do.

However, in Java, there is a mechanism called Garbage Collector,
which identifies and frees up memory from orphan objects and other variables which have become outta scope.

Method remove() doesn't free up allocated RAM by itself.
It just removes the element from the List which references that object.

If no other variable makes reference to an object anymore, it is considered orphan then.
And hopefully/eventually, the GC will identify and free up that useless instance! 

Besides remove(), replacing a reference by another reference makes the former orphan as well.
Or even assigning null is enough to orphanize it! 

There is a user called GoToLoop in MS SmallBasic's forum too that uses the same user-image, what a coincidence!

Yup; it is me here as well!  

arghhh, you misunderstood me probably because I didn't put it on one line up there ^

The script works, the .remove()-method works too on arrayList, but I tried to kill another object like this:

myObjectInstance.remove()

 because I still had no answer for how to remove an object to free memory. In object oriented Basic (VB 6.0) it works like this: 

Set objInstance = Nothing

(where "Null" and "Nothing" are different, "Null" empties a variable - doesn't even contain zero then - while "Nothing" kills an object)

So I thought maybe it's in Processing alike

objInstance = null;

but it's obviously not. I can still refer to objInstance, read it's variables and use it's methods.

Than I thought it might be like in your posted script and all objects inherit a method .Remove() from the core and I tried that. But did not work. So no worry, 2.0b7 still has .remove()-method for arrayLists

Now I read your post and I think my Garbage Collector is lazy or on strike- or even very smart: it sniffes that I was up to try to refer to objInstance after setting it null because it can read the code in advance? 

So I still have to study some more to learn how the memory management in Processing works - but obviously there's no such thing as accessable memory. No way to allocate nor read nor poke sequences of data somewhere? Just objects that can be "marked as deleted" and the interpreter might delete them if it feels like doing so? That doesn't give me the feeling to have everything under control since it's just guessing: "It might do that when it comes to the code"

I already thought of storing my thousand values into a string since my data is a straight line-sequence but they're static and len-fixed? What kind of crap is that? If user types in a sentence that I want to display I have to create a new string after every char the user typed to display the user input on screen? And no built-in methods to convert a string from its Ascii-Char-Values into raw byte/float/int nor vice versa?

Somehow there are too many limitations I don't understand - I thought Processing or Java in general would be a fast and flexible language but now it appears to be a very slow, unstable and static one to me - that the only advantage is the portability to other systems and that makes me think Java was invented by a Mac- or Amiga-user to outrun the advantage of IBM-PCs.

Maybe Processing is not the straightforward, easy to use "All-In-One-Programming-Language-Package" which doesn't need additional modules to be useful + run properly and that offers a built-in 3D library and dynamic variable usage and runs on 32 and 64Bit (mainly Windows), which I was looking for  when I found Processing on the web and I have to continue my search...

How dare I to expect all this in one language? I'm sure it exists somewhere...
Perhaps someone has a hint for me.

So I still have to study some more to learn how the memory management in Processing works - but obviously there's no such thing as accessable memory. No way to allocate nor read nor poke sequences of data somewhere? Just objects that can be "marked as deleted" and the interpreter might delete them if it feels like doing so? That doesn't give me the feeling to have everything under control since it's just guessing: "It might do that when it comes to the code"

It is true that you can not know exactly about the circles of the garbage collector. maybe there is a method t force to go on. But the thing is, you do not need to mark things as deleted. all non-primitives are reference based variables. If some data have no reference anymore they are collected by the gc. For example if you have a class Person

the only one of those I can find documented is HashMap and they are similar to array as far I see.
Nothing about any TreeSets or LinkedLists in the language reference:
If these really exist it would be nice to find them in the shipped description.
If they're part of some additional module - I'm not interested in using an incomplete programming environment that's without additional modules or extensions just like a cripple without crutch or broken toy for kids to play with.  (applies to MS Small Basic)  

"The user of my software is to me the most important person on this planet. When I'm coding programs, the users comfort is all I think about. I would never dare to let him down nor disappoint him. If the user does not believe in me any more, I'll fade like the forgotten ancient gods."

by unknown programmer as translated and quoted by return_true_if_false

http://docs.oracle.com/javase/7/docs/api/index.html?java/util/Collection.html

Here's some links about Garbage Collector both in Java & JavaScript:

garbage-collector-friendly-code

Delete Object in Java