Java Password Generator

Usually, we need to generate a secure password for security purposes. There are several ways to generate a strong password in Java. In this section, we will understand how we can generate a strong password having at least two lowercase characters, two uppercase characters, two digits, and two special characters.

There are the following ways to generate a password in Java:

1. Using Passay Library

Passay is one of the most used password policy enforcement libraries. We use the library to generate a password using a configurable ruleset. We can create the necessary rules for passwords by using the default CharacterData implementation. We can also create our custom CharacterData implementation as per our needs.

In order to use Passay library we need to add the following dependency in the POM.xml file:

<dependency>
    	<groupId>org.passay</groupId>
    	<artifactId>passay</artifactId>
    	<version>1.3.1</version>
</dependency>

Let's take an example to understand how we can use the Passay library to generate random passwords:

GeneratePasswordExample1.java

// import required classes and packages
package javaTpoint.JavaExample;

import org.passay.CharacterRule;
import org.passay.EnglishCharacterData;
import org.passay.PasswordGenerator;

// create class GeneratePasswordExample1 to generate a random and secure password
public class GeneratePasswordExample1 {
	
	// main() method start
	public static void main(String args[]) {
		
		// call the generatePassword() method to generate a random password using the Passay library
		String pass = generateSecurePassword();
		
		// print Passay generated password
		System.out.println("The Passay generated password is:"+pass);
		
	}
	
	// create generateSecurePassword() method that find the secure password and returns it to the main() method
	public static String generateSecurePassword() {
		
		// create character rule for lower case
		CharacterRule LCR = new CharacterRule(EnglishCharacterData.LowerCase);
		// set number of lower case characters
		LCR.setNumberOfCharacters(2);

	    // create character rule for upper case
	    CharacterRule UCR = new CharacterRule(EnglishCharacterData.UpperCase);
	    // set number of upper case characters
	    UCR.setNumberOfCharacters(2);

	    // create character rule for digit
	    CharacterRule DR = new CharacterRule(EnglishCharacterData.Digit);
	    // set number of digits
	    DR.setNumberOfCharacters(2);

	    // create character rule for lower case
	    CharacterRule SR = new CharacterRule(EnglishCharacterData.Special);
	    // set number of special characters
	    SR.setNumberOfCharacters(2);
	    
	    // create instance of the PasswordGenerator class 
	    PasswordGenerator passGen = new PasswordGenerator();
	    
	    // call generatePassword() method of PasswordGenerator class to get Passay generated password
		String password = passGen.generatePassword(8, SR, LCR, UCR, DR);
		
		// return Passay generated password to the main() method 
		return password;
	}
}

Output:

2. Using RandomStringGenerator

It is another way to generate a secure password, i.e., by using RandomStringGenerator in Apache Commons Text. RandomStringGenerator generates Unicode string having a specified number of code points. We use RandomStringGenerator by creating an instance of the generator by using the Builder class of the RandomStringGenerator.

We can also modify the properties of the generator. There is one drawback of using this method, i.e., we cannot specify the number of characters in each set like Passay. However, we can overcome this drawback by combining the result of multiple sets.

Let's take an example to understand how we can generate a secure password using RandomStringGenerator.

GeneratePasswordExample2.java

//import required classes and packages
package javaTpoint.JavaExample;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

import org.apache.commons.text.RandomStringGenerator;
import static org.apache.commons.text.CharacterPredicates.DIGITS;

//create class GeneratePasswordExample2 to generate a random and secure password
public class GeneratePasswordExample2 {
	
	// main() method start
	public static void main(String args[]) {
		
		// call generateSecurePassword() method to generate random password using RandomStringGenerator
		String pass = generateSecurePassword();
		
		// print RandomStringGenerator password
		System.out.println("Password generated by RandomStringGenerator is:"+pass);
		
	}
	
	// create generateSecurePassword() method that find the secure 8 digit password and returns it to the main() method
	public static String generateSecurePassword() {
		
		// generate a string that contains 2 special chars, 2 numbers, 2 uppercase and 2 lower case
		String demoPassword = generateRandomSpecialCharacters(2)
				.concat(generateRandomNumbers(2))
				.concat(generateRandomAlphabet(2, true))
				.concat(generateRandomAlphabet(2, false));
		
		// create a list of Char that stores all the characters, numbers and special characters 
		List<Character> listOfChar = demoPassword.chars()
				.mapToObj(data -> (char) data)
				.collect(Collectors.toList());
		
		// use shuffle() method of the Collections to shuffle the list elements 
		Collections.shuffle(listOfChar);
		
		//generate a random string(secure password) by using list stream() method and collect() method
		String password = listOfChar.stream()
				.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
				.toString();
			    
		// return RandomStringGenerator password to the main() method 
		return password;
	}
	
