语法糖_语法糖具体概念 - CSDN
精华内容
参与话题
  • java 正则密码校验

    千次阅读 2017-09-22 15:13:40
    密码校验需求:1) 密码控制只能输入字母、数字、特殊符号(~!@#$%^&*()_+[]{}|\;:’”,./<>?) 2) 长度 6-16 位,必须包括字母、数字、特殊符号中的2种 3) 密码不能包含用户名信息 /** * 具体规则可以自己定义 java...

    密码校验需求:

    1) 密码控制只能输入字母、数字、特殊符号(~!@#$%^&*()_+[]{}|\;:’”,./<>?)

    2) 长度 6-16 位,必须包括字母、数字、特殊符号中的2种

    3) 密码不能包含用户名信息

        /**
         * 具体规则可以自己定义 java代码
         * @param newPwd 新密码
         * @param loginName 用户名
         * @return
         */
        public boolean checkPwd(String newPwd, String loginName) {
            //判断密码是否包含数字:包含返回1,不包含返回0
            int i = newPwd.matches(".*\\d+.*") ? 1 : 0;
    
            //判断密码是否包含字母:包含返回1,不包含返回0
            int j = newPwd.matches(".*[a-zA-Z]+.*") ? 1 : 0;
    
            //判断密码是否包含特殊符号(~!@#$%^&*()_+|<>,.?/:;'[]{}\):包含返回1,不包含返回0
            int k = newPwd.matches(".*[_+|<>,.?/:;'\\[\\]{}\"]+.*") ? 1 : 0;
    
            //判断密码长度是否在6-16位
            int l = newPwd.length();
    
            //判断密码中是否包含用户名
            boolean contains = newPwd.contains(loginName);
    
            if (i + j + k < 2 || l < 6 || l > 16 || contains) {
                return false;
            }
            return true;
        }
    展开全文
  • (1)密码中连续数字超过3个;(说明:比如123,234,345)。 (2)密码不能有连续3个以上的数字或字母(说明:比如111,222,333,AAA,,bbb)。 (3)密码由6~16位数字和字母组成
  • Java密码正则表达式

    千次阅读 2019-07-02 09:00:44
    密码-【必填字母数字及特殊字符,且以字母开头,8位以上】(二级等保要求) /** * 正则表达式-强密码-【必填字母数字及特殊字符,且以字母开头,8位以上】 */ public static final String REGEX_PASSWORD_...

     强密码-【必填字母数字及特殊字符,且以字母开头,8位以上】(二级等保要求)

     

    /**
     * 正则表达式-强密码-【必填字母数字及特殊字符,且以字母开头,8位以上】
     */
    public static final String REGEX_PASSWORD_STRONG = "^(?![0-9]+$)(?![^0-9]+$)(?![a-zA-Z]+$)(?![^a-zA-Z]+$)(?![a-zA-Z0-9]+$)[a-zA-Z0-9\\S]{8,}$";

     

    展开全文
  • 密码校验需求: 1) 密码控制只能输入字母、数字、特殊符号(~!@#$%^&*()_+[]{}|\;:'",./<>?)2) 长度 6-16 位,必须包括字母、数字、特殊符号中的2种3) 密码不能包含用户名信息 判断密码是否包含数字:...

    密码校验需求:

    1) 密码控制只能输入字母、数字、特殊符号(~!@#$%^&*()_+[]{}|\;:'",./<>?)
    2) 长度 6-16 位,必须包括字母、数字、特殊符号中的2种
    3) 密码不能包含用户名信息


    判断密码是否包含数字:包含返回1,不包含返回0
    int i = newPwd.matches(".*\\d+.*") ? 1 : 0;

    判断密码是否包含字母:包含返回1,不包含返回0
    int j = newPwd.matches(".*[a-zA-Z]+.*") ? 1 : 0;

    判断密码是否包含特殊符号(~!@#$%^&*()_+|<>,.?/:;'[]{}\):包含返回1,不包含返回0
    int k = newPwd.matches(".*[~!@#$%^&*()_+|<>,.?/:;'\\[\\]{}\"]+.*") ? 1 : 0;

    判断密码长度是否在6-16位
    int l = newPwd.length();

    判断密码中是否包含用户名
    boolean contains = newPwd.contains(userId);

    if (i + j + k < 2 || l < 6 || l > 16 || contains) {
      return Password error;
    }

    转载于:https://www.cnblogs.com/goodcheap/p/6051833.html

    展开全文
  • Java 验证密码复杂度的正则表达式

    千次阅读 2019-02-19 09:23:42
    正则表达式 复杂(同时包含数字,字母,特殊符号) "^^(?![a-zA-z]+$)(?!\\d+$)(?![!@#$%^&amp;*_-]+$)(?![a-zA-z\\d]+$)(?![a-zA-z!@#$%^&amp;*_-]+$)(?![\\d!@#$%^&amp;*_-]+$)[a-zA-Z\\d!@...

    一 正则表达式

    复杂(同时包含数字,字母,特殊符号)
    "^^(?![a-zA-z]+$)(?!\\d+$)(?![!@#$%^&*_-]+$)(?![a-zA-z\\d]+$)(?![a-zA-z!@#$%^&*_-]+$)(?![\\d!@#$%^&*_-]+$)[a-zA-Z\\d!@#$%^&*_-]+$"
    
    简单(只包含数字或字母)
    "^(?:\\d+|[a-zA-Z]+|[!@#$%^&*]+)$"
    
    中级(包含字母和数字)
    "^(?![a-zA-z]+$)(?!\\d+$)(?![!@#$%^&*]+$)[a-zA-Z\\d!@#$%^&*]+$"

    二 弱密码校验

    package com.hm.platform.common.util;
    
    import org.apache.commons.lang.StringUtils;
    
    /**
     * 
     * @ClassName: PwdCheckUtil.java
     * @Description: 密码校验工具类
     */
    public class PwdCheckUtil {
    	
    	 public static String[] KEYBOARD_SLOPE_ARR = {
    			 "!qaz", "1qaz", "@wsx","2wsx", "#edc", "3edc", "$rfv", "4rfv", "%tgb", "5tgb",
    	         "^yhn", "6yhn", "&ujm", "7ujm", "*ik,", "8ik,", "(ol.", "9ol.", ")p;/", "0p;/",
    	         "+[;.", "=[;.",  "_pl,", "-pl,", ")okm", "0okm", "(ijn", "9ijn", "*uhb", "8uhb",
    	         "&ygv", "7ygv", "^tfc", "6tfc", "%rdx","5rdx", "$esz","4esz"
    	    };
    	 public static String[] KEYBOARD_HORIZONTAL_ARR = {
    	            "01234567890-=",
    	            "!@#$%^&*()_+",
    	            "qwertyuiop[]",
    	            "QWERTYUIOP{}",
    	            "asdfghjkl;'",
    	            "ASDFGHJKL:",
    	            "zxcvbnm,./",
    	            "ZXCVBNM<>?",
    	    };
    	 
    	 public static String DEFAULT_SPECIAL_CHAR="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
    	 public static String SPECIAL_CHAR = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
    
    	public static void main(String[] args) {
            //System.out.print(checkSequentialSameChars("AAAAA", 5));
            //System.out.print(checkSequentialChars("Abcks", 3, true));
    		//System.out.print(checkKeyboardSlantSite("Qaz", 3, false));
    		//System.out.print(checkLateralKeyboardSite("qwer", 3, false));
    	}
    	
        /**
         * @brief   检测密码中字符长度
         * @param[in] password            密码字符串
         * @return  符合长度要求 返回true
         */
        public static boolean checkPasswordLength(String password, String minNum, String maxNum) {
            boolean flag =false;
            if (StringUtils.isBlank(maxNum))  {
            	minNum = StringUtils.isBlank(minNum) == true ? "0":minNum;
            	 if (password.length() >= Integer.parseInt(minNum)) {
                     flag = true;
                 }
            } else {
            	minNum = StringUtils.isBlank(minNum) == true ? "0":minNum;
            	 if (password.length() >= Integer.parseInt(minNum) &&
                         password.length() <= Integer.parseInt(maxNum)) {
                     flag = true;
                 }
            }
            return flag;
        }
    	
        /**
         * @brief   检测密码中是否包含数字
         * @param[in] password            密码字符串
         * @return  包含数字 返回true
         */
        public static boolean checkContainDigit(String password) {
            char[] chPass = password.toCharArray();
            boolean flag = false;
            int num_count = 0;
     
            for (int i = 0; i < chPass.length; i++) {
                if (Character.isDigit(chPass[i])) {
                    num_count++;
                }
            }
            if (num_count >= 1){
                flag = true;
            }
            return flag;
        }
    	
        /**
         * @brief   检测密码中是否包含字母(不区分大小写)
         * @param[in] password            密码字符串
         * @return  包含字母 返回true
         */
        public static boolean checkContainCase(String password) {
            char[] chPass = password.toCharArray();
            boolean flag = false;
            int char_count = 0;
     
            for (int i = 0; i < chPass.length; i++) {
                if (Character.isLetter(chPass[i])) {
                    char_count++;
                }
            }
            if (char_count >= 1) {
                flag = true;
            }
            return flag;
        }
        
    	
        /**
         * @brief   检测密码中是否包含小写字母
         * @param[in] password            密码字符串
         * @return  包含小写字母 返回true
         */
        public static boolean checkContainLowerCase(String password) {
            char[] chPass = password.toCharArray();
            boolean flag = false;
            int char_count = 0;
     
            for (int i = 0; i < chPass.length; i++) {
                if (Character.isLowerCase(chPass[i])) {
                    char_count++;
                }
            }
            if (char_count >= 1) {
                flag = true;
            }
            return flag;
        }
        
        
        /**
         * @brief   检测密码中是否包含大写字母
         * @param[in] password            密码字符串
         * @return  包含大写字母 返回true
         */
        public static boolean checkContainUpperCase(String password) {
            char[] chPass = password.toCharArray();
            boolean flag = false;
            int char_count = 0;
     
            for (int i = 0; i < chPass.length; i++) {
                if (Character.isUpperCase(chPass[i])) {
                    char_count++;
                }
            }
            if (char_count >= 1) {
                flag = true;
            }
            return flag;
        }
    	
    	
    	/**
         * @brief   检测密码中是否包含特殊符号
         * @param[in] password            密码字符串
         * @return  包含特殊符号 返回true
         */
        public static boolean checkContainSpecialChar(String password) {
            char[] chPass = password.toCharArray();
            boolean flag = false;
            int special_count = 0;
     
            for (int i = 0; i < chPass.length; i++) {
                if (SPECIAL_CHAR.indexOf(chPass[i]) != -1) {
                    special_count++;
                }
            }
     
            if (special_count >= 1){
                flag = true;
            }
            return flag;
        }
    	
    	
    	/**
         * @brief   键盘规则匹配器 横向连续检测
         * @param[in] password            密码字符串
         * @return  含有横向连续字符串 返回true
         */
        public static boolean checkLateralKeyboardSite(String password, int repetitions, boolean isLower) {
            String t_password = new String(password);
            //将所有输入字符转为小写
            t_password = t_password.toLowerCase();
            int n = t_password.length();
            /**
             * 键盘横向规则检测
             */
            boolean flag = false;
            int arrLen = KEYBOARD_HORIZONTAL_ARR.length;
            int limit_num = repetitions ;
     
            for(int i=0; i+limit_num<=n; i++) {
                String str = t_password.substring(i, i+limit_num);
                String distinguishStr = password.substring(i, i+limit_num);
     
                for(int j=0; j<arrLen; j++) {
                    String configStr = KEYBOARD_HORIZONTAL_ARR[j];
                    String revOrderStr = new StringBuffer(KEYBOARD_HORIZONTAL_ARR[j]).reverse().toString();
     
                    //检测包含字母(区分大小写)
                    if (isLower) {
                        //考虑 大写键盘匹配的情况
                        String UpperStr = KEYBOARD_HORIZONTAL_ARR[j].toUpperCase();
                        if((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
                            flag = true;
                            return flag;
                        }
                        //考虑逆序输入情况下 连续输入
                        String revUpperStr = new StringBuffer(UpperStr).reverse().toString();
                        if((revOrderStr.indexOf(distinguishStr) != -1) || (revUpperStr.indexOf(distinguishStr) != -1)) {
                            flag = true;
                            return flag;
                        }
                    }else {
                        if(configStr.indexOf(str) != -1) {
                            flag = true;
                            return flag;
                        }
                        //考虑逆序输入情况下 连续输入
                        if(revOrderStr.indexOf(str) != -1) {
                            flag = true;
                            return flag;
                        }
                    }
                }
            }
            return flag;
        }
        
        
    	
    
        /**
         * 
         * @Title: checkKeyboardSlantSite  
         * @Description: 物理键盘,斜向连接校验, 如1qaz,4rfv, !qaz,@WDC,zaq1 返回true
         * @param password	字符串
         * @param repetitions	重复次数
         * @param isLower		是否区分大小写 true:区分大小写, false:不区分大小写	
         * @return boolean    如1qaz,4rfv, !qaz,@WDC,zaq1 返回true
         * @throws
         */
        public static boolean checkKeyboardSlantSite(String password, int repetitions, boolean isLower) {
            String t_password = new String(password);
            t_password = t_password.toLowerCase();
            int n = t_password.length();
            /**
             * 键盘斜线方向规则检测
             */
            boolean flag = false;
            int arrLen = KEYBOARD_SLOPE_ARR.length;
            int limit_num = repetitions;
     
            for(int i=0; i+limit_num<=n; i++) {
                String str = t_password.substring(i, i+limit_num);
                String distinguishStr = password.substring(i, i+limit_num);
                for(int j=0; j<arrLen; j++) {
                    String configStr = KEYBOARD_SLOPE_ARR[j];
                    String revOrderStr = new StringBuffer(KEYBOARD_SLOPE_ARR[j]).reverse().toString();
                    //检测包含字母(区分大小写)
                    if (isLower) {
                        //考虑 大写键盘匹配的情况
                        String UpperStr = KEYBOARD_SLOPE_ARR[j].toUpperCase();
                        if((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
                            flag = true;
                            return flag;
                        }
                        //考虑逆序输入情况下 连续输入
                        String revUpperStr = new StringBuffer(UpperStr).reverse().toString();
                        if((revOrderStr.indexOf(distinguishStr) != -1) || (revUpperStr.indexOf(distinguishStr) != -1)) {
                            flag = true;
                            return flag;
                        }
                    }else {
                        if(configStr.indexOf(str) != -1) {
                            flag = true;
                            return flag;
                        }
                        //考虑逆序输入情况下 连续输入
                        if(revOrderStr.indexOf(str) != -1) {
                            flag = true;
                            return flag;
                        }
                    }
                }
            }
            return flag;
        }
    	
    	/**
    	 * @Title: checkSequentialChars  
    	 * @Description: 评估a-z,z-a这样的连续字符, 
    	 * @param password	字符串
    	 * @param repetitions	连续个数
    	 * @param isLower		是否区分大小写 true:区分大小写, false:不区分大小写
    	 * @return boolean    含有a-z,z-a连续字符串 返回true
    	 * @throws
    	 */
        public static boolean checkSequentialChars(String password, int repetitions, boolean isLower) {
            String t_password = new String(password);
            boolean flag = false;
            int limit_num = repetitions;
            int normal_count = 0;
            int reversed_count = 0;
            //检测包含字母(区分大小写)
            if (!isLower) {
            	 t_password = t_password.toLowerCase();
            }
            int n = t_password.length();
            char[] pwdCharArr = t_password.toCharArray();
     
            for (int i=0; i+limit_num<=n; i++) {
                normal_count = 0;
                reversed_count = 0;
                for (int j=0; j<limit_num-1; j++) {
                    if (pwdCharArr[i+j+1]-pwdCharArr[i+j]==1) {
                        normal_count++;
                        if(normal_count == limit_num -1){
                            return true;
                        }
                    }
     
                    if (pwdCharArr[i+j]-pwdCharArr[i+j+1]==1) {
                        reversed_count++;
                        if(reversed_count == limit_num -1){
                            return true;
                        }
                    }
                }
            }
            return flag;
        }
     
    	/**
    	 * 
    	 * @Title: checkSequentialSameChars  
    	 * @Description: 验证键盘上是否存在多个连续重复的字符, 如!!!!, qqqq, 1111, ====, AAAA返回true
    	 * @param password	字符串
    	 * @param repetitions	重复次数
    	 * @return    参数  
    	 * @return boolean    返回类型  
    	 * @throws
    	 */
        public static boolean checkSequentialSameChars(String password, int repetitions) {
            String t_password = new String(password);
            int n = t_password.length();
            char[] pwdCharArr = t_password.toCharArray();
            boolean flag = false;
            int limit_num = repetitions;
            int count = 0;
            for (int i=0; i+limit_num<=n; i++) {
                count=0;
                for (int j=0; j<limit_num-1; j++) {
                    if(pwdCharArr[i+j] == pwdCharArr[i+j+1]) {
                        count++;
                        if (count == limit_num -1){
                            return true;
                        }
                    }
                }
            }
            return flag;
        }
    }
    

     

    展开全文
  • JAVA中校验密码正则表达式

    千次阅读 2016-09-24 15:27:58
    正则表达式是一种描述字符串集合的方法,它是以字符串集中各字符串的共有特征为依据的。正则表达式可以用于探索、编辑或者操作文本和数据。它超出了java程序设计语言的标准语法,因此有必要去学习特定的语法来构建...
  • JAVA正则表达式校验密码实战实例

    万次阅读 2017-05-27 09:20:22
    之前开发一个密码校验工具,主要用正则表达式实现,本来计划2个小时完成,结果确用了10个小时左右(通过周末加班搞定),期间遇到一些问题,也有一些收获,针对正则表达式的实战应用自己抽空做了一个总结,近期想给...
  • Java总结:正则表达式进行校验

    千次阅读 2019-05-06 23:37:00
    Java总结:正则表达式进行校验 目录 Java总结:正则表达式进行校验 一、校验数字的表达式 二、校验字符的表达式 了解理论知识,请点击:Java总结:正则表达式 一、校验数字的表达式 1 数字:^[0-9]*$ 2 n位的...
  • import java.util.HashMap; import java.util.Map; import java.util.regex.Pattern; /** * 正则验证工具 * */ public class RegularUtil { /** * 正则表达式:验证用户名 */ public static final String ...
  • Java 正则表达式数据校验

    千次阅读 2016-12-26 17:44:48
    对前端转过来的数据进行校验,验证数据是否合法; 对用户名、密码、手机号、邮箱、身份证、中文进行校验.....
  • 要求:必须由字母+数字组合,长度大于8位。
  • java密码复杂度正则表达式

    千次阅读 2018-07-05 13:21:47
    有一个密码复杂度的要求 1,只能有数字和字母组合,可以出现@#$三种符号 2,长度只能6-8位 2,字母必须2位或以上 3,数字必须1位或以上 (?=[a-zA-Z0-9@$#]*(?:[@$#]*[a-zA-Z]{2,}[0-9]{1,}|[@$#]*[0-9]{1,}[a-zA...
  • java正则表达式校验

    2018-07-02 16:34:18
    Pattern pattern = Pattern.compile("\\d+\\.\\d+$|-\\d+\\.\\d+$");//判断是否为小数Pattern pattern1 = Pattern.compile("^\\d+$|-\\d+$");if (pattern.matcher(monthValue).matches()||...
  • 本文档中收集整理了一些Java开发中常用的正则表达式,使用其可对常见类型进行校验! import java.util.regex.Matcher; import java.util.regex.Pattern; public class ValidateUtil { /** * 整数 */ private ...
  • 密码: 必须是6-20位的字母、数字、下划线(这里字母、数字、下划线是指任意组合,没有必须三类均包含) 效果展示: package cn.zyq.Aug05; import java.util.Scanner; public class Demo1 { pu...
  • 今天要讲的是 Java正则表达式。 一个字符串其实就是一个简单的正则表达式,例如 Hello World 正则表达式匹配&quot;Hello World&quot; 字符串 .(点号)也是一个正则表达式,它匹配任何一个字符如:&...
  • java常用正则校验工具类 正则常用校验工具类   1 import java.util.regex.Pattern; 2 3 /** 4 * @program: 5 * @description: 校验工具类 6 * @author: xujingyang 7 * @create...
1 2 3 4 5 ... 20
收藏数 8,242
精华内容 3,296
关键字:

语法糖