How to generate a random string

sorry, a minor change... if u want numbers between 1-9 only,
change

s += (int)(Math.random()*10);
to
s += (int)(Math.random()*9 + 1);

vemul

How long do you want the string to be? How about 40? Try this
import java.util.*;
class RandString{
public static void main(String[]args){
Random rand = new Random();
String [] charset = {"0","1","2","3","4","5","6","7","8","9",
                     "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z",
                     "A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};  // 62 elements
StringBuffer sb = new StringBuffer();
for(int n=0;n<40;n++){
                      sb = sb.append(charset[rand.nextInt(62)]);
}
System.out.println(sb.toString());
}
}

Heres a class I once wrote for just that purpose:
-------------------------------------------------


import java.util.Random;

/**
 * This class can be used to generate strings of random characters.
 * The length of the generated strings, as well as the charactes the strings
 * are generated with can be specified
 *
 * @see java.util.Random
 * @author Jan Louwerens
 */
public class RandomString
{
   private static final String DEFAULT_SOURCE_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

   private Random random = null;
   private String m_SourceChars = null;

   /**
    * Creates a RandomString instance with the source characters including
    * lowecase letters a-z, uppercase letters A-Z, and numbers 0-9
    */
   public RandomString()
   {
      this(DEFAULT_SOURCE_CHARS);
   }

   /**
    * Creates a RandomString instance with the specified source characters.
    * The sourceChars string must not be null and must contain at least one
    * character
    *
    * @param sourceChars a string of characters from which a random string
    *                    can be derived
    * @throws IllegalArgumentException if sourceChars is null or does not
    *                                  contain at least one character
    */
   public RandomString(String sourceChars)
      throws IllegalArgumentException
   {
      if (sourceChars == null)
         throw new IllegalArgumentException("sourceChars must not be null");

      if (sourceChars.length() <= 0)
         throw new IllegalArgumentException("sourceChars length must not be > 0");

      random = new Random();
      m_SourceChars = sourceChars;
   }

   /**
    * Returns a character chosen at random from the pool of sourceChars
    *
    * @return a character chosen at random from the pool of sourceChars
    */
   public char nextChar()
   {
      int index = random.nextInt(m_SourceChars.length());
      return m_SourceChars.charAt(index);
   }

   /**
    * Returns a string of the specified length whose characters are chosen
    * at random from the pool of sourceChars
    *
    * @param length the length of the generated string. must be >= 0
    * @return a string of the specified length whose characters are chosen
    *         at random from the pool of sourceChars
    * @throws IllegalArgumentException if length < 0
    */
   public String nextString(int length)
      throws IllegalArgumentException
   {
      if (length < 0)
         throw new IllegalArgumentException("length must be >= 0");

      StringBuffer results = new StringBuffer(length);
      for (int index = 0; index < length; index++)
         results.append(nextChar());

      return results.toString();
   }

   /**
    * Returns a character chosen at random from the pool of sourceChars<br>
    * NOTE: If you wish to generate multiple characters, it is suggested
    *       that you create a RandomString instance and use the nextChar()
    *       method
    *
    * @return a character chosen at random from the pool of sourceChars
    * @see RandomString()
    * @see nextChar()
    */
   public static char getRandomChar()
   {
      return getRandomChar(DEFAULT_SOURCE_CHARS);
   }

   /**
    * Returns a character chosen at random from the pool of sourceChars<br>
    * NOTE: If you wish to generate multiple characters, it is suggested
    *       that you create a RandomString instance and use the nextChar(String)
    *       method
    *
    * @param sourceChars a string of characters from which a random character
    *                    can be chosen
    * @return a character chosen at random from the pool of sourceChars
    * @see RandomString(String)
    * @see nextChar(String)
    */
   public static char getRandomChar(String sourceChars)
   {
      RandomString randomString = new RandomString(sourceChars);
      return randomString.nextChar();
   }

   /**
    * Returns a string of the specified length whose characters are chosen
    * at random from the pool of sourceChars<br>
    * NOTE: If you wish to generate multiple strings, it is suggested
    *       that you create a RandomString instance and use the nextString(int)
    *       method
    *
    * @param length the length of the generated string. must be >= 0
    * @return a string of the specified length whose characters are chosen
    *         at random from the pool of sourceChars
    * @throws IllegalArgumentException if length < 0
    * @see RandomString()
    * @see nextString(int)
    */
   public static String getRandomString(int length)
      throws IllegalArgumentException
   {
      return getRandomString(DEFAULT_SOURCE_CHARS, length);
   }

   /**
    * Returns a string of the specified length whose characters are chosen
    * at random from the pool of sourceChars<br>
    * NOTE: If you wish to generate multiple strings, it is suggested
    *       that you create a RandomString instance and use the
    *       nextString(String, int) method
    *
    * @param sourceChars a string of characters from which a random string
    *                    can be derived
    * @param length the length of the generated string. must be >= 0
    * @return a string of the specified length whose characters are chosen
    *         at random from the pool of sourceChars
    * @throws IllegalArgumentException if sourceChars is null or does not
    *                                  contain at least one character, or
    *                                  if length < 0
    * @see RandomString(String)
    * @see nextString(int)
    */
   public static String getRandomString(String sourceChars, int length)
      throws IllegalArgumentException
   {
      RandomString randomString = new RandomString(sourceChars);
      return randomString.nextString(length);
   }
}

yasser_helmy,
er, that not the way u use stringbuffer right? :P

sorry..
replace 's+=' by 's.append()'..
i think the output string will be totally random.. hope it helps.. :)

Hi, all

Most of the codes work well. I think yasser's code is the best. Thanks all.

hi codelover.. i hope i helped you well..
everybody.. thanx for the new great ideas i got from you..
:)