blocks|key|1810478|text|如果您不关心潜在的溢出问题，此函数的执行速度将比使用Integer.parseInt()快20-30倍。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1810479|public+static+boolean+isInteger(String+str)+{
++++if+(str+==+null)+{
++++++++return+false;
++++}
++++int+length+=+str.length();
++++if+(length+==+0)+{
++++++++return+false;
++++}
++++int+i+=+0;
++++if+(str.charAt(0)+==+'-')+{
++++++++if+(length+==+1)+{
++++++++++++return+false;
++++++++}
++++++++i+=+1;
++++}
++++for+(;+i+<+length;+i%2B%2B)+{
++++++++char+c+=+str.charAt(i);
++++++++if+(c+<+'0'+%7C%7C+c+>+'9')+{
++++++++++++return+false;
++++++++}
++++}
++++return+true;
}|code-block|syntax|javascript|1810480|entityMap^0|Q|I|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If you are not concerned with potential overflow problems this function will perform about 20-30 times faster than using <code>Integer.parseInt()</code>.

<pre><code>public static boolean isInteger(String str) {
 if (str == null) {
 return false;
 }
 int length = str.length();
 if (length == 0) {
 return false;
 }
 int i = 0;
 if (str.charAt(0) == '-') {
 if (length == 1) {
 return false;
 }
 i = 1;
 }
 for (; i &lt; length; i++) {
 char c = str.charAt(i);
 if (c &lt; '0' || c &gt; '9') {
 return false;
 }
 }
 return true;
}
</code></pre>

blocks|key|1595445|text|你有它，但是你应该只抓到NumberFormatException。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1595446|entityMap^0|C|L|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

You have it, but you should only catch <code>NumberFormatException</code>.

blocks|key|1810837|text|org.apache.commons.lang.StringUtils.isNumeric+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1810838|尽管Java的标准库确实缺少这样的实用函数|unstyled|1810839|我认为Apache+Commons是每个Java程序员的“必备”|1810840|太糟糕了，它还没有移植到Java5|1810841|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>org.apache.commons.lang.StringUtils.isNumeric 
</code></pre>

though Java's standard lib really misses such utility functions

I think that Apache Commons is a "must have" for every Java programmer

too bad it isn't ported to Java5 yet

blocks|key|1810887|text|因为有可能人们仍然会访问这里，并在基准测试之后对Regex产生偏见……因此，我将提供基准测试的更新版本，以及Regex的编译版本。与之前的基准相反，这一次表明Regex解决方案实际上具有始终如一的良好性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810888|从蜥蜴比尔复制，并用编译版本更新：|1810889|private+final+Pattern+pattern+=+Pattern.compile("%5E-?\\d%2B$");

public+void+runTests()+{
++++String+big_int+=+"1234567890";
++++String+non_int+=+"1234XY7890";

++++long+startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByException(big_int);
++++long+endTime+=+System.currentTimeMillis();
++++System.out.print("ByException+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByException(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByException+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByRegex(big_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("\nByRegex+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByRegex(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByRegex+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for+(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByCompiledRegex(big_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("\nByCompiledRegex+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for+(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByCompiledRegex(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByCompiledRegex+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);


++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByJonas(big_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("\nByJonas+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++++++IsInt_ByJonas(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByJonas+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);
}

private+boolean+IsInt_ByException(String+str)
{
++++try
++++{
++++++++Integer.parseInt(str);
++++++++return+true;
++++}
++++catch(NumberFormatException+nfe)
++++{
++++++++return+false;
++++}
}

private+boolean+IsInt_ByRegex(String+str)
{
++++return+str.matches("%5E-?\\d%2B$");
}

private+boolean+IsInt_ByCompiledRegex(String+str)+{
++++return+pattern.matcher(str).find();
}

public+boolean+IsInt_ByJonas(String+str)
{
++++if+(str+==+null)+{
++++++++++++return+false;
++++}
++++int+length+=+str.length();
++++if+(length+==+0)+{
++++++++++++return+false;
++++}
++++int+i+=+0;
++++if+(str.charAt(0)+==+'-')+{
++++++++++++if+(length+==+1)+{
++++++++++++++++++++return+false;
++++++++++++}
++++++++++++i+=+1;
++++}
++++for+(;+i+<+length;+i%2B%2B)+{
++++++++++++char+c+=+str.charAt(i);
++++++++++++if+(c+<=+'/'+%7C%7C+c+>=+':')+{
++++++++++++++++++++return+false;
++++++++++++}
++++}
++++return+true;
}|code-block|syntax|javascript|1810890|结果：|1810891|ByException+-+integer+data:+45
ByException+-+non-integer+data:+465

ByRegex+-+integer+data:+272
ByRegex+-+non-integer+data:+131

ByCompiledRegex+-+integer+data:+45
ByCompiledRegex+-+non-integer+data:+26

ByJonas+-+integer+data:+8
ByJonas+-+non-integer+data:+2|1810892|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Since there's possibility that people still visit here and will be biased against Regex after the benchmarks... So i'm gonna give an updated version of the benchmark, with a compiled version of the Regex. Which opposed to the previous benchmarks, this one shows Regex solution actually has consistently good performance.

Copied from Bill the Lizard and updated with compiled version:

<pre><code>private final Pattern pattern = Pattern.compile("^-?\\d+$");

public void runTests() {
 String big_int = "1234567890";
 String non_int = "1234XY7890";

 long startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByException(big_int);
 long endTime = System.currentTimeMillis();
 System.out.print("ByException - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByException(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByException - non-integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByRegex(big_int);
 endTime = System.currentTimeMillis();
 System.out.print("\nByRegex - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByRegex(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByRegex - non-integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for (int i = 0; i &lt; 100000; i++)
 IsInt_ByCompiledRegex(big_int);
 endTime = System.currentTimeMillis();
 System.out.print("\nByCompiledRegex - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for (int i = 0; i &lt; 100000; i++)
 IsInt_ByCompiledRegex(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByCompiledRegex - non-integer data: ");
 System.out.println(endTime - startTime);


 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByJonas(big_int);
 endTime = System.currentTimeMillis();
 System.out.print("\nByJonas - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByJonas(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByJonas - non-integer data: ");
 System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
 try
 {
 Integer.parseInt(str);
 return true;
 }
 catch(NumberFormatException nfe)
 {
 return false;
 }
}

private boolean IsInt_ByRegex(String str)
{
 return str.matches("^-?\\d+$");
}

private boolean IsInt_ByCompiledRegex(String str) {
 return pattern.matcher(str).find();
}

public boolean IsInt_ByJonas(String str)
{
 if (str == null) {
 return false;
 }
 int length = str.length();
 if (length == 0) {
 return false;
 }
 int i = 0;
 if (str.charAt(0) == '-') {
 if (length == 1) {
 return false;
 }
 i = 1;
 }
 for (; i &lt; length; i++) {
 char c = str.charAt(i);
 if (c &lt;= '/' || c &gt;= ':') {
 return false;
 }
 }
 return true;
}
</code></pre>

Results:

<pre><code>ByException - integer data: 45
ByException - non-integer data: 465

ByRegex - integer data: 272
ByRegex - non-integer data: 131

ByCompiledRegex - integer data: 45
ByCompiledRegex - non-integer data: 26

ByJonas - integer data: 8
ByJonas - non-integer data: 2
</code></pre>

blocks|key|1596211|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596212|如果您的意思是“可以在Java中转换为int”，那么Jonas的答案是一个很好的开始，但并没有完成工作。例如，它将通过999999999999999999999999999999999999999999。我会在方法的末尾添加来自您自己的问题的普通try/catch调用。|1596213|逐个字符的检查将有效地拒绝“根本不是整数”的情况，留下“它是一个整数，但Java不能处理它”的情况被较慢的异常路由捕获。您也可以手动完成此操作，但这会复杂得多。|1596214|entityMap^0|0|0|0^^$0|@$1|2|3|-4|4|5|6|G|7|@]|8|@]|9|$]]|$1|A|3|B|4|5|6|H|7|@]|8|@]|9|$]]|$1|C|3|D|4|5|6|I|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|J|7|@]|8|@]|9|$]]]|F|$]]

