Quiero generar una cadena aleatoria de 9 siempre separando 3 cadenas con "-"

Debe poner esto al final: XXX-XXX-XXX

Hasta ahora he logrado crear un Random de 9 pero no sé cómo hacer el resto

map.put("referCode", getRandomCode(9));
public static String getRandomCode(int i) {
    final String characters = "ABCDEFGHIJKLMONPQRSTUVWXYZ0123456789";
    StringBuilder result = new StringBuilder();
    while (i > 0) {
        Random random = new Random(); 
        result.append(characters.charAt(random.nextInt(characters.length())));
        i++;
    }
    return result.toString();
}
-2
arma 5 oct. 2021 a las 00:16

6 respuestas

La mejor respuesta

Aquí tienes, este algoritmo es universal. Funcionará para todos los valores, no solo para 9 caracteres.

public class Algorithm {

    private static final String CHARACTERS = "ABCDEFGHIJKLMONPQRSTUVWXYZ0123456789";
    
    public static void main(String[] args) {
        System.out.println(getRandomCode(9));
        System.out.println(getRandomCode(12));
        System.out.println(getRandomCode(15));
        System.out.println(getRandomCode(50));
    }
 
    public static String getRandomCode(int numberOfCharacters) {
        StringBuilder result = new StringBuilder();
        Random random = new Random();
        for (int index = 1; index <= numberOfCharacters; index++) {
            result.append(CHARACTERS.charAt(random.nextInt(CHARACTERS.length())));
            if (index % 3 == 0 && index != numberOfCharacters) {
                result.append("-");
            }
        }
        return result.toString();
    }
} 

Imprimirá:

8PJ-Y6T-4LV
FE7-WRY-64A-2L2
23H-A24-CBF-E8Z-NHD
DXA-8Z3-DB4-2ZS-U2O-SQS-CAR-Y5Z-UXT-AP9-3TI-9ZO-D7T-OMZ-RDN-K34-BB

Además, si desea probar lo mismo con el bucle while, primero puede dividir la cadena por 3, agregar resultados a la lista y luego unirlos con String.join:

public static String getRandomCode(int numberOfCharacters) {

        List<String> results = new ArrayList<>();
        StringBuilder result = new StringBuilder();
        Random random = new Random();
        
        int index = 0;
        int prevIndex = 0;
       
        while (index < numberOfCharacters) {
            index++;
            result.append(CHARACTERS.charAt(random.nextInt(CHARACTERS.length())));
            if (index % 3 == 0) {
                results.add(result.substring(prevIndex, index));
                prevIndex = index;
            }
        }
        return String.join("-", results);
    }

Y si quieres ser súper elástico también puedes parametrizar el punto de división, por lo que no solo en 3, sino también en cualquier otro valor:

private static final String CHARACTERS = "ABCDEFGHIJKLMONPQRSTUVWXYZ0123456789";

    public static void main(String[] args) {
        System.out.println(getRandomCode(9,3));
        System.out.println(getRandomCode(12,4));
        System.out.println(getRandomCode(15,5));
        System.out.println(getRandomCode(150,50));
    }

    public static String getRandomCode(int numberOfCharacters, int splitPointIndex) {

        List<String> results = new ArrayList<>();
        StringBuilder result = new StringBuilder();
        Random random = new Random();

        int index = 0;
        int prevIndex = 0;

        while (index < numberOfCharacters) {
            index++;
            result.append(CHARACTERS.charAt(random.nextInt(CHARACTERS.length())));
            if (index % splitPointIndex == 0) {
                results.add(result.substring(prevIndex, index));
                prevIndex = index;
            }
        }
        return String.join("-", results);
    }

Imprimirá:

HBZ-BWT-MYI
7YSM-DD0K-HJYF
EUQ2P-NFJ4F-L4MRP
MG91WG9F9HF1GM0UH6I91VX7TLNIUDPQUCUK8SXDQ3T087JPAE-JJ6IZHKH2YBZBJKPPHJFR43112JKQDBJ9LSTAA7BTB6O3JXTYX-EGCJBGWJBZJOGBMVCH9TLCL9VSV3L15JR7QZIKIKOZGAOKR6GT

