swap(a, b){
    a = a XOR b;
    b = a XOR b;
    a = a XOR b;
}

a = a + b;
b = a - b;
a = a - b;

Running solutions with settings:
        Initial living: 100
        Repeats: 1000
Solution 'Mirhagk': 15 ms
Solution 'DemonWasp': 125 ms

Running solutions with settings:
        Initial living: 1000
        Repeats: 1000
Solution 'Mirhagk': 15 ms
Solution 'DemonWasp': 172 ms

Running solutions with settings:
        Initial living: 10000
        Repeats: 1000
Solution 'Mirhagk': 985 ms
Solution 'DemonWasp': 156 ms

Running solutions with settings:
        Initial living: 32767
        Repeats: 1000
Solution 'Mirhagk': 12906 ms
Solution 'DemonWasp': 172 ms

Running solutions with settings:
        Initial living: 4000
        Repeats: 1000
Solution 'Mirhagk': 172 ms
Solution 'DemonWasp': 140 ms

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


public class Benchmark {
       
        public static void main(String[] args) {
                final int ALIVE = 30000;
                final int REPEATS = 1000;
                long start, end;
               
                List<Solution> solutions = new ArrayList<Solution>();
                solutions.add ( new Mirhagk() );
                solutions.add ( new Mirhagk2() );
                solutions.add ( new DemonWasp() );
               
                System.out.println ( "Running solutions with settings:" );
                System.out.println ( "\tInitial living: "+ALIVE );
                System.out.println ( "\tRepeats: "+REPEATS );
                System.out.println ();
                for ( Solution s : solutions ) {
                        start = System.currentTimeMillis();
                        s.init ( ALIVE );
                        for ( int repeat = 0; repeat < REPEATS; ++repeat ) {
                                s.update();
                        }
                        end = System.currentTimeMillis();
                       
                        System.out.println ( "Solution '"+s.getClass().getName()+"': "+(end-start)+" ms" );
                }
        }
       
       
}

/**
 * Any solution to the problem must satisfy this interface
 */
interface Solution {
        public void init ( final int alive );
        public void update ();
}

/**
 * mirhagk's suggested solution: keep a linked list of living objects and
 * iterate over them; when they die, remove them from the list of living
 * objects.
 */
class Mirhagk implements Solution {
        protected List<ShortLived> active = null;
       
        public void init ( final int alive ) {
                active = new LinkedList<ShortLived>();

                for ( int i = 0; i < alive; ++i ) {
                        active.add ( new ShortLived() );
                }
        }

        public void update () {
                for ( int i = 0; i < active.size(); ) {
                        ShortLived s = active.get(i);
                        s.update();
                        if ( !s.isActive() ) {
                                active.remove ( i );
                        } else {
                                ++i;
                        }
                }
        }
}

/**
 * A variation on mirhagk's original suggestion that uses ArrayList instead.
 */
class Mirhagk2 extends Mirhagk {

        public void init ( final int alive ) {
                active = new ArrayList<ShortLived>();

                for ( int i = 0; i < alive; ++i ) {
                        active.add ( new ShortLived() );
                }
        }
}

/**
 * The naive solution: use an array of objects; never discard anything.
 */
class DemonWasp implements Solution {

        protected ShortLived[] all = null;
       
        public void init ( final int alive ) {
                all = new ShortLived[Short.MAX_VALUE];
                // Add alive
                for ( int i = 0; i < alive; ++i ) {
                        all[i] = new ShortLived();
                }
                // Add dead
                for ( int i = alive; i < Short.MAX_VALUE; ++i ) {
                        ShortLived s = new ShortLived();
                        s.setActive ( false );
                        all[i] = s;
                }
        }
       
        public void update () {
                for ( int i = 0; i < all.length; ++i ) {
                        if ( all[i].isActive() ) {
                                all[i].update();
                        }
                }
        }
}


/**
 * An example object that doesn't live very long (particle effects, bullets,
 * etc). The update() method should only be called on active objects, and
 * performs some computation (here, almost no computation).
 */
class ShortLived {
        protected boolean active = true;
       
        public void update () {
                if ( Math.random() < 0.1 ) {
                        active = false;
                }
        }

        public boolean isActive() {
                return active;
        }

        public void setActive(boolean active) {
                this.active = active;
        }
}

Running solutions with settings:
        Initial living: 30000
        Repeats: 1000

Solution 'Mirhagk': 9172 ms
Solution 'Mirhagk2': 406 ms
Solution 'DemonWasp': 188 ms
Solution 'Clever': 62 ms

