Java 使用扫描程序验证字符串是否为空，并将空字符串作为有效值返回_Java_String_Validation

Java 使用扫描程序验证字符串是否为空，并将空字符串作为有效值返回

java string validation

Java 使用扫描程序验证字符串是否为空，并将空字符串作为有效值返回,java,string,validation,Java,String,Validation,我使用Java中的Scanner获取用户条目，如姓名、姓氏、电子邮件和电话。姓名和姓氏是必需的，但电子邮件和电话不是必需的，用户只需按enter键即可将其保留为空这是我用来验证每个条目长度的方法，如果长度小于或大于lngMin或lngMax，则显示错误消息 public static String validateString (String msgSoll, String msgErr, int lngMin, int lngMax) {

我使用Java中的Scanner获取用户条目，如姓名、姓氏、电子邮件和电话。姓名和姓氏是必需的，但电子邮件和电话不是必需的，用户只需按enter键即可将其保留为空

这是我用来验证每个条目长度的方法，如果长度小于或大于lngMin或lngMax，则显示错误消息

public static String validateString (String msgSoll, String msgErr, 
               int lngMin, int lngMax) {
          String myString = null;
          
          if (lngMin >= 0 && lngMax >= lngMin) {
             do {
                System.out.print(msgSoll);
                myString = myScanner.nextLine();
                if (myString.length() < lngMin || myString.length() > lngMax) {
                   System.out.println(msgErr);
                }
             } while (myString.length() < lngMin || myString.length() > lngMax);
          }
          return myString;
       }

我有这个方法来验证电话，我使用了一个方法来验证电话是否只包含数字字符。在该方法中，我还需要验证tel是否为空，如果为空，则返回空tel作为有效值

public static String validateEmail() {
        String email = null;
        String validEmail = null;
        boolean isAlpha = false;

            do {

                email = validateString(MSG_SOLL_COURRIEL, MSG_ERR_COURRIEL, 5, 50);

                isAlpha = Tp2Utils.isAlphaNumPlus(email, "@,.,_") && Tp2Utils.hasNChar(email, '.') >= 1 && Tp2Utils.hasNChar(email, '@') == 1;


                    if (isAlpha) {
                        validEmail = email;
                    }


            } while (!isAlpha);

        return validEmail;
}

 public static String validateTel() {
    
            boolean telValid = false;
    
            String tel = null;
            String telVal;
    
            do {
    
                tel = validateString(MSG_SOLL_TEL, MSG_ERR_TEL, 10, 10);
    
                telValid = Tp2Utils.containsOnlyNums(tel);
    
    
            } while (!telValide);
    
            telVal = tel;
    
            return telVal;  
        }

如果有人能帮我解决验证问题，我将不胜感激

感谢的更新（感谢）：

虽然添加新参数，

boolean emmandable

将使代码不那么混乱和干净，但即使处理

lngMin的值，问题也可以得到解决
public static String validateString (String msgSoll, String msgErr, int lngMin, int lngMax) {
    String myString = null;

    if (lngMin >= 0 && lngMax >= lngMin) {
        do {
            System.out.print(msgSoll);
            myString = myScanner.nextLine();

            // Return a blank string if the min required length is 0
            if (lngMin == 0 && myString.isBlank()) {
                return myString;
            }

            if (myString.length() < lngMin || myString.length() > lngMax) {
                System.out.println(msgErr);
            }
        } while (myString.length() < lngMin || myString.length() > lngMax);
    }

    return myString;
}

原始答案：
您可以在方法签名中放置布尔参数，例如布尔强制
。如果将此参数传递给false
，则该方法应返回空字符串，以防用户在未输入任何值的情况下按Enter键
public static String validateString (String msgSoll, String msgErr, int lngMin, int lngMax, boolean mandatory) {
    String myString = null;

    if (lngMin >= 0 && lngMax >= lngMin) {
        do {
            System.out.print(msgSoll);
            myString = myScanner.nextLine();

            // Return a blank string if not mandatory
            if (!mandatory && myString.isBlank()) {
                return myString;
            }

            if (myString.length() < lngMin || myString.length() > lngMax) {
                System.out.println(msgErr);
            }
        } while (myString.length() < lngMin || myString.length() > lngMax);
    }

    return myString;
}

更新（感谢）：
虽然添加新参数，boolean emmandable
将使代码不那么混乱和干净，但即使处理lngMin的值，问题也可以得到解决
public static String validateString (String msgSoll, String msgErr, int lngMin, int lngMax) {
    String myString = null;

    if (lngMin >= 0 && lngMax >= lngMin) {
        do {
            System.out.print(msgSoll);
            myString = myScanner.nextLine();

            // Return a blank string if the min required length is 0
            if (lngMin == 0 && myString.isBlank()) {
                return myString;
            }

            if (myString.length() < lngMin || myString.length() > lngMax) {
                System.out.println(msgErr);
            }
        } while (myString.length() < lngMin || myString.length() > lngMax);
    }

    return myString;
}

原始答案：
您可以在方法签名中放置布尔参数，例如布尔强制
。如果将此参数传递给false
，则该方法应返回空字符串，以防用户在未输入任何值的情况下按Enter键
public static String validateString (String msgSoll, String msgErr, int lngMin, int lngMax, boolean mandatory) {
    String myString = null;

    if (lngMin >= 0 && lngMax >= lngMin) {
        do {
            System.out.print(msgSoll);
            myString = myScanner.nextLine();

            // Return a blank string if not mandatory
            if (!mandatory && myString.isBlank()) {
                return myString;
            }

            if (myString.length() < lngMin || myString.length() > lngMax) {
                System.out.println(msgErr);
            }
        } while (myString.length() < lngMin || myString.length() > lngMax);
    }

    return myString;
}

完整解决方案：
public class Main {


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String name = getValidatedField(in, "Enter your name: ", Validators.NAME_VALIDATOR);
        String surname = getValidatedField(in, "Enter your surname: ", Validators.NAME_VALIDATOR);
        String email = getValidatedField(in, "Enter your email: ", Validators.EMAIL_VALIDATOR);
        String phone = getValidatedField(in, "Enter your phone: ", Validators.PHONE_VALIDATOR);

        // process your validated fields here
    }

    private static String getValidatedField(Scanner in, String message, Function<String, ValidationResult> validationRule) {
        ValidationResult validationResult;
        String input;
        do {
            System.out.println(message);
            input = in.nextLine();
            validationResult = validationRule.apply(input);
            System.out.println(validationResult.getMessage());
        } while (!validationResult.isSuccess());
        return input;
    }
}