¡Salud!

1
MrFisherman 4 oct. 2021 a las 21:46

Además de las respuestas dadas, puede ser posible usar expresiones regulares para insertar un separador / delimitador entre cada N caracteres:

  • usando String::replaceAll:
System.out.println(random.replaceAll("(.{3})(?!$)", "$1-"));

Aquí se utiliza una búsqueda anticipada negativa para detectar el final de la cadena (?!$).

System.out.println(String.join("-", random.split("(?<=\\G.{3})")));

Para la cadena "aleatoria" dada:

for (String random : Arrays.asList("12345678", "ABCDEF123456")) {
    System.out.println(random.replaceAll("(.{3})(?!$)", "$1-"));
  
    System.out.println(String.join("-", random.split("(?<=\\G.{3})")));
}

El resultado es el siguiente:

123-456-78
123-456-78
ABC-DEF-123-456
ABC-DEF-123-456
3
Alex Rudenko 4 oct. 2021 a las 22:32

Puedes hacer algo como esto:

private static final String CHARACTERS = "ABCDEFGHIJKLMONPQRSTUVWXYZ0123456789";
public static String getRandomCode() {
    StringBuilder result = new StringBuilder();
    Random random = new Random(); 
    for (int i = 0; i < 9; i++) {
        result.append(CHARACTERS.charAt(random.nextInt(CHARACTERS.length())));
        if (i == 2 || i == 5)
            resault.append('-');
    }
    return result.toString();
}

Otra opción será usar lo que ya escribió y hacer esto:

String code = getRandomCode(9);
code = code.substring(0,3) + '-' + code.substring(3,6) + '-' + code.substring(6,9);

Para un caso más general, puede usar esto:

private static final String CHARACTERS = "ABCDEFGHIJKLMONPQRSTUVWXYZ0123456789";
public static String getRandomCode(int segmentLength, int segmentAmount) {
    StringBuilder result = new StringBuilder();
    Random random = new Random(); 
    for (int i = 0; i < segmentAmount; i++) {
        if (i != 0)
            resault.append('-');
        for (int j = 0; j < segmentLength; j++)
            result.append(CHARACTERS.charAt(random.nextInt(CHARACTERS.length())));
    }
    return result.toString();
}
1
Ofek 4 oct. 2021 a las 21:37
String randomString = result.toString();
String firstSegment = randomString.substring(0, 3);
String secondSegment = randomString.substring(3, 6);
String thirdSegment = randomString.substring(6, 10);

String finalResult = firstSegment + "-" + secondSegment + "-" + thirdSegment;

return finalResult;
1
JonR85 4 oct. 2021 a las 22:10

Prueba esto.

static final String CHARACTERS = "ABCDEFGHIJKLMONPQRSTUVWXYZ0123456789";

public static String getRandomCode(int i) {
    return new Random().ints(i, 0, CHARACTERS.length())
        .mapToObj(r -> String.valueOf(CHARACTERS.charAt(r)))
        .collect(Collectors.joining())
        .replaceAll(".{3}(?!$)", "$0-");
}

public static void main(String[] args) {
    System.out.println(getRandomCode(9));
    System.out.println(getRandomCode(10));
}

Salida:

MHC-ELK-44H
9X8-L2P-UMD-L
1
saka1029 4 oct. 2021 a las 22:12

Si siempre va a tener una longitud de nueve, entonces esto puede ser bastante compacto.

public static String gen() {
    return String.format("%s-%s-%s", triplet(), triplet(), triplet());
}

private static String triplet() {
    return String.format("%c%c%c", single(), single(), single());
}

private static char single() {
    return (char) ('A' + ThreadLocalRandom.current().nextInt('Z'-'A' + 1));
}
0
PPartisan 4 oct. 2021 a las 22:27