	// create generateRandomSpecialCharacters() method that returns a string of special chars of the specified length
	public static String generateRandomSpecialCharacters(int length) {
		
		// generate special string of specials chars by using Builder(), withinRange() and build() methods
	    RandomStringGenerator generator = new RandomStringGenerator.Builder().withinRange(33, 45)
	        .build();
	    
	    return generator.generate(length);
	    
	}
	// create generateRandomNumbers() method that returns a string of numbers of the specified length
	public static String generateRandomNumbers(int length) {
		
		// generate special string of numbers by using Builder(), withinRange(), filteredBy() and build() methods
	    RandomStringGenerator generator = new RandomStringGenerator.Builder()
	    		.withinRange('0', 'z')
	            .filteredBy(DIGITS)
	            .build();
	    return generator.generate(length);
	    
	}
	
	// create generateRandomAlphabet () method that returns either a upper case string or lower case string
	// of the specified length based on the boolean variable check
	public static String generateRandomAlphabet(int length, boolean check) {
		
		String password;
		
		// for lower case string
		if(check == true) {
			RandomStringGenerator generator = new RandomStringGenerator.Builder().withinRange('a', 'z')
			        .build();
			password = generator.generate(length);
		}
		// for upper case string
		else {
			RandomStringGenerator generator = new RandomStringGenerator.Builder().withinRange('A', 'Z')
			        .build();
			password = generator.generate(length);
		}
	    
	    return password;
	}
}

Output:

3. Using RandomStringUtils

There is one more way to generate a secure password, i.e., by using RandomStringUtils class in Apache Commons Lang Library. The RandomStringUtils class provides several methods for generating a secure random password. The random() method of the class plays an important role in generating a password.

Let's take an example to understand how we can generate a secure password using RandomStringUtils class.

GeneratePasswordExample3.java

//import required classes and packages
package javaTpoint.JavaExample;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

import org.apache.commons.lang3.RandomStringUtils;

//create class GeneratePasswordExample3 to generate a random and secure password
public class GeneratePasswordExample3 {
	
	// main() method start
	public static void main(String args[]) {
		
		// call generateSecurePassword() method to generate random password using RandomStringUtils
		String pass = generateSecurePassword();
		
		// print RandomStringUtils password
		System.out.println("Password generated by RandomStringUtils class is:"+pass);
		
	}
	
	// create generateSecurePassword() method that find the secure 10 digit password and returns it to the main() method
	public static String generateSecurePassword() {
		
		// generate a string of upper case letters having length 2
		String upperCaseStr = RandomStringUtils.random(2, 65, 90, true, true);
	   
		// generate a string of lower case letters having length 2
		String lowerCaseStr = RandomStringUtils.random(2, 97, 122, true, true);
	    
		// generate a string of numeric letters having length 2
		String numbersStr = RandomStringUtils.randomNumeric(2);
	    
		// generate a string of special chars having length 2
		String specialCharStr = RandomStringUtils.random(2, 33, 47, false, false);
	    
		// generate a string of alphanumeric letters having length 2
		String totalCharsStr = RandomStringUtils.randomAlphanumeric(2);
	    
		// concatenate all the strings into a single one
		String demoPassword = upperCaseStr.concat(lowerCaseStr)
	      .concat(numbersStr)
	      .concat(specialCharStr)
	      .concat(totalCharsStr);
		
		// create a list of Char that stores all the characters, numbers and special characters 
		List<Character> listOfChar = demoPassword.chars()
				.mapToObj(data -> (char) data)
				.collect(Collectors.toList());
		
		// use shuffle() method of the Collections to shuffle the list elements 
		Collections.shuffle(listOfChar);
		
		//generate a random string(secure password) by using list stream() method and collect() method
		String password = listOfChar.stream()
				.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
				.toString();
			    
		// return RandomStringGenerator password to the main() method 
		return password;
	}
	
}