class Validators {
    private static final String WRONG_LENGTH_MSG = "Invalid length.";
    private static final String WRONG_FORMAT_MSG = "Wrong format.";
    private static final String EMAIL_PATTERN = "(^$|^[A-Za-z0-9]+@[A-Za-z0-9]+\\.[A-Za-z]+$)";
    private static final String NAME_PATTERN = "^[A-Za-z ,.'-]*$";
    private static final String ONLY_NUMBERS_PATTERN = "^[0-9]*$";

    private static boolean checkMinMaxLength(final String input, int min, int max) {
        int length = input.length();
        return length < min || length > max;
    }

    public static Function<String, ValidationResult> NAME_VALIDATOR = input ->
    {
        final ValidationResult result;
        if (checkMinMaxLength(input, 1, 10)) {
            result = ValidationResult.failure().message(WRONG_LENGTH_MSG);
        } else if (!input.matches(NAME_PATTERN)) {
            result = ValidationResult.failure().message(WRONG_FORMAT_MSG);
        } else {
            result = ValidationResult.success();
        }
        return result;
    };

    public static Function<String, ValidationResult> PHONE_VALIDATOR = input ->
    {
        final ValidationResult result;
        if (!StringUtils.isBlank(input)) {
            if (checkMinMaxLength(input, 2, 11)) {
                result = ValidationResult.failure().message(WRONG_LENGTH_MSG);
            } else if (!input.matches(ONLY_NUMBERS_PATTERN)) {
                result = ValidationResult.failure().message(WRONG_FORMAT_MSG);
            } else {
                result = ValidationResult.success();
            }
        } else {
            result = ValidationResult.success();
        }
        return result;
    };

