On Wed, 03 Oct 2007 12:29:52 GMT, Roedy Green
<see_website@mindprod.com.invalid> wrote, quoted or indirectly quoted
someone who said :

Here is the guts, that handles an int[]. Note how much simpler the
code is. You can download this as part of the common11 package
at http://mindprod.com/products.html#COMMON11

/**
* Shuffles an int[], much like Collections.shuffle
* copyright (c) 2007 Roedy Green, Canadian Mind Products Shareware
 that may be copied and used freely for any purpose but military.
 Roedy Green<
 Canadian Mind Products
 #101 - 2536 Wark Street
 Victoria, BC Canada
 V8T 4G8
 mailto:roedyg@mindprod.com
 http://mindprod.com
*/
package com.mindprod.common11;

import java.util.Random;

/**
* Shuffles an int[], much like Collections.shuffle
*
* @author Roedy Green, Canadian Mind Products
* @version 1.0, 2007-10-03 Created with IntelliJ IDEA.
*/
public class Shuffle {

   // ------------------------------ FIELDS
------------------------------

   /**
    * true if you want the debugging main harness.
    */
   private static final boolean DEBUGGING = true;

   /**
    * default source of randomness for shuffling.
    */
   private static Random wheel;

   // -------------------------- PUBLIC STATIC METHODS
--------------------------

   /**
    * Works much like Collections.shuffle. Randomly permutes the
specified list
    * using a default source of randomness.  All permutations occur
with
    * approximately equal likelihood.<p>
    * <p/>
    * The hedge "approximately" is used in the foregoing description
because
    * default source of randomness is only approximately an unbiased
source of
    * independently chosen bits. If it were a perfect source of
randomly chosen
    * bits, then the algorithm would choose permutations with perfect
    * uniformity.<p>
    * <p/>
    * This implementation traverses the list backwards, from the last
element
    * up to the second, repeatedly swapping a randomly selected
element into
    * the "current position".  Elements are randomly selected from
the portion
    * of the list that runs from the first element to the current
position,
    * inclusive.<p>
    *
    * @param toShuffle the array to be shuffled.
    */
   public static void shuffle( int[] toShuffle )
       {
       // wheel is initialised only once, and only if needed.
       if ( wheel == null )
           {
           wheel = new Random();
           }
       shuffle( toShuffle, wheel );
       }

   /**
    * This method uses the same technique as Collections.shuffle, but
is
    * somewhat simpler with direct array access. Randomly permute the
specified
    * list using the specified source of randomness.  All
permutations occur
    * with equal likelihood assuming that the source of randomness is
fair.<p>
    * <p/>
    * This implementation traverses the array backwards, from the
last element
    * up to the second, repeatedly swapping a randomly selected
element into
    * the "current position".  Elements are randomly selected from
the portion
    * of the list that runs from the first element to the current
position,
    * inclusive.<p>
    *
    * @param toShuffle the array to be shuffled.
    * @param wheel     the source of randomness to use to shuffle the
list.
    */
   public static void shuffle( int[] toShuffle, Random wheel )
       {
       for ( int i = toShuffle.length; i > 1; i-- )
           {
           // swap elt i-1 and a random elt 0..i-1
           final int temp = toShuffle[ i - 1 ];
           final int otherSlot = wheel.nextInt( i );
           toShuffle[ i - 1 ] = toShuffle[ otherSlot ];
           toShuffle[ otherSlot ] = temp;
           }
       }

   // --------------------------- main() method
---------------------------

   /**
    * test driver demonstrate use of shuffle.
    *
    * @param args not used.
    */
   public static void main( String[] args )
       {
       if ( DEBUGGING )
           {
           int[] deck = new int[52];
           for ( int i = 0; i < 52; i++ )
               {
               deck[ i ] = i;
               }
           System.out.println( "\nbefore shuffle" );
           for ( int i = 0; i < 52; i++ )
               {
               System.out.print( " " );
               System.out.print( deck[ i ] );
               }

           shuffle( deck );

           System.out.println( "\nafter shuffle" );

           for ( int i = 0; i < 52; i++ )
               {
               System.out.print( " " );
               System.out.print( deck[ i ] );
               }
           }
       }
}

The reason I find you irritating is not because you elaborate, or
simplify, or translate, or create a webbased explanation including
code example. Those are all honorable things.

The reason is that I first state

And then three hours later, you state

suggesting to the sequential reader that you have found something new,
subsequently stating

While I don't mind you experimenting and coming to your own
conclusions (as I have done), it would be nice and respectful to at
least include a reference or acknowledgement to the other posters, if
you are aware of them, stating that you agree with their findings and
that you have elaborated on it to produce a code demonstration,
located on your website. You are not only targetting an audience of
newbies, you are also participating in a thread, and we are not here
to compete which each other for credits, unless you are purposefully
and irreverently trying to direct as many readers as possible to your
website. So it's not about repetition, it's about acknowledgement.

Yes I read your code example and it certainly didn't explain more than
what I did, although I agree that my explanation could be improved,
for example by stating that the int[] that is wrapped inside an array
is then used as the backing for the List, thus producing a List that
is backed by an array with one int[] element, but that's not the
point.

Btw,

I would suggest to change

into something more understandable. What does »asList backing int[]
array« mean? asList is not backing anything, nor is it backed by
anything. And even if it was, I don't understand it.