You can have something like this: the regular expression you need to validate the data is:

/^[0-9]-[0-9]{7}$/

To use regular expressions in Java, use the package java.util.regex This has two classes that would greatly facilitate the solution to your problem: Pattern and Matcher. Your code would look like this:

 Pattern pat = Pattern.compile("^[0-9]-[0-9]{7}$");
 Matcher mat = pat.matcher(codigo);                                                                           
 if (mat.matches()) {
     System.out.println("Es válido");
 } else {
     System.out.println("El código debe constar de un número + un guión en la segunda posición + 7 números");                                                                                
 }

Based on the comments on my somewhat complicated answers, I leave you with two ways to solve the problem. The first without the need for regular expressions (which are ideal in this case), the second using them.

Solution 1

Note: To improve the way of knowing if it is a number or not, we will create a method that returns boolean if each character of a String is a digit (number). To do this, we will use the method that returns the UNICODEcodePointAt() code of the character, which in turn is backwards compatible with ASCII . As we can see, the digit codes go from 48 to 57, so we will use that as a reference in the solution.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 3;) {
            System.out.println("Ingrese el código:");
            String code = scanner.nextLine();
            if(code.length() != 9) {
                System.out.println("Código inválido." +
                        "\nEl código debe tener una longitud de 9 caracteres");
                continue;
            }
            if (!isNumeric(code.substring(0,1))) {
                System.out.println("Código inválido." +
                        "\nEl primer carácter debe ser un dígito");
                continue;
            }
            if(code.charAt(1) != '-') {
                System.out.println("Código inválido." +
                        "\nEl segundo carácter debe ser un guión");
                continue;
            }
            if (!isNumeric(code.substring(2, code.length()))){
                System.out.println("Código inválido." +
                        "\nLos últimos 7 caracteres deben ser dígitos");
                continue;
            }

            ++i;
        }

        scanner.close();
    }

    private static boolean isNumeric(String text) {
        int unicode_code;
        for (int i = 0; i < text.length(); i++) {
            // nos devuelve el caracter unicode del carácter
            unicode_code = text.codePointAt(i);
            if (unicode_code < 48 || unicode_code >57)
                return false;
        }
        return true;
    }
}

It should be noted that:

• First it is evaluated if the string is 9 characters
• To evaluate the first digit, the method is called isNumericand the first character is passed to it.
• To evaluate the script, simply get the second character of the String
• To evaluate the rest, they are passed from the 3rd character to the last.
• The method isNumericis static so that it can be used within another static context ( main ), it is also private, since it is only used within the class in which it is declared and defined, thus following the principle of least privilege.

Solution 2

This is much better than the first solution and makes use of the Pattern class since we are going to use regular expressions . Here is an incredibly useful cheat sheet .

The pattern you ask for is X-XXXXXXX, where each X is a number. Using the cheat sheet , we can then build the following regex:

Pattern pattern = Pattern.compile("^[0-9]-[0-9]{7}$");
// o
Pattern pattern = Pattern.compile("^\d-\d{7}$");

Where:

• ^Tells you to evaluate the start of the string
• [0-9](it can also be \dbecause they are synonyms) represents any digit between 0 and 9.
• -(Indicates an explicit hyphen)
• [0-9]{7}Indicates that the previous group ( [0-9]) must be exactly 7 times
• $It indicates that the chain should end there

As you will see, the program is greatly simplified, since a text pattern can be evaluated

import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Pattern pattern = Pattern.compile("[0-9]-[0-9]{7}");
        for (int i = 0; i < 3;) {
            System.out.println("Ingrese el código:");
            String code = scanner.nextLine();
            if(!pattern.matcher(code).matches()){
                System.out.println("Código inválido." +
                        "\nRecuerde que el formato es X-XXXXXXX");
                continue;
            }
            ++i;
        }
        scanner.close();
    }
}

It should be noted that:

• To evaluate the regular expression, it must be compared if the pattern matches what was entered.pattern.matcher(code).matches()
• In both solutions the counter i, increments inside the for loop. This is so that if the code does not comply with the pattern, the return is not counted, since the reserved word continuehelps us to skip the rest of the iteration,

Final note:

Almost nobody mentions it when starting to program, but it is good practice to close the Scanner scanner.close();when we stop using it, since it is a data input ( Input Stream ) that requests resources from the operating system. Although at the end of the execution of the program the JVM closes everything, it is "bad" or rather harmful, not to close the resources that you request.