    public static Function<String, ValidationResult> EMAIL_VALIDATOR = input ->
    {
        final ValidationResult result;
        if (!StringUtils.isBlank(input)) {
            if (checkMinMaxLength(input, 4, 20)) {
                result = ValidationResult.failure().message(WRONG_LENGTH_MSG);
            } else if (!input.matches(EMAIL_PATTERN)) {
                result = ValidationResult.failure().message(WRONG_FORMAT_MSG);
            } else {
                result = ValidationResult.success();
            }
        } else {
            result = ValidationResult.success();
        }
        return result;
    };


    private Validators() {
    }
}

class ValidationResult {
    private static final String OK_MSG = "OK";
    private final boolean success;
    private String message;

    public ValidationResult(boolean success) {
        this.success = success;
    }

    public ValidationResult(boolean success, String message) {
        this.success = success;
        this.message = message;
    }

    public static ValidationResult success() {
        return new ValidationResult(Boolean.TRUE, OK_MSG);
    }

    public static ValidationResult failure() {
        return new ValidationResult(Boolean.FALSE);
    }

    public ValidationResult message(String message) {
        this.message = message;
        return this;
    }

    public boolean isSuccess() {
        return success;
    }

    public String getMessage() {
        return message;
    }
}

公共类主{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
String name=getValidatedField（在“输入您的姓名：”中，Validators.name\u VALIDATOR）；
字符串姓氏=getValidatedField（在“输入您的姓氏：”中，Validators.NAME\u VALIDATOR）；
String email=getValidatedField（在“输入您的电子邮件：”中，Validators.email\u VALIDATOR）；
String phone=getValidatedField（在“输入您的电话：”中，Validators.phone\u VALIDATOR）；
//在此处处理已验证的字段
}
私有静态字符串getValidatedField（扫描仪输入、字符串消息、函数验证规则）{
验证结果验证结果；
字符串输入；
做{
System.out.println（消息）；
input=in.nextLine（）；
validationResult=validationRule.apply（输入）；
System.out.println（validationResult.getMessage（））；
}而（！validationResult.issucess（））；
返回输入；
}
}
类验证器{
私有静态最终字符串错误。\u LENGTH\u MSG=“长度无效。”；
私有静态最终字符串格式错误。\u MSG=“格式错误。”；
私有静态最终字符串EMAIL_PATTERN=“（^$|^[A-Za-z0-9]+@[A-Za-z0-9]+\\[A-Za-z]+$）”；
私有静态最终字符串名称_PATTERN=“^[A-Za-z，.-]*$”；
仅限私有静态最终字符串\u数字\u模式=“^[0-9]*$”；
私有静态布尔checkMinMaxLength（最终字符串输入，int-min，int-max）{
int length=input.length（）；
返回长度<最小值|长度>最大值；
}
公共静态函数名\验证程序=输入->
{
最终验证结果；
if（checkMinMaxLength（输入，1，10））{
结果=ValidationResult.failure（）.消息（长度错误消息）；
}如果（！input.matches（NAME_PATTERN））{
结果=ValidationResult.failure（）.消息（格式错误消息）；
}否则{
结果=ValidationResult.success（）；
}
返回结果；
};
公共静态功能电话\验证程序=输入->
{
最终验证结果；
如果（！StringUtils.isBlank（输入））{
if（checkMinMaxLength（输入，2，11））{
结果=ValidationResult.failure（）.消息（长度错误消息）；
}如果（！input.matches（仅\u数字\u模式））{
结果=ValidationResult.failure（）.消息（格式错误消息）；
}否则{
结果=ValidationResult.success（）；
}
}否则{
结果=ValidationResult.success（）；
}
返回结果；
};
公共静态函数EMAIL_VALIDATOR=输入->
{
最终验证结果；
如果（！StringUtils.isBlank（输入））{
if（checkMinMaxLength（输入，4，20））{
结果=ValidationResult.failure（）.消息（长度错误消息）；
}如果（！input.matches（电子邮件模式））{
结果=ValidationResult.failure（）.消息（格式错误消息）；
}否则{
结果=ValidationResult.success（）；
}
}否则{
结果=ValidationResult.success（）；
}
返回结果；
};
专用验证器（）{
}
}
类验证结果{
私有静态最终字符串OK_MSG=“OK”；
个人成功；
私有字符串消息；
公共验证结果（布尔成功）{
成功=成功；
}
公共验证结果（布尔成功，字符串消息）{
成功=成功；
this.message=消息；
}
公共静态验证结果成功（）{
返回新的ValidationResult（Boolean.TRUE，OK_MSG）；
}
公共静态验证结果失败（）{
返回新的ValidationResult（Boolean.FALSE）；
}
公共验证结果消息（字符串消息）{
this.message=消息；
归还这个；
}
公共布尔值isSuccess（）{
回归成功；
}
公共字符串getMessage（）{
返回消息；
}
}
完整解决方案：
public class Main {


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String name = getValidatedField(in, "Enter your name: ", Validators.NAME_VALIDATOR);
        String surname = getValidatedField(in, "Enter your surname: ", Validators.NAME_VALIDATOR);
        String email = getValidatedField(in, "Enter your email: ", Validators.EMAIL_VALIDATOR);
        String phone = getValidatedField(in, "Enter your phone: ", Validators.PHONE_VALIDATOR);

