<pedantic>
Those are not functionally the same. The OP version will return values
in the range of (-6.0, 6.0) exclusive, with a bias to 0.  Your version
will return a value in the range of [-6.0, 6.0), with no bias.
</pedantic>

My guess, the later is more desirable anyway, and the in either case,
the "chances" of a pure zero are so remote that it won't make a
difference in the "average" application.

Also, a little obligatory note about the danger of using non-final
statics the way the OP has.  Don't do it unless you know what you're
doing and why.  Chances are you don't know, so don't do it.  If you
/think/ you know why, then still try to find another way.

Good luck,
Daniel.

Hi All,
Any of these three models would satisfy me.
Thanks to all.

bH

import java.util.Random;

public class GenerateRandomV0{
   public static void main(String[] args) {
       generateRandom();
   }

   private static void generateRandom() {
       //Using another possible solution
       Random r = new Random(System.currentTimeMillis());
       // Or Using Knute's solution...(uncomment if to be checked)
       // Random r = new Random(System.nanoTime());
       double aRis  = 0;
       for( int i=0; i<100; i++ ) {
           aRis = r.nextDouble() * 12.0 - 6.0;
           System.out.println("number is:"+  aRis);
       }
   }
}

import java.util.*;

// <http://mindprod.com/jgloss/pseudorandom.html#LOWHIGH>
//  modified to show shuffle
public class GenerateRandomV1{
   public static void main(String[] args) {
       generateRandom();
   }
   private static void generateRandom() {
       Random wheel = new Random();
       double rndDouble= 0.0;
       String arrayStrRndIDbl[] = new  String [100];

       // generate a number between -6.0 <= x < 6.0,
       // then scale then shuffle
       for ( int i=0; i<50; i++ )
       {
           //all positive values
           rndDouble =  wheel.nextDouble() * 6.0d;
           arrayStrRndIDbl[i] = Double.toString(rndDouble);
       }
       for ( int i=50; i<100; i++ )
       {
           // all negative values
           rndDouble =  wheel.nextDouble() * -6.0d;
           arrayStrRndIDbl[i] = Double.toString(rndDouble);
       }
       List <String> inputList = Arrays.asList(arrayStrRndIDbl);
       Collections.shuffle(inputList);
       for(String s: inputList){
           double dblNum =  Double.parseDouble(s);
           System.out.println(" a number = "+ dblNum);
       }

   }
}

// using alwin's gift
// no import to install

public class GenerateRandomV3{

   public static void main(String[] args) {
       generateRandom();
   }

   private static void generateRandom() {
       double aRis  = 0;// a Random is
       for( int i=0; i<100; i++ ) {
           aRis =   Math.random()*12.0-6.0;
           System.out.println(aRis);
       }
   }
}