Java Generate Random String
Java Generate Random String
In this tutorial, we will learn about to generate random string in Java. Random generation strings mean any string will be generated, which does not follow any pattern. Thus, no one can guess which string is going to be generated. Some of the ways to generate the random string are discussed below.
By Using the random() Method
The Math class has the static method random(), which returns a double value between 0.0 and 1.0.
Syntax:
public static random()
The following program uses the random() method to generate the random strings.
FileName: RandomStringsExample.java
public class RandomStringsExample { // method to generate random strings public String getRandomString(int size) { // Choose a random character from the given string String alphaNumericStr = "abcdefghijklmnopqurestuvwxyz" + "0123456789" + "ABCDEFGHIJKLMNOPQURESTUVWXYZ"; StringBuffer sbfr = new StringBuffer(size); // loop for generating choosing a // random character from the alphaNumericStr variable for (int j = 0; j < size; j++) { // Generating a random number that lies in the range of // 0 to alphaNumericStr variable length double randNo = Math.random(); // getting the index using the randNo int idx = (int)(alphaNumericStr.length() * randNo); // add Character one by one in end of sb sbfr.append(alphaNumericStr.charAt(idx)); } // returning the randomly generated string return sbfr.toString(); } // main method public static void main(String argvs[]) { // creating an object of the RandomStringsExample RandomStringsExample ob = new RandomStringsExample(); int j = 0; System.out.println("The 20 random strings are: \n"); // Loop for generating 20 random strings while(j < 20) { // determining the size of the random string int size = (int)(20 * Math.random()); // printing the randomly generated string String str = ob.getRandomString(size); System.out.println(str); j = j + 1; } } }
Output:
The 20 random strings are: oyDLouoHW zR5UffpV 6sTIPXWkADPUs eOM6cYRF YNwhTNviEqrjU58B02d vREwFR9FknQd 9m r1 b3ALU9EnTlur u6HpQA4ah5BLojv0vno xGEr1F6C4 5z64PXRRLEURety0 Q8Cvq wf SGeM7QdE2csmpHB b 7 Oqqpe T Rj8A5kDGiR6DBf0i0v
Explanation: The strings are generated from picking the characters at random from the alphNumericStr. The size of the randomly generated string is also dependent on the random() method. Therefore, we see different sizes of string in the output. Note that every time we run the above program, different strings of different lengths are generated.
By Using CharSet
CharSet can be used to generate random strings of the random size. The CharSet is present in the java.nio.charset package.
FileName: RandomStringsExample1.java
// importing different packages required in the program import java.nio.charset.*; import java.util.*; public class RandomStringsExample1 { // method to generate random strings public String getRandomString(int size) { // Choose random character from the given string // The length is restricted by 256 characters byte[] arr = new byte[256]; // using the nextBytes method of the Random class // to fil the byte array arr. new Random().nextBytes(arr); // converting the byte array arr into a string // 8-bit Unicode transformation is used String rndmString = new String(arr, Charset.forName("UTF-8")); StringBuilder sbdr = new StringBuilder(); // loop for generating choosing characters from the rndmString variable for (int j = 0; j < size; j++) { // getting character at random basis from // the string rndmString char c = rndmString.charAt(j); // Ensuring that randomly generated // string is alphnumeric if( (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ) { // appending the character sbdr.append(c); } } // getting string from the Stringbuilder String str = sbdr.toString(); // returning the randomly generated string return str; } // main method public static void main(String argvs[]) { // creating an object of the RandomStringsExample1 RandomStringsExample1 ob = new RandomStringsExample1(); int j = 0; System.out.println("The 20 random strings are: \n"); // Loop for generating 20 random strings while(j < 20) { // determining the size of the random string int size = (int)(20 * Math.random()); String str = ob.getRandomString(size); // printing the randomly generated string System.out.println(str); j = j + 1; } } }
Output:
The 20 random strings are: 0Um6 DXeoOU 8fnCws fhdd No M0G4 BM5B H KN gE7 jP dopJ5 7x LP F CtiJL ujA08 U
Explanation: First, we have bounded that the length of the byte array is 256. It means that a string rndmString comprising 256 characters is generated. From this string, alphanumeric characters are filtered with the help of the for-loop. These filtered alphanumeric characters comprise the string str, which is displayed in the output. The blank spaces in the output represent that the for-loop did not encounter any alphanumeric character.
By Using Regular Expressions
Regular expressions can also be used to generate random strings. The following program illustrates the same.
FileName: RandomStringsExample2.java
// importing different packages required in the program import java.nio.charset.*; import java.util.*; public class RandomStringsExample2 { // method to generate random strings public String getRandomString(int size) { // Choose random character from the given string // The length is restricted by 256 characters byte[] arr = new byte[256]; // using the nextBytes method of the Random class // to fil the byte array arr. new Random().nextBytes(arr); // converting the byte array arr into a string // 8-bit Unicode transformation is used String rndmString = new String(arr, Charset.forName("UTF-8")); // creating an object of the StringBuilder class StringBuilder sbdr = new StringBuilder(); // replace all the non alphanumeric characters withe null character String alphaNumericStr = rndmString.replaceAll("[^a-zA-Z0-9]", ""); // loop for choosing character from the alphaNumericStr variable for (int j = 0; j < size; j++) { // getting characters from the string alphaNumericStr char c = alphaNumericStr.charAt(j); // appending the character sbdr.append(c); } // getting string from the Stringbuilder String str = sbdr.toString(); // returning the randomly generated string return str; } // main method public static void main(String argvs[]) { // creating an object of the RandomStringsExample2 RandomStringsExample2 ob = new RandomStringsExample2(); int j = 0; System.out.println("The 20 random strings are: \n"); // Loop for generating 20 random strings while(j < 20) { // determining the size of the random string int size = (int)(20 * Math.random()); String str = ob.getRandomString(size); // printing the randomly generated string System.out.println(str); j = j + 1; } } }
Output:
The 20 random strings are: gK vLWBXmdPucx3wkqDy N5K112 a5W TbQ90aRC Eg0qV iFYcB m4MH9mu kU99SC6a6a3Nl9p nHliLGJFg GxLfHllWPPv095bJt d6idlFKVGczJ TO7J VQ jdIZWzZw7j4r X0zFn52Yf7IyHXyhOgu UMq5wZM zhUMUKr0yvf i1OQVR8
Explanation: The above program is quite similar to the previous one. The only difference is that the usage of the regular expression. Instead of filtering the alphanumeric characters from the string using if-block, we have used the regular expression to eliminate the non-alphanumeric characters from the string.
By Using ASCII Values
The random strings can also be generated using the ASCII values of characters. In this approach, the random() method points to the ASCII value of the character. Using the ASCII value, the character is retrieved and added to the string. The string is then returned. Let’s observe the following example for a better understanding.
FileName: RandomStringsExample3.java
public class RandomStringsExample3 { // method for generating random character // the randomly generated character only comprise // of alphanumeric symbols public char getRandomChar() { // For capital letters A - Z double randNo1 = Math.random(); randNo1 = (randNo1 * (90 - 65 + 1) + 65); int randInt1 = (int)randNo1; // For small letters a -z double randNo2 = Math.random(); randNo2 = (randNo2 * (122 - 97 + 1) + 97); int randInt2 = (int)randNo2; // For numeric values 0 - 9 double randNo3 = Math.random(); randNo3 = (randNo3 * (57 - 48 + 1) + 48); int randInt3 = (int)randNo3; // For choosing between capital or small letters or numbers double randNo4 = Math.random() * 3; int randInt4 = (int)randNo4; char ch; // 2 maps to numeric values if(randInt4 == 2) { ch = (char)randInt3; } // 1 maps to small letters else if(randInt4 == 1) { ch = (char)randInt2; } // 0 maps to capital letters else { ch = (char)randInt1; } return ch; } // method to generate random strings public String getRandomString(int size) { // declaring variable for storing alphanumeric string String alphaNumericStr = ""; // loop for adding character to the alphaNumericStr variable for (int j = 0; j < size; j++) { // invoking the method getRandomChar() char c = getRandomChar(); // getting characters from the string alphaNumericStr alphaNumericStr = alphaNumericStr + c; } // returning the randomly generated string return alphaNumericStr; } // main method public static void main(String argvs[]) { // creating an object of the RandomStringsExample3 RandomStringsExample3 ob = new RandomStringsExample3(); int j = 0; System.out.println("The 20 random strings are: \n"); // Loop for generating 20 random strings while(j < 20) { // determining the size of the random string int size = (int)(20 * Math.random()); String str = ob.getRandomString(size); // printing the randomly generated string System.out.println(str); j = j + 1; } } }
Output:
The 20 random strings are: 3vudQ74356062mSs831 CuMrf66G4CHN9227t Nh6ALPdHL 7wWeF78rPeQaC 99942216r9oI 1Re0A5Ql5E3 1bw1mhKJ5f5zV0F0wv 70L X79LYk7GY3MJ BCHDXUYNyz6M FXRpy3XhLKo 2796rI3Ko3 qW25J9 ny024URSM6bhj20MK 0zFCKB33DQM0g08IAAg 893LH3M2VQBa pcJrEWVzp12cN7 vnFK1xr2 Z45Y2Wzb97ZdAny56uI IM20d5c691tZx8
Explanation: The random() method has been used in such a way that it always generates numbers ranging between 65 – 90, 97 – 122, and 48 – 57. These ranges are nothing but the ASCII value of capital letters, small letters, and digits, respectively. The choice of selection among the capital letters or small letters or digits is also dependent on the random() method. The variable randInt4 determines whether the next character is going to be a capital letter, or smaller letter, or the digits. The randInt4 always gives a random value between 0 to 2, where 0 maps to capital letters, 1 map to small letters, and the 2 maps to digits.