        // process your validated fields here
    }

    private static String getValidatedField(Scanner in, String message, Function<String, ValidationResult> validationRule) {
        ValidationResult validationResult;
        String input;
        do {
            System.out.println(message);
            input = in.nextLine();
            validationResult = validationRule.apply(input);
            System.out.println(validationResult.getMessage());
        } while (!validationResult.isSuccess());
        return input;
    }
}

class Validators {
    private static final String WRONG_LENGTH_MSG = "Invalid length.";
    private static final String WRONG_FORMAT_MSG = "Wrong format.";
    private static final String EMAIL_PATTERN = "(^$|^[A-Za-z0-9]+@[A-Za-z0-9]+\\.[A-Za-z]+$)";
    private static final String NAME_PATTERN = "^[A-Za-z ,.'-]*$";
    private static final String ONLY_NUMBERS_PATTERN = "^[0-9]*$";

    private static boolean checkMinMaxLength(final String input, int min, int max) {
        int length = input.length();
        return length < min || length > max;
    }

    public static Function<String, ValidationResult> NAME_VALIDATOR = input ->
    {
        final ValidationResult result;
        if (checkMinMaxLength(input, 1, 10)) {
            result = ValidationResult.failure().message(WRONG_LENGTH_MSG);
        } else if (!input.matches(NAME_PATTERN)) {
            result = ValidationResult.failure().message(WRONG_FORMAT_MSG);
        } else {
            result = ValidationResult.success();
        }
        return result;
    };

    public static Function<String, ValidationResult> PHONE_VALIDATOR = input ->
    {
        final ValidationResult result;
        if (!StringUtils.isBlank(input)) {
            if (checkMinMaxLength(input, 2, 11)) {
                result = ValidationResult.failure().message(WRONG_LENGTH_MSG);
            } else if (!input.matches(ONLY_NUMBERS_PATTERN)) {
                result = ValidationResult.failure().message(WRONG_FORMAT_MSG);
            } else {
                result = ValidationResult.success();
            }
        } else {
            result = ValidationResult.success();
        }
        return result;
    };

    public static Function<String, ValidationResult> EMAIL_VALIDATOR = input ->
    {
        final ValidationResult result;
        if (!StringUtils.isBlank(input)) {
            if (checkMinMaxLength(input, 4, 20)) {
                result = ValidationResult.failure().message(WRONG_LENGTH_MSG);
            } else if (!input.matches(EMAIL_PATTERN)) {
                result = ValidationResult.failure().message(WRONG_FORMAT_MSG);
            } else {
                result = ValidationResult.success();
            }
        } else {
            result = ValidationResult.success();
        }
        return result;
    };


    private Validators() {
    }
}

class ValidationResult {
    private static final String OK_MSG = "OK";
    private final boolean success;
    private String message;

    public ValidationResult(boolean success) {
        this.success = success;
    }

    public ValidationResult(boolean success, String message) {
        this.success = success;
        this.message = message;
    }

    public static ValidationResult success() {
        return new ValidationResult(Boolean.TRUE, OK_MSG);
    }

    public static ValidationResult failure() {
        return new ValidationResult(Boolean.FALSE);
    }

    public ValidationResult message(String message) {
        this.message = message;
        return this;
    }

    public boolean isSuccess() {
        return success;
    }

    public String getMessage() {
        return message;
    }
}

公共类