Output:

4. Using Custom Utility Method

There is another last way to generate a secure password, i.e., by using Custom Utility Method. We use the SecureRandom class for creating a custom utility class. Here, we create four methods for getting a character stream of numbers, upper case letters, lower case letters, and special characters of the specified length. After that, we concatenate each one of them to generate a strong password.

Let's take an example to understand how we can generate a secure password using Custom Utility Method:

GeneratePasswordExample4.java

//import required classes and packages
package javaTpoint.JavaExample;

import java.security.SecureRandom;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

//create class GeneratePasswordExample4 to generate a random and secure password
public class GeneratePasswordExample4 {
	
	// main() method start
	public static void main(String args[]) {
		
		// call generateSecurePassword() method to generate random password using Custom Utility Method
		String pass = generateSecurePassword();
		
		// print RandomStringUtils password
		System.out.println("Password generated by Custom Utility Method is:"+pass);
		
	}
	
	// create generateSecurePassword() method that find the secure 10 digit password and returns it to the main() method
	public static String generateSecurePassword() {
		
		// generate a string having 2 numbers, 2 special chars, 2 upper case letters, and 2 lower case letters
		 Stream<Character> demoPassword = Stream.concat(getRandomNumbers(2), 
				 Stream.concat(getRandomSpecialChars(2), 
						 Stream.concat(getRandomAlphabets(2, true), getRandomAlphabets(2, false))));
		
		// create a list of Char that stores all the characters, numbers, and special characters 
		List<Character> listOfChar = demoPassword.collect(Collectors.toList());
		
		// use shuffle() method of the Collections to shuffle the list elements 
		Collections.shuffle(listOfChar);
		
		//generate a random string(secure password) by using list stream() method and collect() method
		String password = listOfChar.stream()
				.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
				.toString();
			    
		// return RandomStringGenerator password to the main() method 
		return password;
	}
	// create getRandomSpecialChars() method that returns a Stream of special chars of the specified length
	public static Stream<Character> getRandomSpecialChars(int length) {
		
		Stream<Character> specialCharsStream;
		
		// create instance of SecureRandom
	    Random random = new SecureRandom();
	    
	    // use ints() method of random to get IntStream of special chars of the specified length
	    IntStream specialChars = random.ints(length, 33, 45);
	    specialCharsStream =  specialChars.mapToObj(data -> (char) data);
	    
	    // return stream to the main() method
	    return specialCharsStream;
	}
	
	// create getRandomNumbers() method that returns a Stream of numbers of the specified length
	public static Stream<Character> getRandomNumbers(int length) {
		
		Stream<Character> numberStream;
		
		// create instance of SecureRandom
		Random random = new SecureRandom();
	    
		// use ints() method of random to get IntStream of number of the specified length
		IntStream numberIntStream = random.ints(length, 48, 57);
		numberStream = numberIntStream.mapToObj(data -> (char) data);
	    
		// return number stream to main() method
	    return numberStream;
	}
	
	// create getRandomAlphabets() method that returns either a stream of upper case chars or stream of lower case chars
	// of the specified length based on the boolean variable check
	public static Stream<Character> getRandomAlphabets(int length, boolean check) {
		
		Stream<Character> lowerUpperStream;
		
		// for lower case stream
		if(check == true) {
			// create instance of SecureRandom
		    Random random = new SecureRandom();
		    
		    // use ints() method of random to get IntStream of lower case letters of the specified length
		    IntStream lCaseStream = random.ints(length, 'a', 'z');
		    lowerUpperStream =  lCaseStream.mapToObj(data -> (char) data);
		}
		// for upper case stream
		else {
			// create instance of SecureRandom
		    Random random = new SecureRandom();
		    
		    // use ints() method of random to get IntStream of upper case letters of the specified length
		    IntStream uCaseStream = random.ints(length, 'A', 'Z');
		    lowerUpperStream =  uCaseStream.mapToObj(data -> (char) data);
		}
		
		// return lowerUpperStream to main() method
		return lowerUpperStream;
		
	}
	
}

Output:

All the above-discussed methods are useful in generating a random secure password. However, we mostly use Passay and Apache Common Text libraries for generating a random secure password in Java.

Next TopicJava Program for Shopping Bill

← prev next →