/**
 * A clever solution: keep all the objects in an array. Use a 'next' field to
 * contain the index of the next active node; update this linking as we iterate
 * (when necessary). This solution could be easily extended to do the same with
 * dead values, which would make finding the next object to reuse quite...fast.
 */
class Clever implements Solution {

        protected List<LinkedShortLived> all = null;
       
        protected int firstAlive = 0;
       
        public void init ( final int alive ) {
                all = new ArrayList<LinkedShortLived>(alive);
                // Add alive
                for ( int i = 0; i < alive; ++i ) {
                        LinkedShortLived s = new LinkedShortLived();
                        s.next = i+1;
                        all.add ( s );
                }
                all.get(all.size()-1).next = -1;
        }
       
        public void update () {
                LinkedShortLived prev = null;
                for ( int i = firstAlive; i < all.size() && i != -1; ) {
                       
                        LinkedShortLived s = all.get(i);
                        if ( s.isActive() ) {
                                s.update();
                                if ( prev == null ) {
                                        firstAlive = i; // update head
                                } else {
                                        prev.next = i;  // update middle
                                }
                                prev = s;
                        }
                       
                        i = s.next;     // advance to next node
                }
        }
}

class LinkedShortLived extends ShortLived {
        public int next = 0;
}

class Program
    {
        static void TestIterate(int numObjects, int numIterations)
        {
            TestObject[] testArray = new TestObject[numObjects];
            for (int p = 0; p < numObjects; p++)
            {
                testArray[p] = new TestObject();
            }
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            for (int i = 0; i < numIterations; i++)
            {
                for (int p = 0; p < numObjects; p++)
                {
                    if (testArray[p].alive)
                        testArray[p].Update();
                }
            }
            stopWatch.Stop();
            Console.WriteLine(stopWatch.ElapsedMilliseconds);
        }
        static void TestIterate2(int numObjects, int numIterations)
        {
            LinkedList<TestObject2> testLinkedList = new LinkedList<TestObject2>();
            for (int p = 0; p < numObjects; p++)
            {
                testLinkedList.AddLast(new TestObject2());
            }
            LinkedListNode<TestObject2> node;
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < numIterations; i++)
            {
                node = testLinkedList.First;
                while (node != null)
                {
                    if (!node.Value.Update())
                    {
                        if (node.Next == null)
                        {
                            testLinkedList.Remove(node);
                        }
                        else
                        {
                            node = node.Next;
                            testLinkedList.Remove(node.Previous);
                           
                        }
                    }
                    else
                    {
                        node = node.Next;
                    }

                }
            }
            stopwatch.Stop();
            Console.WriteLine(stopwatch.ElapsedMilliseconds);
        }
        class TestObject2
        {
            static Random rand = new Random();
            public bool Update()
            {
                if (rand.Next(100) == 0)
                    return false;
                return true;
            }
        }
        class TestObject
        {
            public bool alive = false;
            static Random rand = new Random();
            public void Update()
            {
                if (rand.Next(100)==0)
                    alive=false;
            }
        }
        static void Main(string[] args)
        {
            TestIterate(10000, 10000);
            TestIterate2(10000, 10000);
            Console.ReadKey();
        }
    }

Running solutions with settings:
        Initial living: 1000000
        Repeats: 10000

Solution 'Mirhagk': 1098 ms
Solution 'Clever': 739 ms

/**
 * mirhagk's suggested solution: keep a linked list of living objects and
 * iterate over them; when they die, remove them from the list of living
 * objects.
 */
class Mirhagk implements Solution {
        protected List<ShortLived> active = null;

        public void init ( final int alive ) {
                active = new LinkedList<ShortLived>();

                for ( int i = 0; i < alive; ++i ) {
                        active.add ( new ShortLived() );
                }
        }

        public void update () {
                ListIterator<ShortLived> i = active.listIterator();
                for ( ShortLived s = i.next(); i.hasNext(); s = i.next() ) {
                        s.update();
                        if ( !s.isActive() ) {
                                i.remove();
                        } else {
                        }
                }
        }
}

Running solutions with settings:
        Initial living: 100000
        Repeats: 1000

Solution 'Mirhagk': 95 ms
Solution 'Mirhagk2': 1893 ms
Solution 'Clever': 66 ms

Running solutions with settings:
        Initial living: 10000
        Repeats: 10000

Solution 'Mirhagk': 33 ms
Solution 'Mirhagk2': 39 ms
Solution 'DemonWasp': 849 ms
Solution 'Clever': 14 ms