Wie prüfe ich am besten, ob ein String eine ganze Zahl in Java darstellt?
Normalerweise verwende ich den folgenden Ausdruck, um zu prüfen, ob ein String in eine Ganzzahl konvertiert werden kann.
public boolean isInteger( String input ) {
try {
Integer.parseInt( input );
return true;
}
catch( Exception e ) {
return false;
}
}
Ist es nur ich oder scheint das ein bisschen hackig zu sein? Was ist ein besserer Weg?
Sehen Sie meine Antwort (mit Benchmarks basierend auf der früheren Antwort by CodingWithSpike ), um zu sehen, warum ich meine Position geändert habe und Jonas Klemmings Antwort zu diesem Problem akzeptiert habe. Ich denke, dass der ursprüngliche Code von den meisten Benutzern verwendet wird, da er schneller implementiert werden kann und einfacher zu warten ist. Er ist jedoch um Größenordnungen langsamer, wenn nicht ganzzahlige Daten bereitgestellt werden.
Wenn Sie sich nicht mit möglichen Überlaufproblemen beschäftigen, wird diese Funktion etwa 20 bis 30 Mal schneller ausgeführt als mit Integer.parseInt().
public static boolean isInteger(String str) {
if (str == null) {
return false;
}
if (str.isEmpty()) {
return false;
}
int i = 0;
if (str.charAt(0) == '-') {
if (length == 1) {
return false;
}
i = 1;
}
for (; i < length; i++) {
char c = str.charAt(i);
if (c < '0' || c > '9') {
return false;
}
}
return true;
}
Sie haben es, aber Sie sollten nur NumberFormatException fangen.
Hat einen schnellen Benchmark gemacht. Ausnahmen sind nicht wirklich teuer, es sei denn, Sie beginnen, mehrere Methoden zurückzublättern, und die JVM muss eine Menge Arbeit verrichten, um den Ausführungsstack zu installieren. Wenn sie auf dieselbe Weise bleiben, sind sie keine schlechten Künstler.
public void RunTests()
{
String str = "1234567890";
long startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByException(str);
long endTime = System.currentTimeMillis();
System.out.print("ByException: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByRegex(str);
endTime = System.currentTimeMillis();
System.out.print("ByRegex: ");
System.out.println(endTime - startTime);
startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; i++)
IsInt_ByJonas(str);
endTime = System.currentTimeMillis();
System.out.print("ByJonas: ");
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 < length; i++) {
char c = str.charAt(i);
if (c <= '/' || c >= ':') {
return false;
}
}
return true;
}
Ausgabe:
ByException: 31
ByRegex: 453 (Hinweis: Das Muster wird jedes Mal neu kompiliert.)
ByJonas: 16
Ich stimme zu, dass die Lösung von Jonas K auch die robusteste ist. Sieht aus wie er gewinnt :)
Da gibt es die Möglichkeit, dass die Leute noch hierher kommen und nach den Benchmarks gegen Regex voreingenommen sind ... Ich werde also eine aktualisierte Version des Benchmarks mit einer kompilierten Version der Regex geben. Im Gegensatz zu den vorangegangenen Benchmarks zeigt dieser hier, dass die Regex-Lösung eine konstant gute Leistung aufweist.
Aus Bill the Lizard kopiert und mit der kompilierten Version aktualisiert:
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 < 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 < 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 < 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 < 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 < 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 < 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 < 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 < 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 < length; i++) {
char c = str.charAt(i);
if (c <= '/' || c >= ':') {
return false;
}
}
return true;
}
Ergebnisse:
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
org.Apache.commons.lang.StringUtils.isNumeric
obwohl Javas Standard-Bibliothek solche Dienstfunktionen wirklich vermisst
Ich denke, dass Apache Commons für jeden Java-Programmierer ein "Muss" ist
schade, dass es noch nicht auf Java5 portiert ist
Es hängt zum Teil davon ab, was Sie mit "kann in eine ganze Zahl umgewandelt werden" meinen.
Wenn Sie meinen, dass "in Java in ein Int konvertiert werden kann", dann ist die Antwort von Jonas ein guter Anfang, beendet aber den Job nicht ganz. Es würde zum Beispiel 9999999999999999999999999999 übergeben. Ich würde den normalen Try/Catch-Aufruf von Ihrer eigenen Frage am Ende der Methode hinzufügen.
Die zeichenweisen Überprüfungen lehnen Fälle von "überhaupt keine Ganzzahl" ab und lassen Fälle von "es ist eine Ganzzahl, aber Java kann nicht damit umgehen", die von der langsameren Ausnahmeroute abgefangen werden. Sie könnten tun dieses Stück auch von Hand, aber es wäre ein viel komplizierter.
Nur ein Kommentar zu Regex. Jedes hier angegebene Beispiel ist falsch! Wenn Sie regexp verwenden möchten, vergessen Sie nicht, dass das Kompilieren des Patterns viel Zeit in Anspruch nimmt. Diese:
str.matches("^-?\\d+$")
und auch dies:
Pattern.matches("-?\\d+", input);
bewirkt das Kompilieren des Musters bei jedem Methodenaufruf. Um es richtig anzuwenden, folgen Sie bitte:
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 && PATTERN.matcher(input).matches();
}
}
Ich habe den Code aus der Antwort von rally25rs kopiert und einige Tests für nicht ganzzahlige Daten hinzugefügt. Die Ergebnisse sprechen eindeutig für die Methode von Jonas Klemming. Die Ergebnisse für die Exceptions-Methode, die ich ursprünglich gepostet habe, sind ziemlich gut, wenn Sie über ganzzahlige Daten verfügen, aber die schlechtesten, wenn Sie dies nicht tun, während die Ergebnisse für die RegEx-Lösung (auf die ich wette, viele Leute setzen). waren konsequent schlecht. Siehe Felipes Antwort für ein kompiliertes Regex-Beispiel, das viel schneller ist.
public void runTests()
{
String big_int = "1234567890";
String non_int = "1234XY7890";
long startTime = System.currentTimeMillis();
for(int i = 0; i < 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 < 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 < 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 < 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 < 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 < 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 < length; i++) {
char c = str.charAt(i);
if (c <= '/' || c >= ':') {
return false;
}
}
return true;
}
Ergebnisse:
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
Es gibt eine Guavenversion:
import com.google.common.primitives.Ints;
Integer intValue = Ints.tryParse(stringValue);
Wenn keine Zeichenfolge analysiert werden kann, wird null zurückgegeben, anstatt eine Ausnahme auszulösen.
Dies ist kürzer, aber kürzer ist nicht unbedingt besser (und es werden keine ganzzahligen Werte erfasst, die außerhalb des Bereichs liegen, wie in Danatels Kommentar ):
input.matches("^-?\\d+$");
Ich persönlich würde, da die Implementierung in einer Hilfsmethode weggezaubert wird und die Korrektheit die Länge übertrumpft, einfach etwas mit dem machen, was Sie haben (minus dem Einfangen der Exception-Basisklasse statt NumberFormatException).
Sie können die Matches-Methode der String-Klasse verwenden. Das [0-9] stellt alle Werte dar, die es sein kann, das Plus bedeutet, dass es mindestens ein Zeichen lang sein muss, und das * bedeutet, dass es null oder mehr Zeichen sein kann.
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
Dies ist eine Java 8-Variante von Jonas Klemming:
public static boolean isInteger(String str) {
return str != null && str.length() > 0 &&
IntStream.range(0, str.length()).allMatch(i -> i == 0 && (str.charAt(i) == '-' || str.charAt(i) == '+')
|| Character.isDigit(str.charAt(i)));
}
Testcode:
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 -> {
System.out.printf("%15s %s%n", s, isInteger(s));
});
}
Ergebnisse des Testcodes:
1231231 true
-1232312312 true
+12313123131 true
qwqe123123211 false
2 true
0000000001111 true
false
123- false
++123 false
123-23 false
null false
+-123 false
Sie können auch die Klasse Scanner und hasNextInt () - verwenden. Auf diese Weise können Sie auch nach anderen Typen wie Floats usw. suchen.
Wenn Ihr String-Array reine Ganzzahlen und Strings enthält, sollte der folgende Code funktionieren. Sie müssen nur das erste Zeichen betrachten. [4, 44, abc ", 77," bond "]
if (Character.isDigit(string.charAt(0))) {
//Do something with int
}
Sie prüfen nur NumberFormatException : -
String value="123";
try
{
int s=Integer.parseInt(any_int_val);
// do something when integer values comes
}
catch(NumberFormatException nfe)
{
// do something when string values comes
}
Wahrscheinlich müssen Sie den Anwendungsfall auch im Konto berücksichtigen:
Wenn Sie meist davon ausgehen, dass Zahlen gültig sind, führt das Erfassen der Ausnahme nur zu einem Performance-Overhead, wenn Sie versuchen, ungültige Zahlen zu konvertieren. Während das Aufrufen einer isInteger()-Methode und die Konvertierung mit Integer.parseInt()always einen Performance-Overhead für gültige Zahlen verursachen, werden die Zeichenfolgen zweimal analysiert, einmal durch die Prüfung und einmal durch die Konvertierung.
Wie wäre es mit:
return Pattern.matches("-?\\d+", input);
Wenn Sie die Android-API verwenden, können Sie Folgendes verwenden:
TextUtils.isDigitsOnly(str);
Andere Option:
private boolean isNumber(String s) {
boolean isNumber = true;
for (char c : s.toCharArray()) {
isNumber = isNumber && Character.isDigit(c);
}
return isNumber;
}
Wenn Sie überprüfen möchten, ob die Zeichenfolge eine Ganzzahl darstellt, die in einen Int-Typ passt, habe ich die Antwort der Jonas ein wenig geändert, sodass jetzt Zeichenfolgen zurückgegeben werden, die ganze Zahlen darstellen, die größer als Integer.MAX_VALUE oder kleiner als Integer.MIN_VALUE sind falsch. Beispiel: "3147483647" gibt "false" zurück, weil 3147483647 größer als 2147483647 ist, und "-2147483649" gibt ebenfalls "false" zurück, da -2147483649 kleiner als -2147483648 ist.
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 "+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 < len; i++) {
c = s.charAt(i);
if(c < '0' || 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 '+'
// 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 != '+') {
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++) {
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 '+' nor '-' then 11 digits represent a
//bigger integer than 2147483647 (10 digits).
if(c != '+' && 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 < len; i++) {
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;
}
Dies ist eine Modifikation des Jonas '- Codes, mit der geprüft wird, ob sich die Zeichenfolge innerhalb des Bereichs befindet, der in eine Ganzzahl umgewandelt werden soll.
public static boolean isInteger(String str) {
if (str == null) {
return false;
}
int length = str.length();
int i = 0;
// set the length and value for highest positive int or lowest negative int
int maxlength = 10;
String maxnum = String.valueOf(Integer.MAX_VALUE);
if (str.charAt(0) == '-') {
maxlength = 11;
i = 1;
maxnum = String.valueOf(Integer.MIN_VALUE);
}
// verify digit length does not exceed int range
if (length > maxlength) {
return false;
}
// verify that all characters are numbers
if (maxlength == 11 && length == 1) {
return false;
}
for (int num = i; num < length; num++) {
char c = str.charAt(num);
if (c < '0' || c > '9') {
return false;
}
}
// verify that number value is within int range
if (length == maxlength) {
for (; i < length; i++) {
if (str.charAt(i) < maxnum.charAt(i)) {
return true;
}
else if (str.charAt(i) > maxnum.charAt(i)) {
return false;
}
}
}
return true;
}
Ich habe hier viele Antworten gesehen, aber die meisten können feststellen, ob der String numerisch ist, aber sie prüfen nicht, ob die Zahl im Integer-Bereich liegt ...
Deshalb verstehe ich so etwas:
public static boolean isInteger(String str) {
if (str == null || str.isEmpty()) {
return false;
}
try {
long value = Long.valueOf(str);
return value >= -2147483648 && value <= 2147483647;
} catch (Exception ex) {
return false;
}
}
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++){
for(int j=0;j<value[i].length();j++){
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(""+test);
}
}
}
Das funktioniert für mich. Einfach feststellen, ob ein String ein Primitiv oder eine Zahl ist.
private boolean isPrimitive(String value){
boolean status=true;
if(value.length()<1)
return false;
for(int i = 0;i<value.length();i++){
char c=value.charAt(i);
if(Character.isDigit(c) || c=='.'){
}else{
status=false;
break;
}
}
return status;
}
Wenn Erklärungen wichtiger sind als Leistung
Ich bemerkte viele Diskussionen darüber, wie effizient bestimmte Lösungen sind, aber keine über , warum eine Zeichenfolge keine ganze Zahl ist. Außerdem schienen alle davon auszugehen, dass die Zahl "2.00" nicht gleich "2" ist. Mathematisch und menschlich gesehen sind sie gleich (auch wenn die Informatik dies aus gutem Grund nicht behauptet). Aus diesem Grund sind die oben genannten "Integer.parseInt" -Lösungen schwach (abhängig von Ihren Anforderungen).
Um Software intelligenter und menschlicher zu machen, müssen wir auf jeden Fall Software entwickeln, die so denkt wie wir und erklärt , warum etwas fehlgeschlagen ist. In diesem Fall:
public static boolean isIntegerFromDecimalString(String possibleInteger) {
possibleInteger = possibleInteger.trim();
try {
// Integer parsing works great for "regular" integers like 42 or 13.
int num = Integer.parseInt(possibleInteger);
System.out.println("The possibleInteger="+possibleInteger+" is a pure integer.");
return true;
} catch (NumberFormatException e) {
if (possibleInteger.equals(".")) {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it is only a decimal point.");
return false;
} else if (possibleInteger.startsWith(".") && possibleInteger.matches("\\.[0-9]*")) {
if (possibleInteger.matches("\\.[0]*")) {
System.out.println("The possibleInteger=" + possibleInteger + " is an integer because it starts with a decimal point and afterwards is all zeros.");
return true;
} else {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it starts with a decimal point and afterwards is not all zeros.");
return false;
}
} else if (possibleInteger.endsWith(".") && possibleInteger.matches("[0-9]*\\.")) {
System.out.println("The possibleInteger="+possibleInteger+" is an impure integer (ends with decimal point).");
return true;
} else if (possibleInteger.contains(".")) {
String[] partsOfPossibleInteger = possibleInteger.split("\\.");
if (partsOfPossibleInteger.length == 2) {
//System.out.println("The possibleInteger=" + possibleInteger + " is split into '" + partsOfPossibleInteger[0] + "' and '" + partsOfPossibleInteger[1] + "'.");
if (partsOfPossibleInteger[0].matches("[0-9]*")) {
if (partsOfPossibleInteger[1].matches("[0]*")) {
System.out.println("The possibleInteger="+possibleInteger+" is an impure integer (ends with all zeros after the decimal point).");
return true;
} else if (partsOfPossibleInteger[1].matches("[0-9]*")) {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the numbers after the decimal point (" +
partsOfPossibleInteger[1] + ") are not all zeros.");
return false;
} else {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the 'numbers' after the decimal point (" +
partsOfPossibleInteger[1] + ") are not all numeric digits.");
return false;
}
} else {
System.out.println("The possibleInteger=" + possibleInteger + " is NOT an integer because it the 'number' before the decimal point (" +
partsOfPossibleInteger[0] + ") is not a number.");
return false;
}
} else {
System.out.println("The possibleInteger="+possibleInteger+" is NOT an integer because it has a strange number of decimal-period separated parts (" +
partsOfPossibleInteger.length + ").");
return false;
}
} // else
System.out.println("The possibleInteger='"+possibleInteger+"' is NOT an integer, even though it has no decimal point.");
return false;
}
}
Testcode:
String[] testData = {"0", "0.", "0.0", ".000", "2", "2.", "2.0", "2.0000", "3.14159", ".0001", ".", "$4.0", "3E24", "6.0221409e+23"};
int i = 0;
for (String possibleInteger : testData ) {
System.out.println("");
System.out.println(i + ". possibleInteger='" + possibleInteger +"' isIntegerFromDecimalString=" + isIntegerFromDecimalString(possibleInteger));
i++;
}
is_number = true;
try {
Integer.parseInt(mystr)
} catch (NumberFormatException e) {
is_number = false;
}
Was Sie getan haben, funktioniert, aber Sie sollten es wahrscheinlich nicht immer überprüfen. Ausnahmen für das Werfen sollten für "Ausnahmesituationen" reserviert sein (die vielleicht in Ihren Fall passen) und sind sehr kostspielig.
Ich mag keine Methode mit Regex, weil Regex keine Bereiche prüfen kann (Integer.MIN_VALUE, Integer.MAX_VALUE).
Wenn Sie in den meisten Fällen einen int-Wert erwarten und int nicht ungewöhnlich ist, empfehle ich eine Version mit Integer.valueOf oder Integer.parseInt mit NumberFormatException catching. Vorteil dieses Ansatzes - Ihr Code ist gut lesbar:
public static boolean isInt(String s) {
try {
Integer.parseInt(s);
return true;
} catch (NumberFormatException nfe) {
return false;
}
}
Wenn Sie überprüfen müssen, ob String eine Ganzzahl ist, und sich um die Leistung kümmern möchten, ist es am besten, Java jdk-Implementierung von Integer.parseInt zu verwenden, jedoch nur geringfügig zu ändern (Ersetzen von throw durch return false):
Diese Funktion hat eine gute Leistung und garantiert das richtige Ergebnis:
public static boolean isInt(String s) {
int radix = 10;
if (s == null) {
return false;
}
if (radix < Character.MIN_RADIX) {
return false;
}
if (radix > Character.MAX_RADIX) {
return false;
}
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 "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
return false;
if (len == 1) // Cannot have lone "+" or "-"
return false;
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(s.charAt(i++), radix);
if (digit < 0) {
return false;
}
if (result < multmin) {
return false;
}
result *= radix;
if (result < limit + digit) {
return false;
}
result -= digit;
}
} else {
return false;
}
return true;
}
Um nach allen Int-Zeichen zu suchen, können Sie einfach ein doppeltes Negativ verwenden.
if (! searchString.matches ("[^ 0-9] + $")) ...
[^ 0-9] + $ prüft, ob Zeichen vorhanden sind, die nicht ganzzahlig sind. Der Test schlägt fehl, wenn er wahr ist. Nur NICHT das und Sie werden auf Erfolg wahr.
Number number;
try {
number = NumberFormat.getInstance().parse("123");
} catch (ParseException e) {
//not a number - do recovery.
e.printStackTrace();
}
//use number
Ich glaube, es besteht kein Risiko für eine Ausnahme, denn wie Sie unten sehen können, analysieren Sie int immer sicher in String und nicht umgekehrt.
So:
Sie check, wenn jeder Platz in Ihrer Zeichenfolge mindestens übereinstimmtEine der Zeichen {"0", "1", "2", "3", "4") "5", "6", "7", "8", "9"}.
if(aString.substring(j, j+1).equals(String.valueOf(i)))Sie Summe zu allen Zeiten, zu denen Sie in den Steckplätzen die oben genannten Zeichen gefunden haben.
digits++;Und schließlich check, wenn die Zeiten, die Sie als -Zeichen angetroffen haben, der Länge der angegebenen Zeichenfolge entsprechen.
if(digits == aString.length())
Und in der Praxis haben wir:
String aString = "1234224245";
int digits = 0;//count how many digits you encountered
for(int j=0;j<aString.length();j++){
for(int i=0;i<=9;i++){
if(aString.substring(j, j+1).equals(String.valueOf(i)))
digits++;
}
}
if(digits == aString.length()){
System.out.println("It's an integer!!");
}
else{
System.out.println("It's not an integer!!");
}
String anotherString = "1234f22a4245";
int anotherDigits = 0;//count how many digits you encountered
for(int j=0;j<anotherString.length();j++){
for(int i=0;i<=9;i++){
if(anotherString.substring(j, j+1).equals(String.valueOf(i)))
anotherDigits++;
}
}
if(anotherDigits == anotherString.length()){
System.out.println("It's an integer!!");
}
else{
System.out.println("It's not an integer!!");
}
Und die Ergebnisse sind:
Es ist eine ganze Zahl !!
Es ist keine ganze Zahl !!
In ähnlicher Weise können Sie überprüfen, ob ein String ein float oder ein double ist. In diesen Fällen müssen Sie jedoch nur einen. (Punkt) im String erkennen und natürlich prüfen, ob digits == (aString.length()-1)
Auch hier besteht kein Risiko, dass eine Parsing-Ausnahme auftritt. Wenn Sie jedoch planen, eine Zeichenfolge zu analysieren, von der bekannt ist, dass sie eine Zahl enthält (sagen wir int Datentyp), müssen Sie zuerst prüfen, ob sie in den Datentyp. Ansonsten musst du es werfen.
Ich hoffe ich habe geholfen
Finden Sie das kann hilfreich sein:
public static boolean isInteger(String self) {
try {
Integer.valueOf(self.trim());
return true;
} catch (NumberFormatException nfe) {
return false;
}
}
Dies würde nur für positive ganze Zahlen funktionieren.
public static boolean isInt(String str) {
if (str != null && str.length() != 0) {
for (int i = 0; i < str.length(); i++) {
if (!Character.isDigit(str.charAt(i))) return false;
}
}
return true;
}