Efficient way to generate alphanumeric number which is not already in list

This is my code is there any efficient way other than this

        List<String> numbers = Arrays.asList("1234acb","djnjwd222","djwnqfe456");
        boolean unique = false;
        while(!unique){
            final String ALPHA_NUMERIC = "abcdefghijklmnopqrstuvwxyz0123456789";
            StringBuilder builder = new StringBuilder();
            int length = 15;
            while (length-- != 0) {
                int character = (int)(Math.random()*ALPHA_NUMERIC.length());
                builder.append(ALPHA_NUMERIC.charAt(character));
            }
            if(!numbers.contains(builder.toString())){
                unique = true;
            }
        }

Yet another update

Thanks to Joni for reviewing my last update. He rightly pointed out that the code in the last update could use a symbol only once. The following solution solves that issue. It also handles the uniqueness in an improved way.

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

public class Main {
	public static void main(String[] args) {
		List<String> numbers = Arrays.asList("1234acb", "djnjwd222", "djwnqfe456");
		boolean unique = false;

		// Generate the List of string each having only one char from a-z 0-9
		List<String> list = "abcdefghijklmnopqrstuvwxyz0123456789".chars()
								.mapToObj(c -> String.valueOf((char) c))
								.collect(Collectors.toList());

		// Shuffle the elements of the list
		Collections.shuffle(list);

		//Get nano seconds from JVM
		long nano = System.nanoTime();
		StringBuilder str = new StringBuilder();
		while (nano != 0) {
			// Get the string (char) from `list` at the index = last digit of `nano`
			str.append(list.get((int) (nano % 10)));

			// Make nano smaller by one tenth
			nano /= 10;
		}

		System.out.println(str);

		// Check if `numbers` contains `str`
		if (!numbers.contains(str)) {
			unique = true;
		}

		System.out.println(unique ? "Unique" : "Not unique");
	}
}

A sample run:

a5ago6u393g6frf
Unique

Update

As pointed out by Joni, the generated string in the original answer contained only 0-9 a-f. The following solution solves that issue:

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

public class Main {
	public static void main(String[] args) {
		List<String> numbers = Arrays.asList("1234acb", "djnjwd222", "djwnqfe456");
		boolean unique = false;

		// Generate the List of string each having only one char from a-z 0-9
		List<String> list = "abcdefghijklmnopqrstuvwxyz0123456789".chars()
								.mapToObj(c -> String.valueOf((char) c))
								.collect(Collectors.toList());

		// Shuffle the elements of the list
		Collections.shuffle(list);

		// Get a string by joining the first 16 elements of the list
		String str = String.join("", list.subList(0, 16));
		System.out.println(str);
		
		// Check if `numbers` contains `str`
		if (!numbers.contains(str)) {
			unique = true;
		}

		System.out.println(unique ? "Unique" : "Not unique");
	}
}

A sample run:

miblz0o61r89xdg5
Unique

Original answer:

You can use UUID to generate a random alphanumeric string. Note that this string contains - which you can replace with an empty string and then get the first 16 characters from the resulting string.

import java.util.UUID;

public class Main {
	public static void main(String[] args) {
		System.out.println(UUID.randomUUID().toString().replace("-", "").substring(0, 16));
	}
}

Output:

68477a8bf3084a42

Copy pasting @AniketSahrawat's comment before mods clear up the section. The original post is available on pastebin and the comment by user Aniket is/was available here:

Set<String> numbers = new HashSet<>();
while (!numbers.add(ThreadLocalRandom.current().ints()
    .flatMap(l -> Integer.toString(l, 36).chars())
    .limit(15)
    .collect(StringBuilder::new,
        StringBuilder::appendCodePoint,
        StringBuilder::append).toString()));

I would be happy to delete this answer if Aniket decides to post it. Performance difference in another answer by Arvind vs Aniket is:

59968 <- another answer
191   <- this answer

EDIT:

I just tested this answer with UUID.randomUUID().toString().replace("-", "").substring(0, 16) and it turns out that this answer is faster than UUID.randomUUID().toString().replace("-", "").substring(0, 16) using Set<String> as backing data type. Here is it's pastebin.