精华内容
下载资源
问答
  • C#判断字符串是否为数字字符

    千次阅读 2018-12-27 09:59:45
    C#判断字符串是否为数字字符串 在进行C#编程时候,有的时候我们需要判断一个字符串是否数字字符串,我们可以通过以下两种方法来实现。 【方法一】:使用 try{} catch{} 语句。 我们可以在try语句块中试图将string...

    C#判断字符串是否为数字字符串
    在进行C#编程时候,有的时候我们需要判断一个字符串是否是数字字符串,我们可以通过以下两种方法来实现。
    【方法一】:使用 try{} catch{} 语句。
    我们可以在try语句块中试图将string类型的字符串变量转换为int类型,如果该字符串不是数字字符串则会抛出异常,这时在catch语句块中就能捕获异常。一旦发现异常,则不是数字字符串。
    我们可以以下三种方式将string类型转换为int类型。
    (1) int.Parse(string);
    (2) Convert.ToInt16(string); //当数字字符串的位数大于4的时候请使用Convert.ToInt32()
    (3) Convert.ToInt32(string);
    添加一个文本框TextBox1,和一个按钮Button1,当点击按钮时,判断文本框中的内容是否为数字字符串,是的话则输出转换后的数值。
    protected void Button1_Click(object sender, EventArgs e)
    {
    string message = TextBox1.Text.Trim();
    int result;
    if(isNumberic(message,out result))
    {
    string tt=“”);
    }
    protected bool isNumberic(string message,out int result)
    {
    //判断是否为整数字符串
    //是的话则将其转换为数字并将其设为out类型的输出值、返回true, 否则为false
    result = -1; //result 定义为out 用来输出值
    try
    {
    //当数字字符串的为是少于4时,以下三种都可以转换,任选一种
    //如果位数超过4的话,请选用Convert.ToInt32() 和int.Parse()

          //result = int.Parse(message);
          //result = Convert.ToInt16(message);
            result = Convert.ToInt32(message);    
            return true;
        }
        catch
        {
            return false;
        }
    

    }
    上述方法可以将int改为double,如 double.Parse(),这样就可以判断是否为浮点数字符串
    【方法二】:通过正则表达式来判断。
    用正则表达式来验证字符串是否为数字字符串。我们要用到Regex类的isMatch()方法。该类在System.Text.RegularExpressions; 您可以通过using System.Text.RegularExpressions;导入命名空间来访问Regex类。也可以直接通过System.Text.RegularExpressions.Regex 来访问。
    protected bool isNumberic(string message,out int result)
    {
    System.Text.RegularExpressions.Regex rex=
    new System.Text.RegularExpressions.Regex(@"^\d+KaTeX parse error: Expected 'EOF', got '}' at position 185: … return false; }̲ 通过正则表达式判断是否匹配,…"))
    {
    //成功
    Page.ClientScript.RegisterStartupScript(this.GetType(), “”, “”);
    }
    补充
    //正则匹配
    匹配中文字符的正则表达式: [\u4e00-\u9fa5]
    匹配双字节字符(包括汉字在内):[^\x00-\xff]
    匹配空行的正则表达式:\n[\s| ]\r
    匹配HTML标记的正则表达式:/<(.
    )>.</\1>|<(.) />/
    匹配首尾空格的正则表达式:(^\s*)|(\s*$)(像vbscript那样的trim函数)
    匹配Email地址的正则表达式:\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*
    匹配网址URL的正则表达式:http://([\w-]+.)+[\w-]+(/[\w- ./?%&=]*)?
    以下是例子:
    利用正则表达式限制网页表单里的文本框输入内容:
    用正则表达式限制只能输入中文:οnkeyup=“value=value.replace(/[^\u4E00-\u9FA5]/g,’’)”
    onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\u4E00-\u9FA5]/g,’’))”
    1.用正则表达式限制只能输入全角字符: οnkeyup=“value=value.replace(/[^\uFF00-\uFFFF]/g,’’)”
    onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\uFF00-\uFFFF]/g,’’))”
    2.用正则表达式限制只能输入数字:οnkeyup="value=value.replace(/[^\d]/g,’’)
    "onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d]/g,’’))”
    3.用正则表达式限制只能输入数字和英文:οnkeyup="value=value.replace(/[\W]/g,’’)
    "onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d]/g,’’))”

    展开全文
  • StringUtils.isNumeric判断是否数字字符串 org.apache.commons.lang3.StringUtils 字符串工具类StringUtils能够很方便的处理Java字符串问题,简直是Java字符串的一大法宝 可以记录下常用的功能,即便对于字符串...

    StringUtils.isNumeric判断是否是数字字符串

    org.apache.commons.lang3.StringUtils
    字符串工具类StringUtils能够很方便的处理Java字符串问题,简直是Java字符串的一大法宝

    可以记录下常用的功能,即便对于字符串对象为null,也是轻松处理

    IsEmpty/IsBlank - checks if a String contains text
    Trim/Strip - removes leading and trailing whitespace
    Equals/Compare - compares two strings null-safe
    startsWith - check if a String starts with a prefix null-safe
    endsWith - check if a String ends with a suffix null-safe
    IndexOf/LastIndexOf/Contains - null-safe index-of checks
    IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut - index-of any of a set of Strings
    ContainsOnly/ContainsNone/ContainsAny - does String contains only/none/any of these characters
    Substring/Left/Right/Mid - null-safe substring extractions
    SubstringBefore/SubstringAfter/SubstringBetween - substring extraction relative to other strings
    Split/Join - splits a String into an array of substrings and vice versa
    Remove/Delete - removes part of a String
    Replace/Overlay - Searches a String and replaces one String with another
    Chomp/Chop - removes the last part of a String
    UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize - changes the case of a String
    CountMatches - counts the number of occurrences of one String in another
    IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable - checks the characters in a String
    DefaultString - protects against a null input String
    Reverse/ReverseDelimited - reverses a String
    
    StringUtils.isNumeric

    其中需要注意的是 StringUtils.isNumeric 在判断是否是数字字符串的时候,无法包含所有情况
    官网上也有实例说明,对于含有特殊符号的字符串,是无法解析的

     StringUtils.isNumeric(null)   = false
     StringUtils.isNumeric("")     = false
     StringUtils.isNumeric("  ")   = false
     StringUtils.isNumeric("123")  = true
     StringUtils.isNumeric("१२३")  = true
     StringUtils.isNumeric("12 3") = false
     StringUtils.isNumeric("ab2c") = false
     StringUtils.isNumeric("12-3") = false
     StringUtils.isNumeric("12.3") = false
     StringUtils.isNumeric("-123") = false
     StringUtils.isNumeric("+123") = false
     
    看其源码就知道,它这里仅仅对每个字符做了数字判断
      public static boolean isNumeric(String str) {
        if (str == null) {
          return false;
        } else {
          int sz = str.length();
    
          for(int i = 0; i < sz; ++i) {
            if (!Character.isDigit(str.charAt(i))) {
              return false;
            }
          }
    
          return true;
        }
      }
    
    完整的判断

    如果要完整判断一个字符串是不是数字字符串,最方便的就是借助math中的BigDecimal类,如果不是数字就会跑出异常,这时候捕获就可以判定为非数字
    如果确定输入数据不包含正负号、小数点的话,可以直接使用,会提高很多性能,否则需要借助BigDecimal类来完整判别

    import java.math.BigDecimal;
    
      public static boolean isNumeric(String str) {
        try {
          new BigDecimal(str);
        } catch (Exception e) {
          return false;
        }
        return true;
      }
    
    构造函数源码
    // BigDecimal类的相应的构造函数源码,可以看到,它考虑到了很多情况,非常经典,值得好好学习
        public BigDecimal(char[] in, int offset, int len, MathContext mc) {
            // protect against huge length.
            if (offset + len > in.length || offset < 0)
                throw new NumberFormatException("Bad offset or len arguments for char[] input.");
            // This is the primary string to BigDecimal constructor; all
            // incoming strings end up here; it uses explicit (inline)
            // parsing for speed and generates at most one intermediate
            // (temporary) object (a char[] array) for non-compact case.
    
            // Use locals for all fields values until completion
            int prec = 0;                 // record precision value
            int scl = 0;                  // record scale value
            long rs = 0;                  // the compact value in long
            BigInteger rb = null;         // the inflated value in BigInteger
            // use array bounds checking to handle too-long, len == 0,
            // bad offset, etc.
            try {
                // handle the sign
                boolean isneg = false;          // assume positive
                if (in[offset] == '-') {
                    isneg = true;               // leading minus means negative
                    offset++;
                    len--;
                } else if (in[offset] == '+') { // leading + allowed
                    offset++;
                    len--;
                }
    
                // should now be at numeric part of the significand
                boolean dot = false;             // true when there is a '.'
                long exp = 0;                    // exponent
                char c;                          // current character
                boolean isCompact = (len <= MAX_COMPACT_DIGITS);
                // integer significand array & idx is the index to it. The array
                // is ONLY used when we can't use a compact representation.
                int idx = 0;
                if (isCompact) {
                    // First compact case, we need not to preserve the character
                    // and we can just compute the value in place.
                    for (; len > 0; offset++, len--) {
                        c = in[offset];
                        if ((c == '0')) { // have zero
                            if (prec == 0)
                                prec = 1;
                            else if (rs != 0) {
                                rs *= 10;
                                ++prec;
                            } // else digit is a redundant leading zero
                            if (dot)
                                ++scl;
                        } else if ((c >= '1' && c <= '9')) { // have digit
                            int digit = c - '0';
                            if (prec != 1 || rs != 0)
                                ++prec; // prec unchanged if preceded by 0s
                            rs = rs * 10 + digit;
                            if (dot)
                                ++scl;
                        } else if (c == '.') {   // have dot
                            // have dot
                            if (dot) // two dots
                                throw new NumberFormatException();
                            dot = true;
                        } else if (Character.isDigit(c)) { // slow path
                            int digit = Character.digit(c, 10);
                            if (digit == 0) {
                                if (prec == 0)
                                    prec = 1;
                                else if (rs != 0) {
                                    rs *= 10;
                                    ++prec;
                                } // else digit is a redundant leading zero
                            } else {
                                if (prec != 1 || rs != 0)
                                    ++prec; // prec unchanged if preceded by 0s
                                rs = rs * 10 + digit;
                            }
                            if (dot)
                                ++scl;
                        } else if ((c == 'e') || (c == 'E')) {
                            exp = parseExp(in, offset, len);
                            // Next test is required for backwards compatibility
                            if ((int) exp != exp) // overflow
                                throw new NumberFormatException();
                            break; // [saves a test]
                        } else {
                            throw new NumberFormatException();
                        }
                    }
                    if (prec == 0) // no digits found
                        throw new NumberFormatException();
                    // Adjust scale if exp is not zero.
                    if (exp != 0) { // had significant exponent
                        scl = adjustScale(scl, exp);
                    }
                    rs = isneg ? -rs : rs;
                    int mcp = mc.precision;
                    int drop = prec - mcp; // prec has range [1, MAX_INT], mcp has range [0, MAX_INT];
                                           // therefore, this subtract cannot overflow
                    if (mcp > 0 && drop > 0) {  // do rounding
                        while (drop > 0) {
                            scl = checkScaleNonZero((long) scl - drop);
                            rs = divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode);
                            prec = longDigitLength(rs);
                            drop = prec - mcp;
                        }
                    }
                } else {
                    char coeff[] = new char[len];
                    for (; len > 0; offset++, len--) {
                        c = in[offset];
                        // have digit
                        if ((c >= '0' && c <= '9') || Character.isDigit(c)) {
                            // First compact case, we need not to preserve the character
                            // and we can just compute the value in place.
                            if (c == '0' || Character.digit(c, 10) == 0) {
                                if (prec == 0) {
                                    coeff[idx] = c;
                                    prec = 1;
                                } else if (idx != 0) {
                                    coeff[idx++] = c;
                                    ++prec;
                                } // else c must be a redundant leading zero
                            } else {
                                if (prec != 1 || idx != 0)
                                    ++prec; // prec unchanged if preceded by 0s
                                coeff[idx++] = c;
                            }
                            if (dot)
                                ++scl;
                            continue;
                        }
                        // have dot
                        if (c == '.') {
                            // have dot
                            if (dot) // two dots
                                throw new NumberFormatException();
                            dot = true;
                            continue;
                        }
                        // exponent expected
                        if ((c != 'e') && (c != 'E'))
                            throw new NumberFormatException();
                        exp = parseExp(in, offset, len);
                        // Next test is required for backwards compatibility
                        if ((int) exp != exp) // overflow
                            throw new NumberFormatException();
                        break; // [saves a test]
                    }
                    // here when no characters left
                    if (prec == 0) // no digits found
                        throw new NumberFormatException();
                    // Adjust scale if exp is not zero.
                    if (exp != 0) { // had significant exponent
                        scl = adjustScale(scl, exp);
                    }
                    // Remove leading zeros from precision (digits count)
                    rb = new BigInteger(coeff, isneg ? -1 : 1, prec);
                    rs = compactValFor(rb);
                    int mcp = mc.precision;
                    if (mcp > 0 && (prec > mcp)) {
                        if (rs == INFLATED) {
                            int drop = prec - mcp;
                            while (drop > 0) {
                                scl = checkScaleNonZero((long) scl - drop);
                                rb = divideAndRoundByTenPow(rb, drop, mc.roundingMode.oldMode);
                                rs = compactValFor(rb);
                                if (rs != INFLATED) {
                                    prec = longDigitLength(rs);
                                    break;
                                }
                                prec = bigDigitLength(rb);
                                drop = prec - mcp;
                            }
                        }
                        if (rs != INFLATED) {
                            int drop = prec - mcp;
                            while (drop > 0) {
                                scl = checkScaleNonZero((long) scl - drop);
                                rs = divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode);
                                prec = longDigitLength(rs);
                                drop = prec - mcp;
                            }
                            rb = null;
                        }
                    }
                }
            } catch (ArrayIndexOutOfBoundsException e) {
                throw new NumberFormatException();
            } catch (NegativeArraySizeException e) {
                throw new NumberFormatException();
            }
            this.scale = scl;
            this.precision = prec;
            this.intCompact = rs;
            this.intVal = rb;
        }
    
    参考

    官方文档

    展开全文
  • Python判断字符是否为数字

    万次阅读 多人点赞 2018-12-03 18:28:44
    str为字符串 1、str.isalnum() 所有字符都是数字或者字母 2、str.isalpha() 所有字符都是字母 3、str.isdigit() 所有字符都是数字 4、str.islower() 所有字符都是小写 5、str.isupper() 所有字符都是大写 6、str.is...

    str为字符串
    1、str.isalnum() 所有字符都是数字或者字母
    2、str.isalpha() 所有字符都是字母
    3、str.isdigit() 所有字符都是数字
    4、str.islower() 所有字符都是小写
    5、str.isupper() 所有字符都是大写
    6、str.istitle() 所有单词都是首字母大写
    7、str.isspace() 所有字符都是空白字符、\t、\n、\r

    展开全文
  • 前言 ...判断字符是否为数字(整形) 这个直接调用python的库就可以了哈,假设str为字符串 str.isdigit() 判断所有字符都是数字(整形) 返回值 True:该字符串都为数字;False:该字符串不...

    前言

    在Python中处理字符串的函数比较丰富,有时需要把字符串转化为整形、浮点型等;转换过程中,发现有时会报错,比如字符串“12*76”,转换为整形,直接转换int(“12*76”),会报无法转换的错误的,因为*无法转换为整形;所以在转换前,需要先进行判断该字符串的类型。

     

    判断字符串是否为数字(整形)

    这个直接调用python的库就可以了哈,假设str为字符串

    str.isdigit()    判断所有字符都是数字(整形)   

    返回值 True:该字符串都为数字;False:该字符串不都是数字。


    str.isalnum() 判断所有字符都是数字或者字母    

    返回值 True:该字符串都为数字或者字母;False:该字符串不都是数字或者字母。

     

     

    判断字符串是否为浮点数

    这个就不能直接使用python的库,毕竟浮点数有小数点的,小数点也算是一种符号,单纯使用str.isdigit()    所有字符都是数字 来判断是不行的;

    不妨使用字符串分割(切片)函数,把浮点数分为小数点左边部分、小数点右边部分,再分别检测各部分是否为全数字

    代码实现:

    # 输入参数 str 需要判断的字符串
    # 返回值   True:该字符串为浮点数;False:该字符串不是浮点数。
    def IsFloatNum(str):
        s=str.split('.')
        if len(s)>2:
            return False
        else:
            for si in s:
                if not si.isdigit():
                    return False
            return True

     

    判断字符串是否为字母

    这个直接调用python的库就可以了哈,假设str为字符串

    str.isalpha()  判断所有字符都是字母 

    返回值 True:所有字符都是字母;False:所有字符不都是字母。


    str.islower()  判断所有字符都是小写 

    str.isupper() 判断所有字符都是大写

    str.istitle()    判断所有单词都是首字母大写

     

    判断字符串是否为空

    str.isspace() 判断所有字符都是空白字符、\t、\n、\r

     

    汇总

    str.isdigit()    判断所有字符都是数字(整形)   

    str.isalnum() 判断所有字符都是数字或者字母    

    str.isalpha()  判断所有字符都是字母 

    str.islower()  判断所有字符都是小写 

    str.isupper() 判断所有字符都是大写

    str.istitle()    判断所有单词都是首字母大写

     

     

     

     

    展开全文
  • 判断字符是否为数字

    千次阅读 2018-08-26 09:21:54
    可以通过以下判断字符或字符串中某个字符为数字。   名称 说明 IsNumber(Char) 指示指定的 Unicode 字符是否属于数字类别。 IsNumber(String, Int32) 指示指定字符串中位于...
  • 如何判断一个字符是否为数字?  /**  * 判断是否为数字  * @param str String对象   * @return boolean :true 是;false : 不是。  * @author code_chen  * */  public static boolean isNumeric(String ...
  • 要用python判断一个字符字符是否为数字,可以用如下方法,在代码中写下列函数,然后调用函数 is_number(str)即可 可以正确分辨小数和负数: def is_number(s): try: # 如果能运行float(s)语句,返回True(字符...
  •  * 判断字符是否为数字(包含小数点)  * @param str  * @return  */ public static boolean isNumeric(String str){   Pattern pattern = Pattern.compile("[0-9]+.*[0-9]*");   Matcher isNum = p
  • C#判断字符串是否为数字字符串(转)

    千次阅读 2010-05-21 09:39:00
    在进行C#编程时候,有的时候我们需要判断一个字符串是否数字字符串,我们可以通过以下两种方法来实现。【方法一】:使用 try{} catch{} 语句。 我们可以在try语句块中试图将string类型的字符串变量转换int类型...
  • 一、判断字符是否为空 String.Empty和string=””是一样的,同样都是需要占用内存空间&lt;空字符串&gt;;但优先推荐使用string.Empty Console.WriteLine("".Equals(string.Empty));//结果:...
  • 判断输入的字符是否为数字

    千次阅读 2019-09-27 18:35:43
    创建一个函数,使其接收一个字符串并判断字符是否为数字。 代码实现 C #include <ctype.h> #include <stdlib.h> int isNumeric (const char * s) { if (s == NULL || *s == '\0' || isspace(*s)) ...
  • 正则表达式判断字符是否为数字

    千次阅读 2018-09-14 09:30:47
    IF cl_abap_matcher=&gt;matches( pattern = '^(-?[1-9]\d*(\.\d*[1-9])?)|(-?0\.\d*[1-9])$' text = '1.01' ) = abap_true. ... WRITE '数字'. ELSE. WRITE '非数字'. ENDIF.   -? :负号 [1-9]\d* ...
  • //判断字符属于是什么 char ch; while((ch=getchar())!=EOF) { if(ch>='0'&&ch<='9') ... printf("%c是数字字符:",ch); } else if(ch>='a'&&ch<='z') { print...
  • public class ZhStringUtil { ... * 判断字符是否为数字 * @param str * @return */ public static boolean isNumberic(String str) { Pattern pattern = Pattern.compile("[0-9]*"); ...
  • 判断字符是否为数字

    千次阅读 2018-11-15 13:57:37
    1.用正则表达式 import java.util.regex.Pattern 和 java.util.regex.Matcher ... * 利用正则表达式判断字符是否数字 * @param str * @return */ public boolean isNumeric(String str){ Patter...
  • 判断一个字符是否为数字的两种方法(C/C++) 在平时,我们经常遇见判断字符是否为数字这种题目,虽然感觉还是很简单,不过我是个更喜欢用函数的人,因为我觉得这样更便捷,所以我更推荐第二种方式。 1.直接判断 ...
  • javascript 判断参数是否为非0整数数字或者整数数字字符串的简单方法(小装逼) 我们来判断一个值是否为数字,可以把它转化数字,看是否为NaN 然后,再判断是否等于0即可简单的来实现判断了。 所以,代码如下 ...
  • java判断字符是否为数字类型

    千次阅读 2016-11-21 16:11:20
     * 字符是否为数字,包含小数  * @author 许凯勋  * @date 2016年11月20日 下午11:35:36   * @param str  * @return  */  public static boolean isNumber(String str){  String reg = ...
  • Java判断字符是否为数字字符!...

    千次阅读 2012-03-17 16:41:53
    //一行代码ok Character.isDigit('x')
  • C# 判断字符是否可以转化为数字

    千次阅读 2014-01-24 10:32:30
    /// /// 判断字符是否可以转化为数字 /// /// 要检查的字符串 /// true:可以转换为数字;false:不是数字 public static bool IsNumberic(string str) { double vsNum; b
  • 判断字符是否为数字和字母

    千次阅读 2019-05-08 17:31:02
    /***********************************************************************/ / 判断字符是否为数字和字母 / /******************************************************...
  • php判断字符是否为数字

    千次阅读 2015-12-14 15:12:50
    is_bool();//判断是否为布尔型  is_float(); //判断是否为浮点型  is_int(); //判断是否为整型 ... //判断是否为字符串  is_array(); //判断是否为数组  is_object(); //判断是否为对象 if(mb_subst
  • Javascript判断字符是否为数字

    千次阅读 2021-03-18 21:29:38
    判断一个字符串是不是数字通常有下面三个方法,感觉2和3配合起来用好一些。 1. isNaN() 函数 NaN 即 Not a Number,isNaN() 函数会把 null,空格 以及 空串按照 0 来处理。举例说明。 console.log(isNaN(123)); // ...
  • a = '1234' a.isdigit() # 是否是全数字
  • js 超简单 判断是否字符是否为数字 if(Number(num)+'' !==NaN+'' ){ console.log('是纯数字') }else{ console.log('不是纯数字') }
  • C语言判断字符是否为数字

    万次阅读 2015-04-15 23:06:24
    C语言判断一个字符是否为数字, 听起来很简单,实现还是有点难度的。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 612,559
精华内容 245,023
关键字:

判断是否为数字字符