It partly depend on what you mean by "can be converted to an integer".

If you mean "can be converted into an int in Java" then the answer from Jonas is a good start, but doesn't quite finish the job. It would pass 999999999999999999999999999999 for example. I would add the normal try/catch call from your own question at the end of the method.

The character-by-character checks will efficiently reject "not an integer at all" cases, leaving "it's an integer but Java can't handle it" cases to be caught by the slower exception route. You could do this bit by hand too, but it would be a lot more complicated.

blocks|key|1810805|text|只有一条关于regexp的评论。这里提供的每个示例都是错误的！如果您想使用regexp，不要忘记编译模式需要花费很多时间。这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810806|str.matches("%5E-?\\d%2B$")|code-block|syntax|javascript|1810807|还有这个：|1810808|Pattern.matches("-?\\d%2B",+input);|1810809|导致在每次方法调用中编译模式。要正确使用它，请遵循以下步骤：|1810810|import+java.util.regex.Pattern;

/**
+*+@author+Rastislav+Komara
+*/
public+class+NaturalNumberChecker+{
++++public+static+final+Pattern+PATTERN+=+Pattern.compile("%5E\\d%2B$");

++++boolean+isNaturalNumber(CharSequence+input)+{
++++++++return+input+!=+null+&&+PATTERN.matcher(input).matches();
++++}
}|1810811|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Just one comment about regexp. Every example provided here is wrong!. If you want to use regexp don't forget that compiling the pattern take a lot of time. This:

<pre><code>str.matches("^-?\\d+$")
</code></pre>

and also this:

<pre><code>Pattern.matches("-?\\d+", input);
</code></pre>

causes compile of pattern in every method call. To used it correctly follow:

<pre><code>import java.util.regex.Pattern;

/**
 * @author Rastislav Komara
 */
public class NaturalNumberChecker {
 public static final Pattern PATTERN = Pattern.compile("^\\d+$");

 boolean isNaturalNumber(CharSequence input) {
 return input != null &amp;&amp; PATTERN.matcher(input).matches();
 }
}
</code></pre>

blocks|key|1811049|text|有芭乐版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811050|import+com.google.common.primitives.Ints;

Integer+intValue+=+Ints.tryParse(stringValue);|code-block|syntax|javascript|1811051|如果解析字符串失败，它将返回null，而不是抛出异常。|1811052|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

There is guava version:

<pre><code>import com.google.common.primitives.Ints;

Integer intValue = Ints.tryParse(stringValue);
</code></pre>

It will return null instead of throwing an exception if it fails to parse string.

