正則表達式--密碼復雜度驗證--必須包含大寫、小寫、數字、特殊字符中的至少三項

密碼復雜度要求：

大寫字母、小寫字母、數字、特殊字符，四項中至少包含三項。

import org.junit.Test;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @Author Jareyliu
 * @Date 2021/1/11 12:07
 * @Version 1.0
 */
public class PasswordTest {
/**
     * 1.全部包含：大寫、小寫、數字、特殊字符；
     * 2.無大寫：小寫、數字、特殊字符；
     * 3.無小寫：大寫、數字、特殊字符；
     * 4.無數字：大寫、小寫、特殊字符；
     * 5.無特殊字符：大寫、小寫、數字；
     */
    @Test
    public void complexTest(){
        List<String> list = Arrays.asList(new String[]{
                //全包含
                "aBcd12@",
                "aB2@dfgh",
                "aB2_dfgh",
                "123Abc_",
                "_123Abc",
                "~123Abc",

                //無大寫
                "abcd12@",
                "!abcd12",
                "(abcd12",
                ")abcd12",
                "{abcd12",
                "}abcd12",
                "[abcd12",
                "]abcd12",
                "|abcd12",
                "\\abcd12",
                "\"abcd12",
                "'abcd12",
                ":abcd12",
                "?abcd12",
                "<abcd12",
                ">abcd12",
                "~abcd12",
                "3~bcd12",
                "F~bcd12",

                //無小寫
                "ABCD12@",
                "!ABCD12",
                "!AB12333",

                //無數字
                "aBcd_@",
                "!Abcd",

                //無特殊字符
                "abCd12",
                "abcD12",

                "12345678",
                "abcdefgh",
                "ABCDEFGH",
                "abcd1234",
                "ABCD1234",

                //無特殊字符
                "aBcd1234",

                //無數字
                "abcdEfgh!",

                "~!@#$%^&*()_+{}:'?<>",
                "abcd!@#$",
                "1234!@#$",
                "",
                null

        });

        List<String> matches = new ArrayList<String>();

        for(String word : list){
            //
            if(isComplexityMatches(word)) {
                matches.add(word);
            }
        }

        System.out.println(Arrays.toString(matches.toArray()));

        List<String> matches2 = new ArrayList<String>();
        for(String word : list){
            //
            if(isComplexityMatches2(word)) {
                matches2.add(word);
            }
        }
        System.out.println(Arrays.toString(matches2.toArray()));

        List<String> matches3 = new ArrayList<String>();
        for(String word : list){
            //
            if(isComplexityMatches3(word,5,6)) {
                matches3.add(word);
            }
        }
        System.out.println(Arrays.toString(matches3.toArray()));
    }

    /**
     * 復雜度要求：
     * 大寫、小寫、數字、特殊字符，需要包含其中至少三項
     *
     * @param content
     * @return
     */
    private boolean isComplexityMatches(String content){

        if(!StringUtils.hasLength(content)){
            return false;
        }

        //1.全部包含：大寫、小寫、數字、特殊字符；
        String regex1 = "(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[\\W_])^.*$";

        //2.無大寫：小寫、數字、特殊字符；
        String regex2 = "(?=.*[a-z])(?=.*[0-9])(?=.*[\\W_])^.*$";

        //3.無小寫：大寫、數字、特殊字符；
        String regex3 = "(?=.*[A-Z])(?=.*[0-9])(?=.*[\\W_])^.*$";

        //4.無數字：大寫、小寫、特殊字符；
        String regex4 = "(?=.*[A-Z])(?=.*[a-z])(?=.*[\\W_])^.*$";

        //5.無特殊字符：大寫、小寫、數字；
        String regex5 = "(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])^.*$";

        String regex = "(" + regex1 + ")|(" + regex2 + ")|(" + regex3 + ")|(" + regex4 + ")|(" + regex5 + ")";

        return content.matches(regex);
    }

    private boolean isComplexityMatches2(String content){
        if(!StringUtils.hasLength(content)){
            return false;
        }
        //String regex = "^(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_!@#$%^&*`~()-+=]+$)(?![a-z0-9]+$)(?![a-z\\W_!@#$%^&*`~()-+=]+$)(?![0-9\\W_!@#$%^&*`~()-+=]+$)[a-zA-Z0-9\\W_!@#$%^&*`~()-+=]{8,30}$";
        //String regex = "^(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)[a-zA-Z0-9\\W_]{8,30}$";
        //String regex = "^(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)[a-zA-Z0-9\\W_]{5,30}$";
        //String regex = "^(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)[a-zA-Z0-9\\W_]{5,}$";
        String regex = "^(?![A-Za-z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)[A-Za-z0-9\\W_]{5,}$";//ok
        //String regex = "(?![A-Za-z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)^[A-Za-z0-9\\W_]{5,}$";//ok
        //String regex = "^[A-Za-z0-9\\W_]{5,}$(?![A-Za-z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)";

        //錯誤的模式，測試結果不正確（此模式匹配的是：大寫、小寫、數字、特殊字符等四項必須全部包含）
        String regex2 = "^(?![A-Za-z0-9]+$)(?![a-z0-9\\W]+$)(?![A-Za-z\\W]+$)(?![A-Z0-9\\W]+$)[a-zA-Z0-9\\W]{5,30}$";

        return content.matches(regex);
        //return content.matches(regex2);
    }

    private boolean isComplexityMatches3(String content,Integer minLength,Integer maxLength){
        if(!StringUtils.hasLength(content)){
            return false;
        }

        if(minLength != null && maxLength != null && minLength > maxLength){
            System.out.println("參數非法：最小長度不能大於最大長度。");
            return false;
        }

        if(minLength == null && maxLength != null && maxLength < 0){
            System.out.println("參數非法：最大長度不能小於0。");
            return false;
        }

        String length = "";
        if(minLength == null || minLength < 1){
            length = "{0,";
        }else{
            length = "{" + minLength + ",";
        }
        if(maxLength == null){
            length = length + "}";
        }else {
            length = length + maxLength + "}";
        }

        //String regex = "^(?![A-Za-z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)[A-Za-z0-9\\W_]{5,}$";//ok
        String regex = "^(?![A-Za-z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_]+$)(?![a-z0-9]+$)(?![a-z\\W_]+$)(?![0-9\\W_]+$)[A-Za-z0-9\\W_]" + length + "$";

        return content.matches(regex);
    }
}