arrayCopy copies the content, so oldArray doesn't change its size. You could have done:
oldArray = tempArray;
effectively replacing the old array with the new one.
But as you found, ArrayList is more effective... The above above is extraordinarily... inefficient!

Instead of copying arrays (which is inefficient, yep), why not do a random shuffle of the indexes of the array?

I.e., create a primary array or ArrayList of objects and then fill an "index array" of integers with values 0 to length - 1 and shuffle it:

1. import java.util.*;
2. 
   
3. private Random randGenerator;
   
4. 
   
5.    /**
        * Returns the internal random number generator.
        * @return an instance of Random
        */
       public Random randGenerator() {
           if (null == randGenerator) {
               randGenerator = new Random();
           }
           return randGenerator;
       }
   
6. 
   
7.    /**
8.      * Shuffles an array of integers into random order.
9.      * @param intArray an array of <code>int</code>s, changed on exit
10.      */
11.     public void shuffle(int[] intArray) {
12.         for (int lastPlace = intArray.length - 1; lastPlace > 0; lastPlace--) {
13.             // Choose a random location from 0..lastPlace
14.             int randLoc = (int) (randGenerator().nextInt(lastPlace + 1));
15.             // Swap items in locations randLoc and lastPlace
16.             int temp = intArray[randLoc];
17.             intArray[randLoc] = intArray[lastPlace];
18.             intArray[lastPlace] = temp;
19.         }
20.     }

That way, if your primary array is of elements of a complex type (instantiated objects), you don't have to move them around in memory. If you want to get them out of the array in random order, you just shuffle the index array and step through it. Once you create the primary array, you never have to rearrange it--though if you want, the code above can be modified to handle arrays of Object or even shuffle ArrayLists.

HTH.





----- |(*,+,#,=)(#,=,*,+)(=,#,+,*)(+,*,=,#)| ---

I am new to processing.  I use one line of code to randomly shuffle a list and another line of code to reference new first element in the arraylist, or, loop through the shuffled arraylist to reference more than one random element.

1. Collections.shuffle(Arrays.asList(SpriteNames));

1. SpriteNames[0] or SpriteNames[i]

If you want to make sure that each element can only be used once in the array, use code to that lets you shuffle, remove elements from the list, and repopulate the list.  Integer lists are handled a little different and other arraylist objects.  The following example repopulates the list from an integer list called LevelList where the integers in the list are values used to select which of seven levels appear and in what order in a simple game.  Upon a level complete event a check is made to see if the level is in the list, and, if it is, it removes it from the list.  On a level start event, it randomly selects one level from the new shortened list (instead of shuffling the list and referring to an elements index number.)

declare ArrayList LevelBrains; and int[] LevelList = new int[] {1,2,3,4,5,6,7};

setup or re-populate the arraylist:

1.   LevelBrains = new ArrayList();
2.   for (int i = 0; i <= LevelList.length-1; i++) {
3.     LevelBrains.add(LevelList[i]);
4.   }

refer randomly to integer element: (Integer)LevelBrains.get(int(random(LevelBrains.size())))

remove integer elements from the array so they can only be used once:

1.   if (LevelBrains.contains(c_level)) {
2.     for (int i=0;i<LevelBrains.size(); i++) {
3.       int val=(Integer)LevelBrains.get(i);
4.       println(str(val));
5.       if (val==c_level) {
6.         LevelBrains.remove(i);
7.         //println("removing level: " + str(c_level));
8.         println("Brain Size: " + str(LevelBrains.size()) + "levelling from: " + str(c_level) + " val: " + str(val) + "\n" + LevelBrains );
9.         Level = Level +1;
10.         HitPoints=int(random(6))+HitPoints;
11.         VolumeMod=VolumeMod*1.1;
12.         Score = c_score;
13.        break;
14.       }

hi benjamin,

can you please share the code you came up with...I am stuck with a similar problem and dont know how to solve the problem.

thanks in advance

Not sure if it can help, but there is this Fisher–Yates_shuffle wicth helped me once...

Well I believe the first of the above codes does just this...