blocks|key|1596446|text|我复制了rally25rs+answer中的代码，并添加了一些针对非整数数据的测试。不可否认，结果支持Jonas+Klemming发布的方法。当你有整数数据时，我最初发布的Exception方法的结果是相当好的，但是当你没有整数数据时，结果是最差的，而RegEx解决方案(我打赌很多人都在使用它)的结果总是很糟糕。有关编译后的正则表达式示例，请参阅Felipe's+answer，它的速度要快得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1596447|public+void+runTests()
{
++++String+big_int+=+"1234567890";
++++String+non_int+=+"1234XY7890";

++++long+startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++IsInt_ByException(big_int);
++++long+endTime+=+System.currentTimeMillis();
++++System.out.print("ByException+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++IsInt_ByException(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByException+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++IsInt_ByRegex(big_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("\nByRegex+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++IsInt_ByRegex(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByRegex+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++IsInt_ByJonas(big_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("\nByJonas+-+integer+data:+");
++++System.out.println(endTime+-+startTime);

++++startTime+=+System.currentTimeMillis();
++++for(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++IsInt_ByJonas(non_int);
++++endTime+=+System.currentTimeMillis();
++++System.out.print("ByJonas+-+non-integer+data:+");
++++System.out.println(endTime+-+startTime);
}

private+boolean+IsInt_ByException(String+str)
{
++++try
++++{
++++++++Integer.parseInt(str);
++++++++return+true;
++++}
++++catch(NumberFormatException+nfe)
++++{
++++++++return+false;
++++}
}

private+boolean+IsInt_ByRegex(String+str)
{
++++return+str.matches("%5E-?\\d%2B$");
}

public+boolean+IsInt_ByJonas(String+str)
{
++++if+(str+==+null)+{
++++++++++++return+false;
++++}
++++int+length+=+str.length();
++++if+(length+==+0)+{
++++++++++++return+false;
++++}
++++int+i+=+0;
++++if+(str.charAt(0)+==+'-')+{
++++++++++++if+(length+==+1)+{
++++++++++++++++++++return+false;
++++++++++++}
++++++++++++i+=+1;
++++}
++++for+(;+i+<+length;+i%2B%2B)+{
++++++++++++char+c+=+str.charAt(i);
++++++++++++if+(c+<=+'/'+%7C%7C+c+>=+':')+{
++++++++++++++++++++return+false;
++++++++++++}
++++}
++++return+true;
}|code-block|syntax|javascript|1596448|结果：|1596449|ByException+-+integer+data:+47
ByException+-+non-integer+data:+547

ByRegex+-+integer+data:+390
ByRegex+-+non-integer+data:+313

ByJonas+-+integer+data:+0
ByJonas+-+non-integer+data:+16|1596450|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/7324087/1288^0|4U|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I copied the code from rally25rs answer and added some tests for non-integer data. The results are undeniably in favor of the method posted by Jonas Klemming. The results for the Exception method that I originally posted are pretty good when you have integer data, but they're the worst when you don't, while the results for the RegEx solution (that I'll bet a lot of people use) were consistently bad. See <a href="https://stackoverflow.com/a/7324087/1288">Felipe's answer</a> for a compiled regex example, which is much faster.

<pre><code>public void runTests()
{
 String big_int = "1234567890";
 String non_int = "1234XY7890";

 long startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByException(big_int);
 long endTime = System.currentTimeMillis();
 System.out.print("ByException - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByException(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByException - non-integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByRegex(big_int);
 endTime = System.currentTimeMillis();
 System.out.print("\nByRegex - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByRegex(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByRegex - non-integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByJonas(big_int);
 endTime = System.currentTimeMillis();
 System.out.print("\nByJonas - integer data: ");
 System.out.println(endTime - startTime);

 startTime = System.currentTimeMillis();
 for(int i = 0; i &lt; 100000; i++)
 IsInt_ByJonas(non_int);
 endTime = System.currentTimeMillis();
 System.out.print("ByJonas - non-integer data: ");
 System.out.println(endTime - startTime);
}

private boolean IsInt_ByException(String str)
{
 try
 {
 Integer.parseInt(str);
 return true;
 }
 catch(NumberFormatException nfe)
 {
 return false;
 }
}

private boolean IsInt_ByRegex(String str)
{
 return str.matches("^-?\\d+$");
}

public boolean IsInt_ByJonas(String str)
{
 if (str == null) {
 return false;
 }
 int length = str.length();
 if (length == 0) {
 return false;
 }
 int i = 0;
 if (str.charAt(0) == '-') {
 if (length == 1) {
 return false;
 }
 i = 1;
 }
 for (; i &lt; length; i++) {
 char c = str.charAt(i);
 if (c &lt;= '/' || c &gt;= ':') {
 return false;
 }
 }
 return true;
}
</code></pre>

Results:

<pre><code>ByException - integer data: 47
ByException - non-integer data: 547

ByRegex - integer data: 390
ByRegex - non-integer data: 313

ByJonas - integer data: 0
ByJonas - non-integer data: 16
</code></pre>

blocks|key|1595598|text|这是更短的，但更短并不一定更好(并且它不会捕获超出范围的整数值，as+pointed+out+in+danatel's+comment)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1595599|input.matches("%5E-?\\d%2B$");|code-block|syntax|javascript|1595600|1595601|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/237159/whats-the-best-way-to-check-to-see-if-a-string-represents-an-integer-in-java#237161^0|W|Z|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|W|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

This is shorter, but shorter isn't necessarily better (and it won't catch integer values which are out of range, <a href="https://stackoverflow.com/questions/237159/whats-the-best-way-to-check-to-see-if-a-string-represents-an-integer-in-java#237161">as pointed out in danatel's comment</a>):

<pre><code>input.matches("^-?\\d+$");
</code></pre>

Personally, since the implementation is squirrelled away in a helper method and correctness trumps length, I would just go with something like what you have (minus catching the base <code>Exception</code> class rather than <code>NumberFormatException</code>).

blocks|key|1810954|text|您可以使用string类的matches方法。0-9表示它可以是的所有值，%2B表示它必须至少有一个字符长度，而*表示它可以是零个或多个字符长度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810955|boolean+isNumeric+=+yourString.matches("[0-9]%2B");+//+1+or+more+characters+long,+numbers+only
boolean+isNumeric+=+yourString.matches("[0-9]*");+//+0+or+more+characters+long,+numbers+only|code-block|syntax|javascript|1810956|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use the matches method of the string class. The [0-9] represents all the values it can be, the + means it must be at least one character long, and the * means it can be zero or more characters long. 

<pre><code>boolean isNumeric = yourString.matches("[0-9]+"); // 1 or more characters long, numbers only
boolean isNumeric = yourString.matches("[0-9]*"); // 0 or more characters long, numbers only
</code></pre>

blocks|key|1809826|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1809827|return+Pattern.matches("-?\\d%2B",+input);|code-block|syntax|javascript|1809828|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How about:

<pre><code>return Pattern.matches("-?\\d+", input);
</code></pre>

blocks|key|1811074|text|这是Jonas+Klemming答案的Java+8变体：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811075|public+static+boolean+isInteger(String+str)+{
++++return+str+!=+null+&&+str.length()+>+0+&&
+++++++++IntStream.range(0,+str.length()).allMatch(i+->+i+==+0+&&+(str.charAt(i)+==+'-'+%7C%7C+str.charAt(i)+==+'%2B')
++++++++++++++++++%7C%7C+Character.isDigit(str.charAt(i)));
}|code-block|syntax|javascript|1811076|测试代码：|1811077|public+static+void+main(String[]+args)+throws+NoSuchAlgorithmException,+UnsupportedEncodingException+{
++++Arrays.asList("1231231",+"-1232312312",+"%2B12313123131",+"qwqe123123211",+"2",+"0000000001111",+"",+"123-",+"%2B%2B123",
++++++++++++"123-23",+null,+"%2B-123").forEach(s+->+{
++++++++System.out.printf("%2515s+%25s%25n",+s,+isInteger(s));
++++});
}|1811078|测试代码的结果：|1811079|++++++++1231231+true
++++-1232312312+true
+++%2B12313123131+true
++qwqe123123211+false
++++++++++++++2+true
++0000000001111+true
++++++++++++++++false
+++++++++++123-+false
++++++++++%2B%2B123+false
+++++++++123-23+false
+++++++++++null+false
++++++++++%2B-123+false|1811080|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is a Java 8 variation of Jonas Klemming answer:

<pre><code>public static boolean isInteger(String str) {
 return str != null &amp;&amp; str.length() &gt; 0 &amp;&amp;
 IntStream.range(0, str.length()).allMatch(i -&gt; i == 0 &amp;&amp; (str.charAt(i) == '-' || str.charAt(i) == '+')
 || Character.isDigit(str.charAt(i)));
}
</code></pre>

Test code:

<pre><code>public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
 Arrays.asList("1231231", "-1232312312", "+12313123131", "qwqe123123211", "2", "0000000001111", "", "123-", "++123",
 "123-23", null, "+-123").forEach(s -&gt; {
 System.out.printf("%15s %s%n", s, isInteger(s));
 });
}
</code></pre>

Results of the test code:

<pre><code> 1231231 true
 -1232312312 true
 +12313123131 true
 qwqe123123211 false
 2 true
 0000000001111 true
 false
 123- false
 ++123 false
 123-23 false
 null false
 +-123 false
</code></pre>

blocks|key|1810494|text|您还可以使用Scanner类和hasNextInt()+-这也允许您测试其他类型，如浮点数等。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1810495|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html|1|https://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html#hasNextInt--^0|6|7|0|F|C|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

You can also use the <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html" rel="nofollow noreferrer">Scanner</a> class, and use <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html#hasNextInt--" rel="nofollow noreferrer">hasNextInt()</a> - and this allows you to test for other types, too, like floats, etc.

blocks|key|1810993|text|如果字符串数组包含纯整数和字符串，下面的代码应该可以工作。您只需查看第一个字符。例如"4"，"44"，"abc"，"77"，"bond“|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810994|if+(Character.isDigit(string.charAt(0)))+{
++++//Do+something+with+int
}|code-block|syntax|javascript|1810995|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If your String array contains pure Integers and Strings, code below should work. You only have to look at first character.
e.g. ["4","44","abc","77","bond"]

<pre><code>if (Character.isDigit(string.charAt(0))) {
 //Do something with int
}
</code></pre>

blocks|key|1811057|text|另一种选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811058|private+boolean+isNumber(String+s)+{
++++boolean+isNumber+=+true;
++++for+(char+c+:+s.toCharArray())+{
++++++++isNumber+=+isNumber+&&+Character.isDigit(c);
++++}
++++return+isNumber;
}|code-block|syntax|javascript|1811059|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another option:

<pre><code>private boolean isNumber(String s) {
 boolean isNumber = true;
 for (char c : s.toCharArray()) {
 isNumber = isNumber &amp;&amp; Character.isDigit(c);
 }
 return isNumber;
}
</code></pre>

blocks|key|1810958|text|您可以尝试apache+utils|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810959|NumberUtils.isCreatable(myText)|code-block|syntax|javascript|1810960|See+the+javadoc+here|offset|length|1810961|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/math/NumberUtils.html#isCreatable-java.lang.String-^0|0|0|0|K|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You may try apache utils

<pre><code>NumberUtils.isCreatable(myText)
</code></pre>

<a href="http://commons.apache.org/proper/commons-lang/javadocs/api-release/org/apache/commons/lang3/math/NumberUtils.html#isCreatable-java.lang.String-" rel="nofollow noreferrer">See the javadoc here</a>

blocks|key|1811082|text|如果您想检查字符串是否表示适合整数类型的整数，我对jonas的答案做了一些修改，以便表示大于Integer.MAX_VALUE或小于Integer.MIN_VALUE的整数的字符串现在将返回false。例如："+3147483647“将返回false，因为3147483647大于2147483647，同样，"+-2147483649”也将返回false，因为-2147483649小于-2147483648。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811083|public+static+boolean+isInt(String+s)+{
++if(s+==+null)+{
++++return+false;
++}
++s+=+s.trim();+//Don't+get+tricked+by+whitespaces.
++int+len+=+s.length();
++if(len+==+0)+{
++++return+false;
++}
++//The+bottom+limit+of+an+int+is+-2147483648+which+is+11+chars+long.
++//[note+that+the+upper+limit+(2147483647)+is+only+10+chars+long]
++//Thus+any+string+with+more+than+11+chars,+even+if+represents+a+valid+integer,+
++//it+won't+fit+in+an+int.
++if(len+>+11)+{
++++return+false;
++}
++char+c+=+s.charAt(0);
++int+i+=+0;
++//I+don't+mind+the+plus+sign,+so+"%2B13"+will+return+true.
++if(c+==+'-'+%7C%7C+c+==+'%2B')+{
++++//A+single+"%2B"+or+"-"+is+not+a+valid+integer.
++++if(len+==+1)+{
++++++return+false;
++++}
++++i+=+1;
++}
++//Check+if+all+chars+are+digits
++for(;+i+<+len;+i%2B%2B)+{
++++c+=+s.charAt(i);
++++if(c+<+'0'+%7C%7C+c+>+'9')+{
++++++return+false;
++++}
++}
++//If+we+reached+this+point+then+we+know+for+sure+that+the+string+has+at
++//most+11+chars+and+that+they're+all+digits+(the+first+one+might+be+a+'%2B'
++//+or+'-'+thought).
++//Now+we+just+need+to+check,+for+10+and+11+chars+long+strings,+if+the+numbers
++//represented+by+the+them+don't+surpass+the+limits.
++c+=+s.charAt(0);
++char+l;
++String+limit;
++if(len+==+10+&&+c+!=+'-'+&&+c+!=+'%2B')+{
++++limit+=+"2147483647";
++++//Now+we+are+going+to+compare+each+char+of+the+string+with+the+char+in
++++//the+limit+string+that+has+the+same+index,+so+if+the+string+is+"ABC"+and
++++//the+limit+string+is+"DEF"+then+we+are+gonna+compare+A+to+D,+B+to+E+and+so+on.
++++//c+is+the+current+string's+char+and+l+is+the+corresponding+limit's+char
++++//Note+that+the+loop+only+continues+if+c+==+l.+Now+imagine+that+our+string
++++//is+"2150000000",+2+==+2+(next),+1+==+1+(next),+5+>+4+as+you+can+see,
++++//because+5+>+4+we+can+guarantee+that+the+string+will+represent+a+bigger+integer.
++++//Similarly,+if+our+string+was+"2139999999",+when+we+find+out+that+3+<+4,
++++//we+can+also+guarantee+that+the+integer+represented+will+fit+in+an+int.
++++for(i+=+0;+i+<+len;+i%2B%2B)+{
++++++c+=+s.charAt(i);
++++++l+=+limit.charAt(i);
++++++if(c+>+l)+{
++++++++return+false;
++++++}
++++++if(c+<+l)+{
++++++++return+true;
++++++}
++++}
++}
++c+=+s.charAt(0);
++if(len+==+11)+{
++++//If+the+first+char+is+neither+'%2B'+nor+'-'+then+11+digits+represent+a+
++++//bigger+integer+than+2147483647+(10+digits).
++++if(c+!=+'%2B'+&&+c+!=+'-')+{
++++++return+false;
++++}
++++limit+=+(c+==+'-')+?+"-2147483648"+:+"%2B2147483647";
++++//Here+we're+applying+the+same+logic+that+we+applied+in+the+previous+case
++++//ignoring+the+first+char.
++++for(i+=+1;+i+<+len;+i%2B%2B)+{
++++++c+=+s.charAt(i);
++++++l+=+limit.charAt(i);
++++++if(c+>+l)+{
++++++++return+false;
++++++}
++++++if(c+<+l)+{
++++++++return+true;
++++++}
++++}
++}
++//The+string+passed+all+tests,+so+it+must+represent+a+number+that+fits
++//in+an+int...
++return+true;
}|code-block|syntax|javascript|1811084|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to check if the string represents an integer that fits in an int type, I did a little modification to the jonas' answer, so that strings that represent integers bigger than Integer.MAX_VALUE or smaller than Integer.MIN_VALUE, will now return false. For example: "3147483647" will return false because 3147483647 is bigger than 2147483647, and likewise, "-2147483649" will also return false because -2147483649 is smaller than -2147483648.

<pre><code>public static boolean isInt(String s) {
 if(s == null) {
 return false;
 }
 s = s.trim(); //Don't get tricked by whitespaces.
 int len = s.length();
 if(len == 0) {
 return false;
 }
 //The bottom limit of an int is -2147483648 which is 11 chars long.
 //[note that the upper limit (2147483647) is only 10 chars long]
 //Thus any string with more than 11 chars, even if represents a valid integer, 
 //it won't fit in an int.
 if(len &gt; 11) {
 return false;
 }
 char c = s.charAt(0);
 int i = 0;
 //I don't mind the plus sign, so "+13" will return true.
 if(c == '-' || c == '+') {
 //A single "+" or "-" is not a valid integer.
 if(len == 1) {
 return false;
 }
 i = 1;
 }
 //Check if all chars are digits
 for(; i &lt; len; i++) {
 c = s.charAt(i);
 if(c &lt; '0' || c &gt; '9') {
 return false;
 }
 }
 //If we reached this point then we know for sure that the string has at
 //most 11 chars and that they're all digits (the first one might be a '+'
 // or '-' thought).
 //Now we just need to check, for 10 and 11 chars long strings, if the numbers
 //represented by the them don't surpass the limits.
 c = s.charAt(0);
 char l;
 String limit;
 if(len == 10 &amp;&amp; c != '-' &amp;&amp; c != '+') {
 limit = "2147483647";
 //Now we are going to compare each char of the string with the char in
 //the limit string that has the same index, so if the string is "ABC" and
 //the limit string is "DEF" then we are gonna compare A to D, B to E and so on.
 //c is the current string's char and l is the corresponding limit's char
 //Note that the loop only continues if c == l. Now imagine that our string
 //is "2150000000", 2 == 2 (next), 1 == 1 (next), 5 &gt; 4 as you can see,
 //because 5 &gt; 4 we can guarantee that the string will represent a bigger integer.
 //Similarly, if our string was "2139999999", when we find out that 3 &lt; 4,
 //we can also guarantee that the integer represented will fit in an int.
 for(i = 0; i &lt; len; i++) {
 c = s.charAt(i);
 l = limit.charAt(i);
 if(c &gt; l) {
 return false;
 }
 if(c &lt; l) {
 return true;
 }
 }
 }
 c = s.charAt(0);
 if(len == 11) {
 //If the first char is neither '+' nor '-' then 11 digits represent a 
 //bigger integer than 2147483647 (10 digits).
 if(c != '+' &amp;&amp; c != '-') {
 return false;
 }
 limit = (c == '-') ? "-2147483648" : "+2147483647";
 //Here we're applying the same logic that we applied in the previous case
 //ignoring the first char.
 for(i = 1; i &lt; len; i++) {
 c = s.charAt(i);
 l = limit.charAt(i);
 if(c &gt; l) {
 return false;
 }
 if(c &lt; l) {
 return true;
 }
 }
 }
 //The string passed all tests, so it must represent a number that fits
 //in an int...
 return true;
}
</code></pre>

blocks|key|1810932|text|您可能还需要考虑用例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810933|如果在大多数情况下，您希望数字是有效的，那么捕获异常只会在尝试转换无效数字时导致性能开销。然而，调用某个isInteger()方法，然后使用Integer.parseInt()进行转换将始终导致有效数字的性能开销-字符串被解析两次，一次由检查，一次由转换。|offset|length|style|CODE|1810934|entityMap^0|0|1G|B|1Y|I|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

You probably need to take the use case in account too:

If most of the time you expect numbers to be valid, then catching the exception is only causing a performance overhead when attempting to convert invalid numbers. Whereas calling some <code>isInteger()</code> method and then convert using <code>Integer.parseInt()</code> will always cause a performance overhead for valid numbers - the strings are parsed twice, once by the check and once by the conversion.

blocks|key|1811045|text|如果您使用的是Android+API，则可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811046|TextUtils.isDigitsOnly(str);|code-block|syntax|javascript|1811047|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you are using the Android API you can use:

<pre><code>TextUtils.isDigitsOnly(str);
</code></pre>

blocks|key|1595873|text|抛出异常应该保留为“异常”情况(不过，这可能适合您的情况)，并且在性能方面是非常昂贵的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1595874|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

What you did works, but you probably shouldn't always check that way. Throwing exceptions should be reserved for "exceptional" situations (maybe that fits in your case, though), and are very costly in terms of performance.

blocks|key|1810919|text|这只适用于正整数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810920|public+static+boolean+isInt(String+str)+{
++++if+(str+!=+null+&&+str.length()+!=+0)+{
++++++++for+(int+i+=+0;+i+<+str.length();+i%2B%2B)+{
++++++++++++if+(!Character.isDigit(str.charAt(i)))+return+false;
++++++++}
++++}
++++return+true;++++++++
}|code-block|syntax|javascript|1810921|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This would work only for positive integers.

<pre><code>public static boolean isInt(String str) {
 if (str != null &amp;&amp; str.length() != 0) {
 for (int i = 0; i &lt; str.length(); i++) {
 if (!Character.isDigit(str.charAt(i))) return false;
 }
 }
 return true; 
}
</code></pre>

blocks|key|1811001|text|这对我很有效。简单地识别字符串是基元还是数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811002|private+boolean+isPrimitive(String+value){
++++++++boolean+status=true;
++++++++if(value.length()<1)
++++++++++++return+false;
++++++++for(int+i+=+0;i<value.length();i%2B%2B){
++++++++++++char+c=value.charAt(i);
++++++++++++if(Character.isDigit(c)+%7C%7C+c=='.'){

++++++++++++}else{
++++++++++++++++status=false;
++++++++++++++++break;
++++++++++++}
++++++++}
++++++++return+status;
++++}|code-block|syntax|javascript|1811003|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This works for me. Simply to identify whether a String is a primitive or a number.

<pre><code>private boolean isPrimitive(String value){
 boolean status=true;
 if(value.length()&lt;1)
 return false;
 for(int i = 0;i&lt;value.length();i++){
 char c=value.charAt(i);
 if(Character.isDigit(c) || c=='.'){

 }else{
 status=false;
 break;
 }
 }
 return status;
 }
</code></pre>

blocks|key|1596664|text|要检查所有整型字符，您可以简单地使用双重否定。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596665|如果(!searchString.matches("%5E0-9%2B$"))+...|1596666|%5E0-9%2B$检查是否有任何不是整数的字符，因此如果为真，则测试失败。只要不是这样，你就会在成功时变得真实。|1596667|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

To check for all int chars, you can simply use a double negative. 

if (!searchString.matches("[^0-9]+$")) ...

[^0-9]+$ checks to see if there are any characters that are not integer, so the test fails if it's true. Just NOT that and you get true on success.

blocks|key|1811065|text|我在这里看到了很多答案，但大多数都能够确定字符串是否为数字，但无法检查数字是否在整数范围内……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811066|因此，我的目的如下：|1811067|public+static+boolean+isInteger(String+str)+{
++++if+(str+==+null+%7C%7C+str.isEmpty())+{
++++++++return+false;
++++}
++++try+{
++++++++long+value+=+Long.valueOf(str);
++++++++return+value+>=+-2147483648+&&+value+<=+2147483647;
++++}+catch+(Exception+ex)+{
++++++++return+false;
++++}
}|code-block|syntax|javascript|1811068|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I have seen a lot of answers here, but most of them are able to determine whether the String is numeric, but they fail checking whether the number is in Integer range...

Therefore I purpose something like this:

<pre><code>public static boolean isInteger(String str) {
 if (str == null || str.isEmpty()) {
 return false;
 }
 try {
 long value = Long.valueOf(str);
 return value &gt;= -2147483648 &amp;&amp; value &lt;= 2147483647;
 } catch (Exception ex) {
 return false;
 }
}
</code></pre>

blocks|key|1811092|text|这是对@Jonas+K+anwser的一点改进，这个函数将排除像"*"这样的单个运算符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1811093|public+boolean+isInteger(String+str)+{
++++//+null+pointer
++++if+(str+==+null)+{
++++++++return+false;
++++}
++++int+len+=+str.length();
++++//+empty+string
++++if+(len+==+0)+{
++++++++return+false;
++++}
++++//+one+digit,+cannot+begin+with+0
++++if+(len+==+1)+{
++++++++char+c+=+str.charAt(0);
++++++++if+((c+<+'1')+%7C%7C+(c+>+'9'))+{
++++++++++++return+false;
++++++++}
++++}

++++for+(int+i+=+0;+i+<+len;+i%2B%2B)+{
++++++++char+c+=+str.charAt(i);
++++++++//+check+positive,+negative+sign
++++++++if+(i+==+0)+{
++++++++++++if+(c+==+'-'+%7C%7C+c+==+'%2B')+{
++++++++++++++++continue;
++++++++++++}
++++++++}
++++++++//+check+each+character+matches+[0-9]
++++++++if+((c+<+'0')+%7C%7C+(c+>+'9'))+{
++++++++++++return+false;
++++++++}
++++}
++++return+true;
}|code-block|syntax|javascript|1811094|entityMap^0|W|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

a little improvement to @Jonas K anwser, this function will rule out one single operator like <code>&quot;*&quot;</code>.
<pre class="lang-java prettyprint-override"><code>public boolean isInteger(String str) {
 // null pointer
 if (str == null) {
 return false;
 }
 int len = str.length();
 // empty string
 if (len == 0) {
 return false;
 }
 // one digit, cannot begin with 0
 if (len == 1) {
 char c = str.charAt(0);
 if ((c &lt; '1') || (c &gt; '9')) {
 return false;
 }
 }

 for (int i = 0; i &lt; len; i++) {
 char c = str.charAt(i);
 // check positive, negative sign
 if (i == 0) {
 if (c == '-' || c == '+') {
 continue;
 }
 }
 // check each character matches [0-9]
 if ((c &lt; '0') || (c &gt; '9')) {
 return false;
 }
 }
 return true;
}

</code></pre>

blocks|key|1811103|text|我最近(今天)需要找出一种快速的方法来做到这一点，当然，当猴子在肩膀上(良知)醒来时，我将使用异常方法来轻松地完成，所以它把我带进了这个熟悉的老兔子洞；没有异常并没有那么昂贵，事实上，有时异常更快(旧的AIX多处理器系统)，但不管它是多么优雅，所以我做了一些年轻的我从未做过的事情，令我惊讶的是，这里也没有人做过(如果有人做了，道歉，我错过了它，老实说，我没有找到)：那么我认为我们都错过了什么？看看JRE是如何实现它的，是的，他们抛出了一个异常，但我们总是可以跳过这一部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811104|10年前的年轻我会觉得这比他低，但他又是一个大嘴巴的卖弄，气质差，有神的情结，所以就是这样。|1811105|我把这个放在这里是为了将来来这里的任何人的利益。这是我发现的：|1811106|public+static+int+parseInt(String+s,+int+radix)+throws+NumberFormatException
{
++++/*
+++++*+WARNING:+This+method+may+be+invoked+early+during+VM+initialization
+++++*+before+IntegerCache+is+initialized.+Care+must+be+taken+to+not+use
+++++*+the+valueOf+method.
+++++*/

++++if+(s+==+null)+{
++++++++throw+new+NumberFormatException("null");
++++}

++++if+(radix+<+Character.MIN_RADIX)+{
++++++++throw+new+NumberFormatException("radix+"+%2B+radix+%2B
++++++++++++++++++++++++++++++++++++++++"+less+than+Character.MIN_RADIX");
++++}

++++if+(radix+>+Character.MAX_RADIX)+{
++++++++throw+new+NumberFormatException("radix+"+%2B+radix+%2B
++++++++++++++++++++++++++++++++++++++++"+greater+than+Character.MAX_RADIX");
++++}

++++int+result+=+0;
++++boolean+negative+=+false;
++++int+i+=+0,+len+=+s.length();
++++int+limit+=+-Integer.MAX_VALUE;
++++int+multmin;
++++int+digit;

++++if+(len+>+0)+{
++++++++char+firstChar+=+s.charAt(0);
++++++++if+(firstChar+<+'0')+{+//+Possible+leading+"%2B"+or+"-"
++++++++++++if+(firstChar+==+'-')+{
++++++++++++++++negative+=+true;
++++++++++++++++limit+=+Integer.MIN_VALUE;
++++++++++++}+else+if+(firstChar+!=+'%2B')
++++++++++++++++throw+NumberFormatException.forInputString(s);

++++++++++++if+(len+==+1)+//+Cannot+have+lone+"%2B"+or+"-"
++++++++++++++++throw+NumberFormatException.forInputString(s);
++++++++++++i%2B%2B;
++++++++}
++++++++multmin+=+limit+/+radix;
++++++++while+(i+<+len)+{
++++++++++++//+Accumulating+negatively+avoids+surprises+near+MAX_VALUE
++++++++++++digit+=+Character.digit(s.charAt(i%2B%2B),radix);
++++++++++++if+(digit+<+0)+{
++++++++++++++++throw+NumberFormatException.forInputString(s);
++++++++++++}
++++++++++++if+(result+<+multmin)+{
++++++++++++++++throw+NumberFormatException.forInputString(s);
++++++++++++}
++++++++++++result+*=+radix;
++++++++++++if+(result+<+limit+%2B+digit)+{
++++++++++++++++throw+NumberFormatException.forInputString(s);
++++++++++++}
++++++++++++result+-=+digit;
++++++++}
++++}+else+{
++++++++throw+NumberFormatException.forInputString(s);
++++}
++++return+negative+?+result+:+-result;
}|code-block|syntax|javascript|1811107|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I recently (today) needed to figure out a quick way to do this and of course I was going to use the exception approach for ease when the monkey on the shoulder (conscience) woke up so it took me down this old familiar rabbit hole; no exceptions are not that much more expensive in fact sometimes exceptions are faster (old AIX multiprocessor systems) but regardless it’s to elegant so I did something that the younger me never did and to my amazement nobody here did either (apologize if someone did and I missed it I honestly did not find) : so what did I think we all missed; taking a look at how the JRE implemented it, yes they threw an exception but we can always skip that part.
The younger me from 10 years ago would have felt this to be beneath him, but then again he is a loud mouthed show off with a poor temperament and a god complex so there is that.
I am putting this here for the benefit of anyone coming here in the future. Here is what I found:
<pre><code>public static int parseInt(String s, int radix) throws NumberFormatException
{
 /*
 * WARNING: This method may be invoked early during VM initialization
 * before IntegerCache is initialized. Care must be taken to not use
 * the valueOf method.
 */

 if (s == null) {
 throw new NumberFormatException(&quot;null&quot;);
 }

 if (radix &lt; Character.MIN_RADIX) {
 throw new NumberFormatException(&quot;radix &quot; + radix +
 &quot; less than Character.MIN_RADIX&quot;);
 }

 if (radix &gt; Character.MAX_RADIX) {
 throw new NumberFormatException(&quot;radix &quot; + radix +
 &quot; greater than Character.MAX_RADIX&quot;);
 }

 int result = 0;
 boolean negative = false;
 int i = 0, len = s.length();
 int limit = -Integer.MAX_VALUE;
 int multmin;
 int digit;

 if (len &gt; 0) {
 char firstChar = s.charAt(0);
 if (firstChar &lt; '0') { // Possible leading &quot;+&quot; or &quot;-&quot;
 if (firstChar == '-') {
 negative = true;
 limit = Integer.MIN_VALUE;
 } else if (firstChar != '+')
 throw NumberFormatException.forInputString(s);

 if (len == 1) // Cannot have lone &quot;+&quot; or &quot;-&quot;
 throw NumberFormatException.forInputString(s);
 i++;
 }
 multmin = limit / radix;
 while (i &lt; len) {
 // Accumulating negatively avoids surprises near MAX_VALUE
 digit = Character.digit(s.charAt(i++),radix);
 if (digit &lt; 0) {
 throw NumberFormatException.forInputString(s);
 }
 if (result &lt; multmin) {
 throw NumberFormatException.forInputString(s);
 }
 result *= radix;
 if (result &lt; limit + digit) {
 throw NumberFormatException.forInputString(s);
 }
 result -= digit;
 }
 } else {
 throw NumberFormatException.forInputString(s);
 }
 return negative ? result : -result;
}
</code></pre>

blocks|key|1811109|text|这里有几个答案，说要尝试解析成一个整数并捕获NumberFormatException，但你不应该这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1811110|这种方式将创建异常对象，并在每次调用它时生成堆栈跟踪，但它不是整数。|1811111|对于Java+8，一种更好的方法是使用流：|1811112|boolean+isInteger+=+returnValue.chars().allMatch(Character::isDigit);|code-block|syntax|javascript|1811113|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

several answers here saying to try parsing to an integer and catching the NumberFormatException but you should not do this.
That way would create exception object and generates a stack trace each time you called it and it was not an integer.
A better way with Java 8 would be to use a stream:
<pre><code>boolean isInteger = returnValue.chars().allMatch(Character::isDigit);
</code></pre>

blocks|key|1596216|text|Number+number;
try+{
++++number+=+NumberFormat.getInstance().parse("123");
}+catch+(ParseException+e)+{
++++//not+a+number+-+do+recovery.
++++e.printStackTrace();
}
//use+number|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1596217|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Number number;
try {
 number = NumberFormat.getInstance().parse("123");
} catch (ParseException e) {
 //not a number - do recovery.
 e.printStackTrace();
}
//use number
</code></pre>

blocks|key|1810997|text|对于那些像我一样在问题提出多年后来到这里的读者，我有一个关于这个问题的更一般的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810998|/**
+*+Checks,+if+the+string+represents+a+number.
+*
+*+@param+string+the+string
+*+@return+true,+if+the+string+is+a+number
+*/
public+static+boolean+isANumber(final+String+string)+{
++++if+(string+!=+null)+{
++++++++final+int+length+=+string.length();
++++++++if+(length+!=+0)+{
++++++++++++int+i+=+0;
++++++++++++if+(string.charAt(0)+==+'-')+{
++++++++++++++++if+(length+==+1)+{
++++++++++++++++++++return+false;
++++++++++++++++}
++++++++++++++++i%2B%2B;
++++++++++++}
++++++++++++for+(;+i+<+length;+i%2B%2B)+{
++++++++++++++++final+char+c+=+string.charAt(i);
++++++++++++++++if+((c+<=+PERIOD)+%7C%7C+((c+>=+COLON)))+{
++++++++++++++++++++final+String+strC+=+Character.toString(c).toUpperCase();
++++++++++++++++++++final+boolean+isExponent+=+strC.equals("E");
++++++++++++++++++++final+boolean+isPeriod+=+(c+==+PERIOD);
++++++++++++++++++++final+boolean+isPlus+=+(c+==+PLUS);

++++++++++++++++++++if+(!isExponent+&&+!isPeriod+&&+!isPlus)+{
++++++++++++++++++++++++return+false;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++++++return+true;
++++++++}
++++}
++++return+false;
}|code-block|syntax|javascript|1810999|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For those readers who arrive here like me years after the question was asked, I have a more general solution for this question.

<pre><code>/**
 * Checks, if the string represents a number.
 *
 * @param string the string
 * @return true, if the string is a number
 */
public static boolean isANumber(final String string) {
 if (string != null) {
 final int length = string.length();
 if (length != 0) {
 int i = 0;
 if (string.charAt(0) == '-') {
 if (length == 1) {
 return false;
 }
 i++;
 }
 for (; i &lt; length; i++) {
 final char c = string.charAt(i);
 if ((c &lt;= PERIOD) || ((c &gt;= COLON))) {
 final String strC = Character.toString(c).toUpperCase();
 final boolean isExponent = strC.equals("E");
 final boolean isPeriod = (c == PERIOD);
 final boolean isPlus = (c == PLUS);

 if (!isExponent &amp;&amp; !isPeriod &amp;&amp; !isPlus) {
 return false;
 }
 }
 }
 return true;
 }
 }
 return false;
}
</code></pre>

blocks|key|1596669|text|发现这可能会有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596670|public+static+boolean+isInteger(String+self)+{
++++try+{
++++++++Integer.valueOf(self.trim());
++++++++return+true;
++++}+catch+(NumberFormatException+nfe)+{
++++++++return+false;
++++}
}|code-block|syntax|javascript|1596671|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Find this may helpful:

<pre><code>public static boolean isInteger(String self) {
 try {
 Integer.valueOf(self.trim());
 return true;
 } catch (NumberFormatException nfe) {
 return false;
 }
}
</code></pre>

blocks|key|1811054|text|public+class+HelloWorld{

++++static+boolean+validateIP(String+s){
++++++++String[]+value+=+s.split("\\.");
++++++++if(value.length!=4)+return+false;
++++++++int[]+v+=+new+int[4];
++++++++for(int+i=0;i<4;i%2B%2B){
++++++++++++for(int+j=0;j<value[i].length();j%2B%2B){
++++++++++++++++if(!Character.isDigit(value[i].charAt(j)))+
+++++++++++++++++return+false;
++++++++++++}
++++++++++++v[i]=Integer.parseInt(value[i]);
++++++++++++if(!(v[i]>=0+&&+v[i]<=255))+return+false;
++++++++}
++++++++return+true;
++++}

++++public+static+void+main(String[]+argv){
++++++++String+test+=+"12.23.8.9j";
++++++++if(validateIP(test)){
++++++++++++System.out.println(""%2Btest);
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1811055|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class HelloWorld{

 static boolean validateIP(String s){
 String[] value = s.split("\\.");
 if(value.length!=4) return false;
 int[] v = new int[4];
 for(int i=0;i&lt;4;i++){
 for(int j=0;j&lt;value[i].length();j++){
 if(!Character.isDigit(value[i].charAt(j))) 
 return false;
 }
 v[i]=Integer.parseInt(value[i]);
 if(!(v[i]&gt;=0 &amp;&amp; v[i]&lt;=255)) return false;
 }
 return true;
 }

 public static void main(String[] argv){
 String test = "12.23.8.9j";
 if(validateIP(test)){
 System.out.println(""+test);
 }
 }
}
</code></pre>

blocks|key|1596101|text|Integer.valueOf(string);+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1596102|大部分时间对我来说都是有效的！|unstyled|1596103|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>Integer.valueOf(string); 
</code></pre>

works for me most of the time!

I normally use the following idiom to check if a String can be converted to an integer.

<pre><code>public boolean isInteger( String input ) {
 try {
 Integer.parseInt( input );
 return true;
 }
 catch( Exception e ) {
 return false;
 }
}
</code></pre>

Is it just me, or does this seem a bit hackish? What's a better way?

<hr>

See my answer (with benchmarks, based on the <a href="https://stackoverflow.com/a/237321/1288">earlier answer</a> by <a href="https://stackoverflow.com/users/28278/codingwithspike">CodingWithSpike</a>) to see why I've reversed my position and accepted <a href="https://stackoverflow.com/a/237204/1288">Jonas Klemming's answer</a> to this problem. I think this original code will be used by most people because it's quicker to implement, and more maintainable, but it's orders of magnitude slower when non-integer data is provided.

What's the best way to check if a String represents an integer in Java?

Android

路由

Java

我通常使用以下习惯用法来检查字符串是否可以转换为整数。public boolean isInteger( String input ) {    try {        Integer.parseInt( input );        return true;    }    catch( Exception e ) {        return false;    }}是不是只有我，或者这

问在Java中检查字符串是否表示整数的最佳方法是什么？
EN

回答 32

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中检查字符串是否表示整数的最佳方法是什么？EN

回答 32

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中检查字符串是否表示整数的最佳方法是什么？
EN